@assistant-ui/react-ag-ui 0.0.57 → 0.0.59

package/README.md

@@ -33,6 +33,22 @@ export function Provider({ children }: { children: React.ReactNode }) {
 }
 ```
 
+## Subagents
+
+An AG-UI backend that runs subagents (the agents-as-tools pattern) emits `SUBAGENT_STARTED` / `SUBAGENT_FINISHED` / `SUBAGENT_ERROR` plus a `subagentRunId` on the events each subagent produces. This adapter groups that activity into one nested assistant message per subagent run and attaches it to the spawning tool call as `ToolCallMessagePart.messages`, joined on `SUBAGENT_STARTED.parentToolCallId`. `PartPrimitive.Messages` renders it without extra wiring, and the subagent's name, description, result, and error code ride on that message's `agui` metadata.
+
+A subagent that names no reachable spawning call (`parentToolCallId` is optional, may name a call this run never saw, or two runs may name each other) has nowhere to nest, so its output renders in the parent thread instead of being dropped. This matches the downgrade the protocol's own pre-subagent compatibility middleware performs.
+
+A subagent's frontend-executed tool calls work the same way the root agent's do: a call nested on `ToolCallMessagePart.messages` is reachable by `getPendingToolCalls()`, resolves through `addToolResult`, and its result rides the resume as a `tool` record on the spawning assistant record, the same flattened wire shape these calls had before subagent attribution.
+
+Approval gates cover nested calls too: a gate that names a subagent-scoped call projects onto the nested part, the frontend tool stays unexecuted while the gate is open, decisions recorded through `respondToToolApproval` land on the nested part, and an undecided gate's result is never exported to the backend.
+
+Two limitations are worth knowing before you rely on this:
+
+- **Nested structure does not survive a reload.** Thread restore reads the flattened wire shape, so a restored subagent tool call comes back as a root-level part rather than nested under its spawning call. Results and decisions are preserved; only the nesting is not.
+
+- **Nested human-in-the-loop is not wired up.** A `SUBAGENT_FINISHED` with a `suspended` outcome marks the nested message `requires-action`, and its `interruptIds` are preserved on the message metadata, but there is no resume path that answers them yet.
+
 ## See also
 
 - `@assistant-ui/react-a2a` for the A2A v1.0 protocol.

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,6 +16,7 @@ type CoreOptions = {
   agent: AbstractAgent;
   logger: Logger;
   showThinking: boolean;
+  resumeTranscript?: AgUiResumeTranscript | undefined;
   autoCancelPendingToolCalls?: boolean | undefined;
   onError?: (error: Error) => void;
   onCancel?: () => void;
@@ -26,6 +27,7 @@ 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;
@@ -89,9 +92,9 @@ declare class AgUiThreadRuntimeCore {
    */
   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
+   * A rejected decision reaches the caller through the approval seam, and
+   * `onError` in addition, because a consumer watching only the runtime would
+   * otherwise miss it. 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.
    */
@@ -117,7 +120,15 @@ declare class AgUiThreadRuntimeCore {
   private startRun;
   private consumeResumeStream;
   private buildRunInput;
-  private installResumeShim;
+  /**
+   * 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;

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;EAYrB,cAAc,SAAS,KAAK;EAsB5B,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;;EAcI,yBACJ,oBAAoB,oBACnB;;;;;;;UAuCW;;;;;;;;EAed,YAAY;UAYJ;EAwBF,sBACJ,SAAS,+BACR;EAsEG,UACJ,SAAS,qBACT,qBAAqB,oBACpB;UAyCK;UAkBA;UAiCA;UA0BA;EAmCR,yBAAyB;UAkBjB;EAiBR,cAAc,SAAS;EAyBvB,eAAe,QAAQ;UA4Bf;UAYA;UA6BA;EAUR,sBAAsB,mBAAmB;EAkDzC,kBAAkB,OAAO;EAKzB,SACE,MACI,sBACE,MAAM,kCAAkC;EAOhD;UAKc;UAyPA;UA2DN;UAkCA;UAqBA;UAKA;UAQA;UAyBA;UAkEA;UAiDA;UA4BA;UA6BA;UAgEA;UA2EA;UA8DA;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;;cAoCW;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;EA+BvB,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;UA0BA;UA6BA;UAgEA;UA0EA;UA6DA;UAuDA;UAQA;UAIA;UAKA;UAMA;UAQA;UAsDA;UAqBA"}

package/dist/runtime/AgUiThreadRuntimeCore.js

@@ -5,14 +5,13 @@ import { AG_UI_METADATA_NAMESPACE, RunAggregator, isPlainObject, tryParseJSON }
 import { fromAgUiMessages, toAgUiMessages, toAgUiTools } from "./adapter/conversions.js";
 import { createAgUiSubscriber } from "./adapter/subscriber.js";
 import { fromThreadMessageLike, generateId, isMcpAppUri } from "@assistant-ui/core";
-import { createMessageRepositorySession, invokeUserCallback } from "@assistant-ui/core/internal";
+import { createMessageRepositorySession, invokeUserCallback, iterateToolCallParts, mapToolCallPartsDeep } from "@assistant-ui/core/internal";
 import jsonpatch from "fast-json-patch";
 //#region src/runtime/AgUiThreadRuntimeCore.ts
 const optimisticPrefix = "__optimistic__";
 const generateOptimisticId = () => `${optimisticPrefix}${generateId()}`;
 const isOptimisticId = (id) => id.startsWith(optimisticPrefix);
 const isResolvedToolCall = (part) => part.type === "tool-call" && "result" in part && part.result !== void 0;
-const symbolResumeShim = Symbol("agui-resume-shim");
 const FALLBACK_USER_STATUS = {
 	type: "complete",
 	reason: "unknown"
@@ -37,6 +36,7 @@ var AgUiThreadRuntimeCore = class {
 	agent;
 	logger;
 	showThinking;
+	resumeTranscript;
 	autoCancelPendingToolCalls;
 	onError;
 	onCancel;
@@ -61,7 +61,6 @@ var AgUiThreadRuntimeCore = class {
 	abortController = null;
 	activeRunAgent = null;
 	stateSnapshot;
-	pendingError = null;
 	history;
 	lastRunConfig;
 	assistantHistoryParents = /* @__PURE__ */ new Map();
@@ -71,30 +70,30 @@ 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;
 		this.history = options.history;
 		this.notifyUpdate = options.notifyUpdate;
-		this.installResumeShim();
 	}
 	updateOptions(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;
 		const previousHistory = this.history;
 		this.history = options.history;
-		this.installResumeShim();
 		if (this._loadRequested && !this._loadPromise && !previousHistory && options.history && this.session.getMessages().length === 0) this.__internal_load();
 	}
 	attachRuntime(runtime) {
@@ -153,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() {
@@ -187,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();
@@ -234,8 +249,7 @@ var AgUiThreadRuntimeCore = class {
 		const assistant = this.findRequiresActionAssistant("tool-calls");
 		if (!assistant) return null;
 		const toolCallIds = [];
-		for (const part of assistant.content) {
-			if (part.type !== "tool-call") continue;
+		for (const part of iterateToolCallParts(assistant.content)) {
 			if (isResolvedToolCall(part)) continue;
 			toolCallIds.push(part.toolCallId);
 		}
@@ -263,12 +277,15 @@ 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
+		});
 	}
 	/**
-	* 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
+	* A rejected decision reaches the caller through the approval seam, and
+	* `onError` in addition, because a consumer watching only the runtime would
+	* otherwise miss it. 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.
 	*/
@@ -293,7 +310,7 @@ var AgUiThreadRuntimeCore = class {
 		const pending = this.getPendingInterrupts();
 		if (!pending) throw new Error("[agui] respondToToolApproval: no pending interrupts on this thread");
 		const gatedMessage = this.session.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}"`);
+		if (![...projectAgUiToolApprovals(pending.interrupts, new Set(Array.from(iterateToolCallParts(gatedMessage?.content ?? [])).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.session.updateMessage(pending.messageId, (message) => {
 			if (message.role !== "assistant") return message;
@@ -335,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 ?? []);
@@ -372,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,
@@ -411,8 +431,8 @@ var AgUiThreadRuntimeCore = class {
 		for (let index = messages.length - 1; index >= 0; index--) {
 			const message = messages[index];
 			if (!message || message.role !== "assistant") continue;
-			for (const part of message.content) {
-				if (part.type !== "tool-call" || part.toolCallId !== toolCallId) continue;
+			for (const part of iterateToolCallParts(message.content)) {
+				if (part.toolCallId !== toolCallId) continue;
 				if (!isResolvedToolCall(part)) return message.id;
 				fallbackMessageId ??= message.id;
 			}
@@ -423,8 +443,8 @@ var AgUiThreadRuntimeCore = class {
 		if (this.session.updateMessage(messageId, (message) => {
 			if (message.role !== "assistant") return message;
 			const assistant = message;
-			const content = assistant.content.map((part) => {
-				if (part.type !== "tool-call" || isResolvedToolCall(part)) return part;
+			const { content } = mapToolCallPartsDeep(assistant.content, (part) => {
+				if (isResolvedToolCall(part)) return part;
 				return {
 					...part,
 					result: { error: "Tool call cancelled by user" },
@@ -438,12 +458,14 @@ var AgUiThreadRuntimeCore = class {
 		})) this.notifyUpdate();
 	}
 	addToolResult(options) {
-		if (!this.session.updateMessage(options.messageId, (message) => {
+		const sessionMessageId = this.session.tryGetMessage(options.messageId) ? options.messageId : this.findMessageIdForToolCall(options.toolCallId);
+		if (sessionMessageId === void 0) return;
+		if (!this.session.updateMessage(sessionMessageId, (message) => {
 			if (message.role !== "assistant") return message;
 			const assistant = message;
 			let matchedToolCall = false;
-			const content = assistant.content.map((part) => {
-				if (part.type !== "tool-call" || part.toolCallId !== options.toolCallId) return part;
+			const { content } = mapToolCallPartsDeep(assistant.content, (part) => {
+				if (part.toolCallId !== options.toolCallId) return part;
 				matchedToolCall = true;
 				return {
 					...part,
@@ -459,7 +481,7 @@ var AgUiThreadRuntimeCore = class {
 			};
 		})) return;
 		this.notifyUpdate();
-		this.maybeResumeAfterToolResults(options.messageId);
+		this.maybeResumeAfterToolResults(sessionMessageId);
 	}
 	sendA2uiAction(action) {
 		this.assertNoPendingInterrupts();
@@ -473,16 +495,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);
@@ -492,7 +519,12 @@ var AgUiThreadRuntimeCore = class {
 		if (!message || message.role !== "assistant") return false;
 		const assistant = message;
 		if (assistant.status?.type !== "requires-action" || assistant.status.reason !== "tool-calls") return false;
-		if (!assistant.content.every((part) => part.type !== "tool-call" || isResolvedToolCall(part))) return false;
+		let allResolved = true;
+		for (const part of iterateToolCallParts(assistant.content)) if (!isResolvedToolCall(part)) {
+			allResolved = false;
+			break;
+		}
+		if (!allResolved) return false;
 		if (!this.session.updateMessage(messageId, (current) => current.role === "assistant" ? {
 			...current,
 			status: {
@@ -510,7 +542,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();
@@ -548,6 +580,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) {
@@ -563,13 +597,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;
@@ -644,7 +679,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,
@@ -653,7 +688,7 @@ var AgUiThreadRuntimeCore = class {
 					ensureAssistant,
 					applyUpdate,
 					getAssistantMessageId: () => assistantMessageId
-				});
+				}) ?? null;
 			} else {
 				const runId = generateId();
 				aggregator.handle({
@@ -667,7 +702,7 @@ var AgUiThreadRuntimeCore = class {
 					logger: this.logger,
 					onRunFailed: (error) => {
 						if (abortSignal.aborted) return;
-						this.pendingError = error;
+						pendingError = error;
 						invokeRuntimeCallback("onError", this.onError, error);
 					}
 				});
@@ -686,28 +721,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;
@@ -726,7 +757,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 = {
@@ -745,11 +776,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",
@@ -757,10 +788,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",
@@ -769,7 +799,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,
@@ -787,35 +817,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;
 	}
-	installResumeShim() {
-		const agent = this.agent;
-		if (agent[symbolResumeShim]) return;
-		agent[symbolResumeShim] = true;
-		const original = Object.hasOwn(agent, "prepareRunAgentInput") ? agent.prepareRunAgentInput : Object.getPrototypeOf(agent)?.prepareRunAgentInput;
-		if (typeof original !== "function") return;
-		agent.prepareRunAgentInput = function(params) {
-			const input = original.call(this, params);
-			if (params?.resume !== void 0 && input && typeof input === "object") return {
-				...input,
-				resume: params.resume
-			};
-			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()) {
@@ -914,14 +948,12 @@ var AgUiThreadRuntimeCore = class {
 	}
 	preserveToolResults(previous, next) {
 		const resolved = /* @__PURE__ */ new Map();
-		for (const part of previous) if (part.type === "tool-call" && isResolvedToolCall(part)) resolved.set(part.toolCallId, part);
+		for (const part of iterateToolCallParts(previous)) if (isResolvedToolCall(part)) resolved.set(part.toolCallId, part);
 		if (resolved.size === 0) return next;
-		let changed = false;
-		const merged = next.map((part) => {
-			if (part.type !== "tool-call" || isResolvedToolCall(part)) return part;
+		const { content: merged, changed } = mapToolCallPartsDeep(next, (part) => {
+			if (isResolvedToolCall(part)) return part;
 			const prior = resolved.get(part.toolCallId);
 			if (!prior) return part;
-			changed = true;
 			return {
 				...part,
 				result: prior.result,
@@ -996,8 +1028,8 @@ var AgUiThreadRuntimeCore = class {
 			const assistant = message;
 			const mcpAppUri = readMcpAppResourceUri(event.mcpResult?._meta);
 			let matchedToolCall = false;
-			const content = assistant.content.map((part) => {
-				if (part.type !== "tool-call" || part.toolCallId !== event.toolCallId) return part;
+			const { content } = mapToolCallPartsDeep(assistant.content, (part) => {
+				if (part.toolCallId !== event.toolCallId) return part;
 				matchedToolCall = true;
 				if (part.mcp?.app !== void 0 && isPlainObject(part.result) && Array.isArray(part.result["content"])) return {
 					...part,
@@ -1040,8 +1072,8 @@ var AgUiThreadRuntimeCore = class {
 			if (message.role !== "assistant") return message;
 			const assistant = message;
 			let matchedToolCall = false;
-			const content = assistant.content.map((part) => {
-				if (part.type !== "tool-call" || part.toolCallId !== toolCallId) return part;
+			const { content } = mapToolCallPartsDeep(assistant.content, (part) => {
+				if (part.toolCallId !== toolCallId) return part;
 				matchedToolCall = true;
 				return {
 					...part,