@assistant-ui/react-ag-ui 0.0.53 → 0.0.56

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { AgUiInterrupt, AgUiInterruptReason, AgUiResumeEntry, AgUiRunFinishedOutcome, UseAgUiRuntimeAdapters, UseAgUiRuntimeOptions, UseAgUiThreadListAdapter } from "./runtime/types.js";
 import { useAgUiInterrupts, useAgUiSendA2uiAction, useAgUiSetState, useAgUiState, useAgUiSteerAway, useAgUiSubmitInterruptResponses } from "./hooks.js";
 import { AgUiAssistantRuntime, useAgUiRuntime } from "./useAgUiRuntime.js";
-import { FromAgUiMessagesOptions, fromAgUiMessages } from "./runtime/adapter/conversions.js";
-export { type AgUiAssistantRuntime, type AgUiInterrupt, type AgUiInterruptReason, type AgUiResumeEntry, type AgUiRunFinishedOutcome, type FromAgUiMessagesOptions, type UseAgUiRuntimeAdapters, type UseAgUiRuntimeOptions, type UseAgUiThreadListAdapter, fromAgUiMessages, useAgUiInterrupts, useAgUiRuntime, useAgUiSendA2uiAction, useAgUiSetState, useAgUiState, useAgUiSteerAway, useAgUiSubmitInterruptResponses };
+import { AgUiMessage, FromAgUiMessagesOptions, fromAgUiMessages, toAgUiMessages } from "./runtime/adapter/conversions.js";
+export { type AgUiAssistantRuntime, type AgUiInterrupt, type AgUiInterruptReason, type AgUiMessage, type AgUiResumeEntry, type AgUiRunFinishedOutcome, type FromAgUiMessagesOptions, type UseAgUiRuntimeAdapters, type UseAgUiRuntimeOptions, type UseAgUiThreadListAdapter, fromAgUiMessages, toAgUiMessages, useAgUiInterrupts, useAgUiRuntime, useAgUiSendA2uiAction, useAgUiSetState, useAgUiState, useAgUiSteerAway, useAgUiSubmitInterruptResponses };

package/dist/index.js

@@ -1,4 +1,4 @@
 import { useAgUiInterrupts, useAgUiSendA2uiAction, useAgUiSetState, useAgUiState, useAgUiSteerAway, useAgUiSubmitInterruptResponses } from "./hooks.js";
-import { fromAgUiMessages } from "./runtime/adapter/conversions.js";
+import { fromAgUiMessages, toAgUiMessages } from "./runtime/adapter/conversions.js";
 import { useAgUiRuntime } from "./useAgUiRuntime.js";
-export { fromAgUiMessages, useAgUiInterrupts, useAgUiRuntime, useAgUiSendA2uiAction, useAgUiSetState, useAgUiState, useAgUiSteerAway, useAgUiSubmitInterruptResponses };
+export { fromAgUiMessages, toAgUiMessages, useAgUiInterrupts, useAgUiRuntime, useAgUiSendA2uiAction, useAgUiSetState, useAgUiState, useAgUiSteerAway, useAgUiSubmitInterruptResponses };

package/dist/runtime/AgUiThreadRuntimeCore.d.ts

@@ -1,6 +1,6 @@
 import { Logger } from "./logger.js";
 import { AgUiInterrupt, AgUiResumeEntry } from "./types.js";
-import { AddToolResultOptions, AppendMessage, AssistantRuntime, ChatModelRunOptions, ChatModelRunResult, CreateAppendMessage, ExportedMessageRepository, ThreadHistoryAdapter, ThreadMessage } from "@assistant-ui/core";
+import { AddToolResultOptions, AppendMessage, AssistantRuntime, ChatModelRunOptions, ChatModelRunResult, CreateAppendMessage, ExportedMessageRepository, RespondToToolApprovalOptions, ThreadHistoryAdapter, ThreadMessage } from "@assistant-ui/core";
 import { AbstractAgent } from "@ag-ui/client";
 import { ReadonlyJSONValue } from "assistant-stream/utils";
 //#region src/runtime/AgUiThreadRuntimeCore.d.ts
@@ -30,6 +30,7 @@ declare class AgUiThreadRuntimeCore {
   private onError;
   private onCancel;
   private readonly notifyUpdate;
+  private readonly reportedErrors;
   private runtime;
   private readonly repository;
   private exportedRepository;
@@ -41,7 +42,9 @@ declare class AgUiThreadRuntimeCore {
   private history;
   private lastRunConfig;
   private readonly assistantHistoryParents;
-  private readonly recordedHistoryIds;
+  private readonly snapshotHistoryIds;
+  private readonly persistedHistoryIds;
+  private readonly historyWrites;
   private _isLoading;
   private _loadPromise;
   private pendingResumeMessageId;
@@ -88,6 +91,23 @@ declare class AgUiThreadRuntimeCore {
     toolCallIds: string[];
   } | null;
   submitInterruptResponses(responses: readonly AgUiResumeEntry[]): Promise<void>;
+  /**
+   * Resumes with an already validated resume array. Answerability is checked
+   * once per submission: re-checking here would let a clock crossing reject a
+   * decision this runtime has already recorded, stranding the gate decided and
+   * unretryable.
+   */
+  private resumeWithResponses;
+  /**
+   * The core seams that reach `respondToToolApproval` discard the promise they
+   * receive, so a rejected decision would otherwise surface only as an
+   * unhandled rejection. A failure raised by the resumed run itself was already
+   * reported by `startRun` before it rethrew, so reporting it here again would
+   * give the consumer two notifications for one failure.
+   */
+  reportError(error: unknown): void;
+  private assertInterruptsAnswerable;
+  respondToToolApproval(options: RespondToToolApprovalOptions): Promise<void>;
   steerAway(message: CreateAppendMessage, responses?: readonly AgUiResumeEntry[]): Promise<void>;
   private resolveSteerAwayResume;
   private collectInterruptResponses;
@@ -127,6 +147,7 @@ declare class AgUiThreadRuntimeCore {
   private markPendingAssistantHistory;
   private persistAssistantHistory;
   private appendHistoryItem;
+  private chainHistoryWrite;
 }
 //#endregion
 export { AgUiThreadRuntimeCore };

package/dist/runtime/AgUiThreadRuntimeCore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AgUiThreadRuntimeCore.d.ts","names":[],"sources":["../../src/runtime/AgUiThreadRuntimeCore.ts"],"mappings":";;;;;;KAoEK,YAAY,YAAY;KACxB,gBACH,SAAS,wBACN,eAAe;KACf;EACH;EACA;EACA,WAAW;EACX,SAAS;;KAGN;EACH,OAAO;EACP,QAAQ;EACR;EACA;EACA,WAAW,OAAO;EAClB;EACA,UAAU;EACV;;cAmCW;UACH;UACA;UACA;UACA;UACA;UACA;mBACS;UAET;mBACS;UACT;UACA;UACA;UAGA;UACA;UACA;UACA;UACA;mBACS;mBACA;UACT;UACA;UACA;UACA;UACA;EAEI,YAAA,SAAS;EAYrB,cAAc,SAAS,KAAK;EAW5B,cAAc,SAAS;EAIvB;EAIA,wBAAwB;EAIxB,wBAAwB;UAmBhB;UAQA;UAUA;UAIA;UAQA;UAQA;UAMA;UAKA;UAKA;UAKA;EAYR,YAAY;EAIZ;MAII;EAIJ,mBAAmB;EA6Cb,OAAO,SAAS,gBAAgB;UAW9B;UAQA;EAiBF,KAAK,SAAS,gBAAgB;EAI9B,OACJ,yBACA;IAAU,YAAY;MACrB;EAMG,UAAU;EAcV,OAAO,QAAQ,kBAAkB;EAUjC,kBAAkB,mBAAmB,kBAAkB;UAwBrD;UAOA;EAgBR;IACE;IACA,qBAAqB;;EAavB;IACE;IACA;;EAcI,yBACJ,oBAAoB,oBACnB;EAoDG,UACJ,SAAS,qBACT,qBAAqB,oBACpB;UAyCK;UAkBA;UAiCA;UA0BA;EA+BR,yBAAyB;UAkBjB;EAiBR,cAAc,SAAS;EAyBvB,eAAe,QAAQ;UA4Bf;UAYA;UA6BA;EAUR,sBAAsB,mBAAmB;UAkDjC;EAgER,kBAAkB,OAAO;EAKzB,SACE,MACI,sBACE,MAAM,kCAAkC;EAOhD;UAKc;UAuMA;UA2DN;UAkCA;UAqBA;UAKA;UAQA;UAyBA;UA2CA;UAiDA;UA4BA;UA6BA;UAgEA;UA2EA;UA8DA;UAgDA;UAQA;UAIA;UAKA;UAIA;UAQA;UAWA"}
+{"version":3,"file":"AgUiThreadRuntimeCore.d.ts","names":[],"sources":["../../src/runtime/AgUiThreadRuntimeCore.ts"],"mappings":";;;;;;KA2EK,YAAY,YAAY;KACxB,gBACH,SAAS,wBACN,eAAe;KACf;EACH;EACA;EACA,WAAW;EACX,SAAS;;KAGN;EACH,OAAO;EACP,QAAQ;EACR;EACA;EACA,WAAW,OAAO;EAClB;EACA,UAAU;EACV;;cAuDW;UACH;UACA;UACA;UACA;UACA;UACA;mBACS;mBACA;UAET;mBACS;UACT;UACA;UACA;UAGA;UACA;UACA;UACA;UACA;mBACS;mBACA;mBACA;mBACA;UACT;UACA;UACA;UACA;UACA;EAEI,YAAA,SAAS;EAYrB,cAAc,SAAS,KAAK;EAW5B,cAAc,SAAS;EAIvB;EAOA,wBAAwB;EAIxB,wBAAwB;UAmBhB;UAQA;UAUA;UAIA;UAQA;UAQA;UAMA;UAKA;UAKA;UAKA;EAYR,YAAY;EAIZ;MAII;EAIJ,mBAAmB;EA6Cb,OAAO,SAAS,gBAAgB;UAW9B;UAQA;EAiBF,KAAK,SAAS,gBAAgB;EAI9B,OACJ,yBACA;IAAU,YAAY;MACrB;EAMG,UAAU;EAcV,OAAO,QAAQ,kBAAkB;EAUjC,kBAAkB,mBAAmB,kBAAkB;UAwBrD;UAOA;EAgBR;IACE;IACA,qBAAqB;;EAavB;IACE;IACA;;EAcI,yBACJ,oBAAoB,oBACnB;;;;;;;UAuCW;;;;;;;;EAed,YAAY;UAYJ;EAwBF,sBACJ,SAAS,+BACR;EAoEG,UACJ,SAAS,qBACT,qBAAqB,oBACpB;UAyCK;UAkBA;UAiCA;UA0BA;EAmCR,yBAAyB;UAkBjB;EAiBR,cAAc,SAAS;EAyBvB,eAAe,QAAQ;UA4Bf;UAYA;UA6BA;EAUR,sBAAsB,mBAAmB;UAkDjC;EAiER,kBAAkB,OAAO;EAKzB,SACE,MACI,sBACE,MAAM,kCAAkC;EAOhD;UAKc;UAoOA;UA2DN;UAkCA;UAqBA;UAKA;UAQA;UAyBA;UAkEA;UAiDA;UA4BA;UA6BA;UAgEA;UA2EA;UA8DA;UAuDA;UAQA;UAIA;UAKA;UAMA;UAQA;UAsDA;UAqBA"}

package/dist/runtime/AgUiThreadRuntimeCore.js

@@ -1,5 +1,6 @@
 "use client";
 import { readMcpAppResourceUri } from "./mcp-tool-result.js";
+import { buildToolApprovalResume, projectAgUiToolApprovals, withSettledToolApprovals, withToolApprovalDecision } from "./adapter/tool-approval.js";
 import { AG_UI_METADATA_NAMESPACE, RunAggregator, isPlainObject, tryParseJSON } from "./adapter/run-aggregator.js";
 import { fromAgUiMessages, toAgUiMessages, toAgUiTools } from "./adapter/conversions.js";
 import { createAgUiSubscriber } from "./adapter/subscriber.js";
@@ -30,6 +31,19 @@ const invokeRuntimeCallback = (name, callback, ...args) => {
 		reportCallbackError(name, error);
 	}
 };
+const mergeAgUiNamespace = (current, incoming) => {
+	const merged = {
+		...current,
+		...incoming
+	};
+	const currentNs = current?.[AG_UI_METADATA_NAMESPACE];
+	const incomingNs = incoming[AG_UI_METADATA_NAMESPACE];
+	if (typeof currentNs === "object" && currentNs !== null && typeof incomingNs === "object" && incomingNs !== null) merged[AG_UI_METADATA_NAMESPACE] = {
+		...currentNs,
+		...incomingNs
+	};
+	return merged;
+};
 var AgUiThreadRuntimeCore = class {
 	agent;
 	logger;
@@ -38,6 +52,7 @@ var AgUiThreadRuntimeCore = class {
 	onError;
 	onCancel;
 	notifyUpdate;
+	reportedErrors = /* @__PURE__ */ new WeakSet();
 	runtime;
 	repository = new MessageRepository();
 	exportedRepository;
@@ -49,7 +64,9 @@ var AgUiThreadRuntimeCore = class {
 	history;
 	lastRunConfig;
 	assistantHistoryParents = /* @__PURE__ */ new Map();
-	recordedHistoryIds = /* @__PURE__ */ new Set();
+	snapshotHistoryIds = /* @__PURE__ */ new Set();
+	persistedHistoryIds = /* @__PURE__ */ new Set();
+	historyWrites = /* @__PURE__ */ new Map();
 	_isLoading = false;
 	_loadPromise;
 	pendingResumeMessageId = null;
@@ -81,6 +98,9 @@ var AgUiThreadRuntimeCore = class {
 	}
 	detachRuntime() {
 		this.runtime = void 0;
+		this.cancel().catch((error) => {
+			this.logger.error("[agui] failed to cancel run during teardown", error);
+		});
 	}
 	getMessages() {
 		return this.repository.getMessages();
@@ -285,17 +305,65 @@ 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);
+		await this.resumeWithResponses(pending.messageId, openIds.map((id) => responsesById.get(id)));
+	}
+	/**
+	* Resumes with an already validated resume array. Answerability is checked
+	* once per submission: re-checking here would let a clock crossing reject a
+	* decision this runtime has already recorded, stranding the gate decided and
+	* unretryable.
+	*/
+	async resumeWithResponses(messageId, resume) {
+		this.clearPendingInterrupts(messageId, resume);
+		await this.startRun(messageId, this.lastRunConfig, resume);
+	}
+	/**
+	* The core seams that reach `respondToToolApproval` discard the promise they
+	* receive, so a rejected decision would otherwise surface only as an
+	* unhandled rejection. A failure raised by the resumed run itself was already
+	* reported by `startRun` before it rethrew, so reporting it here again would
+	* give the consumer two notifications for one failure.
+	*/
+	reportError(error) {
+		if (this.reportedErrors.has(error)) {
+			this.reportedErrors.delete(error);
+			return;
+		}
+		invokeRuntimeCallback("onError", this.onError, error instanceof Error ? error : new Error(String(error)));
+	}
+	assertInterruptsAnswerable(method, interrupts) {
 		const now = Date.now();
-		for (const interrupt of pending.interrupts) {
+		for (const interrupt of interrupts) {
 			if (!interrupt.expiresAt) continue;
 			const expiry = new Date(interrupt.expiresAt).getTime();
-			if (Number.isNaN(expiry)) throw new Error(`[agui] submitInterruptResponses: interrupt ${interrupt.id} has malformed expiresAt "${interrupt.expiresAt}"`);
-			if (expiry <= now) throw new Error(`[agui] submitInterruptResponses: interrupt ${interrupt.id} expired at ${interrupt.expiresAt}`);
+			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}`);
 		}
-		const resume = openIds.map((id) => responsesById.get(id));
-		if (this.isRunningFlag) throw new Error("[agui] submitInterruptResponses: a run is already in progress");
-		this.clearPendingInterrupts(pending.messageId);
-		await this.startRun(pending.messageId, this.lastRunConfig, resume);
+		if (this.isRunningFlag) throw new Error(`[agui] ${method}: a run is already in progress`);
+	}
+	async respondToToolApproval(options) {
+		const pending = this.getPendingInterrupts();
+		if (!pending) throw new Error("[agui] respondToToolApproval: no pending interrupts on this thread");
+		const gatedMessage = this.tryGetMessage(pending.messageId)?.message;
+		if (![...projectAgUiToolApprovals(pending.interrupts, new Set((gatedMessage?.content ?? []).filter((part) => part.type === "tool-call").map((part) => part.toolCallId))).values()].some((approval) => approval.id === options.approvalId)) throw new Error(`[agui] respondToToolApproval: no pending tool-call interrupt for approval id "${options.approvalId}"`);
+		this.assertInterruptsAnswerable("respondToToolApproval", pending.interrupts);
+		if (!this.updateMessage(pending.messageId, (message) => {
+			if (message.role !== "assistant") return message;
+			const assistant = message;
+			const content = withToolApprovalDecision(assistant.content, options);
+			if (content === assistant.content) return assistant;
+			return {
+				...assistant,
+				content
+			};
+		})) throw new Error(`[agui] respondToToolApproval: approval "${options.approvalId}" is already decided`);
+		this.notifyUpdate();
+		const assistant = this.tryGetMessage(pending.messageId)?.message;
+		if (!assistant) return;
+		const resume = buildToolApprovalResume(assistant.content, pending.interrupts);
+		if (!resume) return;
+		await this.resumeWithResponses(pending.messageId, resume);
 	}
 	async steerAway(message, responses) {
 		const pending = this.getPendingInterrupts();
@@ -318,7 +386,7 @@ var AgUiThreadRuntimeCore = class {
 		const resume = this.resolveSteerAwayResume(pending.interrupts, responses);
 		if (this.isRunningFlag) throw new Error("[agui] steerAway: a run is already in progress");
 		const normalized = this.toAppendMessage(message);
-		this.clearPendingInterrupts(pending.messageId);
+		this.clearPendingInterrupts(pending.messageId, resume);
 		const threadMessageId = this.appendEntry(normalized);
 		await this.startRun(threadMessageId, normalized.runConfig, resume);
 	}
@@ -367,7 +435,7 @@ var AgUiThreadRuntimeCore = class {
 			startRun: message.startRun
 		};
 	}
-	clearPendingInterrupts(messageId) {
+	clearPendingInterrupts(messageId, resume) {
 		if (this.updateMessage(messageId, (message) => {
 			if (message.role !== "assistant") return message;
 			const assistant = message;
@@ -378,6 +446,7 @@ var AgUiThreadRuntimeCore = class {
 			else delete newCustom["agui"];
 			return {
 				...assistant,
+				content: withSettledToolApprovals(assistant.content, resume),
 				status: {
 					type: "complete",
 					reason: "unknown"
@@ -530,8 +599,8 @@ var AgUiThreadRuntimeCore = class {
 			}
 			this.resetRepositoryHead(lastAppliedId);
 		}
-		this.recordedHistoryIds.clear();
-		for (const { message } of this.getMessageRepository().messages) this.recordedHistoryIds.add(message.id);
+		this.snapshotHistoryIds.clear();
+		for (const { message } of this.getMessageRepository().messages) this.snapshotHistoryIds.add(message.id);
 		this.notifyUpdate();
 	}
 	applyExternalMessageRepository(loaded) {
@@ -580,8 +649,9 @@ var AgUiThreadRuntimeCore = class {
 			this.resetRepositoryHead(previousId);
 		} else this.resetRepositoryHead(headId);
 		this.assistantHistoryParents.clear();
-		this.recordedHistoryIds.clear();
-		for (const { message } of loaded.messages) this.recordedHistoryIds.add(message.id);
+		this.snapshotHistoryIds.clear();
+		this.persistedHistoryIds.clear();
+		for (const { message } of loaded.messages) this.persistedHistoryIds.add(message.id);
 		this.notifyUpdate();
 	}
 	loadExternalState(state) {
@@ -602,6 +672,7 @@ var AgUiThreadRuntimeCore = class {
 		const parent = parentId === null ? void 0 : this.tryGetMessage(parentId);
 		const shouldEagerlyInsertAssistant = parentId !== null && parent !== void 0 && parentId !== this.repository.headId;
 		const historicalMessages = [...shouldEagerlyInsertAssistant ? this.tryGetMessages(parentId) ?? this.repository.getMessages() : this.repository.getMessages()];
+		const runStartMessageIds = new Set(this.getMessageRepository().messages.map(({ message }) => message.id));
 		this.pendingError = null;
 		const assistantParentId = parent ? parentId : this.repository.headId;
 		let assistantMessageId;
@@ -610,7 +681,8 @@ var AgUiThreadRuntimeCore = class {
 			const cached = assistantMessageId;
 			if (cached !== void 0 && this.tryGetMessage(cached)) return cached;
 			if (cached !== void 0 && (assistantCollided || !allowRecreate)) return cached;
-			const parentId = cached === void 0 && assistantParentId && this.hasMessage(assistantParentId) ? assistantParentId : this.repository.headId;
+			const repositoryHeadId = this.repository.headId;
+			const parentId = (cached === void 0 || shouldEagerlyInsertAssistant && (repositoryHeadId === null || runStartMessageIds.has(repositoryHeadId))) && assistantParentId && this.hasMessage(assistantParentId) ? assistantParentId : repositoryHeadId;
 			const created = this.insertAssistantPlaceholder(parentId, cached);
 			assistantMessageId = created;
 			this.markPendingAssistantHistory(created, parentId);
@@ -618,8 +690,8 @@ var AgUiThreadRuntimeCore = class {
 		};
 		if (shouldEagerlyInsertAssistant) ensureAssistant();
 		const applyUpdate = (update) => {
-			const hasContent = Array.isArray(update.content) && update.content.length > 0;
-			const resolved = this.updateAssistantMessage(ensureAssistant(hasContent), update);
+			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;
 		};
 		const aggregator = new RunAggregator({
@@ -629,8 +701,15 @@ var AgUiThreadRuntimeCore = class {
 			onServerMessageId: (serverId) => {
 				const placeholder = ensureAssistant(true);
 				if (placeholder === serverId) return;
-				if (this.reassignAssistantId(placeholder, serverId)) assistantMessageId = serverId;
-				else assistantCollided = true;
+				const reassigned = this.reassignAssistantId(placeholder, serverId);
+				const adoptsVisibleCollision = !reassigned && !runStartMessageIds.has(serverId) && this.repository.headId === serverId;
+				if (reassigned || adoptsVisibleCollision) {
+					assistantMessageId = serverId;
+					if (adoptsVisibleCollision) {
+						const parentId = this.tryGetMessage(serverId)?.parentId ?? null;
+						this.markPendingAssistantHistory(serverId, parentId);
+					}
+				} else assistantCollided = true;
 			}
 		});
 		const dispatch = (event) => this.handleEvent(aggregator, event, assistantMessageId);
@@ -701,6 +780,7 @@ var AgUiThreadRuntimeCore = class {
 		}
 		if (this.pendingError) {
 			const err = this.pendingError;
+			this.reportedErrors.add(err);
 			this.pendingError = null;
 			this.pendingResumeMessageId = null;
 			this.pendingA2uiResume = false;
@@ -872,9 +952,24 @@ var AgUiThreadRuntimeCore = class {
 			this.assistantHistoryParents.delete(oldId);
 			if (!collidesWithExisting && !this.assistantHistoryParents.has(newId)) this.assistantHistoryParents.set(newId, pendingParent);
 		}
-		if (this.recordedHistoryIds.has(oldId)) {
-			this.recordedHistoryIds.delete(oldId);
-			if (!collidesWithExisting) this.recordedHistoryIds.add(newId);
+		for (const ids of [this.snapshotHistoryIds, this.persistedHistoryIds]) if (ids.has(oldId)) {
+			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);
+			}
 		}
 		this.notifyUpdate();
 		return !collidesWithExisting;
@@ -934,10 +1029,7 @@ var AgUiThreadRuntimeCore = class {
 			steps,
 			...current.isOptimistic ? { isOptimistic: true } : {},
 			...incoming.timing ? { timing: incoming.timing } : {},
-			custom: incoming.custom ? {
-				...current.custom,
-				...incoming.custom
-			} : current.custom
+			custom: incoming.custom ? mergeAgUiNamespace(current.custom, incoming.custom) : current.custom
 		};
 	}
 	handleEvent(aggregator, event, activeAssistantId) {
@@ -1074,14 +1166,16 @@ var AgUiThreadRuntimeCore = class {
 			} catch (error) {
 				this.logger.error?.("[agui] failed to import message from snapshot", error);
 			}
-			const snapshotHeadId = converted.at(-1)?.id ?? null;
 			const snapshotContainsActiveAssistant = converted.some((message) => message.id === activeAssistant?.id);
 			const preservesActiveAssistant = activeAssistant !== void 0 && !snapshotContainsActiveAssistant && (activeAssistant.metadata.isOptimistic !== true || converted.at(-1)?.role !== "assistant");
 			if (preservesActiveAssistant) converted.push(activeAssistant);
 			this.applyExternalMessages(converted);
-			if (preservesActiveAssistant) {
-				this.recordedHistoryIds.delete(activeAssistant.id);
-				this.markPendingAssistantHistory(activeAssistant.id, snapshotHeadId);
+			if (activeAssistant !== void 0) {
+				const activeItem = this.tryGetMessage(activeAssistant.id);
+				if (activeItem) {
+					if (preservesActiveAssistant) this.snapshotHistoryIds.delete(activeAssistant.id);
+					this.markPendingAssistantHistory(activeAssistant.id, activeItem.parentId);
+				}
 			}
 		} catch (error) {
 			this.logger.error?.("[agui] failed to import messages snapshot", error);
@@ -1098,32 +1192,82 @@ var AgUiThreadRuntimeCore = class {
 		return status?.type === "requires-action" && status.reason === "interrupt";
 	}
 	recordHistoryEntry(parentId, message) {
-		this.appendHistoryItem(parentId, message);
+		this.appendHistoryItem(parentId, message)?.catch((error) => {
+			this.logger.error?.("[agui] failed to append history entry", error);
+		});
 	}
 	markPendingAssistantHistory(messageId, parentId) {
 		if (!this.history) return;
 		this.assistantHistoryParents.set(messageId, parentId);
 	}
 	persistAssistantHistory(messageId) {
-		if (!this.history) return;
+		const history = this.history;
+		if (!history) return;
 		const parentId = this.assistantHistoryParents.get(messageId);
 		if (parentId === void 0) return;
 		const message = this.tryGetMessage(messageId)?.message;
 		if (!message || message.role !== "assistant") return;
 		if (!this.isPersistableStatus(message.status)) return;
+		const wasPersisted = this.persistedHistoryIds.has(messageId);
+		const update = history.update;
+		if (update !== void 0 && (wasPersisted || this.snapshotHistoryIds.has(messageId))) {
+			const write = this.chainHistoryWrite(messageId, () => update.call(history, {
+				parentId,
+				message
+			}));
+			this.assistantHistoryParents.delete(messageId);
+			write.then(() => {
+				this.persistedHistoryIds.add(messageId);
+			}, (error) => {
+				const pending = this.historyWrites.get(messageId);
+				if (pending === void 0 || pending === write) this.assistantHistoryParents.set(messageId, parentId);
+				this.logger.error?.("[agui] failed to update history entry", error);
+			});
+			return;
+		}
+		if (wasPersisted) {
+			this.assistantHistoryParents.delete(messageId);
+			return;
+		}
+		const write = this.appendHistoryItem(parentId, message);
+		if (!write) return;
 		this.assistantHistoryParents.delete(messageId);
-		this.appendHistoryItem(parentId, message);
+		write.then(() => {}, (error) => {
+			const pending = this.historyWrites.get(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.recordedHistoryIds.has(message.id)) return;
-		this.recordedHistoryIds.add(message.id);
-		this.history.append({
+		if (!this.history || this.persistedHistoryIds.has(message.id)) return;
+		const pending = this.historyWrites.get(message.id);
+		if (pending) return pending;
+		const append = this.history.append.bind(this.history);
+		const write = this.chainHistoryWrite(message.id, () => append({
 			parentId,
 			message
-		}).catch((error) => {
-			this.recordedHistoryIds.delete(message.id);
-			this.logger.error?.("[agui] failed to append history entry", error);
+		}));
+		write.then(() => {
+			this.persistedHistoryIds.add(message.id);
+		}, () => {});
+		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