@assistant-ui/react-ag-ui 0.1.4 → 0.1.6

package/dist/runtime/adapter/run-aggregator.js

@@ -63,11 +63,41 @@ const scanJSONContainerDelta = (scanner, delta) => {
 	return completed && scanner.state === "complete";
 };
 const isPlainObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
+const createMessageBuffer = (id) => ({
+	id,
+	textParts: /* @__PURE__ */ new Map(),
+	openTextFrames: /* @__PURE__ */ new Set(),
+	activeTextMessageIdByScope: /* @__PURE__ */ new Map(),
+	reasoningParts: /* @__PURE__ */ new Map(),
+	reasoningSignatures: /* @__PURE__ */ new Map(),
+	reasoningSignatureIds: /* @__PURE__ */ new Map(),
+	hiddenSignatures: /* @__PURE__ */ new Map(),
+	hiddenSignatureAnchors: /* @__PURE__ */ new Map(),
+	hiddenBlockAnchors: /* @__PURE__ */ new Map(),
+	hiddenReasoningIds: /* @__PURE__ */ new Set(),
+	hiddenActiveReasoningId: void 0,
+	hasEmittedOpaqueReasoning: false,
+	loggedDroppedOpaqueIds: /* @__PURE__ */ new Set(),
+	reasoningMessageIds: /* @__PURE__ */ new Map(),
+	activeReasoningKeyByScope: /* @__PURE__ */ new Map(),
+	subagentRuns: /* @__PURE__ */ new Map(),
+	nestingMemo: void 0,
+	toolCalls: /* @__PURE__ */ new Map(),
+	a2uiBuckets: /* @__PURE__ */ new Map(),
+	a2uiToolCallIds: /* @__PURE__ */ new Set(),
+	activityParts: /* @__PURE__ */ new Map(),
+	lastResolvedToolCallIdByScope: /* @__PURE__ */ new Map(),
+	partOrder: [],
+	lastReasoningBeforeToolCall: void 0,
+	textPartCounter: 0,
+	reportedServerMessageId: void 0
+});
 /**
 * Collects AG-UI events into assistant-ui run snapshots that can be yielded from a ChatModelAdapter.
 *
-* The aggregator keeps a single assistant message worth of parts. Each incoming event updates the parts and
-* emits a fresh snapshot through the provided `emit` callback. `CUSTOM` events
+* Each incoming event updates the parts of the assistant message it names and
+* emits a fresh snapshot: through `emit` for the message the run streams into,
+* and through `onRetainedMessage` for one it moved on from. `CUSTOM` events
 * become canonical data parts; integration plumbing names such as
 * `on_interrupt`, `PredictState`, `Exit`, `hook_error`, `state_update_error`,
 * `system:*`, and `MultiAgentHandoff` are forwarded the same way, so apps only
@@ -80,36 +110,17 @@ var RunAggregator = class {
 	logger;
 	onServerMessageId;
 	onTextMessageStart;
+	onRetainedMessage;
+	canRetainMessage;
 	status;
 	interrupts;
 	pendingToolCallIds;
-	textParts = /* @__PURE__ */ new Map();
 	pendingSnapshotText = /* @__PURE__ */ new Map();
-	activeTextMessageIdByScope = /* @__PURE__ */ new Map();
-	reasoningParts = /* @__PURE__ */ new Map();
-	reasoningSignatures = /* @__PURE__ */ new Map();
-	reasoningSignatureIds = /* @__PURE__ */ new Map();
-	hiddenSignatures = /* @__PURE__ */ new Map();
-	hiddenSignatureAnchors = /* @__PURE__ */ new Map();
-	hiddenBlockAnchors = /* @__PURE__ */ new Map();
-	hiddenReasoningIds = /* @__PURE__ */ new Set();
-	hiddenActiveReasoningId;
-	hasEmittedOpaqueReasoning = false;
-	loggedDroppedOpaqueIds = /* @__PURE__ */ new Set();
-	reasoningMessageIds = /* @__PURE__ */ new Map();
-	activeReasoningKeyByScope = /* @__PURE__ */ new Map();
-	subagentRuns = /* @__PURE__ */ new Map();
-	nestingMemo;
-	toolCalls = /* @__PURE__ */ new Map();
-	a2uiBuckets = /* @__PURE__ */ new Map();
-	a2uiToolCallIds = /* @__PURE__ */ new Set();
-	activityParts = /* @__PURE__ */ new Map();
-	lastResolvedToolCallIdByScope = /* @__PURE__ */ new Map();
-	partOrder = [];
-	lastReasoningBeforeToolCall;
-	textPartCounter = 0;
+	current = createMessageBuffer();
+	buf = this.current;
+	retained = /* @__PURE__ */ new Map();
+	unannounced;
 	serverMessageIdReported = false;
-	reportedServerMessageId;
 	lastTextMessageId;
 	streamStartTime;
 	firstTokenTime;
@@ -121,41 +132,186 @@ var RunAggregator = class {
 		this.logger = options.logger;
 		this.onServerMessageId = options.onServerMessageId;
 		this.onTextMessageStart = options.onTextMessageStart;
+		this.onRetainedMessage = options.onRetainedMessage;
+		this.canRetainMessage = options.canRetainMessage;
 	}
 	hasToolCall(toolCallId) {
-		return this.toolCalls.has(toolCallId);
+		return this.buffers().some((buffer) => buffer.toolCalls.has(toolCallId));
+	}
+	isRetained(messageId) {
+		return this.retained.has(messageId);
 	}
-	rebaseMessage(messageId) {
-		const snapshotText = this.pendingSnapshotText.get(messageId);
-		this.resetMessageParts();
+	/**
+	* Makes `messageId` the message the run streams into. The previous message
+	* keeps its parts under `previousId`, and returns true when it does; call
+	* `announceRetained` to publish its state once the caller can apply it.
+	*/
+	rebaseMessage(messageId, previousId) {
+		const retained = this.openMessage(messageId, previousId);
 		this.lastTextMessageId = messageId;
-		this.reportedServerMessageId = messageId;
-		if (snapshotText !== void 0) this.pendingSnapshotText.set(messageId, snapshotText);
+		this.current.reportedServerMessageId = messageId;
 		this.startTextMessage(ROOT_SCOPE, messageId);
+		if (retained) this.unannounced = retained;
+		return retained !== void 0;
+	}
+	announceRetained() {
+		const buffer = this.unannounced;
+		this.unannounced = void 0;
+		if (buffer && this.retained.get(buffer.id) === buffer) this.withBuffer(buffer, () => this.emit());
 	}
 	handle(event) {
+		const owner = this.ownerOf(event);
+		if (owner === this.current) this.apply(event);
+		else this.withBuffer(owner, () => this.apply(event));
+	}
+	buffers() {
+		return [this.current, ...this.retained.values()];
+	}
+	withBuffer(buffer, fn) {
+		const previous = this.buf;
+		this.buf = buffer;
+		try {
+			fn();
+		} finally {
+			this.buf = previous;
+		}
+	}
+	openMessage(messageId, previousId) {
+		const outgoing = this.current;
+		const next = this.retained.get(messageId) ?? createMessageBuffer(messageId);
+		this.retained.delete(messageId);
+		let retained;
+		if (previousId !== void 0 && previousId !== messageId) {
+			outgoing.id = previousId;
+			this.retained.set(previousId, outgoing);
+			retained = outgoing;
+		}
+		this.current = next;
+		this.buf = next;
+		return retained;
+	}
+	ownerForMessage(messageId) {
+		if (!messageId || messageId === this.current.id) return this.current;
+		const retained = this.retained.get(messageId);
+		if (retained) return retained;
+		if (this.canRetainMessage?.(messageId)) {
+			const buffer = createMessageBuffer(messageId);
+			this.retained.set(messageId, buffer);
+			if (this.pendingSnapshotText.has(messageId)) this.withBuffer(buffer, () => this.startTextMessage(ROOT_SCOPE, messageId));
+			return buffer;
+		}
+		return this.current;
+	}
+	ownerForToolCall(toolCallId) {
+		if (typeof toolCallId !== "string") return void 0;
+		return this.buffers().find((buffer) => buffer.toolCalls.has(toolCallId));
+	}
+	ownerForSubagent(subagentRunId) {
+		return this.buffers().find((buffer) => buffer.subagentRuns.has(subagentRunId)) ?? this.current;
+	}
+	ownerForActivity(event) {
+		if (event.subagentRunId !== void 0) return this.ownerForSubagent(event.subagentRunId);
+		if (event.messageId === void 0) return this.current;
+		const key = `message:${event.messageId}`;
+		return this.buffers().find((buffer) => buffer.activityParts.has(key)) ?? this.current;
+	}
+	ownerOf(event) {
+		if (this.joinStrategy === "concat-content") return this.current;
 		switch (event.type) {
-			case "RUN_STARTED":
-				this.resetMessageParts();
+			case "TEXT_MESSAGE_START":
+			case "TEXT_MESSAGE_CONTENT":
+			case "TEXT_MESSAGE_END": return event.subagentRunId !== void 0 ? this.ownerForSubagent(event.subagentRunId) : this.ownerForMessage(event.messageId);
+			case "TOOL_CALL_START": return event.subagentRunId !== void 0 ? this.ownerForSubagent(event.subagentRunId) : this.ownerForMessage(event.parentMessageId);
+			case "TOOL_CALL_ARGS":
+			case "TOOL_CALL_END":
+			case "TOOL_CALL_RESULT": return this.ownerForToolCall(event.toolCallId) ?? (event.subagentRunId !== void 0 ? this.ownerForSubagent(event.subagentRunId) : this.current);
+			case "SUBAGENT_STARTED": {
+				const existing = this.buffers().find((buffer) => buffer.subagentRuns.has(event.subagentRunId));
+				if (existing) return existing;
+				if (event.parentToolCallId !== void 0) {
+					const owner = this.ownerForToolCall(event.parentToolCallId);
+					if (owner) return owner;
+				}
+				if (event.parentSubagentRunId !== void 0) return this.ownerForSubagent(event.parentSubagentRunId);
+				return this.ownerForMessage(event.parentMessageId);
+			}
+			case "SUBAGENT_FINISHED":
+			case "SUBAGENT_ERROR": return this.ownerForSubagent(event.subagentRunId);
+			case "ACTIVITY_SNAPSHOT":
+				if (event.activityType === "mcp-apps") {
+					const owner = this.ownerForToolCall(event.content.toolCallId);
+					if (owner) return owner;
+				}
+				if (event.activityType === "a2ui-surface") return this.current;
+				return this.ownerForActivity(event);
+			case "ACTIVITY_DELTA": return this.ownerForActivity(event);
+			case "REASONING_START":
+			case "REASONING_MESSAGE_START":
+			case "REASONING_MESSAGE_CONTENT":
+			case "REASONING_MESSAGE_END":
+			case "REASONING_END":
+			case "REASONING_ENCRYPTED_VALUE": {
+				if (event.subagentRunId !== void 0) return this.ownerForSubagent(event.subagentRunId);
+				const id = event.type === "REASONING_ENCRYPTED_VALUE" ? event.entityId : event.messageId;
+				return this.buffers().find((buffer) => buffer.reasoningParts.has(id) || buffer.hiddenReasoningIds.has(id)) ?? this.current;
+			}
+			default: return this.current;
+		}
+	}
+	retainedState(buffer) {
+		const openToolCallIds = Array.from(buffer.toolCalls.values()).filter((call) => call.result === void 0 && !buffer.a2uiToolCallIds.has(call.toolCallId)).map((call) => call.toolCallId);
+		return {
+			messageId: buffer.id,
+			openToolCallIds,
+			streaming: buffer.openTextFrames.size > 0 || Array.from(buffer.subagentRuns.values()).some((run) => run.status.type === "running")
+		};
+	}
+	apply(event) {
+		switch (event.type) {
+			case "RUN_STARTED": {
+				this.retained.clear();
+				this.unannounced = void 0;
+				const { hasEmittedOpaqueReasoning } = this.current;
+				this.current = createMessageBuffer();
+				this.current.hasEmittedOpaqueReasoning = hasEmittedOpaqueReasoning;
+				this.buf = this.current;
+				this.pendingSnapshotText.clear();
 				this.interrupts = void 0;
 				this.serverMessageIdReported = false;
 				this.lastTextMessageId = void 0;
-				this.reportedServerMessageId = void 0;
 				this.streamStartTime = Date.now();
 				this.firstTokenTime = void 0;
 				this.totalChunks = 0;
 				this.status = { type: "running" };
 				this.emit();
 				break;
-			case "MESSAGES_SNAPSHOT":
+			}
+			case "MESSAGES_SNAPSHOT": {
 				this.pendingSnapshotText.clear();
+				const buffers = this.buffers();
 				for (const message of event.messages) {
-					if (message.role !== "assistant" || typeof message.content !== "string") continue;
-					const part = this.textParts.get(message.id);
-					if (part) part.buffer = message.content;
-					else this.pendingSnapshotText.set(message.id, message.content);
+					if (message?.role !== "assistant") continue;
+					if (typeof message.content === "string") {
+						const part = buffers.map((buffer) => buffer.textParts.get(message.id)).find((entry) => entry !== void 0);
+						if (part) part.buffer = message.content;
+						else this.pendingSnapshotText.set(message.id, message.content);
+					}
+					for (const call of Array.isArray(message.toolCalls) ? message.toolCalls : []) {
+						const args = call?.function?.arguments;
+						if (typeof args !== "string" || args.length === 0) continue;
+						for (const buffer of buffers) {
+							const entry = buffer.toolCalls.get(call.id);
+							if (entry === void 0 || entry.argsText !== "") continue;
+							entry.argsText = args;
+							entry.argsTextScanner = createJSONContainerScanner();
+							scanJSONContainerDelta(entry.argsTextScanner, args);
+							const parsed = tryParseJSON(args);
+							entry.parsedArgs = isPlainObject(parsed) ? parsed : void 0;
+						}
+					}
 				}
 				break;
+			}
 			case "RUN_FINISHED": {
 				if (event.outcome?.type === "cancelled") {
 					this.interrupts = void 0;
@@ -179,9 +335,9 @@ var RunAggregator = class {
 				this.interrupts = void 0;
 				const pendingToolCallIds = event.outcome?.type === "success" ? event.outcome.pendingToolCallIds : void 0;
 				const hasUnresolvedToolCalls = pendingToolCallIds && pendingToolCallIds.length > 0 ? pendingToolCallIds.some((id) => {
-					const call = this.toolCalls.get(id);
+					const call = this.buf.toolCalls.get(id);
 					return call !== void 0 && call.result === void 0;
-				}) : Array.from(this.toolCalls.values()).some((tc) => tc.result === void 0);
+				}) : Array.from(this.buf.toolCalls.values()).some((tc) => tc.result === void 0);
 				this.status = hasUnresolvedToolCalls ? {
 					type: "requires-action",
 					reason: "tool-calls"
@@ -214,11 +370,12 @@ var RunAggregator = class {
 				break;
 			case "TEXT_MESSAGE_START": {
 				const scope = this.scopeOf(event);
-				if (scope === ROOT_SCOPE) {
+				if (scope === ROOT_SCOPE && this.buf === this.current) {
 					this.beginDistinctTextMessage(event.messageId);
 					this.reportServerMessageId(event.messageId);
 					if (event.messageId) this.lastTextMessageId = event.messageId;
 				}
+				if (scope === ROOT_SCOPE && event.messageId) this.buf.openTextFrames.add(event.messageId);
 				this.startTextMessage(scope, event.messageId);
 				this.emit();
 				break;
@@ -226,11 +383,12 @@ var RunAggregator = class {
 			case "TEXT_MESSAGE_CONTENT": {
 				const incomingId = event.messageId;
 				const scope = this.scopeOf(event);
-				if (scope === ROOT_SCOPE) {
+				if (scope === ROOT_SCOPE && this.buf === this.current) {
 					this.beginDistinctTextMessage(incomingId, true);
 					this.reportServerMessageId(incomingId);
 					if (incomingId) this.lastTextMessageId = incomingId;
 				}
+				if (scope === ROOT_SCOPE && incomingId) this.buf.openTextFrames.add(incomingId);
 				if (!event.delta) break;
 				this.recordFirstToken();
 				const id = this.resolveTextMessageId(scope, incomingId);
@@ -241,14 +399,17 @@ var RunAggregator = class {
 			}
 			case "TEXT_MESSAGE_END": {
 				const scope = this.scopeOf(event);
-				if (scope === ROOT_SCOPE) this.reportServerMessageId(event.messageId);
-				if (event.messageId && this.activeTextMessageIdByScope.get(scope) === this.partKey(scope, event.messageId)) this.activeTextMessageIdByScope.delete(scope);
+				if (scope === ROOT_SCOPE && event.messageId) {
+					if (this.buf === this.current) this.reportServerMessageId(event.messageId);
+					this.buf.openTextFrames.delete(event.messageId);
+				}
+				if (event.messageId && this.buf.activeTextMessageIdByScope.get(scope) === this.partKey(scope, event.messageId)) this.buf.activeTextMessageIdByScope.delete(scope);
 				this.emit();
 				break;
 			}
 			case "CUSTOM":
-				this.activeTextMessageIdByScope.delete(ROOT_SCOPE);
-				this.partOrder.push({
+				this.buf.activeTextMessageIdByScope.delete(ROOT_SCOPE);
+				this.buf.partOrder.push({
 					kind: "data",
 					name: event.name,
 					value: event.value
@@ -263,14 +424,14 @@ var RunAggregator = class {
 				if (event.subtype === "message") {
 					const scope = this.scopeOf(event);
 					const entityKey = this.partKey(scope, event.entityId);
-					const key = this.showThinking && this.reasoningParts.has(entityKey) ? entityKey : void 0;
+					const key = this.showThinking && this.buf.reasoningParts.has(entityKey) ? entityKey : void 0;
 					if (key !== void 0) {
-						this.reasoningSignatures.set(key, event.encryptedValue);
-						this.reasoningSignatureIds.set(key, event.entityId);
+						this.buf.reasoningSignatures.set(key, event.encryptedValue);
+						this.buf.reasoningSignatureIds.set(key, event.entityId);
 						this.emit();
-					} else if (!this.showThinking && scope === ROOT_SCOPE && event.entityId.trim().length > 0 && event.encryptedValue.trim().length > 0 && this.hiddenReasoningIds.has(event.entityId)) {
-						this.hiddenSignatures.set(event.entityId, event.encryptedValue);
-						this.hiddenSignatureAnchors.set(event.entityId, this.hiddenBlockAnchors.get(event.entityId) ?? this.partOrder.length);
+					} else if (!this.showThinking && scope === ROOT_SCOPE && event.entityId.trim().length > 0 && event.encryptedValue.trim().length > 0 && this.buf.hiddenReasoningIds.has(event.entityId)) {
+						this.buf.hiddenSignatures.set(event.entityId, event.encryptedValue);
+						this.buf.hiddenSignatureAnchors.set(event.entityId, this.buf.hiddenBlockAnchors.get(event.entityId) ?? this.buf.partOrder.length);
 						this.emit();
 					}
 				}
@@ -286,7 +447,7 @@ var RunAggregator = class {
 				break;
 			case "TOOL_CALL_START": {
 				const scope = this.scopeOf(event);
-				if (scope === ROOT_SCOPE) this.reportServerMessageId(event.parentMessageId);
+				if (scope === ROOT_SCOPE && this.buf === this.current) this.reportServerMessageId(event.parentMessageId);
 				this.startToolCall(scope, event.toolCallId, event.toolCallName, event.parentMessageId);
 				this.emit();
 				break;
@@ -314,8 +475,8 @@ var RunAggregator = class {
 				}
 				const activityScope = this.scopeOf(event);
 				const toolCallId = event.content.toolCallId;
-				const fallbackId = this.lastResolvedToolCallIdByScope.get(activityScope);
-				const entry = typeof toolCallId === "string" ? this.toolCalls.get(toolCallId) : fallbackId ? this.toolCalls.get(fallbackId) : void 0;
+				const fallbackId = this.buf.lastResolvedToolCallIdByScope.get(activityScope);
+				const entry = typeof toolCallId === "string" ? this.buf.toolCalls.get(toolCallId) : fallbackId ? this.buf.toolCalls.get(fallbackId) : void 0;
 				const resourceUri = event.content.resourceUri;
 				if (entry && typeof resourceUri === "string" && isMcpAppUri(resourceUri)) {
 					entry.mcpAppResourceUri = resourceUri;
@@ -338,7 +499,7 @@ var RunAggregator = class {
 				break;
 			}
 			case "SUBAGENT_STARTED": {
-				const existing = this.subagentRuns.get(event.subagentRunId);
+				const existing = this.buf.subagentRuns.get(event.subagentRunId);
 				if (existing) {
 					existing.name = event.name;
 					if (event.description !== void 0) existing.description = event.description;
@@ -346,8 +507,8 @@ var RunAggregator = class {
 					this.emit();
 					break;
 				}
-				this.nestingMemo = void 0;
-				this.subagentRuns.set(event.subagentRunId, {
+				this.buf.nestingMemo = void 0;
+				this.buf.subagentRuns.set(event.subagentRunId, {
 					subagentRunId: event.subagentRunId,
 					name: event.name,
 					...event.description !== void 0 ? { description: event.description } : {},
@@ -361,7 +522,7 @@ var RunAggregator = class {
 				break;
 			}
 			case "SUBAGENT_FINISHED": {
-				const run = this.subagentRuns.get(event.subagentRunId);
+				const run = this.buf.subagentRuns.get(event.subagentRunId);
 				if (run) {
 					run.status = event.outcome?.type === "suspended" ? {
 						type: "requires-action",
@@ -377,7 +538,7 @@ var RunAggregator = class {
 				break;
 			}
 			case "SUBAGENT_ERROR": {
-				const run = this.subagentRuns.get(event.subagentRunId);
+				const run = this.buf.subagentRuns.get(event.subagentRunId);
 				if (run) {
 					run.status = {
 						type: "incomplete",
@@ -397,7 +558,7 @@ var RunAggregator = class {
 	}
 	handleActivityDelta(event) {
 		const scope = this.scopeOf(event);
-		const existing = this.activityParts.get(this.partKey(scope, `message:${event.messageId}`));
+		const existing = this.buf.activityParts.get(this.partKey(scope, `message:${event.messageId}`));
 		if (!existing) {
 			this.logger.debug?.("[agui] activity delta has no snapshot", event);
 			return;
@@ -420,18 +581,18 @@ var RunAggregator = class {
 		const operations = event.content["a2ui_operations"];
 		if (!Array.isArray(operations)) return;
 		const messageId = event.messageId ?? "a2ui:anonymous";
-		if (event.replace === false && this.a2uiBuckets.has(messageId)) return;
+		if (event.replace === false && this.buf.a2uiBuckets.has(messageId)) return;
 		const { state, warnings } = applyA2uiOperations(/* @__PURE__ */ new Map(), operations);
 		for (const warning of warnings) this.logger.debug("[agui] a2ui operation warning", warning);
-		this.a2uiBuckets.delete(messageId);
-		this.a2uiBuckets.set(messageId, state);
+		this.buf.a2uiBuckets.delete(messageId);
+		this.buf.a2uiBuckets.set(messageId, state);
 		this.synthesizeA2uiToolCalls();
 		this.emit();
 	}
 	handleActivitySnapshot(event) {
 		const scope = this.scopeOf(event);
 		const key = this.partKey(scope, event.messageId !== void 0 ? `message:${event.messageId}` : `type:${event.activityType}`);
-		const existing = this.activityParts.get(key);
+		const existing = this.buf.activityParts.get(key);
 		if (existing) {
 			if (event.replace === false) return;
 			existing.name = `agui-activity/${event.activityType}`;
@@ -447,15 +608,15 @@ var RunAggregator = class {
 				value: event.content,
 				subagentRunId: scope
 			};
-			this.activityParts.set(key, part);
-			this.partOrder.push(part);
-			this.activeTextMessageIdByScope.delete(scope);
+			this.buf.activityParts.set(key, part);
+			this.buf.partOrder.push(part);
+			this.buf.activeTextMessageIdByScope.delete(scope);
 		}
 		this.emit();
 	}
 	synthesizeA2uiToolCalls() {
 		const surfaces = /* @__PURE__ */ new Map();
-		for (const bucket of this.a2uiBuckets.values()) for (const [surfaceId, surface] of bucket) surfaces.set(surfaceId, surface);
+		for (const bucket of this.buf.a2uiBuckets.values()) for (const [surfaceId, surface] of bucket) surfaces.set(surfaceId, surface);
 		const activeToolCallIds = /* @__PURE__ */ new Set();
 		for (const [surfaceId, surface] of surfaces) {
 			const { toolCall, warnings } = surfaceToPresentToolCall(surfaceId, surface);
@@ -473,21 +634,21 @@ var RunAggregator = class {
 				artifact: toolCall.artifact,
 				snapshotResultApplied: false
 			};
-			if (!this.toolCalls.has(toolCallId)) this.partOrder.push({
+			if (!this.buf.toolCalls.has(toolCallId)) this.buf.partOrder.push({
 				kind: "tool-call",
 				toolCallId
 			});
-			this.nestingMemo = void 0;
-			this.toolCalls.set(toolCallId, entry);
-			this.a2uiToolCallIds.add(toolCallId);
+			this.buf.nestingMemo = void 0;
+			this.buf.toolCalls.set(toolCallId, entry);
+			this.buf.a2uiToolCallIds.add(toolCallId);
 		}
-		for (const toolCallId of this.a2uiToolCallIds) {
+		for (const toolCallId of this.buf.a2uiToolCallIds) {
 			if (activeToolCallIds.has(toolCallId)) continue;
-			this.nestingMemo = void 0;
-			this.toolCalls.delete(toolCallId);
-			const partIndex = this.partOrder.findIndex((part) => part.kind === "tool-call" && part.toolCallId === toolCallId);
-			if (partIndex !== -1) this.partOrder.splice(partIndex, 1);
-			this.a2uiToolCallIds.delete(toolCallId);
+			this.buf.nestingMemo = void 0;
+			this.buf.toolCalls.delete(toolCallId);
+			const partIndex = this.buf.partOrder.findIndex((part) => part.kind === "tool-call" && part.toolCallId === toolCallId);
+			if (partIndex !== -1) this.buf.partOrder.splice(partIndex, 1);
+			this.buf.a2uiToolCallIds.delete(toolCallId);
 		}
 	}
 	reportServerMessageId(messageId) {
@@ -495,41 +656,19 @@ var RunAggregator = class {
 		if (this.lastTextMessageId === void 0) this.lastTextMessageId = messageId;
 		if (this.serverMessageIdReported) return;
 		this.serverMessageIdReported = true;
-		this.reportedServerMessageId = messageId;
+		this.buf.reportedServerMessageId = messageId;
 		this.onServerMessageId?.(messageId);
 	}
-	clearTextParts() {
-		this.textParts.clear();
-	}
-	resetMessageParts() {
-		this.clearTextParts();
-		this.pendingSnapshotText.clear();
-		this.reasoningParts.clear();
-		this.reasoningSignatures.clear();
-		this.reasoningSignatureIds.clear();
-		this.reasoningMessageIds.clear();
-		this.hiddenSignatures.clear();
-		this.hiddenSignatureAnchors.clear();
-		this.hiddenBlockAnchors.clear();
-		this.hiddenReasoningIds.clear();
-		this.hiddenActiveReasoningId = void 0;
-		this.loggedDroppedOpaqueIds.clear();
-		this.activeReasoningKeyByScope.clear();
-		this.nestingMemo = void 0;
-		this.subagentRuns.clear();
-		this.toolCalls.clear();
-		this.a2uiBuckets.clear();
-		this.a2uiToolCallIds.clear();
-		this.activityParts.clear();
-		this.lastResolvedToolCallIdByScope.clear();
-		this.partOrder.length = 0;
-		this.lastReasoningBeforeToolCall = void 0;
-		this.textPartCounter = 0;
-		this.activeTextMessageIdByScope.clear();
-		this.reportedServerMessageId = void 0;
-	}
 	closeOpenSubagentRuns(status) {
-		for (const run of this.subagentRuns.values()) if (run.status.type === "running") run.status = status;
+		for (const buffer of this.buffers()) {
+			let closed = false;
+			for (const run of buffer.subagentRuns.values()) {
+				if (run.status.type !== "running") continue;
+				run.status = status;
+				closed = true;
+			}
+			if (closed && buffer !== this.current) this.withBuffer(buffer, () => this.emit());
+		}
 	}
 	scopeOf(event) {
 		return event.subagentRunId ?? ROOT_SCOPE;
@@ -541,38 +680,37 @@ var RunAggregator = class {
 		if (this.joinStrategy === "concat-content" || !messageId || this.lastTextMessageId === void 0 || this.lastTextMessageId === messageId || !this.onTextMessageStart) return;
 		const carried = this.takeTrailingReasoning();
 		if (carried.parts.length > 0 || carried.hiddenSignatures.length > 0) this.emit();
-		const openToolCallIds = Array.from(this.toolCalls.values()).filter((call) => call.result === void 0).map((call) => call.toolCallId);
-		const snapshotText = preserveSnapshotText ? this.pendingSnapshotText.get(messageId) : void 0;
-		this.resetMessageParts();
-		if (snapshotText !== void 0) this.pendingSnapshotText.set(messageId, snapshotText);
-		this.onTextMessageStart(messageId, openToolCallIds);
+		const openToolCallIds = Array.from(this.buf.toolCalls.values()).filter((call) => call.result === void 0).map((call) => call.toolCallId);
+		if (!preserveSnapshotText) this.pendingSnapshotText.delete(messageId);
+		const outgoingId = this.onTextMessageStart(messageId, openToolCallIds) || void 0;
+		this.openMessage(messageId, outgoingId);
 		this.restoreReasoning(carried);
 	}
 	takeTrailingReasoning() {
 		const parts = [];
-		let last = this.partOrder.at(-1);
-		while (last?.kind === "reasoning" && last.subagentRunId === void 0 && last !== this.lastReasoningBeforeToolCall) {
-			this.partOrder.pop();
+		let last = this.buf.partOrder.at(-1);
+		while (last?.kind === "reasoning" && last.subagentRunId === void 0 && last !== this.buf.lastReasoningBeforeToolCall) {
+			this.buf.partOrder.pop();
 			parts.unshift({
 				key: last.key,
-				entry: this.reasoningParts.get(last.key) ?? { buffer: "" },
-				signature: this.reasoningSignatures.get(last.key),
-				signatureId: this.reasoningSignatureIds.get(last.key),
-				reasoningId: this.reasoningMessageIds.get(last.key)
+				entry: this.buf.reasoningParts.get(last.key) ?? { buffer: "" },
+				signature: this.buf.reasoningSignatures.get(last.key),
+				signatureId: this.buf.reasoningSignatureIds.get(last.key),
+				reasoningId: this.buf.reasoningMessageIds.get(last.key)
 			});
-			last = this.partOrder.at(-1);
+			last = this.buf.partOrder.at(-1);
 		}
-		const cut = this.partOrder.length;
-		const hiddenSignatures = Array.from(this.hiddenSignatures).filter(([id]) => this.hiddenSignatureAnchors.get(id) >= cut);
+		const cut = this.buf.partOrder.length;
+		const hiddenSignatures = Array.from(this.buf.hiddenSignatures).filter(([id]) => this.buf.hiddenSignatureAnchors.get(id) >= cut);
 		for (const [id] of hiddenSignatures) {
-			this.hiddenSignatures.delete(id);
-			this.hiddenSignatureAnchors.delete(id);
+			this.buf.hiddenSignatures.delete(id);
+			this.buf.hiddenSignatureAnchors.delete(id);
 		}
-		const hiddenBlockIds = Array.from(this.hiddenBlockAnchors).filter(([, anchor]) => anchor >= cut).map(([id]) => id);
-		const hiddenActiveReasoningId = this.hiddenActiveReasoningId;
+		const hiddenBlockIds = Array.from(this.buf.hiddenBlockAnchors).filter(([, anchor]) => anchor >= cut).map(([id]) => id);
+		const hiddenActiveReasoningId = this.buf.hiddenActiveReasoningId;
 		return {
 			parts,
-			activeKey: this.activeReasoningKeyByScope.get(ROOT_SCOPE),
+			activeKey: this.buf.activeReasoningKeyByScope.get(ROOT_SCOPE),
 			hiddenSignatures,
 			hiddenBlockIds,
 			hiddenActiveReasoningId: hiddenActiveReasoningId !== void 0 && hiddenBlockIds.includes(hiddenActiveReasoningId) ? hiddenActiveReasoningId : void 0
@@ -580,57 +718,57 @@ var RunAggregator = class {
 	}
 	restoreReasoning(carried) {
 		for (const part of carried.parts) {
-			this.partOrder.push({
+			this.buf.partOrder.push({
 				kind: "reasoning",
 				key: part.key
 			});
-			this.reasoningParts.set(part.key, part.entry);
-			if (part.signature !== void 0) this.reasoningSignatures.set(part.key, part.signature);
-			if (part.signatureId !== void 0) this.reasoningSignatureIds.set(part.key, part.signatureId);
-			if (part.reasoningId !== void 0) this.reasoningMessageIds.set(part.key, part.reasoningId);
+			this.buf.reasoningParts.set(part.key, part.entry);
+			if (part.signature !== void 0) this.buf.reasoningSignatures.set(part.key, part.signature);
+			if (part.signatureId !== void 0) this.buf.reasoningSignatureIds.set(part.key, part.signatureId);
+			if (part.reasoningId !== void 0) this.buf.reasoningMessageIds.set(part.key, part.reasoningId);
 		}
-		if (carried.activeKey !== void 0 && this.reasoningParts.has(carried.activeKey)) this.activeReasoningKeyByScope.set(ROOT_SCOPE, carried.activeKey);
+		if (carried.activeKey !== void 0 && this.buf.reasoningParts.has(carried.activeKey)) this.buf.activeReasoningKeyByScope.set(ROOT_SCOPE, carried.activeKey);
 		for (const [id, encryptedValue] of carried.hiddenSignatures) {
-			this.hiddenSignatures.set(id, encryptedValue);
-			this.hiddenSignatureAnchors.set(id, 0);
+			this.buf.hiddenSignatures.set(id, encryptedValue);
+			this.buf.hiddenSignatureAnchors.set(id, 0);
 		}
 		for (const id of carried.hiddenBlockIds) {
-			this.hiddenReasoningIds.add(id);
-			this.hiddenBlockAnchors.set(id, 0);
+			this.buf.hiddenReasoningIds.add(id);
+			this.buf.hiddenBlockAnchors.set(id, 0);
 		}
-		this.hiddenActiveReasoningId = carried.hiddenActiveReasoningId;
+		this.buf.hiddenActiveReasoningId = carried.hiddenActiveReasoningId;
 	}
 	generateTextKey() {
-		this.textPartCounter += 1;
-		return `text-${this.textPartCounter}`;
+		this.buf.textPartCounter += 1;
+		return `text-${this.buf.textPartCounter}`;
 	}
 	startTextMessage(scope, messageId) {
 		const id = messageId ?? this.generateTextKey();
 		const key = this.ensureTextPart(scope, id);
 		if (scope === ROOT_SCOPE && messageId) {
 			const snapshotText = this.pendingSnapshotText.get(messageId);
-			const part = this.textParts.get(key);
+			const part = this.buf.textParts.get(key);
 			if (snapshotText !== void 0 && part) {
 				part.buffer = snapshotText;
 				this.pendingSnapshotText.delete(messageId);
 			}
 		}
-		this.activeTextMessageIdByScope.set(scope, key);
+		this.buf.activeTextMessageIdByScope.set(scope, key);
 		return key;
 	}
 	resolveTextMessageId(scope, messageId) {
 		if (messageId) return this.startTextMessage(scope, messageId);
-		const active = this.activeTextMessageIdByScope.get(scope);
+		const active = this.buf.activeTextMessageIdByScope.get(scope);
 		if (active) return active;
 		const key = this.ensureTextPart(scope, this.generateTextKey());
-		this.activeTextMessageIdByScope.set(scope, key);
+		this.buf.activeTextMessageIdByScope.set(scope, key);
 		return key;
 	}
 	ensureTextPart(scope, id) {
 		const key = this.partKey(scope, id);
-		if (!this.textParts.has(key)) {
-			this.textParts.set(key, { buffer: "" });
-			if (!this.partOrder.some((part) => part.kind === "text" && part.key === key)) this.partOrder.push(scope === ROOT_SCOPE ? {
+		if (!this.buf.textParts.has(key)) {
+			this.buf.textParts.set(key, { buffer: "" });
+			if (!this.buf.partOrder.some((part) => part.kind === "text" && part.key === key)) this.buf.partOrder.push(scope === ROOT_SCOPE ? {
 				kind: "text",
 				key
 			} : {
@@ -642,15 +780,15 @@ var RunAggregator = class {
 		return key;
 	}
 	appendText(id, delta) {
-		const entry = this.textParts.get(id);
+		const entry = this.buf.textParts.get(id);
 		if (!entry) return;
 		entry.buffer += delta;
 	}
 	startToolCall(scope, id, name, parentMessageId) {
 		if (!id) return;
-		this.activeTextMessageIdByScope.delete(scope);
-		if (!this.partOrder.some((part) => part.kind === "tool-call" && part.toolCallId === id)) {
-			if (scope === ROOT_SCOPE) this.lastReasoningBeforeToolCall = this.partOrder.findLast((part) => part.kind === "reasoning" && part.subagentRunId === void 0);
+		this.buf.activeTextMessageIdByScope.delete(scope);
+		if (!this.buf.partOrder.some((part) => part.kind === "tool-call" && part.toolCallId === id)) {
+			if (scope === ROOT_SCOPE) this.buf.lastReasoningBeforeToolCall = this.buf.partOrder.findLast((part) => part.kind === "reasoning" && part.subagentRunId === void 0);
 			this.insertToolPart(scope, id, parentMessageId);
 		}
 		const state = {
@@ -664,8 +802,8 @@ var RunAggregator = class {
 		};
 		if (parentMessageId) state.parentMessageId = parentMessageId;
 		if (scope !== ROOT_SCOPE) state.subagentRunId = scope;
-		this.nestingMemo = void 0;
-		this.toolCalls.set(id, state);
+		this.buf.nestingMemo = void 0;
+		this.buf.toolCalls.set(id, state);
 	}
 	insertToolPart(scope, id, parentMessageId) {
 		const entry = {
@@ -674,25 +812,25 @@ var RunAggregator = class {
 		};
 		if (parentMessageId) {
 			const parentKey = this.partKey(scope, parentMessageId);
-			const parentIndex = this.partOrder.findIndex((part) => part.kind === "text" && part.key === parentKey);
+			const parentIndex = this.buf.partOrder.findIndex((part) => part.kind === "text" && part.key === parentKey);
 			if (parentIndex !== -1) {
 				let insertAt = parentIndex + 1;
-				while (insertAt < this.partOrder.length) {
-					const part = this.partOrder[insertAt];
-					if (part?.kind === "tool-call" && this.toolCalls.get(part.toolCallId)?.parentMessageId === parentMessageId) {
+				while (insertAt < this.buf.partOrder.length) {
+					const part = this.buf.partOrder[insertAt];
+					if (part?.kind === "tool-call" && this.buf.toolCalls.get(part.toolCallId)?.parentMessageId === parentMessageId) {
 						insertAt += 1;
 						continue;
 					}
 					break;
 				}
-				this.partOrder.splice(insertAt, 0, entry);
+				this.buf.partOrder.splice(insertAt, 0, entry);
 				return;
 			}
 		}
-		this.partOrder.push(entry);
+		this.buf.partOrder.push(entry);
 	}
 	appendToolArgs(id, delta) {
-		const entry = id ? this.toolCalls.get(id) : void 0;
+		const entry = id ? this.buf.toolCalls.get(id) : void 0;
 		if (!entry) return;
 		if (!entry.argsTextScanner) entry.argsTextScanner = createJSONContainerScanner();
 		entry.argsText += delta;
@@ -711,7 +849,7 @@ var RunAggregator = class {
 	finishToolCall(scope, id, content, isError, toolMessageId, mcpResult, metadata) {
 		if (!id) return;
 		const modelText = toolContentText(content);
-		let entry = this.toolCalls.get(id);
+		let entry = this.buf.toolCalls.get(id);
 		if (!entry) {
 			entry = {
 				toolCallId: id,
@@ -723,10 +861,10 @@ var RunAggregator = class {
 				snapshotResultApplied: false,
 				...scope !== ROOT_SCOPE ? { subagentRunId: scope } : {}
 			};
-			this.nestingMemo = void 0;
-			this.toolCalls.set(id, entry);
+			this.buf.nestingMemo = void 0;
+			this.buf.toolCalls.set(id, entry);
 		}
-		if (!this.partOrder.some((part) => part.kind === "tool-call" && part.toolCallId === id)) this.partOrder.push({
+		if (!this.buf.partOrder.some((part) => part.kind === "tool-call" && part.toolCallId === id)) this.buf.partOrder.push({
 			kind: "tool-call",
 			toolCallId: id
 		});
@@ -758,21 +896,21 @@ var RunAggregator = class {
 			...entry.resultMetadata,
 			...metadata
 		};
-		this.lastResolvedToolCallIdByScope.set(scope, id);
+		this.buf.lastResolvedToolCallIdByScope.set(scope, id);
 	}
 	nesting() {
-		if (!this.nestingMemo) {
+		if (!this.buf.nestingMemo) {
 			const subagentsByParentToolCallId = this.subagentsByParentToolCallId();
-			this.nestingMemo = {
+			this.buf.nestingMemo = {
 				subagentsByParentToolCallId,
 				reachable: this.reachableSubagentRunIds(subagentsByParentToolCallId)
 			};
 		}
-		return this.nestingMemo;
+		return this.buf.nestingMemo;
 	}
 	subagentsByParentToolCallId() {
 		const map = /* @__PURE__ */ new Map();
-		for (const run of this.subagentRuns.values()) {
+		for (const run of this.buf.subagentRuns.values()) {
 			if (!run.parentToolCallId) continue;
 			const list = map.get(run.parentToolCallId) ?? [];
 			list.push(run.subagentRunId);
@@ -784,7 +922,7 @@ var RunAggregator = class {
 		const reachable = /* @__PURE__ */ new Set();
 		const walk = (scope, depth) => {
 			if (depth > 16) return;
-			for (const entry of this.toolCalls.values()) {
+			for (const entry of this.buf.toolCalls.values()) {
 				if ((entry.subagentRunId ?? ROOT_SCOPE) !== scope) continue;
 				for (const id of subagentsByParentToolCallId.get(entry.toolCallId) ?? []) {
 					if (reachable.has(id)) continue;
@@ -797,7 +935,7 @@ var RunAggregator = class {
 		return reachable;
 	}
 	materializeSubagentMessage(subagentRunId, depth, ctx) {
-		const run = this.subagentRuns.get(subagentRunId);
+		const run = this.buf.subagentRuns.get(subagentRunId);
 		if (!run || depth > 16) return void 0;
 		const content = this.buildParts(subagentRunId, depth + 1, ctx);
 		return {
@@ -830,7 +968,7 @@ var RunAggregator = class {
 				if (isRoot && ctx.root) ctx.root.lastMaterializedIndex = index;
 			};
 			if (part.kind === "tool-call") {
-				const entry = this.toolCalls.get(part.toolCallId);
+				const entry = this.buf.toolCalls.get(part.toolCallId);
 				if (!entry) continue;
 				const approval = ctx.approvals.get(entry.toolCallId);
 				const nestedMessages = (ctx.subagentsByParentToolCallId.get(entry.toolCallId) ?? []).filter((id) => ctx.reachable.has(id)).map((id) => this.materializeSubagentMessage(id, depth, ctx)).filter((m) => m !== void 0);
@@ -861,12 +999,12 @@ var RunAggregator = class {
 			const rawScope = "subagentRunId" in part ? part.subagentRunId ?? ROOT_SCOPE : ROOT_SCOPE;
 			if (part.kind === "reasoning") {
 				if (this.showThinking) {
-					const entry = this.reasoningParts.get(part.key);
+					const entry = this.buf.reasoningParts.get(part.key);
 					const buffer = entry?.buffer ?? "";
-					const isActive = this.activeReasoningKeyByScope.get(rawScope) === part.key;
+					const isActive = this.buf.activeReasoningKeyByScope.get(rawScope) === part.key;
 					if (buffer.length > 0 || isActive) {
-						const encryptedValue = this.reasoningSignatures.get(part.key);
-						const reasoningId = this.reasoningMessageIds.get(part.key);
+						const encryptedValue = this.buf.reasoningSignatures.get(part.key);
+						const reasoningId = this.buf.reasoningMessageIds.get(part.key);
 						const meta = {
 							...reasoningId !== void 0 ? { reasoningId } : {},
 							...encryptedValue !== void 0 ? { encryptedValue } : {}
@@ -879,8 +1017,8 @@ var RunAggregator = class {
 						});
 						materialized();
 					} else if (isRoot && ctx.root) {
-						const encryptedValue = this.reasoningSignatures.get(part.key);
-						const id = this.reasoningSignatureIds.get(part.key);
+						const encryptedValue = this.buf.reasoningSignatures.get(part.key);
+						const id = this.buf.reasoningSignatureIds.get(part.key);
 						if (id?.trim() && encryptedValue?.trim()) ctx.root.opaqueCandidates.push({
 							id,
 							encryptedValue,
@@ -891,7 +1029,7 @@ var RunAggregator = class {
 				continue;
 			}
 			if (part.kind === "text") {
-				const entry = this.textParts.get(part.key);
+				const entry = this.buf.textParts.get(part.key);
 				if (entry && entry.buffer.trim().length > 0) {
 					snapshot.push({
 						type: "text",
@@ -916,16 +1054,16 @@ var RunAggregator = class {
 	emit() {
 		const { subagentsByParentToolCallId, reachable } = this.nesting();
 		const root = {
-			opaqueCandidates: Array.from(this.hiddenSignatures, ([id, encryptedValue]) => ({
+			opaqueCandidates: Array.from(this.buf.hiddenSignatures, ([id, encryptedValue]) => ({
 				id,
 				encryptedValue,
-				anchor: this.hiddenSignatureAnchors.get(id)
+				anchor: this.buf.hiddenSignatureAnchors.get(id)
 			})),
 			lastMaterializedIndex: -1
 		};
 		const partsByScope = /* @__PURE__ */ new Map();
-		for (const [index, part] of this.partOrder.entries()) {
-			const rawScope = part.kind === "tool-call" ? this.toolCalls.get(part.toolCallId)?.subagentRunId ?? ROOT_SCOPE : "subagentRunId" in part ? part.subagentRunId ?? ROOT_SCOPE : ROOT_SCOPE;
+		for (const [index, part] of this.buf.partOrder.entries()) {
+			const rawScope = part.kind === "tool-call" ? this.buf.toolCalls.get(part.toolCallId)?.subagentRunId ?? ROOT_SCOPE : "subagentRunId" in part ? part.subagentRunId ?? ROOT_SCOPE : ROOT_SCOPE;
 			const bucketScope = rawScope === ROOT_SCOPE || reachable.has(rawScope) ? rawScope : ROOT_SCOPE;
 			const bucket = partsByScope.get(bucketScope);
 			if (bucket) bucket.push({
@@ -941,18 +1079,18 @@ var RunAggregator = class {
 			subagentsByParentToolCallId,
 			reachable,
 			partsByScope,
-			approvals: projectAgUiToolApprovals(this.status?.type === "requires-action" ? this.interrupts : void 0, new Set(Array.from(this.toolCalls.values()).map((entry) => entry.toolCallId))),
+			approvals: projectAgUiToolApprovals(this.buf === this.current && this.status?.type === "requires-action" ? this.interrupts : void 0, new Set(Array.from(this.buf.toolCalls.values()).map((entry) => entry.toolCallId))),
 			root
 		};
 		const snapshot = this.buildParts(ROOT_SCOPE, 0, ctx);
 		const { opaqueCandidates, lastMaterializedIndex } = root;
 		const toolMessageIds = /* @__PURE__ */ new Set();
-		for (const call of this.toolCalls.values()) if (call.toolMessageId) toolMessageIds.add(call.toolMessageId);
+		for (const call of this.buf.toolCalls.values()) if (call.toolMessageId) toolMessageIds.add(call.toolMessageId);
 		opaqueCandidates.sort((a, b) => a.anchor - b.anchor);
 		const publishableOpaqueReasoning = opaqueCandidates.filter((entry) => {
-			const collides = this.textParts.has(entry.id) || entry.id === this.reportedServerMessageId || toolMessageIds.has(entry.id);
-			if (collides && !this.loggedDroppedOpaqueIds.has(entry.id)) {
-				this.loggedDroppedOpaqueIds.add(entry.id);
+			const collides = this.buf.textParts.has(entry.id) || entry.id === this.buf.reportedServerMessageId || toolMessageIds.has(entry.id);
+			if (collides && !this.buf.loggedDroppedOpaqueIds.has(entry.id)) {
+				this.buf.loggedDroppedOpaqueIds.add(entry.id);
 				this.logger.debug?.("[agui] aggregator dropped opaque reasoning signature: id collides with a message id", entry.id);
 			}
 			return !collides;
@@ -960,8 +1098,15 @@ var RunAggregator = class {
 			...entry,
 			after: true
 		} : entry);
-		if (publishableOpaqueReasoning.length > 0) this.hasEmittedOpaqueReasoning = true;
-		const includeOpaque = this.hasEmittedOpaqueReasoning;
+		if (publishableOpaqueReasoning.length > 0) this.buf.hasEmittedOpaqueReasoning = true;
+		const includeOpaque = this.buf.hasEmittedOpaqueReasoning;
+		if (this.buf !== this.current) {
+			this.onRetainedMessage?.({
+				content: snapshot,
+				...includeOpaque ? { metadata: { custom: { [AG_UI_METADATA_NAMESPACE]: { opaqueReasoning: publishableOpaqueReasoning } } } } : {}
+			}, this.retainedState(this.buf));
+			return;
+		}
 		const timing = this.getTiming();
 		const metadata = {
 			...timing ? { timing } : {},
@@ -984,7 +1129,7 @@ var RunAggregator = class {
 	getTiming() {
 		if (this.streamStartTime === void 0) return void 0;
 		const totalStreamTime = Date.now() - this.streamStartTime;
-		const tokenCount = this.totalChunks > 0 ? Math.ceil(Array.from(this.textParts.values()).reduce((sum, p) => sum + p.buffer.length, 0) / 4) : void 0;
+		const tokenCount = this.totalChunks > 0 ? Math.ceil(Array.from(this.buf.textParts.values()).reduce((sum, p) => sum + p.buffer.length, 0) / 4) : void 0;
 		const tokensPerSecond = tokenCount && totalStreamTime > 0 ? tokenCount / totalStreamTime * 1e3 : void 0;
 		return {
 			streamStartTime: this.streamStartTime,
@@ -993,24 +1138,24 @@ var RunAggregator = class {
 			...tokenCount !== void 0 ? { tokenCount } : {},
 			...tokensPerSecond !== void 0 ? { tokensPerSecond } : {},
 			totalChunks: this.totalChunks,
-			toolCallCount: this.toolCalls.size
+			toolCallCount: this.buf.toolCalls.size
 		};
 	}
 	handleReasoningStart(scope, messageId, isMessageId = false, timestamp) {
 		if (!this.showThinking) {
 			if (scope !== ROOT_SCOPE) return;
-			const anchor = this.partOrder.length;
-			this.hiddenReasoningIds.add(messageId);
-			this.hiddenBlockAnchors.set(messageId, anchor);
-			this.hiddenActiveReasoningId = messageId;
+			const anchor = this.buf.partOrder.length;
+			this.buf.hiddenReasoningIds.add(messageId);
+			this.buf.hiddenBlockAnchors.set(messageId, anchor);
+			this.buf.hiddenActiveReasoningId = messageId;
 			return;
 		}
-		this.activeTextMessageIdByScope.delete(scope);
+		this.buf.activeTextMessageIdByScope.delete(scope);
 		const key = this.partKey(scope, messageId);
-		if (isMessageId) this.reasoningMessageIds.set(key, messageId);
-		if (!this.reasoningParts.has(key)) {
-			this.reasoningParts.set(key, { buffer: "" });
-			this.partOrder.push(scope === ROOT_SCOPE ? {
+		if (isMessageId) this.buf.reasoningMessageIds.set(key, messageId);
+		if (!this.buf.reasoningParts.has(key)) {
+			this.buf.reasoningParts.set(key, { buffer: "" });
+			this.buf.partOrder.push(scope === ROOT_SCOPE ? {
 				kind: "reasoning",
 				key
 			} : {
@@ -1019,38 +1164,38 @@ var RunAggregator = class {
 				subagentRunId: scope
 			});
 		}
-		const entry = this.reasoningParts.get(key);
+		const entry = this.buf.reasoningParts.get(key);
 		if (entry?.timing) entry.timing = { startedAt: entry.timing.startedAt };
 		else if (entry && typeof timestamp === "number" && Number.isFinite(timestamp)) entry.timing = { startedAt: timestamp };
-		this.activeReasoningKeyByScope.set(scope, key);
+		this.buf.activeReasoningKeyByScope.set(scope, key);
 		this.emit();
 	}
 	handleReasoningContent(scope, delta, messageId, isMessageId = false) {
 		if (!delta) return;
 		if (!this.showThinking) {
 			if (scope !== ROOT_SCOPE) return;
-			if (this.hiddenActiveReasoningId === void 0) this.handleReasoningStart(scope, messageId, isMessageId);
+			if (this.buf.hiddenActiveReasoningId === void 0) this.handleReasoningStart(scope, messageId, isMessageId);
 			return;
 		}
-		if (!this.activeReasoningKeyByScope.has(scope)) this.handleReasoningStart(scope, messageId, isMessageId);
-		const key = this.activeReasoningKeyByScope.get(scope);
+		if (!this.buf.activeReasoningKeyByScope.has(scope)) this.handleReasoningStart(scope, messageId, isMessageId);
+		const key = this.buf.activeReasoningKeyByScope.get(scope);
 		if (!key) return;
-		const entry = this.reasoningParts.get(key);
+		const entry = this.buf.reasoningParts.get(key);
 		if (entry) entry.buffer += delta;
 		this.emit();
 	}
 	handleReasoningEnd(scope, timestamp) {
 		if (!this.showThinking) {
-			if (scope === ROOT_SCOPE) this.hiddenActiveReasoningId = void 0;
+			if (scope === ROOT_SCOPE) this.buf.hiddenActiveReasoningId = void 0;
 			return;
 		}
-		const key = this.activeReasoningKeyByScope.get(scope);
-		const entry = key ? this.reasoningParts.get(key) : void 0;
+		const key = this.buf.activeReasoningKeyByScope.get(scope);
+		const entry = key ? this.buf.reasoningParts.get(key) : void 0;
 		if (entry?.timing && typeof timestamp === "number" && Number.isFinite(timestamp)) entry.timing = {
 			...entry.timing,
 			completedAt: timestamp
 		};
-		this.activeReasoningKeyByScope.delete(scope);
+		this.buf.activeReasoningKeyByScope.delete(scope);
 		this.emit();
 	}
 };