@assistant-ui/react-ag-ui 0.0.58 → 0.0.60

package/dist/agUiExtras.d.ts

@@ -1,6 +1,5 @@
 import { AgUiRuntimeExtras } from "./runtime/types.js";
 //#region src/agUiExtras.d.ts
-declare const agUiExtras: import("@assistant-ui/core/react").RuntimeExtras<AgUiRuntimeExtras>;
+export declare const agUiExtras: import("@assistant-ui/core/react").RuntimeExtras<AgUiRuntimeExtras>;
 //#endregion
-export { agUiExtras };
 //# sourceMappingURL=agUiExtras.d.ts.map

package/dist/agUiExtras.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agUiExtras.d.ts","names":[],"sources":["../src/agUiExtras.ts"],"mappings":";;cAGa,+CAAU,cAAA"}
+{"version":3,"file":"agUiExtras.d.ts","names":[],"sources":["../src/agUiExtras.ts"],"mappings":";;qBAGa,+CAAU,cAAA"}

package/dist/hooks.d.ts

@@ -6,17 +6,17 @@ import { ReadonlyJSONValue } from "assistant-stream/utils";
  * Read the pending AG-UI interrupts on the current thread. Returns an empty
  * array when no interrupts are pending, so consumers can `.map` without a guard.
  */
-declare const useAgUiInterrupts: () => readonly AgUiInterrupt[];
+export declare const useAgUiInterrupts: () => readonly AgUiInterrupt[];
 /**
  * Returns a stable function that sends an A2UI action back to the agent and
  * resumes the run.
  */
-declare const useAgUiSendA2uiAction: () => (action: Record<string, unknown>) => void;
+export declare const useAgUiSendA2uiAction: () => (action: Record<string, unknown>) => void;
 /**
  * Returns a function that submits responses (each `resolved` or `cancelled`)
  * for the pending AG-UI interrupts and resumes the run.
  */
-declare const useAgUiSubmitInterruptResponses: () => (responses: readonly AgUiResumeEntry[]) => Promise<void>;
+export declare const useAgUiSubmitInterruptResponses: () => (responses: readonly AgUiResumeEntry[]) => Promise<void>;
 /**
  * Returns a function that discards the pending AG-UI interrupts or pending
  * client-side tool calls and appends the given user message, starting a fresh
@@ -30,9 +30,8 @@ declare const useAgUiSubmitInterruptResponses: () => (responses: readonly AgUiRe
  * `autoCancelPendingToolCalls` runtime option, this hook cancels regardless
  * of that option's value.
  */
-declare const useAgUiSteerAway: () => (message: CreateAppendMessage, responses?: readonly AgUiResumeEntry[]) => Promise<void>;
-declare const useAgUiState: <TState = ReadonlyJSONValue>() => TState | undefined;
-declare const useAgUiSetState: <TState = ReadonlyJSONValue>() => (next: TState | ((prev: TState | undefined) => TState)) => void;
+export declare const useAgUiSteerAway: () => (message: CreateAppendMessage, responses?: readonly AgUiResumeEntry[]) => Promise<void>;
+export declare const useAgUiState: <TState = ReadonlyJSONValue>() => TState | undefined;
+export declare const useAgUiSetState: <TState = ReadonlyJSONValue>() => (next: TState | ((prev: TState | undefined) => TState)) => void;
 //#endregion
-export { useAgUiInterrupts, useAgUiSendA2uiAction, useAgUiSetState, useAgUiState, useAgUiSteerAway, useAgUiSubmitInterruptResponses };
 //# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hooks.d.ts","names":[],"sources":["../src/hooks.ts"],"mappings":";;;;;;;;cAea,kCAAiC;;;;;cAOjC,8BAAqB,QAGrB;;;;;cAUA,wCAEH,oBAAoB,sBAAoB;;;;;;;;;;;;;;cAiBrC,yBAGT,SAAS,qBACT,qBAAqB,sBACpB;cAGQ,eAAgB,SAAS,wBAClC;cAIS,kBAAmB,SAAS,yBAE/B,MAAM,WAAW,MAAM,uBAAuB"}
+{"version":3,"file":"hooks.d.ts","names":[],"sources":["../src/hooks.ts"],"mappings":";;;;;;;;qBAea,kCAAiC;;;;;qBAOjC,8BAAqB,QAGrB;;;;;qBAUA,wCAEH,oBAAoB,sBAAoB;;;;;;;;;;;;;;qBAiBrC,yBAGT,SAAS,qBACT,qBAAqB,sBACpB;qBAGQ,eAAgB,SAAS,wBAClC;qBAIS,kBAAmB,SAAS,yBAE/B,MAAM,WAAW,MAAM,uBAAuB"}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { AgUiInterrupt, AgUiInterruptReason, AgUiResumeEntry, AgUiRunFinishedOutcome, UseAgUiRuntimeAdapters, UseAgUiRuntimeOptions, UseAgUiThreadListAdapter } from "./runtime/types.js";
+import { AgUiInterrupt, AgUiInterruptReason, AgUiResumeEntry, AgUiResumeTranscript, 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 { 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 };
+export { type AgUiAssistantRuntime, type AgUiInterrupt, type AgUiInterruptReason, type AgUiMessage, type AgUiResumeEntry, type AgUiResumeTranscript, type AgUiRunFinishedOutcome, type FromAgUiMessagesOptions, type UseAgUiRuntimeAdapters, type UseAgUiRuntimeOptions, type UseAgUiThreadListAdapter, fromAgUiMessages, toAgUiMessages, useAgUiInterrupts, useAgUiRuntime, useAgUiSendA2uiAction, useAgUiSetState, useAgUiState, useAgUiSteerAway, useAgUiSubmitInterruptResponses };

package/dist/runtime/AgUiThreadRuntimeCore.d.ts

@@ -1,5 +1,5 @@
 import { Logger } from "./logger.js";
-import { AgUiInterrupt, AgUiResumeEntry } from "./types.js";
+import { AgUiInterrupt, AgUiResumeEntry, AgUiResumeTranscript } from "./types.js";
 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";
@@ -16,16 +16,18 @@ type CoreOptions = {
   agent: AbstractAgent;
   logger: Logger;
   showThinking: boolean;
+  resumeTranscript?: AgUiResumeTranscript | undefined;
   autoCancelPendingToolCalls?: boolean | undefined;
   onError?: (error: Error) => void;
   onCancel?: () => void;
   history?: ThreadHistoryAdapter;
   notifyUpdate: () => void;
 };
-declare class AgUiThreadRuntimeCore {
+export declare class AgUiThreadRuntimeCore {
   private agent;
   private logger;
   private showThinking;
+  private resumeTranscript;
   private autoCancelPendingToolCalls;
   private onError;
   private onCancel;
@@ -37,7 +39,6 @@ declare class AgUiThreadRuntimeCore {
   private abortController;
   private activeRunAgent;
   private stateSnapshot;
-  private pendingError;
   private history;
   private lastRunConfig;
   private readonly assistantHistoryParents;
@@ -47,8 +48,8 @@ declare class AgUiThreadRuntimeCore {
   private _isLoading;
   private _loadPromise;
   private _loadRequested;
-  private pendingResumeMessageId;
-  private pendingA2uiResume;
+  private pendingResume;
+  private pendingA2uiResumeOwner;
   private pendingA2uiAction;
   constructor(options: CoreOptions);
   updateOptions(options: Omit<CoreOptions, "notifyUpdate">): void;
@@ -68,6 +69,8 @@ declare class AgUiThreadRuntimeCore {
     runConfig?: RunConfig;
   }): Promise<void>;
   cancel(): Promise<void>;
+  private abortActiveRun;
+  private supersedeActiveRun;
   resume(config: ResumeRunConfig): Promise<void>;
   resumeInFlightRun(messages: readonly ThreadMessage[]): Promise<void>;
   private assertNoPendingInterrupts;
@@ -117,6 +120,15 @@ declare class AgUiThreadRuntimeCore {
   private startRun;
   private consumeResumeStream;
   private buildRunInput;
+  /**
+   * An anchor the thread no longer carries falls back to the whole transcript.
+   * The anchor is missing exactly when a snapshot import replaced the messages
+   * this resume was raised against, and a host that expects a delta tolerates
+   * being told more than it knows, while one rebuilding the run from the
+   * transcript cannot recover from being told less.
+   */
+  private selectRunMessages;
+  private clearDeferredContinuations;
   private setRunning;
   private finishRun;
   private insertAssistantPlaceholder;
@@ -138,5 +150,4 @@ declare class AgUiThreadRuntimeCore {
   private chainHistoryWrite;
 }
 //#endregion
-export { AgUiThreadRuntimeCore };
 //# sourceMappingURL=AgUiThreadRuntimeCore.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"AgUiThreadRuntimeCore.d.ts","names":[],"sources":["../../src/runtime/AgUiThreadRuntimeCore.ts"],"mappings":";;;;;;KA8EK,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;;cAoCW;UACH;UACA;UACA;UACA;UACA;UACA;mBACS;mBACA;UAET;mBACS;UAgBT;UACA;UAGA;UACA;UACA;UACA;UACA;mBACS;mBACA;mBACA;mBACA;UACT;UACA;UACA;UACA;UACA;UACA;EAEI,YAAA,SAAS;EAWrB,cAAc,SAAS,KAAK;EAoB5B,cAAc,SAAS;EAIvB;EAOA,wBAAwB;EAIxB,wBAAwB;EAIxB,YAAY;EAIZ;MAII;EAIJ,mBAAmB;EAsDb,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;;EAaI,yBACJ,oBAAoB,oBACnB;;;;;;;UAuCW;;;;;;;;EAed,YAAY;UAYJ;EAwBF,sBACJ,SAAS,+BACR;EAsEG,UACJ,SAAS,qBACT,qBAAqB,oBACpB;UAyCK;UAkBA;UAiCA;UA0BA;EAmCR,yBAAyB;UAiBjB;EAiBR,cAAc,SAAS;EA+BvB,eAAe,QAAQ;UA4Bf;UAYA;UAiCA;EAUR,sBAAsB,mBAAmB;EAkDzC,kBAAkB,OAAO;EAKzB,SACE,MACI,sBACE,MAAM,kCAAkC;EAOhD;UAKc;UAyPA;UA2DN;UAkCA;UAKA;UAQA;UAyBA;UAkEA;UAiDA;UA0BA;UA6BA;UAgEA;UA0EA;UA6DA;UAuDA;UAQA;UAIA;UAKA;UAMA;UAQA;UAsDA;UAqBA"}
+{"version":3,"file":"AgUiThreadRuntimeCore.d.ts","names":[],"sources":["../../src/runtime/AgUiThreadRuntimeCore.ts"],"mappings":";;;;;;KAmFK,YAAY,YAAY;KACxB,gBACH,SAAS,wBACN,eAAe;KACf;EACH;EACA;EACA,WAAW;EACX,SAAS;;KAaN;EACH,OAAO;EACP,QAAQ;EACR;EACA,mBAAmB;EACnB;EACA,WAAW,OAAO;EAClB;EACA,UAAU;EACV;;qBAoCW;UACH;UACA;UACA;UACA;UACA;UACA;UACA;mBACS;mBACA;UAET;mBACS;UAgBT;UACA;UAGA;UACA;UACA;UACA;mBACS;mBACA;mBACA;mBACA;UACT;UACA;UACA;UACA;UAEA;UACA;EAEI,YAAA,SAAS;EAYrB,cAAc,SAAS,KAAK;EAqB5B,cAAc,SAAS;EAIvB;EAOA,wBAAwB;EAIxB,wBAAwB;EAIxB,YAAY;EAIZ;MAII;EAIJ,mBAAmB;EAsDb,OAAO,SAAS,gBAAgB;UAgB9B;UAQA;EAiBF,KAAK,SAAS,gBAAgB;EAI9B,OACJ,yBACA;IAAU,YAAY;MACrB;EAMG,UAAU;UAWR;UAiBA;EAaF,OAAO,QAAQ,kBAAkB;EAUjC,kBAAkB,mBAAmB,kBAAkB;UAwBrD;UAOA;EAgBR;IACE;IACA,qBAAqB;;EAavB;IACE;IACA;;EAaI,yBACJ,oBAAoB,oBACnB;;;;;;;UAuCW;;;;;;;;EAkBd,YAAY;UAYJ;EAwBF,sBACJ,SAAS,+BACR;EAsEG,UACJ,SAAS,qBACT,qBAAqB,oBACpB;UA4CK;UAkBA;UAiCA;UA2BA;EAmCR,yBAAyB;UAiBjB;EAiBR,cAAc,SAAS;EAqCvB,eAAe,QAAQ;UA6Bf;UAaA;UAiCA;EAUR,sBAAsB,mBAAmB;EA6DzC,kBAAkB,OAAO;EAKzB,SACE,MACI,sBACE,MAAM,kCAAkC;EAOhD;UAKc;UA0PA;UA2DN;;;;;;;;UA4CA;UAaA;UAUA;UAKA;UAOA;UAyBA;UAkEA;UAiDA;UA6BA;UA6BA;UAgEA;UA0EA;UA6DA;UAuDA;UAQA;UAIA;UAKA;UAMA;UAQA;UAsDA;UAqBA"}

package/dist/runtime/AgUiThreadRuntimeCore.js

@@ -36,6 +36,7 @@ var AgUiThreadRuntimeCore = class {
 	agent;
 	logger;
 	showThinking;
+	resumeTranscript;
 	autoCancelPendingToolCalls;
 	onError;
 	onCancel;
@@ -60,7 +61,6 @@ var AgUiThreadRuntimeCore = class {
 	abortController = null;
 	activeRunAgent = null;
 	stateSnapshot;
-	pendingError = null;
 	history;
 	lastRunConfig;
 	assistantHistoryParents = /* @__PURE__ */ new Map();
@@ -70,13 +70,14 @@ var AgUiThreadRuntimeCore = class {
 	_isLoading = false;
 	_loadPromise;
 	_loadRequested = false;
-	pendingResumeMessageId = null;
-	pendingA2uiResume = false;
+	pendingResume = null;
+	pendingA2uiResumeOwner = null;
 	pendingA2uiAction;
 	constructor(options) {
 		this.agent = options.agent;
 		this.logger = options.logger;
 		this.showThinking = options.showThinking;
+		this.resumeTranscript = options.resumeTranscript ?? "full";
 		this.autoCancelPendingToolCalls = options.autoCancelPendingToolCalls;
 		this.onError = options.onError;
 		this.onCancel = options.onCancel;
@@ -87,6 +88,7 @@ var AgUiThreadRuntimeCore = class {
 		this.agent = options.agent;
 		this.logger = options.logger;
 		this.showThinking = options.showThinking;
+		this.resumeTranscript = options.resumeTranscript ?? "full";
 		this.autoCancelPendingToolCalls = options.autoCancelPendingToolCalls;
 		this.onError = options.onError;
 		this.onCancel = options.onCancel;
@@ -150,12 +152,14 @@ var AgUiThreadRuntimeCore = class {
 	}
 	async append(message) {
 		const startRun = message.startRun ?? message.role === "user";
+		let ownsThread = true;
 		if (startRun) {
 			this.assertNoPendingInterrupts();
 			this.maybeAutoCancelPendingToolCalls();
+			ownsThread = this.supersedeActiveRun();
 		}
 		const threadMessageId = this.appendEntry(message);
-		if (!startRun) return;
+		if (!startRun || !ownsThread) return;
 		await this.startRun(threadMessageId, message.runConfig);
 	}
 	maybeAutoCancelPendingToolCalls() {
@@ -184,12 +188,26 @@ var AgUiThreadRuntimeCore = class {
 		await this.startRun(parentId, config.runConfig);
 	}
 	async cancel() {
-		if (!this.abortController) return;
+		this.abortActiveRun();
+	}
+	abortActiveRun() {
+		const controller = this.abortController;
+		if (!controller) return;
 		try {
 			(this.activeRunAgent ?? this.agent).abortRun();
 		} finally {
-			this.abortController.abort();
+			controller.abort();
+		}
+	}
+	supersedeActiveRun() {
+		try {
+			this.abortActiveRun();
+		} catch (error) {
+			this.logger.error?.("[agui] agent abortRun failed", error);
 		}
+		if (this.abortController === null) return true;
+		this.logger.debug?.("[agui] onCancel started a replacement run; dropping the superseding send");
+		return false;
 	}
 	async resume(config) {
 		this.assertNoPendingInterrupts();
@@ -259,7 +277,10 @@ var AgUiThreadRuntimeCore = class {
 	*/
 	async resumeWithResponses(messageId, resume) {
 		this.clearPendingInterrupts(messageId, resume);
-		await this.startRun(messageId, this.lastRunConfig, resume);
+		await this.startRun(messageId, this.lastRunConfig, {
+			entries: resume,
+			interruptedMessageId: messageId
+		});
 	}
 	/**
 	* A rejected decision reaches the caller through the approval seam, and
@@ -331,7 +352,10 @@ var AgUiThreadRuntimeCore = class {
 		const normalized = this.toAppendMessage(message);
 		this.clearPendingInterrupts(pending.messageId, resume);
 		const threadMessageId = this.appendEntry(normalized);
-		await this.startRun(threadMessageId, normalized.runConfig, resume);
+		await this.startRun(threadMessageId, normalized.runConfig, {
+			entries: resume,
+			interruptedMessageId: pending.messageId
+		});
 	}
 	resolveSteerAwayResume(interrupts, responses) {
 		const responsesById = this.collectInterruptResponses("steerAway", interrupts, responses ?? []);
@@ -368,7 +392,7 @@ var AgUiThreadRuntimeCore = class {
 		};
 		return {
 			createdAt: message.createdAt ?? /* @__PURE__ */ new Date(),
-			parentId: message.parentId ?? this.session.headId,
+			parentId: message.parentId === void 0 ? this.session.headId : message.parentId,
 			sourceId: message.sourceId ?? null,
 			role: message.role ?? "user",
 			content: message.content,
@@ -446,8 +470,9 @@ var AgUiThreadRuntimeCore = class {
 				return {
 					...part,
 					result: options.result,
-					artifact: options.artifact,
-					isError: options.isError
+					isError: options.isError,
+					...options.artifact !== void 0 && { artifact: options.artifact },
+					...options.modelContent !== void 0 && { modelContent: options.modelContent }
 				};
 			});
 			if (!matchedToolCall) return message;
@@ -471,16 +496,21 @@ var AgUiThreadRuntimeCore = class {
 		delete userAction.type;
 		if (!("timestamp" in userAction)) userAction.timestamp = (/* @__PURE__ */ new Date()).toISOString();
 		this.pendingA2uiAction = userAction;
-		if (this.isRunningFlag) {
-			this.pendingA2uiResume = true;
+		const owner = this.abortController;
+		if (owner) {
+			this.pendingA2uiResumeOwner = owner;
 			return;
 		}
 		this.startResumeRun(parentId);
 	}
 	maybeResumeAfterToolResults(messageId) {
 		if (!this.maybeCompleteAfterToolResults(messageId)) return;
-		if (this.isRunningFlag) {
-			this.pendingResumeMessageId = messageId;
+		const owner = this.abortController;
+		if (owner) {
+			this.pendingResume = {
+				owner,
+				messageId
+			};
 			return;
 		}
 		this.startResumeRun(messageId);
@@ -513,7 +543,7 @@ var AgUiThreadRuntimeCore = class {
 		});
 	}
 	applyExternalMessages(messages) {
-		this.pendingA2uiResume = false;
+		this.pendingA2uiResumeOwner = null;
 		this.pendingA2uiAction = void 0;
 		this.assistantHistoryParents.clear();
 		if (messages.length === 0) this.session.clear();
@@ -551,6 +581,8 @@ 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;
 		this.notifyUpdate();
 	}
 	loadExternalState(state) {
@@ -566,13 +598,14 @@ var AgUiThreadRuntimeCore = class {
 		this.notifyUpdate();
 	}
 	async startRun(parentId, runConfig, resume, resumeStream) {
+		if (!this.supersedeActiveRun()) return;
 		const normalizedRunConfig = runConfig ?? {};
 		this.lastRunConfig = 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));
-		this.pendingError = null;
+		let pendingError = null;
 		const assistantParentId = parent ? parentId : this.session.headId;
 		let assistantMessageId;
 		let assistantCollided = false;
@@ -647,7 +680,7 @@ var AgUiThreadRuntimeCore = class {
 					type: "incomplete",
 					reason: "cancelled"
 				} });
-				await this.consumeResumeStream(resumeStream, {
+				pendingError = await this.consumeResumeStream(resumeStream, {
 					runConfig: normalizedRunConfig,
 					threadId: this.agent.threadId || "main",
 					parentId: assistantParentId,
@@ -656,7 +689,7 @@ var AgUiThreadRuntimeCore = class {
 					ensureAssistant,
 					applyUpdate,
 					getAssistantMessageId: () => assistantMessageId
-				});
+				}) ?? null;
 			} else {
 				const runId = generateId();
 				aggregator.handle({
@@ -670,7 +703,7 @@ var AgUiThreadRuntimeCore = class {
 					logger: this.logger,
 					onRunFailed: (error) => {
 						if (abortSignal.aborted) return;
-						this.pendingError = error;
+						pendingError = error;
 						invokeRuntimeCallback("onError", this.onError, error);
 					}
 				});
@@ -689,28 +722,24 @@ var AgUiThreadRuntimeCore = class {
 					message: err.message
 				});
 				invokeRuntimeCallback("onError", this.onError, err);
-				this.pendingError = this.pendingError ?? err;
+				pendingError ??= err;
 			}
 		} finally {
 			this.finishRun(abortController);
 		}
-		if (this.pendingError) {
-			const err = this.pendingError;
+		if (pendingError) {
+			const err = pendingError;
 			this.reportedErrors.add(err);
-			this.pendingError = null;
-			this.pendingResumeMessageId = null;
-			this.pendingA2uiResume = false;
-			this.pendingA2uiAction = void 0;
+			this.clearDeferredContinuations(abortController);
 			throw err;
 		}
-		if (this.pendingResumeMessageId !== null) {
-			const resumeMessageId = this.pendingResumeMessageId;
-			this.pendingResumeMessageId = null;
-			if (!abortSignal.aborted) this.startResumeRun(resumeMessageId);
-			else this.pendingA2uiAction = void 0;
+		if (this.pendingResume?.owner === abortController) {
+			const { messageId } = this.pendingResume;
+			this.pendingResume = null;
+			if (!abortSignal.aborted) this.startResumeRun(messageId);
 		}
-		if (this.pendingA2uiResume) {
-			this.pendingA2uiResume = false;
+		if (this.pendingA2uiResumeOwner === abortController) {
+			this.pendingA2uiResumeOwner = null;
 			if (!abortSignal.aborted && this.pendingA2uiAction !== void 0) {
 				if (this.getPendingInterrupts()) {
 					this.pendingA2uiAction = void 0;
@@ -729,7 +758,7 @@ var AgUiThreadRuntimeCore = class {
 	}
 	async consumeResumeStream(stream, ctx) {
 		this.pendingA2uiAction = void 0;
-		this.pendingA2uiResume = false;
+		this.pendingA2uiResumeOwner = null;
 		const assistantId = ctx.ensureAssistant();
 		const currentId = () => ctx.getAssistantMessageId() ?? assistantId;
 		const options = {
@@ -748,11 +777,11 @@ var AgUiThreadRuntimeCore = class {
 		};
 		try {
 			for await (const result of stream(options)) {
-				if (ctx.abortSignal.aborted) return;
+				if (ctx.abortSignal.aborted) return void 0;
 				ctx.applyUpdate(result);
 			}
 		} catch (error) {
-			if (ctx.abortSignal.aborted) return;
+			if (ctx.abortSignal.aborted) return void 0;
 			const err = error instanceof Error ? error : new Error(String(error));
 			ctx.applyUpdate({ status: {
 				type: "incomplete",
@@ -760,10 +789,9 @@ var AgUiThreadRuntimeCore = class {
 				error: err.message
 			} });
 			invokeRuntimeCallback("onError", this.onError, err);
-			this.pendingError = this.pendingError ?? err;
-			return;
+			return err;
 		}
-		if (ctx.abortSignal.aborted) return;
+		if (ctx.abortSignal.aborted) return void 0;
 		const current = this.session.tryGetMessage(currentId())?.message;
 		if (!current || current.status?.type === "running") ctx.applyUpdate({ status: {
 			type: "complete",
@@ -772,7 +800,7 @@ var AgUiThreadRuntimeCore = class {
 	}
 	buildRunInput(runId, runConfig, historyMessages, resume) {
 		const threadId = this.agent.threadId || "main";
-		const messages = toAgUiMessages(historyMessages ?? this.session.getMessages());
+		const messages = toAgUiMessages(this.selectRunMessages(historyMessages ?? this.session.getMessages(), resume));
 		const context = this.runtime?.thread.getModelContext();
 		const input = {
 			threadId,
@@ -790,20 +818,39 @@ var AgUiThreadRuntimeCore = class {
 				...runConfig?.custom ? { runConfig: runConfig.custom } : {},
 				...this.pendingA2uiAction ? { a2uiAction: { userAction: this.pendingA2uiAction } } : {}
 			},
-			...resume !== void 0 ? { resume } : {}
+			...resume !== void 0 ? { resume: resume.entries } : {}
 		};
 		this.pendingA2uiAction = void 0;
 		return input;
 	}
+	/**
+	* An anchor the thread no longer carries falls back to the whole transcript.
+	* The anchor is missing exactly when a snapshot import replaced the messages
+	* this resume was raised against, and a host that expects a delta tolerates
+	* being told more than it knows, while one rebuilding the run from the
+	* transcript cannot recover from being told less.
+	*/
+	selectRunMessages(messages, resume) {
+		if (resume === void 0 || this.resumeTranscript !== "appended") return messages;
+		const anchor = messages.findIndex((message) => message.id === resume.interruptedMessageId);
+		if (anchor === -1) return messages;
+		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;
+		}
+	}
 	setRunning(running) {
 		this.isRunningFlag = running;
 		this.notifyUpdate();
 	}
 	finishRun(controller) {
-		if (this.abortController === controller) {
-			this.abortController = null;
-			this.activeRunAgent = null;
-		}
+		if (this.abortController !== controller) return;
+		this.abortController = null;
+		this.activeRunAgent = null;
 		this.setRunning(false);
 	}
 	insertAssistantPlaceholder(parentId, id = generateOptimisticId()) {
@@ -912,7 +959,8 @@ var AgUiThreadRuntimeCore = class {
 				...part,
 				result: prior.result,
 				...prior.artifact !== void 0 ? { artifact: prior.artifact } : {},
-				...prior.isError !== void 0 ? { isError: prior.isError } : {}
+				...prior.isError !== void 0 ? { isError: prior.isError } : {},
+				...prior.modelContent !== void 0 ? { modelContent: prior.modelContent } : {}
 			};
 		});
 		return changed ? merged : next;