@astralbeam/sdk 0.13.5 → 0.13.7

package/dist/{core-c6eS1h0R.js → core-BhxhgxMN.js}

@@ -1,4 +1,4 @@
-import { A as resolveApiUrl, O as astralBeamChatFetch, c as getCurrentUser, i as getChatConfig, k as isAstralBeamApiError, v as getRunChatUrl } from "./api-DiwSihrG.js";
+import { A as resolveApiUrl, O as astralBeamChatFetch, c as getCurrentUser, i as getChatConfig, k as isAstralBeamApiError, v as getRunChatUrl } from "./api-CsRaydMf.js";
 import { d as JWTInvalid, h as strictDecoder, r as isObject, s as decode } from "./type_checks-C-WTHaWs.js";
 //#region \0rolldown/runtime.js
 var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
@@ -26,7 +26,7 @@ function decodeJwt(jwt) {
 	return result;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.28.0/node_modules/@tanstack/ai-client/dist/esm/response-stream.js
+//#region node_modules/.deno/@tanstack+ai-client@0.36.0/node_modules/@tanstack/ai-client/dist/esm/response-stream.js
 var UnsupportedResponseStreamError = class extends Error {
 	missingFeature;
 	constructor(missingFeature) {
@@ -48,14 +48,46 @@ function createResponseStreamTextDecoder() {
 	return new globalThis.TextDecoder();
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.28.0/node_modules/@tanstack/ai-client/dist/esm/sse-utils.js
+//#region node_modules/.deno/@tanstack+ai-client@0.36.0/node_modules/@tanstack/ai-client/dist/esm/sse-utils.js
 function parseSseDataLine(line) {
 	if (!line.startsWith("data:")) return line;
 	const data = line.slice(5);
 	return data.startsWith(" ") ? data.slice(1) : data;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/utilities/ag-ui-usage.js
+//#region node_modules/.deno/@tanstack+ai-client@0.36.0/node_modules/@tanstack/ai-client/dist/esm/message-date-normalizer.js
+function validDate(value) {
+	if (value instanceof Date) return Number.isNaN(value.getTime()) ? void 0 : value;
+	if (typeof value !== "string") return void 0;
+	const date = new Date(value);
+	return Number.isNaN(date.getTime()) ? void 0 : date;
+}
+function normalizeMessageDates(message) {
+	const messageDate = validDate(message.createdAt);
+	const parts = message.parts.map((part) => {
+		if (part.type !== "tool-result") return part;
+		const date = validDate(part.createdAt);
+		const { createdAt: _ignored, ...rest } = part;
+		return date ? {
+			...rest,
+			createdAt: date
+		} : rest;
+	});
+	const { createdAt: _ignored, ...rest } = message;
+	return messageDate ? {
+		...rest,
+		parts,
+		createdAt: messageDate
+	} : {
+		...rest,
+		parts
+	};
+}
+function normalizeMessagesDates(messages) {
+	return messages.map(normalizeMessageDates);
+}
+//#endregion
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/utilities/ag-ui-usage.js
 function definedDetails(value) {
 	return Object.keys(value).length > 0 ? value : void 0;
 }
@@ -68,11 +100,22 @@ function rebuildTokenUsage(usage, leftover) {
 	return fromSpecTokenUsage(void 0, leftover);
 }
 function fromSpecTokenUsage(usage, leftover) {
-	const spec = usage?.[0];
-	if (spec == null && leftover == null) return;
+	const spec = usage?.reduce((total, entry) => {
+		for (const key of [
+			"inputTokens",
+			"outputTokens",
+			"totalTokens",
+			"cachedInputTokens",
+			"cacheWriteInputTokens",
+			"reasoningTokens"
+		]) if (entry[key] !== void 0) total[key] = (total[key] ?? 0) + entry[key];
+		return total;
+	}, {});
+	if ((usage === void 0 || usage.length === 0) && leftover == null) return;
 	const { promptTokensDetails: leftoverPromptDetails, completionTokensDetails: leftoverCompletionDetails, ...leftoverRest } = leftover ?? {};
 	const promptTokensDetails = definedDetails({
 		...spec?.cachedInputTokens !== void 0 ? { cachedTokens: spec.cachedInputTokens } : {},
+		...spec?.cacheWriteInputTokens !== void 0 ? { cacheWriteTokens: spec.cacheWriteInputTokens } : {},
 		...leftoverPromptDetails
 	});
 	const completionTokensDetails = definedDetails({
@@ -89,7 +132,7 @@ function fromSpecTokenUsage(usage, leftover) {
 	};
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/utilities/merge-metadata.js
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/utilities/merge-metadata.js
 function isPlainRecord$1(value) {
 	return value != null && typeof value === "object" && !Array.isArray(value);
 }
@@ -129,8 +172,11 @@ function withTanstackMetadata(value, tanstack) {
 	};
 }
 //#endregion
-//#region node_modules/.deno/@ag-ui+core@0.1.1-canary.beta.0/node_modules/@ag-ui/core/dist/events-BaoNrGbE.mjs
-let EventType$1 = /* @__PURE__ */ function(EventType) {
+//#region node_modules/.deno/@ag-ui+core@1.0.0/node_modules/@ag-ui/core/dist/version-CTNE2I0_.mjs
+/**
+* The discriminator carried by every event.
+*/
+let EventType = /* @__PURE__ */ function(EventType) {
 	EventType["TEXT_MESSAGE_START"] = "TEXT_MESSAGE_START";
 	EventType["TEXT_MESSAGE_CONTENT"] = "TEXT_MESSAGE_CONTENT";
 	EventType["TEXT_MESSAGE_END"] = "TEXT_MESSAGE_END";
@@ -140,16 +186,6 @@ let EventType$1 = /* @__PURE__ */ function(EventType) {
 	EventType["TOOL_CALL_END"] = "TOOL_CALL_END";
 	EventType["TOOL_CALL_CHUNK"] = "TOOL_CALL_CHUNK";
 	EventType["TOOL_CALL_RESULT"] = "TOOL_CALL_RESULT";
-	/** @deprecated Use REASONING_START instead. Will be removed in 1.0.0. */
-	EventType["THINKING_START"] = "THINKING_START";
-	/** @deprecated Use REASONING_END instead. Will be removed in 1.0.0. */
-	EventType["THINKING_END"] = "THINKING_END";
-	/** @deprecated Use REASONING_MESSAGE_START instead. Will be removed in 1.0.0. */
-	EventType["THINKING_TEXT_MESSAGE_START"] = "THINKING_TEXT_MESSAGE_START";
-	/** @deprecated Use REASONING_MESSAGE_CONTENT instead. Will be removed in 1.0.0. */
-	EventType["THINKING_TEXT_MESSAGE_CONTENT"] = "THINKING_TEXT_MESSAGE_CONTENT";
-	/** @deprecated Use REASONING_MESSAGE_END instead. Will be removed in 1.0.0. */
-	EventType["THINKING_TEXT_MESSAGE_END"] = "THINKING_TEXT_MESSAGE_END";
 	EventType["STATE_SNAPSHOT"] = "STATE_SNAPSHOT";
 	EventType["STATE_DELTA"] = "STATE_DELTA";
 	EventType["MESSAGES_SNAPSHOT"] = "MESSAGES_SNAPSHOT";
@@ -169,10 +205,13 @@ let EventType$1 = /* @__PURE__ */ function(EventType) {
 	EventType["REASONING_MESSAGE_CHUNK"] = "REASONING_MESSAGE_CHUNK";
 	EventType["REASONING_END"] = "REASONING_END";
 	EventType["REASONING_ENCRYPTED_VALUE"] = "REASONING_ENCRYPTED_VALUE";
+	EventType["SUBAGENT_STARTED"] = "SUBAGENT_STARTED";
+	EventType["SUBAGENT_FINISHED"] = "SUBAGENT_FINISHED";
+	EventType["SUBAGENT_ERROR"] = "SUBAGENT_ERROR";
 	return EventType;
 }({});
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/interrupt-serialization.js
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/interrupt-serialization.js
 var SHA256_K = new Uint32Array([
 	1116352408,
 	1899447441,
@@ -347,7 +386,7 @@ function cloneAndDeepFreezeJson(value) {
 	return clone;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/interrupts.js
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/interrupts.js
 function canonicalizeInterruptResolutions(resolutions) {
 	const frozen = cloneAndDeepFreezeJson([...resolutions].sort((left, right) => left.interruptId.localeCompare(right.interruptId)));
 	const canonicalResolutions = canonicalInterruptJson(frozen);
@@ -358,7 +397,7 @@ function canonicalizeInterruptResolutions(resolutions) {
 	});
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/activities/chat/tools/schema-converter.js
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/activities/chat/tools/schema-converter.js
 /**
 * Build a JSONSchema object from any plain key/value source. The `JSONSchema`
 * interface's `[key: string]: any` index signature makes every property
@@ -410,6 +449,21 @@ function isStandardSchema(schema) {
 function pruneMap(map) {
 	return Object.keys(map).length > 0 ? map : void 0;
 }
+function coerceArrayItems(items) {
+	if (Array.isArray(items)) {
+		const nested = items.map((item) => makeStructuredOutputCompatible(item, item.required || []));
+		const itemMaps = nested.map((entry) => entry.nullWidening ?? {});
+		return {
+			schema: nested.map((entry) => entry.schema),
+			itemMap: itemMaps.some((entry) => Object.keys(entry).length > 0) ? itemMaps : void 0
+		};
+	}
+	const nested = makeStructuredOutputCompatible(items, items.required || []);
+	return {
+		schema: nested.schema,
+		itemMap: nested.nullWidening
+	};
+}
 /**
 * Transform a JSON schema to be compatible with OpenAI's structured output requirements.
 * OpenAI requires:
@@ -447,15 +501,14 @@ function makeStructuredOutputCompatible(schema, originalRequired = []) {
 				widenedHere = wasOptional;
 				childMap = nested.nullWidening;
 			} else if (prop.type === "array" && prop.items) {
-				const items = Array.isArray(prop.items) ? prop.items[0] : prop.items;
-				const nestedItems = items ? makeStructuredOutputCompatible(items, items.required || []) : void 0;
+				const nestedItems = coerceArrayItems(prop.items);
 				properties[propName] = {
 					...prop,
-					items: nestedItems ? nestedItems.schema : prop.items,
+					items: nestedItems.schema,
 					...wasOptional ? { type: ["array", "null"] } : {}
 				};
 				widenedHere = wasOptional;
-				childMap = nestedItems?.nullWidening ? { items: nestedItems.nullWidening } : void 0;
+				childMap = nestedItems.itemMap ? { items: nestedItems.itemMap } : void 0;
 			} else if (wasOptional) {
 				if (prop.type && !Array.isArray(prop.type)) {
 					properties[propName] = {
@@ -482,12 +535,9 @@ function makeStructuredOutputCompatible(schema, originalRequired = []) {
 		if (Object.keys(propertyMaps).length > 0) map.properties = propertyMaps;
 	}
 	if (result.type === "array" && result.items) {
-		const items = Array.isArray(result.items) ? result.items[0] : result.items;
-		if (items) {
-			const nestedItems = makeStructuredOutputCompatible(items, items.required || []);
-			result.items = nestedItems.schema;
-			if (nestedItems.nullWidening) map.items = nestedItems.nullWidening;
-		}
+		const nestedItems = coerceArrayItems(result.items);
+		result.items = nestedItems.schema;
+		if (nestedItems.itemMap) map.items = nestedItems.itemMap;
 	}
 	return {
 		schema: result,
@@ -589,38 +639,32 @@ function convertSchemaToJsonSchema(schema, options = {}) {
 	return makeStructuredOutputCompatible(base, base.required || []).schema;
 }
 /**
-* Error thrown when Standard Schema validation fails. Carries the original
-* `issues` array so consumers (middleware `onError`, callers catching from
-* `chat({ outputSchema })`) can programmatically inspect each failure.
-*/
-var StandardSchemaValidationError = class extends Error {
-	name = "StandardSchemaValidationError";
-	issues;
-	constructor(issues) {
-		super(`Validation failed: ${issues.map((i) => i.message || "Validation failed").join(", ")}`);
-		this.issues = issues;
-	}
-};
-/**
-* Synchronously validates data against a Standard Schema compliant schema.
-* Note: Some Standard Schema implementations may only support async validation.
-* In those cases, this function will throw.
+* Validates data against a Standard Schema compliant schema.
 *
 * @param schema - Standard Schema compliant schema
 * @param data - Data to validate
-* @returns Parsed/validated data
-* @throws StandardSchemaValidationError if validation fails; Error if the
-*         schema only supports async validation.
+* @returns Validation result with success status, data or issues
 */
-function parseWithStandardSchema(schema, data) {
-	if (!isStandardSchema(schema)) return data;
-	const result = schema["~standard"].validate(data);
-	if (result instanceof Promise) throw new Error("Schema validation returned a Promise. Use validateWithStandardSchema for async validation.");
-	if (!result.issues) return result.value;
-	throw new StandardSchemaValidationError(result.issues);
+async function validateWithStandardSchema(schema, data) {
+	if (!isStandardSchema(schema)) return {
+		success: true,
+		data
+	};
+	const result = await schema["~standard"].validate(data);
+	if (!result.issues) return {
+		success: true,
+		data: result.value
+	};
+	return {
+		success: false,
+		issues: result.issues.map((issue) => ({
+			message: issue.message || "Validation failed",
+			path: issue.path?.map(String)
+		}))
+	};
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/activities/chat/tools/approval-schema.js
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/activities/chat/tools/approval-schema.js
 var jsonSchemaKeywords = /* @__PURE__ */ new Set([
 	"$schema",
 	"$id",
@@ -732,7 +776,7 @@ function hashSchemaInput(schema) {
 	return digestInterruptJson(canonicalInterruptJson(schemaToWire(schema).jsonSchema ?? { standardValidator: "unserialized" }));
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/interrupt-resume.js
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/interrupt-resume.js
 /**
 * The `Interrupt.metadata` key under which this package's resume binding
 * travels.
@@ -853,7 +897,7 @@ function readInterruptBinding(descriptor) {
 	};
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/interrupt-definition.js
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/interrupt-definition.js
 var INTERRUPT_PAYLOAD_METADATA_KEY = "tanstack:interruptPayload";
 function schemaJson(schema, name) {
 	if (!isStandardJSONSchema(schema)) throw new TypeError(`${name} must be a Standard Schema with a JSON Schema converter.`);
@@ -878,7 +922,7 @@ function hashInterruptDefinitionSchema(schema) {
 	return digestInterruptJson(schemaJson(schema, "Interrupt schema").canonicalJson);
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/generic-interrupt-continuation.js
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/generic-interrupt-continuation.js
 /**
 * `ResumeEntry.metadata` key for a first-party generic request.
 *
@@ -886,7 +930,7 @@ function hashInterruptDefinitionSchema(schema) {
 * The original request rides here so an ephemeral server can rebuild it.
 */
 var INTERRUPT_CONTINUATION_METADATA_KEY = "tanstack:interruptContinuation";
-function isRecord(value) {
+function isRecord$3(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 /** Put a parsed continuation on `ResumeEntry.metadata`. */
@@ -901,7 +945,7 @@ function wrapGenericInterruptContinuation(continuation) {
 function genericInterruptContinuationFromDescriptor(interrupt) {
 	const binding = readUnopenedInterruptBinding(interrupt);
 	if (binding?.kind !== "generic" || binding.definitionId === void 0 || binding.key === void 0 || binding.batchIndex === void 0) return;
-	const metadata = isRecord(interrupt.metadata) ? interrupt.metadata : void 0;
+	const metadata = isRecord$3(interrupt.metadata) ? interrupt.metadata : void 0;
 	const hasPayload = metadata !== void 0 && Object.prototype.hasOwnProperty.call(metadata, "tanstack:interruptPayload");
 	return {
 		v: 1,
@@ -917,174 +961,37 @@ function genericInterruptContinuationFromDescriptor(interrupt) {
 	};
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/utilities/ag-ui-wire.js
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/utilities/provider-executed.js
 /**
-* Serialize TanStack `UIMessage`s into the AG-UI `RunAgentInput.messages`
-* wire shape. Anchors are spec-only (`id`, `role`, `name`, `content`,
-* `toolCalls`, `metadata`). Tool results and thinking parts on assistant
-* messages are additionally emitted as fan-out `{role:'tool',...}` and
-* `{role:'reasoning',...}` entries for strict AG-UI server consumers.
+* Narrow a tool call's opaque `metadata` to the provider-executed convention.
+* Returns the typed metadata when the call is provider-executed, else `null`.
+*
+* @see ProviderExecutedToolMetadata
 */
-function uiMessagesToWire(messages) {
-	const wire = [];
-	for (const msg of messages) {
-		const parts = msg.parts ?? [];
-		if (msg.role === "system") {
-			wire.push(toAnchor(msg, { content: parts.length > 0 ? collectText(parts) : msg.content ?? "" }, parts));
-			continue;
-		}
-		if (msg.role === "user") {
-			wire.push(toAnchor(msg, { content: parts.length > 0 ? collectUserContent(parts) : msg.content ?? "" }, parts));
-			continue;
-		}
-		for (const part of parts) if (part.type === "thinking") {
-			const reasoning = {
-				role: "reasoning",
-				id: deriveReasoningId(msg.id, part),
-				content: part.content
-			};
-			if (part.signature) reasoning.encryptedValue = part.signature;
-			wire.push(reasoning);
-		}
-		const text = collectText(parts);
-		const toolCalls = collectToolCalls(parts);
-		wire.push(toAnchor(msg, {
-			...text !== "" && { content: text },
-			...toolCalls && { toolCalls }
-		}, parts));
-		for (const part of parts) if (part.type === "tool-result") wire.push({
-			role: "tool",
-			id: deriveToolMessageId(part.toolCallId),
-			toolCallId: part.toolCallId,
-			content: typeof part.content === "string" ? part.content : JSON.stringify(part.content),
-			...part.error !== void 0 && { error: part.error }
-		});
-	}
-	return wire;
-}
-function toAnchor(msg, extras, parts) {
-	const metadata = messageMetadata(msg, parts);
-	const name = msg.name;
-	return {
-		id: msg.id,
-		role: msg.role,
-		...name !== void 0 && { name },
-		...extras,
-		...metadata !== void 0 && { metadata }
-	};
-}
-function messageMetadata(msg, parts) {
-	const base = { ...msg.metadata ?? {} };
-	const tanstack = { ...tanstackMetadata(msg) ?? {} };
-	if (msg.createdAt) tanstack.createdAt = msg.createdAt.toISOString();
-	const leftover = unfinishedStructuredOutput(parts);
-	if (leftover) tanstack.structuredOutput = leftover;
-	const toolCallMetadata = {};
-	for (const part of parts) if (part.type === "tool-call" && part.metadata !== void 0) toolCallMetadata[part.id] = part.metadata;
-	if (Object.keys(toolCallMetadata).length > 0) tanstack.toolCallMetadata = toolCallMetadata;
-	const uiResources = parts.filter((p) => p.type === "ui-resource");
-	if (uiResources.length > 0) tanstack.uiResources = uiResources;
-	if (Object.keys(tanstack).length > 0) base.tanstack = tanstack;
-	return Object.keys(base).length > 0 ? base : void 0;
-}
-function unfinishedStructuredOutput(parts) {
-	for (const p of parts) if (p.type === "structured-output" && p.status !== "complete") return structuredOutputLeftover(p);
-}
-function structuredOutputLeftover(part) {
-	return {
-		status: part.status,
-		raw: part.raw,
-		...part.errorMessage !== void 0 && { errorMessage: part.errorMessage }
-	};
-}
-function collectText(parts) {
-	const out = [];
-	for (const p of parts) if (p.type === "text") out.push(p.content);
-	else if (p.type === "structured-output" && p.status === "complete" && p.raw !== "") out.push(p.raw);
-	return out.join("");
-}
-function collectUserContent(parts) {
-	if (!parts.some((p) => p.type === "image" || p.type === "audio" || p.type === "video" || p.type === "document")) return collectText(parts);
-	const out = [];
-	for (const p of parts) if (p.type === "text") out.push({
-		type: "text",
-		text: p.content
-	});
-	else if (p.type === "image" || p.type === "audio" || p.type === "video" || p.type === "document") out.push(p);
-	return out;
-}
-function thoughtSignatureFromMetadata(metadata) {
-	if (metadata == null || typeof metadata !== "object" || Array.isArray(metadata)) return;
-	if (!("thoughtSignature" in metadata)) return void 0;
-	const value = metadata.thoughtSignature;
-	return typeof value === "string" && value !== "" ? value : void 0;
-}
-function collectToolCalls(parts) {
-	const calls = [];
-	for (const p of parts) if (p.type === "tool-call") {
-		const encryptedValue = thoughtSignatureFromMetadata(p.metadata);
-		calls.push({
-			id: p.id,
-			type: "function",
-			function: {
-				name: p.name,
-				arguments: p.arguments
-			},
-			...encryptedValue !== void 0 ? { encryptedValue } : {}
-		});
-	}
-	return calls.length > 0 ? calls : void 0;
-}
-function deriveReasoningId(messageId, part) {
-	return `${messageId}-reasoning-${part.id ?? hashContent(part.content)}`;
-}
-function deriveToolMessageId(toolCallId) {
-	return `tool-${toolCallId}`;
-}
-function hashContent(s) {
-	let h = 0;
-	for (let i = 0; i < s.length; i++) h = h * 31 + s.charCodeAt(i) | 0;
-	return Math.abs(h).toString(36);
+function getProviderExecutedMetadata(toolCall) {
+	const metadata = toolCall?.metadata;
+	if (typeof metadata === "object" && metadata !== null && metadata.providerExecuted === true) return metadata;
+	return null;
 }
-//#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/utilities/restore-inbound-chunk.js
 /**
-* Rebuild TanStack `TokenUsage` (`promptTokens`) from spec `usage[]` plus
-* leftover fields in `metadata.tanstack.usage`. Restore in-process aliases
-* that the wire does not keep (`toolName`, `TOOL_CALL_END.input`). Mutates
-* in place so WeakMap run-id stamps stay attached.
+* True when a tool call was executed by the provider (e.g. Anthropic
+* `web_search` / `web_fetch` server tools) rather than the agent loop. Such
+* calls must not be routed to client-side execution and are already "complete".
 */
-function restorePublicUsage(chunk) {
-	if ((chunk.type === EventType$1.RUN_FINISHED || chunk.type === EventType$1.RUN_ERROR) && (Array.isArray(chunk.usage) || isTanstackUsage(chunk.usage))) {
-		const rebuilt = rebuildTokenUsage(chunk.usage, tanstackMetadata(chunk)?.usage);
-		if (rebuilt !== void 0) chunk.usage = rebuilt;
-	}
-	if (chunk.type === EventType$1.TOOL_CALL_START && chunk.toolName === void 0 && chunk.toolCallName) chunk.toolName = chunk.toolCallName;
-	if (chunk.type === EventType$1.TOOL_CALL_END && chunk.input === void 0) {
-		const input = tanstackMetadata(chunk)?.input;
-		if (input !== void 0) chunk.input = input;
-	}
-	return chunk;
+function isProviderExecutedToolCall(toolCall) {
+	return getProviderExecutedMetadata(toolCall) !== null;
 }
 /**
-* Rebuild the pre-wire chunk shape after SSE/HTTP/WS ingest.
-* Copies `metadata.tanstack` extras back to top-level fields and rebuilds
-* TanStack `TokenUsage` from spec `usage[]` when present.
+* True when `id` is a `${parentId}-segment-${n}` message. The wire and the
+* run loop split one provider turn into segments at thinking that follows a
+* provider-executed tool call, to keep signed thinking order. Readers fold a
+* segment back into its parent so the UI still shows one message.
 */
-function restoreInboundChunk(chunk) {
-	restorePublicUsage(chunk);
-	const tanstack = tanstackMetadata(chunk);
-	const next = chunk;
-	if (tanstack == null) return next;
-	for (const [key, value] of Object.entries(tanstack)) {
-		if (key === "usage" || key === "interruptErrors") continue;
-		if (next[key] === void 0 && value !== void 0) next[key] = value;
-	}
-	if (tanstack.interruptErrors !== void 0) next["tanstack:interruptErrors"] = tanstack.interruptErrors;
-	return next;
+function isAssistantSegmentOf(id, parentId) {
+	return id?.startsWith(`${parentId}-segment-`) === true;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/utilities/tool-result.js
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/utilities/tool-result.js
 var CONTENT_PART_TYPES = /* @__PURE__ */ new Set([
 	"text",
 	"image",
@@ -1092,10 +999,14 @@ var CONTENT_PART_TYPES = /* @__PURE__ */ new Set([
 	"video",
 	"document"
 ]);
+function isToolResultOutcome(value) {
+	return value === "cancelled" || value === "denied";
+}
 /**
 * Structural check for a single `ContentPart`. A text part must carry a string
-* `content`; every other modality must carry a `source` with `type` of
-* `'url' | 'data'` and a string `value`.
+* `content`. Every other part carries a source with a string `value`; a file
+* source's `value` is a non-empty opaque handle, and its optional `provider`
+* is a string.
 */
 function isContentPart$1(value) {
 	if (typeof value !== "object" || value === null) return false;
@@ -1106,6 +1017,7 @@ function isContentPart$1(value) {
 	if (typeof source !== "object" || source === null) return false;
 	const src = source;
 	if (typeof src.value !== "string") return false;
+	if (src.type === "file") return src.value.length > 0 && (src.provider === void 0 || typeof src.provider === "string");
 	if (src.type === "data") return typeof src.mimeType === "string";
 	return src.type === "url";
 }
@@ -1119,6 +1031,16 @@ function isContentPartArray(value) {
 	return Array.isArray(value) && value.length > 0 && value.every(isContentPart$1);
 }
 /**
+* Error text for a failed tool result: `output.error` when it is a string,
+* else the output itself when it is a string, else a generic message.
+* `StreamProcessor` and `chat()` history share it, so a reload shows the
+* same text as the live stream.
+*/
+function toolResultErrorText(output) {
+	if (output && typeof output === "object" && "error" in output && typeof output.error === "string") return output.error;
+	return typeof output === "string" ? output : "Tool execution failed";
+}
+/**
 * Normalize a tool's return value for transport:
 * - string            → unchanged
 * - ContentPart array → unchanged (multimodal, passed through to the adapter)
@@ -1130,28 +1052,114 @@ function normalizeToolResult(result) {
 	return JSON.stringify(result);
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/utilities/provider-executed.js
-/**
-* Narrow a tool call's opaque `metadata` to the provider-executed convention.
-* Returns the typed metadata when the call is provider-executed, else `null`.
-*
-* @see ProviderExecutedToolMetadata
-*/
-function getProviderExecutedMetadata(toolCall) {
-	const metadata = toolCall?.metadata;
-	if (typeof metadata === "object" && metadata !== null && metadata.providerExecuted === true) return metadata;
-	return null;
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/utilities/subagent-wire.js
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function wireSubagentRunId(message) {
+	if (!isRecord$2(message) || "parts" in message) return void 0;
+	const id = message.subagentRunId;
+	return typeof id === "string" && id !== "" ? id : void 0;
+}
+function wireSubagentInfo(message) {
+	if (!isRecord$2(message) || !isRecord$2(message.metadata)) return void 0;
+	const tanstack = message.metadata.tanstack;
+	if (!isRecord$2(tanstack) || !isRecord$2(tanstack.subagent)) return void 0;
+	const { name, status, error, interruptIds } = tanstack.subagent;
+	if (typeof name !== "string" || !isStatus(status)) return void 0;
+	const { description, parentSubagentRunId, parentToolCallId, metadata, placeholder } = tanstack.subagent;
+	return {
+		name,
+		status,
+		...typeof description === "string" && { description },
+		...isRecord$2(error) && typeof error.message === "string" && { error: {
+			message: error.message,
+			...typeof error.code === "string" && { code: error.code }
+		} },
+		...Array.isArray(interruptIds) && { interruptIds: interruptIds.filter((id) => typeof id === "string") },
+		...typeof parentSubagentRunId === "string" && { parentSubagentRunId },
+		...typeof parentToolCallId === "string" && { parentToolCallId },
+		...isRecord$2(metadata) && { metadata },
+		...placeholder === true && { placeholder: true }
+	};
+}
+function isStatus(value) {
+	return value === "running" || value === "finished" || value === "error" || value === "suspended";
+}
+function untag(message) {
+	if (!isRecord$2(message)) return message;
+	const { subagentRunId: _id, ...rest } = message;
+	const metadata = isRecord$2(rest.metadata) ? rest.metadata : void 0;
+	const tanstack = isRecord$2(metadata?.tanstack) ? metadata.tanstack : void 0;
+	if (!metadata || !tanstack || !("subagent" in tanstack)) return rest;
+	const { subagent: _info, ...tanstackRest } = tanstack;
+	return {
+		...rest,
+		metadata: {
+			...metadata,
+			tanstack: tanstackRest
+		}
+	};
 }
 /**
-* True when a tool call was executed by the provider (e.g. Anthropic
-* `web_search` / `web_fetch` server tools) rather than the agent loop. Such
-* calls must not be routed to client-side execution and are already "complete".
+* Split wire messages into the parent's own messages and one group per direct
+* child. A nested child's messages stay inside its parent's group.
 */
-function isProviderExecutedToolCall(toolCall) {
-	return getProviderExecutedMetadata(toolCall) !== null;
+function splitSubagentWire(messages) {
+	const parentOf = /* @__PURE__ */ new Map();
+	for (const message of messages) {
+		const id = wireSubagentRunId(message);
+		if (id !== void 0 && !parentOf.has(id)) parentOf.set(id, wireSubagentInfo(message)?.parentSubagentRunId);
+	}
+	const rootOf = (id) => {
+		let current = id;
+		for (let depth = 0; depth < 64; depth++) {
+			const parent = parentOf.get(current);
+			if (parent === void 0 || !parentOf.has(parent)) return current;
+			current = parent;
+		}
+		return current;
+	};
+	const top = [];
+	const groups = /* @__PURE__ */ new Map();
+	for (const message of messages) {
+		const id = wireSubagentRunId(message);
+		if (id === void 0) {
+			top.push(message);
+			continue;
+		}
+		const root = rootOf(id);
+		let group = groups.get(root);
+		if (!group) {
+			group = {
+				id: root,
+				info: {
+					name: "subagent",
+					status: "finished"
+				},
+				messages: [],
+				hostIndex: top.length - 1
+			};
+			groups.set(root, group);
+		}
+		if (id !== root) {
+			group.messages.push(message);
+			continue;
+		}
+		const info = wireSubagentInfo(message);
+		if (info) group.info = info;
+		if (!info?.placeholder) group.messages.push(untag(message));
+	}
+	return {
+		top,
+		groups: [...groups.values()]
+	};
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/activities/chat/messages.js
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/activities/chat/messages.js
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 /**
 * Check if a MessagePart is a content part (text, image, audio, video, document)
 * that maps directly to a ModelMessage ContentPart.
@@ -1196,6 +1204,126 @@ function getTextContent(content) {
 	if (typeof content === "string") return content;
 	return content.filter((part) => part.type === "text").map((part) => part.content).join("");
 }
+function historyTextFromParts(parts) {
+	const blocks = [];
+	for (const part of parts) if (part.type === "text" && part.content !== "") blocks.push(part.content);
+	else if (part.type === "structured-output" && part.status === "complete" && part.raw !== "") blocks.push(part.raw);
+	else if (part.type === "subagent") {
+		const nested = subagentHistoryText(part);
+		if (nested !== "") blocks.push(nested);
+	}
+	return blocks.join("\n\n");
+}
+/** Child text for a later turn. The name stays so the next agent can tell the notes apart. */
+function subagentHistoryText(part) {
+	const blocks = [];
+	for (const message of part.subagent.messages) {
+		if (!("parts" in message)) continue;
+		const text = historyTextFromParts(message.parts).trim();
+		if (text !== "") blocks.push(text);
+	}
+	if (blocks.length === 0) return "";
+	return `${part.subagent.name}:\n${blocks.join("\n\n")}`;
+}
+function toolResultContent(content) {
+	return Array.isArray(content) ? content : getTextContent(content);
+}
+function restoreToolResultOwnership(message) {
+	if (!("role" in message) || message.role !== "tool") return message;
+	const source = message;
+	const owned = tanstackMetadata(source)?.toolResult;
+	if (!isRecord$1(owned)) return message;
+	if ("content" in owned && !isContentPartArray(owned.content)) return message;
+	const next = { ...message };
+	if (!("id" in owned)) Reflect.deleteProperty(next, "id");
+	if (!("createdAt" in owned)) Reflect.deleteProperty(next, "createdAt");
+	if (typeof owned.id === "string") Reflect.set(next, "id", owned.id);
+	if (typeof owned.createdAt === "string") {
+		const createdAt = coerceCreatedAt(owned.createdAt);
+		if (createdAt) Reflect.set(next, "createdAt", createdAt);
+	}
+	if (isContentPartArray(owned.content)) Reflect.set(next, "content", owned.content);
+	const sourceMetadata = Reflect.get(source, "metadata");
+	if (isRecord$1(sourceMetadata)) {
+		const tanstack = sourceMetadata.tanstack;
+		if (isRecord$1(tanstack)) {
+			const { toolResult: _toolResult, ...restTanstack } = tanstack;
+			const restMetadata = { ...sourceMetadata };
+			if (Object.keys(restTanstack).length) restMetadata.tanstack = restTanstack;
+			else delete restMetadata.tanstack;
+			if (Object.keys(restMetadata).length) Reflect.set(next, "metadata", restMetadata);
+			else Reflect.deleteProperty(next, "metadata");
+		}
+	}
+	return next;
+}
+/**
+* Rebuild a `Date` from a live `Date` or from an ISO string.
+* `JSON.stringify` turns `Date` into a string, so persistence reload
+* and AG-UI wire both land here as strings.
+*/
+function coerceCreatedAt(value) {
+	if (value instanceof Date) return Number.isNaN(value.getTime()) ? void 0 : value;
+	if (typeof value !== "string") return void 0;
+	const createdAt = new Date(value);
+	return Number.isNaN(createdAt.getTime()) ? void 0 : createdAt;
+}
+function normalizeMessagePart(part) {
+	if (part.type !== "tool-result") return part;
+	const createdAt = coerceCreatedAt(part.createdAt);
+	const { createdAt: _createdAt, ...rest } = part;
+	return createdAt === void 0 ? rest : {
+		...rest,
+		createdAt
+	};
+}
+function createdAtFromMetadata(source) {
+	return coerceCreatedAt(tanstackMetadata(source)?.createdAt);
+}
+function optionalCreatedAt(source) {
+	const createdAt = coerceCreatedAt(source.createdAt);
+	return createdAt !== void 0 ? { createdAt } : {};
+}
+function optionalName(source) {
+	return source.name !== void 0 ? { name: source.name } : {};
+}
+function isUiResourcePart(value) {
+	if (value == null || typeof value !== "object" || Array.isArray(value)) return false;
+	if (!("type" in value) || value.type !== "ui-resource") return false;
+	if (!("toolCallId" in value) || typeof value.toolCallId !== "string") return false;
+	if (!("toolName" in value) || typeof value.toolName !== "string") return false;
+	if (!("resource" in value) || value.resource == null || typeof value.resource !== "object" || Array.isArray(value.resource)) return false;
+	const resource = value.resource;
+	return "uri" in resource && typeof resource.uri === "string" && "mimeType" in resource && typeof resource.mimeType === "string";
+}
+function uiResourceKey(part) {
+	return `${part.toolCallId}\0${part.toolName}\0${part.resource.uri}`;
+}
+function appendUiResources(ui, resources) {
+	if (resources.length === 0) return ui;
+	const seen = new Set(ui.parts.filter(isUiResourcePart).map((part) => uiResourceKey(part)));
+	const extra = resources.filter((part) => !seen.has(uiResourceKey(part)));
+	if (extra.length === 0) return ui;
+	return {
+		...ui,
+		parts: [...ui.parts, ...extra]
+	};
+}
+function assistantMetadata(uiMessage) {
+	const fromParts = uiMessage.parts.filter(isUiResourcePart);
+	const current = uiMessage.metadata ?? {};
+	const previous = tanstackMetadata(uiMessage);
+	const tanstack = {};
+	if (previous?.model !== void 0) tanstack.model = previous.model;
+	if (previous?.runId !== void 0) tanstack.runId = previous.runId;
+	if (previous?.run?.id !== void 0) tanstack.run = { id: previous.run.id };
+	if (previous?.signature !== void 0) tanstack.signature = previous.signature;
+	if (fromParts.length > 0) tanstack.uiResources = fromParts;
+	const result = { ...current };
+	if (Object.keys(tanstack).length > 0) result.tanstack = tanstack;
+	else delete result.tanstack;
+	return Object.keys(result).length > 0 ? result : void 0;
+}
 /**
 * Convert a UIMessage to ModelMessage(s)
 *
@@ -1231,7 +1359,9 @@ function buildUserOrToolMessage(uiMessage) {
 		id: uiMessage.id,
 		role: uiMessage.role,
 		content: collapseContentParts(contentParts),
-		...uiMessage.createdAt !== void 0 && { createdAt: uiMessage.createdAt }
+		...optionalName(uiMessage),
+		...optionalCreatedAt(uiMessage),
+		...uiMessage.metadata !== void 0 && { metadata: uiMessage.metadata }
 	};
 }
 function createSegment() {
@@ -1257,20 +1387,29 @@ function buildAssistantMessages(uiMessage) {
 	let current = createSegment();
 	let pendingThinking = [];
 	const emittedToolResultIds = /* @__PURE__ */ new Set();
-	function flushSegment() {
+	const identityFields = {
+		id: uiMessage.id,
+		...optionalName(uiMessage),
+		...optionalCreatedAt(uiMessage)
+	};
+	const metadata = assistantMetadata(uiMessage);
+	const assistantFields = {
+		...identityFields,
+		...metadata !== void 0 && { metadata }
+	};
+	function flushSegment(force = false) {
 		const content = collapseContentParts(current.contentParts);
 		const hasContent = content !== null;
 		const hasToolCalls = current.toolCalls.length > 0;
 		const hasThinking = pendingThinking.length > 0;
-		if (hasContent || hasToolCalls || hasThinking) {
+		if (force || hasContent || hasToolCalls || hasThinking) {
 			messageList.push({
-				id: uiMessage.id,
+				...assistantFields,
 				role: "assistant",
 				content,
 				...hasToolCalls && { toolCalls: current.toolCalls },
 				...hasThinking && { thinking: pendingThinking },
-				...current.structuredOutput && { structuredOutput: current.structuredOutput },
-				...uiMessage.createdAt !== void 0 && { createdAt: uiMessage.createdAt }
+				...current.structuredOutput && { structuredOutput: current.structuredOutput }
 			});
 			pendingThinking = [];
 		}
@@ -1296,20 +1435,24 @@ function buildAssistantMessages(uiMessage) {
 			});
 			break;
 		case "tool-result":
-			flushSegment();
+			flushSegment(messageList.length === 0);
 			if ((part.state === "complete" || part.state === "error") && !emittedToolResultIds.has(part.toolCallId)) {
+				const metadata = part.outcome === void 0 ? part.metadata : withTanstackMetadata(part, { toolResultOutcome: part.outcome }).metadata;
 				messageList.push({
-					id: uiMessage.id,
+					...part.id !== void 0 && { id: part.id },
+					...optionalCreatedAt(part),
 					role: "tool",
 					content: part.content,
 					toolCallId: part.toolCallId,
-					...uiMessage.createdAt !== void 0 && { createdAt: uiMessage.createdAt }
+					...part.name !== void 0 && { name: part.name },
+					...metadata !== void 0 && { metadata },
+					...part.error !== void 0 && { error: part.error }
 				});
 				emittedToolResultIds.add(part.toolCallId);
 			}
 			break;
 		case "thinking":
-			if (part.content) {
+			if (part.content || part.signature) {
 				if (current.toolCalls.some(isProviderExecutedToolCall)) flushSegment();
 				pendingThinking.push({
 					content: part.content,
@@ -1317,15 +1460,29 @@ function buildAssistantMessages(uiMessage) {
 				});
 			}
 			break;
-		case "structured-output": if (part.status === "complete") {
-			const serialized = part.raw !== "" ? part.raw : part.data !== void 0 ? safeJsonStringify(part.data) : "";
-			if (serialized !== "") {
+		case "structured-output":
+			if (part.status === "complete") {
+				const serialized = part.raw !== "" ? part.raw : part.data !== void 0 ? safeJsonStringify(part.data) : "";
+				if (serialized !== "") {
+					current.contentParts.push({
+						type: "text",
+						content: serialized
+					});
+					current.structuredOutput = part;
+				}
+			}
+			break;
+		case "ui-resource": break;
+		case "subagent": {
+			const block = part.subagent.parentToolCallId === void 0 ? subagentHistoryText(part) : "";
+			if (block !== "") {
+				const prefix = current.contentParts.length > 0 ? "\n\n" : "";
 				current.contentParts.push({
 					type: "text",
-					content: serialized
+					content: `${prefix}${block}`
 				});
-				current.structuredOutput = part;
 			}
+			break;
 		}
 	}
 	flushSegment();
@@ -1333,18 +1490,15 @@ function buildAssistantMessages(uiMessage) {
 		if (part.type !== "tool-call") continue;
 		if (part.output !== void 0 && !emittedToolResultIds.has(part.id)) {
 			messageList.push({
-				id: uiMessage.id,
 				role: "tool",
 				content: normalizeToolResult(part.output),
-				toolCallId: part.id,
-				...uiMessage.createdAt !== void 0 && { createdAt: uiMessage.createdAt }
+				toolCallId: part.id
 			});
 			emittedToolResultIds.add(part.id);
 		}
 		if (part.output === void 0 && part.state === "approval-responded" && part.approval?.approved !== void 0 && !emittedToolResultIds.has(part.id)) {
 			const approved = part.approval.approved;
 			messageList.push({
-				id: uiMessage.id,
 				role: "tool",
 				content: JSON.stringify({
 					approved,
@@ -1352,16 +1506,15 @@ function buildAssistantMessages(uiMessage) {
 					message: approved ? "User approved this action" : "User denied this action"
 				}),
 				toolCallId: part.id,
-				...uiMessage.createdAt !== void 0 && { createdAt: uiMessage.createdAt }
+				...approved === false && { metadata: { tanstack: { toolResultOutcome: "denied" } } }
 			});
 			emittedToolResultIds.add(part.id);
 		}
 	}
 	if (messageList.length === 0) messageList.push({
-		id: uiMessage.id,
+		...assistantFields,
 		role: "assistant",
-		content: null,
-		...uiMessage.createdAt !== void 0 && { createdAt: uiMessage.createdAt }
+		content: null
 	});
 	return messageList;
 }
@@ -1379,22 +1532,43 @@ function buildAssistantMessages(uiMessage) {
 */
 function modelMessageToUIMessage(modelMessage, id) {
 	const parts = [];
+	const createdAt = coerceCreatedAt(modelMessage.createdAt);
 	if (modelMessage.role === "assistant" && modelMessage.thinking?.length) for (const thinking of modelMessage.thinking) {
-		if (!thinking.content) continue;
+		if (!thinking.content && !thinking.signature) continue;
 		parts.push({
 			type: "thinking",
 			content: thinking.content,
 			...thinking.signature && { signature: thinking.signature }
 		});
 	}
-	if (modelMessage.role === "assistant" && modelMessage.structuredOutput) parts.push(modelMessage.structuredOutput);
-	else if (modelMessage.role === "tool" && modelMessage.toolCallId) parts.push({
-		type: "tool-result",
-		toolCallId: modelMessage.toolCallId,
-		content: getTextContent(modelMessage.content),
-		state: "complete"
-	});
-	else if (Array.isArray(modelMessage.content)) for (const part of modelMessage.content) parts.push(part);
+	const structuredOutput = modelMessage.structuredOutput ?? snapshotStructuredOutput(tanstackMetadata(modelMessage)?.structuredOutput);
+	if (modelMessage.role === "assistant" && structuredOutput) {
+		if (typeof modelMessage.content === "string" && modelMessage.content && modelMessage.content !== structuredOutput.raw) {
+			const suffix = structuredOutput.raw;
+			const text = suffix !== "" && modelMessage.content.endsWith(suffix) ? modelMessage.content.slice(0, -suffix.length) : modelMessage.content;
+			if (text) parts.push({
+				type: "text",
+				content: text
+			});
+		}
+		parts.push(structuredOutput);
+	} else if (modelMessage.role === "tool" && modelMessage.toolCallId) {
+		const rawToolResultOutcome = tanstackMetadata(modelMessage)?.toolResultOutcome;
+		const toolResultOutcome = isToolResultOutcome(rawToolResultOutcome) ? rawToolResultOutcome : void 0;
+		const resultState = modelMessage.error === void 0 && toolResultOutcome === void 0 ? "complete" : "error";
+		parts.push({
+			type: "tool-result",
+			toolCallId: modelMessage.toolCallId,
+			content: toolResultContent(modelMessage.content),
+			state: resultState,
+			...toolResultOutcome !== void 0 && { outcome: toolResultOutcome },
+			...modelMessage.id !== void 0 && { id: modelMessage.id },
+			...modelMessage.name !== void 0 && { name: modelMessage.name },
+			...modelMessage.metadata !== void 0 && { metadata: modelMessage.metadata },
+			...createdAt !== void 0 && { createdAt },
+			...modelMessage.error !== void 0 && { error: modelMessage.error }
+		});
+	} else if (Array.isArray(modelMessage.content)) for (const part of modelMessage.content) parts.push(part);
 	else {
 		const textContent = getTextContent(modelMessage.content);
 		if (textContent) parts.push({
@@ -1419,12 +1593,16 @@ function modelMessageToUIMessage(modelMessage, id) {
 			...toolCall.metadata !== void 0 && { metadata: toolCall.metadata }
 		});
 	}
-	return {
+	const ui = {
 		id: id || generateMessageId(),
 		role: modelMessage.role === "tool" ? "assistant" : modelMessage.role,
 		parts,
-		...modelMessage.createdAt !== void 0 && { createdAt: modelMessage.createdAt }
+		...optionalName(modelMessage),
+		...createdAt !== void 0 && { createdAt },
+		...modelMessage.metadata !== void 0 && { metadata: modelMessage.metadata }
 	};
+	const storedResources = tanstackMetadata(modelMessage)?.uiResources;
+	return appendUiResources(ui, Array.isArray(storedResources) ? storedResources.filter(isUiResourcePart) : []);
 }
 /**
 * Normalize a single AG-UI `MESSAGES_SNAPSHOT` message into a `UIMessage`.
@@ -1455,25 +1633,38 @@ function aguiSnapshotMessageToUIMessage(message) {
 			parts: aguiUserContentToParts(message.content)
 		});
 		case "assistant": {
-			const toolCallMetadata = tanstackMetadata(message)?.toolCallMetadata;
+			const metadata = tanstackMetadata(message);
+			const toolCallMetadata = metadata?.toolCallMetadata;
+			const structuredOutput = snapshotStructuredOutput(metadata?.structuredOutput);
 			const toolCalls = message.toolCalls?.map((toolCall) => {
-				const metadata = toolCallMetadata != null && typeof toolCallMetadata === "object" ? toolCallMetadata[toolCall.id] : void 0;
-				return metadata !== void 0 ? {
+				const callMetadata = toolCallMetadata != null && typeof toolCallMetadata === "object" ? toolCallMetadata[toolCall.id] : void 0;
+				return callMetadata !== void 0 ? {
 					...toolCall,
-					metadata
+					metadata: callMetadata
 				} : toolCall;
 			});
 			return applySnapshotMetadata(message, modelMessageToUIMessage({
 				role: "assistant",
 				content: message.content ?? null,
-				...toolCalls && { toolCalls }
+				...optionalName(message),
+				...toolCalls && { toolCalls },
+				...structuredOutput && { structuredOutput }
+			}, id));
+		}
+		case "tool": {
+			message = restoreToolResultOwnership(message);
+			const createdAt = coerceCreatedAt("createdAt" in message ? message.createdAt : void 0) ?? createdAtFromMetadata(message);
+			return applySnapshotMetadata(message, modelMessageToUIMessage({
+				role: "tool",
+				content: isContentPartArray(message.content) ? message.content : aguiContentToContentParts(message.content),
+				toolCallId: message.toolCallId,
+				..."name" in message && typeof message.name === "string" ? { name: message.name } : {},
+				..."id" in message && typeof message.id === "string" ? { id: message.id } : {},
+				..."metadata" in message && message.metadata != null ? { metadata: message.metadata } : {},
+				...createdAt !== void 0 ? { createdAt } : {},
+				...message.error !== void 0 && { error: message.error }
 			}, id));
 		}
-		case "tool": return applySnapshotMetadata(message, modelMessageToUIMessage({
-			role: "tool",
-			content: message.content,
-			toolCallId: message.toolCallId
-		}, id));
 		case "system":
 		case "developer": return applySnapshotMetadata(message, {
 			id,
@@ -1485,12 +1676,13 @@ function aguiSnapshotMessageToUIMessage(message) {
 		});
 		case "reasoning": {
 			const signature = encryptedValueFrom(message);
+			const content = typeof message.content === "string" ? message.content : "";
 			return applySnapshotMetadata(message, {
 				id,
 				role: "assistant",
-				parts: message.content ? [{
+				parts: content || signature !== void 0 ? [{
 					type: "thinking",
-					content: message.content,
+					content,
 					...signature !== void 0 ? { signature } : {}
 				}] : []
 			});
@@ -1504,17 +1696,50 @@ function aguiSnapshotMessageToUIMessage(message) {
 }
 /** Copy snapshot metadata when it is a record. Rebuild createdAt from tanstack.createdAt. */
 function applySnapshotMetadata(source, ui) {
-	if (!("metadata" in source)) return ui;
-	const raw = source.metadata;
-	if (raw == null || typeof raw !== "object" || Array.isArray(raw)) return ui;
-	const metadata = raw;
-	const createdAtRaw = tanstackMetadata(metadata)?.createdAt;
-	const createdAt = typeof createdAtRaw === "string" ? new Date(createdAtRaw) : void 0;
-	const createdAtValid = createdAt !== void 0 && !Number.isNaN(createdAt.getTime());
-	return {
+	const normalizedParts = ui.parts.map((part) => normalizeMessagePart(part));
+	if (normalizedParts !== ui.parts) ui = {
+		...ui,
+		parts: normalizedParts
+	};
+	const name = "name" in source && typeof source.name === "string" ? source.name : void 0;
+	let next = name !== void 0 ? {
 		...ui,
-		metadata,
-		...createdAtValid ? { createdAt } : {}
+		name
+	} : ui;
+	let metadata;
+	if ("metadata" in source) {
+		const raw = source.metadata;
+		if (raw != null && typeof raw === "object" && !Array.isArray(raw)) {
+			metadata = raw;
+			next = {
+				...next,
+				metadata
+			};
+		}
+	}
+	const createdAt = coerceCreatedAt(next.createdAt) ?? (metadata !== void 0 ? createdAtFromMetadata(metadata) : void 0);
+	if (createdAt !== void 0 && !Object.is(createdAt, next.createdAt)) next = {
+		...next,
+		createdAt
+	};
+	else if (createdAt === void 0 && next.createdAt !== void 0) {
+		const { createdAt: _invalid, ...rest } = next;
+		next = rest;
+	}
+	const uiResources = tanstackMetadata(metadata)?.uiResources;
+	const resources = Array.isArray(uiResources) ? uiResources.filter(isUiResourcePart) : [];
+	return appendUiResources(next, resources);
+}
+function snapshotStructuredOutput(value) {
+	if (value == null || value.status !== "streaming" && value.status !== "complete" && value.status !== "error" || typeof value.raw !== "string") return;
+	return {
+		type: "structured-output",
+		status: value.status,
+		raw: value.raw,
+		...value.partial !== void 0 ? { partial: value.partial } : {},
+		...value.data !== void 0 ? { data: value.data } : {},
+		...value.reasoning ? { reasoning: value.reasoning } : {},
+		...value.errorMessage !== void 0 ? { errorMessage: value.errorMessage } : {}
 	};
 }
 /**
@@ -1523,21 +1748,26 @@ function applySnapshotMetadata(source, ui) {
 * AG-UI user content is either a plain string or a multimodal array whose text
 * entries use `{ type: 'text', text }` (vs. TanStack's `{ type: 'text', content }`).
 * Text entries are rewritten to the TanStack shape; image/audio/video/document
-* entries already match `ContentPart` and pass through. `binary` entries have no
-* TanStack equivalent and are dropped.
+* entries already match `ContentPart` and pass through.
 */
 function aguiUserContentToParts(content) {
-	if (typeof content === "string") return content ? [{
-		type: "text",
-		content
-	}] : [];
-	const parts = [];
-	for (const part of content) if (part.type === "text") parts.push({
+	const converted = aguiContentToContentParts(content);
+	return typeof converted === "string" ? converted ? [{
 		type: "text",
-		content: part.text
+		content: converted
+	}] : [] : converted;
+}
+/** Convert wire content parts. Data, url, and file sources pass through. */
+function aguiContentToContentParts(content) {
+	if (typeof content === "string") return content;
+	return content.map((part) => {
+		if (part.type !== "text") return part;
+		const { text, ...rest } = part;
+		return {
+			...rest,
+			content: text
+		};
 	});
-	else if (part.type !== "binary") parts.push(part);
-	return parts;
 }
 /**
 * Normalize a message (UIMessage or ModelMessage) to a UIMessage
@@ -1548,14 +1778,17 @@ function aguiUserContentToParts(content) {
 * @returns A UIMessage with guaranteed id and createdAt
 */
 function normalizeToUIMessage(message, generateId) {
-	if ("parts" in message) return {
-		...message,
-		id: message.id || generateId(),
-		createdAt: message.createdAt || /* @__PURE__ */ new Date()
-	};
-	else return {
+	if ("parts" in message) {
+		const parts = message.parts.map((part) => normalizeMessagePart(part));
+		return {
+			...message,
+			parts,
+			id: message.id || generateId(),
+			createdAt: coerceCreatedAt(message.createdAt) ?? /* @__PURE__ */ new Date()
+		};
+	} else return {
 		...modelMessageToUIMessage(message, generateId()),
-		createdAt: message.createdAt ?? /* @__PURE__ */ new Date()
+		createdAt: coerceCreatedAt(message.createdAt) ?? /* @__PURE__ */ new Date()
 	};
 }
 /**
@@ -1565,7 +1798,357 @@ function generateMessageId() {
 	return `msg-${Date.now()}-${Math.random().toString(36).substring(7)}`;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/activities/chat/tools/tool-definition.js
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/utilities/ag-ui-wire.js
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function rebuiltToolMetadata(metadata, createdAt, id, content, anchorOwnsUiResources = false, outcome) {
+	const source = isRecord(metadata) ? metadata : {};
+	const tanstack = isRecord(source.tanstack) ? { ...source.tanstack } : {};
+	if (anchorOwnsUiResources) delete tanstack.uiResources;
+	const date = coerceCreatedAt(createdAt);
+	const toolResult = {
+		...id !== void 0 ? { id } : {},
+		...date && { createdAt: date.toISOString() },
+		...Array.isArray(content) && { content }
+	};
+	const result = {
+		...source,
+		tanstack: {
+			...tanstack,
+			...outcome !== void 0 && { toolResultOutcome: outcome },
+			toolResult
+		}
+	};
+	return Object.keys(result).length ? result : void 0;
+}
+/**
+* Serialize TanStack `UIMessage`s and `ModelMessage`s into the AG-UI
+* `RunAgentInput.messages` wire shape. Anchors are spec-only (`id`, `role`,
+* `name`, `content`, `toolCalls`, `metadata`). Tool results and thinking parts
+* on assistant messages are additionally emitted as fan-out
+* `{role:'tool',...}` and `{role:'reasoning',...}` entries for strict AG-UI
+* server consumers. Set `includeSnapshotStructuredOutput` to retain complete
+* structured-output metadata for UI snapshots.
+*/
+function uiMessagesToWire(messages, options) {
+	const wire = [];
+	const usedWireIds = new Set(messages.flatMap((message) => "id" in message && message.id && message.role !== "tool" ? [message.id] : []));
+	const includeSnapshotStructuredOutput = options?.includeSnapshotStructuredOutput ?? false;
+	const assistantIds = /* @__PURE__ */ new Set();
+	for (const msg of messages) if (msg.role === "assistant" && msg.id !== void 0) assistantIds.add(msg.id);
+	for (const msg of messages) {
+		if (!("parts" in msg) && msg.role === "tool" && msg.toolCallId) {
+			const id = uniqueToolWireId(toolWireId(msg.id, msg.toolCallId, assistantIds), usedWireIds);
+			const metadata = rebuiltToolMetadata(msg.metadata, msg.createdAt, msg.id, msg.content);
+			wire.push({
+				role: "tool",
+				id,
+				...msg.name !== void 0 && { name: msg.name },
+				toolCallId: msg.toolCallId,
+				content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+				...msg.error !== void 0 && { error: msg.error },
+				...metadata !== void 0 && { metadata }
+			});
+			continue;
+		}
+		const uiMessage = "parts" in msg ? msg : modelMessageToUIMessage(msg, msg.id);
+		const parts = uiMessage.parts;
+		usedWireIds.add(uiMessage.id);
+		if (msg.role === "system") {
+			wire.push(toAnchor(uiMessage, "system", { content: parts.length > 0 ? collectText(parts) : msg.content ?? "" }, parts, includeSnapshotStructuredOutput));
+			continue;
+		}
+		if (msg.role === "user") {
+			wire.push(toAnchor(uiMessage, "user", { content: parts.length > 0 ? collectUserContent(parts) : msg.content ?? "" }, parts, includeSnapshotStructuredOutput));
+			continue;
+		}
+		let current = {
+			thinking: [],
+			parts: []
+		};
+		const segments = [current];
+		for (const part of parts) if (part.type === "thinking") if (current.parts.some((p) => p.type === "tool-call" && isProviderExecutedToolCall(p))) {
+			current = {
+				thinking: [part],
+				parts: []
+			};
+			segments.push(current);
+		} else current.thinking.push(part);
+		else current.parts.push(part);
+		segments.forEach((segment, index) => {
+			for (const part of segment.thinking) {
+				const reasoning = {
+					role: "reasoning",
+					id: uniqueWireId(deriveReasoningId(uiMessage.id, part), usedWireIds),
+					content: part.content
+				};
+				if (part.signature) reasoning.encryptedValue = part.signature;
+				wire.push(reasoning);
+			}
+			const text = collectText(segment.parts);
+			const toolCalls = collectToolCalls(segment.parts);
+			const anchorMessage = index === 0 ? uiMessage : {
+				...uiMessage,
+				id: uniqueWireId(`${uiMessage.id}-segment-${index}`, usedWireIds)
+			};
+			wire.push(toAnchor(anchorMessage, "assistant", {
+				...text !== "" && { content: text },
+				...toolCalls && { toolCalls }
+			}, segment.parts, includeSnapshotStructuredOutput));
+		});
+		const explicitToolResults = new Set(parts.flatMap((part) => part.type === "tool-result" ? [part.toolCallId] : []));
+		for (const part of parts) if (part.type === "tool-result") {
+			const id = uniqueToolWireId(part.id ?? deriveToolMessageId(part.toolCallId), usedWireIds);
+			const metadata = rebuiltToolMetadata(part.metadata, part.createdAt, part.id, part.content, true, part.outcome);
+			wire.push({
+				role: "tool",
+				id,
+				toolCallId: part.toolCallId,
+				...part.name !== void 0 && { name: part.name },
+				content: typeof part.content === "string" ? part.content : JSON.stringify(part.content),
+				...part.error !== void 0 && { error: part.error },
+				...metadata !== void 0 && { metadata }
+			});
+		} else if (part.type === "tool-call") {
+			const approved = part.approval?.approved;
+			if (explicitToolResults.has(part.id) || part.output === void 0 && (part.state !== "approval-responded" || approved === void 0)) continue;
+			const result = part.output !== void 0 ? normalizeToolResult(part.output) : JSON.stringify({
+				approved,
+				...approved && { pendingExecution: true },
+				message: approved ? "User approved this action" : "User denied this action"
+			});
+			const content = typeof result === "string" ? result : JSON.stringify(result);
+			wire.push({
+				role: "tool",
+				id: uniqueToolWireId(deriveToolMessageId(part.id), usedWireIds),
+				toolCallId: part.id,
+				content,
+				metadata: rebuiltToolMetadata(void 0, void 0, void 0, result, false, part.approval?.approved === false ? "denied" : void 0)
+			});
+		}
+		for (const part of parts) if (part.type === "subagent") wire.push(...subagentToWire(part, options));
+	}
+	return wire;
+}
+function toAnchor(msg, role, extras, parts, includeSnapshotStructuredOutput) {
+	const metadata = messageMetadata(msg, parts, includeSnapshotStructuredOutput);
+	const base = {
+		id: msg.id,
+		...msg.name !== void 0 && { name: msg.name },
+		...metadata !== void 0 && { metadata }
+	};
+	if (role === "system") return {
+		...base,
+		role,
+		content: String(extras.content ?? "")
+	};
+	if (role === "user") return {
+		...base,
+		role,
+		content: extras.content ?? ""
+	};
+	return {
+		...base,
+		role,
+		...typeof extras.content === "string" && { content: extras.content },
+		...extras.toolCalls !== void 0 && { toolCalls: extras.toolCalls }
+	};
+}
+function messageMetadata(msg, parts, includeSnapshotStructuredOutput) {
+	const base = { ...msg.metadata ?? {} };
+	const previousTanstack = tanstackMetadata(msg);
+	const tanstack = {};
+	if (previousTanstack?.model !== void 0) tanstack.model = previousTanstack.model;
+	if (previousTanstack?.runId !== void 0) tanstack.runId = previousTanstack.runId;
+	if (previousTanstack?.run?.id !== void 0) tanstack.run = { id: previousTanstack.run.id };
+	if (previousTanstack?.signature !== void 0) tanstack.signature = previousTanstack.signature;
+	const createdAt = coerceCreatedAt(msg.createdAt);
+	if (createdAt !== void 0) tanstack.createdAt = createdAt.toISOString();
+	const structuredOutput = serializedStructuredOutput(parts, includeSnapshotStructuredOutput);
+	if (structuredOutput) tanstack.structuredOutput = structuredOutput;
+	const toolCallMetadata = {};
+	for (const part of parts) if (part.type === "tool-call" && part.metadata !== void 0) toolCallMetadata[part.id] = part.metadata;
+	if (Object.keys(toolCallMetadata).length > 0) tanstack.toolCallMetadata = toolCallMetadata;
+	const uiResources = parts.filter((p) => p.type === "ui-resource");
+	if (uiResources.length > 0) tanstack.uiResources = uiResources;
+	if (Object.keys(tanstack).length > 0) base.tanstack = tanstack;
+	else delete base.tanstack;
+	return Object.keys(base).length > 0 ? base : void 0;
+}
+function serializedStructuredOutput(parts, includeSnapshotStructuredOutput) {
+	for (const p of parts) if (p.type === "structured-output" && (includeSnapshotStructuredOutput || p.status !== "complete")) return structuredOutputMetadata(p, includeSnapshotStructuredOutput);
+}
+function structuredOutputMetadata(part, includeSnapshotStructuredOutput) {
+	return {
+		status: part.status,
+		raw: part.raw,
+		...includeSnapshotStructuredOutput && part.partial !== void 0 ? { partial: part.partial } : {},
+		...includeSnapshotStructuredOutput && part.data !== void 0 ? { data: part.data } : {},
+		...includeSnapshotStructuredOutput && part.reasoning ? { reasoning: part.reasoning } : {},
+		...part.errorMessage !== void 0 && { errorMessage: part.errorMessage }
+	};
+}
+function collectText(parts) {
+	const out = [];
+	for (const p of parts) if (p.type === "text") out.push(p.content);
+	else if (p.type === "structured-output" && p.status === "complete" && p.raw !== "") out.push(p.raw);
+	return out.join("");
+}
+/**
+* A child's messages, tagged with its AG-UI `subagentRunId`. The card data
+* rides in `metadata.tanstack.subagent`, so the other side can rebuild the
+* card and continue a suspended child.
+*/
+function subagentToWire(part, options) {
+	const { subagent } = part;
+	const info = {
+		name: subagent.name,
+		status: subagent.status,
+		...subagent.description !== void 0 && { description: subagent.description },
+		...subagent.error !== void 0 && { error: subagent.error },
+		...subagent.interruptIds !== void 0 && { interruptIds: subagent.interruptIds },
+		...subagent.parentSubagentRunId !== void 0 && { parentSubagentRunId: subagent.parentSubagentRunId },
+		...subagent.parentToolCallId !== void 0 && { parentToolCallId: subagent.parentToolCallId },
+		...subagent.metadata !== void 0 && { metadata: subagent.metadata }
+	};
+	const child = uiMessagesToWire(subagent.messages, options);
+	const own = child.some((message) => wireSubagentRunId(message) === void 0);
+	return (own ? child : [{
+		id: `subagent:${subagent.id}`,
+		role: "assistant"
+	}, ...child]).map((message, index) => {
+		const nestedId = wireSubagentRunId(message);
+		if (nestedId !== void 0) {
+			const nested = wireSubagentInfo(message);
+			if (!nested || nested.parentSubagentRunId !== void 0) return message;
+			return withSubagentInfo(message, nestedId, {
+				...nested,
+				parentSubagentRunId: subagent.id
+			});
+		}
+		return withSubagentInfo(message, subagent.id, !own && index === 0 ? {
+			...info,
+			placeholder: true
+		} : info);
+	});
+}
+function withSubagentInfo(message, subagentRunId, info) {
+	const metadata = isRecord(message.metadata) ? message.metadata : {};
+	const tanstack = isRecord(metadata.tanstack) ? metadata.tanstack : {};
+	return {
+		...message,
+		subagentRunId,
+		metadata: {
+			...metadata,
+			tanstack: {
+				...tanstack,
+				subagent: info
+			}
+		}
+	};
+}
+function collectUserContent(parts) {
+	if (!parts.some((p) => p.type === "image" || p.type === "audio" || p.type === "video" || p.type === "document")) return collectText(parts);
+	const out = [];
+	for (const p of parts) if (p.type === "text") out.push({
+		type: "text",
+		text: p.content
+	});
+	else if (p.type === "image" || p.type === "audio" || p.type === "video" || p.type === "document") out.push(p);
+	return out;
+}
+function thoughtSignatureFromMetadata(metadata) {
+	if (metadata == null || typeof metadata !== "object" || Array.isArray(metadata)) return;
+	if (!("thoughtSignature" in metadata)) return void 0;
+	const value = metadata.thoughtSignature;
+	return typeof value === "string" && value !== "" ? value : void 0;
+}
+function collectToolCalls(parts) {
+	const calls = [];
+	for (const p of parts) if (p.type === "tool-call") {
+		const encryptedValue = thoughtSignatureFromMetadata(p.metadata);
+		calls.push({
+			id: p.id,
+			type: "function",
+			function: {
+				name: p.name,
+				arguments: p.arguments
+			},
+			...encryptedValue !== void 0 ? { encryptedValue } : {}
+		});
+	}
+	return calls.length > 0 ? calls : void 0;
+}
+function deriveReasoningId(messageId, part) {
+	return `${messageId}-reasoning-${part.id ?? hashContent(part.content)}`;
+}
+function deriveToolMessageId(toolCallId) {
+	return `tool-${toolCallId}`;
+}
+function uniqueToolWireId(id, used) {
+	return uniqueWireId(id, used);
+}
+function uniqueWireId(id, used) {
+	if (!used.has(id)) {
+		used.add(id);
+		return id;
+	}
+	let suffix = 2;
+	while (used.has(`${id}-${suffix}`)) suffix++;
+	const unique = `${id}-${suffix}`;
+	used.add(unique);
+	return unique;
+}
+function toolWireId(id, toolCallId, assistantIds) {
+	const derived = deriveToolMessageId(toolCallId);
+	if (id === void 0 || assistantIds.has(id)) return derived;
+	return id;
+}
+function hashContent(s) {
+	let h = 0;
+	for (let i = 0; i < s.length; i++) h = h * 31 + s.charCodeAt(i) | 0;
+	return Math.abs(h).toString(36);
+}
+//#endregion
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/utilities/restore-inbound-chunk.js
+/**
+* Rebuild TanStack `TokenUsage` (`promptTokens`) from spec `usage[]` plus
+* leftover fields in `metadata.tanstack.usage`. Restore in-process aliases
+* that the wire does not keep (`toolName`, `TOOL_CALL_END.input`). Mutates
+* in place so WeakMap run-id stamps stay attached.
+*/
+function restorePublicUsage(chunk) {
+	if ((chunk.type === EventType.RUN_FINISHED || chunk.type === EventType.RUN_ERROR) && (Array.isArray(chunk.usage) || isTanstackUsage(chunk.usage))) {
+		const rebuilt = rebuildTokenUsage(chunk.usage, tanstackMetadata(chunk)?.usage);
+		if (rebuilt !== void 0) chunk.usage = rebuilt;
+	}
+	if (chunk.type === EventType.TOOL_CALL_START && chunk.toolName === void 0 && chunk.toolCallName) chunk.toolName = chunk.toolCallName;
+	if (chunk.type === EventType.TOOL_CALL_END && chunk.input === void 0) {
+		const input = tanstackMetadata(chunk)?.input;
+		if (input !== void 0) chunk.input = input;
+	}
+	return chunk;
+}
+/**
+* Rebuild the pre-wire chunk shape after SSE/HTTP/WS ingest.
+* Copies `metadata.tanstack` extras back to top-level fields and rebuilds
+* TanStack `TokenUsage` from spec `usage[]` when present.
+*/
+function restoreInboundChunk(chunk) {
+	restorePublicUsage(chunk);
+	const tanstack = tanstackMetadata(chunk);
+	const next = chunk;
+	if (tanstack == null) return next;
+	for (const [key, value] of Object.entries(tanstack)) {
+		if (key === "usage" || key === "interruptErrors") continue;
+		if (next[key] === void 0 && value !== void 0) next[key] = value;
+	}
+	if (tanstack.interruptErrors !== void 0) next["tanstack:interruptErrors"] = tanstack.interruptErrors;
+	return next;
+}
+//#endregion
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/activities/chat/tools/tool-definition.js
 /**
 * Create an isomorphic tool definition that can be used directly or instantiated for server/client
 *
@@ -1627,6 +2210,7 @@ function toolDefinition(config) {
 	const outputSchema = config.outputSchema;
 	const approvalSchema = config.approvalSchema;
 	const needsApproval = config.needsApproval;
+	const execution = config.execution;
 	return {
 		__toolSide: "definition",
 		...config,
@@ -1634,6 +2218,7 @@ function toolDefinition(config) {
 		outputSchema,
 		approvalSchema,
 		needsApproval,
+		execution,
 		server(execute) {
 			return {
 				__toolSide: "server",
@@ -1642,6 +2227,7 @@ function toolDefinition(config) {
 				outputSchema,
 				approvalSchema,
 				needsApproval,
+				execution,
 				execute
 			};
 		},
@@ -1653,13 +2239,14 @@ function toolDefinition(config) {
 				outputSchema,
 				approvalSchema,
 				needsApproval,
+				execution,
 				...execute !== void 0 && { execute }
 			};
 		}
 	};
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/utilities/chunk-ids.js
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/utilities/chunk-ids.js
 function stringField(value) {
 	return typeof value === "string" && value !== "" ? value : void 0;
 }
@@ -1762,7 +2349,7 @@ var require_options = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.default = exports.Allow;
 }));
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/json-parser.js
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/json-parser.js
 var import_dist = (/* @__PURE__ */ __commonJSMin(((exports) => {
 	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
 		if (k2 === void 0) k2 = k;
@@ -1984,7 +2571,7 @@ function parsePartialJSON(jsonString) {
 	return defaultJSONParser.parse(jsonString);
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/strategies.js
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/strategies.js
 /**
 * Immediate Strategy - emit on every chunk (default behavior)
 */
@@ -1994,7 +2581,7 @@ var ImmediateStrategy = class {
 	}
 };
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/utilities/errors.js
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/utilities/errors.js
 /**
 * Convert an AG-UI RUN_ERROR event to the Error shape exposed to consumers.
 * Preserves the provider code and sanitized raw event when available, while
@@ -2008,7 +2595,7 @@ function runErrorEventToError(chunk) {
 	return error;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/message-updaters.js
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/message-updaters.js
 /**
 * Message Updaters (Internal)
 *
@@ -2072,7 +2659,7 @@ function updateToolCallPart(messages, messageId, toolCall) {
 /**
 * Update or add a tool result part to a message.
 */
-function updateToolResultPart(messages, messageId, toolCallId, content, state, error) {
+function updateToolResultPart(messages, messageId, toolCallId, content, state, error, outcome) {
 	return messages.map((msg) => {
 		if (msg.id !== messageId) return msg;
 		const parts = [...msg.parts];
@@ -2082,6 +2669,7 @@ function updateToolResultPart(messages, messageId, toolCallId, content, state, e
 			toolCallId,
 			content,
 			state,
+			...outcome !== void 0 && { outcome },
 			...error && { error }
 		};
 		if (resultPartIndex >= 0) parts[resultPartIndex] = toolResultPart;
@@ -2284,12 +2872,19 @@ function updateThinkingPart(messages, messageId, stepId, content, signature) {
 	return messages.map((msg) => {
 		if (msg.id !== messageId) return msg;
 		const parts = [...msg.parts];
-		const thinkingPartIndex = parts.findIndex((p) => p.type === "thinking" && p.stepId === stepId);
+		let thinkingPartIndex = parts.findIndex((p) => p.type === "thinking" && p.stepId === stepId);
+		let adopted;
+		if (thinkingPartIndex < 0) {
+			thinkingPartIndex = parts.findIndex((p) => p.type === "thinking" && p.stepId === void 0);
+			const candidate = parts[thinkingPartIndex];
+			if (candidate?.type === "thinking") adopted = candidate;
+		}
+		const nextSignature = signature ?? adopted?.signature;
 		const thinkingPart = {
 			type: "thinking",
 			content,
 			stepId,
-			...signature && { signature }
+			...nextSignature && { signature: nextSignature }
 		};
 		if (thinkingPartIndex >= 0) parts[thinkingPartIndex] = thinkingPart;
 		else parts.push(thinkingPart);
@@ -2300,7 +2895,7 @@ function updateThinkingPart(messages, messageId, stepId, content, signature) {
 	});
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/processor.js
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/processor.js
 /**
 * Unified Stream Processor
 *
@@ -2330,6 +2925,22 @@ function interruptBatchHasGeneric(interrupts) {
 	});
 }
 /**
+* The canonical arguments string for a `TOOL_CALL_END.input`, or `undefined`
+* when JSON cannot carry it: `JSON.stringify` returns `undefined` (despite
+* its declared type) for a top-level function or symbol and throws on BigInt
+* and circular references. `null` is not tool arguments either, so it also
+* keeps the streamed value instead of writing `arguments = "null"`.
+*/
+function serializeToolInput(input) {
+	if (input === void 0 || input === null) return void 0;
+	try {
+		const serialized = JSON.stringify(input);
+		return typeof serialized === "string" ? serialized : void 0;
+	} catch {
+		return;
+	}
+}
+/**
 * StreamProcessor - State machine for processing AI response streams
 *
 * Manages the full UIMessage[] conversation and emits events on changes.
@@ -2359,12 +2970,17 @@ var StreamProcessor = class StreamProcessor {
 	structuredMessageIds = /* @__PURE__ */ new Set();
 	structuredOutputUpdateBatches = /* @__PURE__ */ new Map();
 	activeRuns = /* @__PURE__ */ new Set();
+	childProcessors = /* @__PURE__ */ new Map();
+	childToolCalls = /* @__PURE__ */ new Map();
 	finishReason = null;
 	hasError = false;
 	isDone = false;
+	streamEndEmitted = false;
 	recording = null;
 	recordingStartTime = 0;
+	subagentRunId;
 	constructor(options = {}) {
+		this.subagentRunId = options.subagentRunId;
 		this.chunkStrategy = options.chunkStrategy || new ImmediateStrategy();
 		this.events = options.events || {};
 		this.jsonParser = options.jsonParser || defaultJSONParser;
@@ -2379,6 +2995,33 @@ var StreamProcessor = class StreamProcessor {
 		this.emitMessagesChange();
 	}
 	/**
+	* Put older UI messages at the front of the conversation.
+	*
+	* Skip a message if its id is already in the list. Keep the existing message.
+	* Then emit the same messages-change event as `setMessages`.
+	*
+	* Use this for older history pages. The first hydrate window uses `setMessages`.
+	*
+	* @param messages Older UI messages in insertion order. The first item is the oldest.
+	*
+	* @example
+	* ```ts
+	* processor.setMessages([newest])
+	* processor.prependMessages([oldest])
+	* ```
+	*/
+	prependMessages(messages) {
+		const existingIds = new Set(this.messages.map((message) => message.id));
+		const olderMessages = [];
+		for (const message of messages) {
+			if (existingIds.has(message.id)) continue;
+			existingIds.add(message.id);
+			olderMessages.push(message);
+		}
+		this.messages = [...olderMessages, ...this.messages];
+		this.emitMessagesChange();
+	}
+	/**
 	* Add a user message to the conversation.
 	* Supports both simple string content and multimodal content arrays.
 	*
@@ -2456,6 +3099,11 @@ var StreamProcessor = class StreamProcessor {
 	addToolResult(toolCallId, output, error) {
 		const messageWithToolCall = this.messages.find((msg) => msg.parts.some((p) => p.type === "tool-call" && p.id === toolCallId));
 		if (!messageWithToolCall) {
+			const owner = this.childOwningToolCall((part) => part.id === toolCallId);
+			if (owner !== void 0) {
+				this.updateChild(owner, (child) => child.addToolResult(toolCallId, output, error));
+				return;
+			}
 			console.warn(`[StreamProcessor] Could not find message with tool call ${toolCallId}`);
 			return;
 		}
@@ -2470,6 +3118,11 @@ var StreamProcessor = class StreamProcessor {
 	* Add an approval response (called by client after handling onApprovalRequest)
 	*/
 	addToolApprovalResponse(approvalId, approved) {
+		const owner = this.childOwningToolCall((part) => part.approval?.id === approvalId);
+		if (owner !== void 0) {
+			this.updateChild(owner, (child) => child.addToolApprovalResponse(approvalId, approved));
+			return;
+		}
 		this.messages = updateToolCallApprovalResponse(this.messages, approvalId, approved);
 		this.emitMessagesChange();
 	}
@@ -2523,6 +3176,8 @@ var StreamProcessor = class StreamProcessor {
 		this.structuredMessageIds.clear();
 		this.structuredOutputUpdateBatches.clear();
 		this.pendingManualMessageId = null;
+		this.childProcessors.clear();
+		this.childToolCalls.clear();
 		this.emitMessagesChange();
 	}
 	/**
@@ -2551,7 +3206,17 @@ var StreamProcessor = class StreamProcessor {
 			timestamp: Date.now(),
 			index: this.recording.chunks.length
 		});
+		if (this.routeToChild(chunk)) return;
 		switch (chunk.type) {
+			case "SUBAGENT_STARTED":
+				this.handleSubagentStartedEvent(chunk);
+				break;
+			case "SUBAGENT_FINISHED":
+				this.handleSubagentFinishedEvent(chunk);
+				break;
+			case "SUBAGENT_ERROR":
+				this.handleSubagentErrorEvent(chunk);
+				break;
 			case "TEXT_MESSAGE_START":
 				this.handleTextMessageStartEvent(chunk);
 				break;
@@ -2659,8 +3324,16 @@ var StreamProcessor = class StreamProcessor {
 			const state = this.messageStates.get(id);
 			if (state && state.role === "assistant") return id;
 		}
+		for (const [id, state] of [...this.messageStates].reverse()) if (state.role === "assistant") return id;
 		return null;
 	}
+	resumeAssistantState(id, state) {
+		this.activeMessageIds.add(id);
+		if (state.isComplete || this.isDone) {
+			state.isComplete = false;
+			this.isDone = false;
+		}
+	}
 	/**
 	* Ensure an active assistant message exists, creating one if needed.
 	* Used for backward compat when events arrive without prior TEXT_MESSAGE_START.
@@ -2673,18 +3346,24 @@ var StreamProcessor = class StreamProcessor {
 	ensureAssistantMessage(preferredId) {
 		if (preferredId) {
 			const state = this.getMessageState(preferredId);
-			if (state) return {
-				messageId: preferredId,
-				state
-			};
+			if (state) {
+				this.resumeAssistantState(preferredId, state);
+				return {
+					messageId: preferredId,
+					state
+				};
+			}
 		}
 		const activeId = this.getActiveAssistantMessageId();
 		if (activeId) {
 			const state = this.getMessageState(activeId);
-			if (state) return {
-				messageId: activeId,
-				state
-			};
+			if (state) {
+				this.resumeAssistantState(activeId, state);
+				return {
+					messageId: activeId,
+					state
+				};
+			}
 		}
 		if (preferredId) {
 			const existingMsg = this.messages.find((m) => m.id === preferredId);
@@ -2738,9 +3417,8 @@ var StreamProcessor = class StreamProcessor {
 			tanstack: Object.fromEntries(Object.entries(incomingTanstack).filter(([key]) => key !== "content" && key !== "args"))
 		} : incomingRecord;
 		const metadata = mergeMetadata(message.metadata, toMerge);
-		const createdAtRaw = tanstackMetadata(incomingRecord)?.createdAt;
-		const createdAt = typeof createdAtRaw === "string" ? new Date(createdAtRaw) : void 0;
-		const createdAtValid = createdAt !== void 0 && !Number.isNaN(createdAt.getTime());
+		const createdAt = coerceCreatedAt(tanstackMetadata(incomingRecord)?.createdAt);
+		const createdAtValid = createdAt !== void 0;
 		this.messages = this.messages.map((msg) => msg.id === messageId ? {
 			...msg,
 			...metadata !== void 0 ? { metadata } : {},
@@ -2748,6 +3426,164 @@ var StreamProcessor = class StreamProcessor {
 		} : msg);
 		this.emitMessagesChange();
 	}
+	findSubagentPart(subagentRunId) {
+		for (const message of this.messages) for (const part of message.parts) if (part.type === "subagent" && part.subagent.id === subagentRunId) return {
+			message,
+			part
+		};
+	}
+	/**
+	* The direct child whose card holds `id`: the child itself, or a nested
+	* child inside its messages.
+	*/
+	childOwning(id) {
+		const holds = (messages) => messages.some((message) => message.parts.some((part) => part.type === "subagent" && (part.subagent.id === id || holds(part.subagent.messages))));
+		for (const message of this.messages) for (const part of message.parts) {
+			if (part.type !== "subagent") continue;
+			if (part.subagent.id === id || holds(part.subagent.messages)) return part.subagent.id;
+		}
+	}
+	/** The direct child whose messages hold this tool call. */
+	childOwningToolCall(matches) {
+		const holds = (messages) => messages.some((message) => message.parts.some((part) => part.type === "tool-call" && matches(part) || part.type === "subagent" && holds(part.subagent.messages)));
+		for (const message of this.messages) for (const part of message.parts) if (part.type === "subagent" && holds(part.subagent.messages)) return part.subagent.id;
+	}
+	/**
+	* The processor for a direct child. The card's messages are the source of
+	* truth. The processor re-reads them when something else replaced them.
+	*/
+	childProcessor(subagentRunId) {
+		const found = this.findSubagentPart(subagentRunId);
+		if (!found) return void 0;
+		const messages = found.part.subagent.messages;
+		const existing = this.childProcessors.get(subagentRunId);
+		if (existing) {
+			if (existing.getMessages() !== messages) existing.messages = messages;
+			return existing;
+		}
+		const child = new StreamProcessor({
+			subagentRunId,
+			initialMessages: messages,
+			events: {
+				onToolCall: (args) => this.events.onToolCall?.(args),
+				onApprovalRequest: (args) => this.events.onApprovalRequest?.(args),
+				onCustomEvent: (name, value, context) => this.events.onCustomEvent?.(name, value, context)
+			}
+		});
+		this.childProcessors.set(subagentRunId, child);
+		return child;
+	}
+	/** Run `update` on a direct child, then copy its messages onto the card. */
+	updateChild(subagentRunId, update) {
+		const child = this.childProcessor(subagentRunId);
+		if (!child) return;
+		update(child);
+		const messages = child.getMessages();
+		this.patchSubagent(subagentRunId, (subagent) => {
+			subagent.messages = messages;
+		});
+	}
+	handleSubagentStartedEvent(chunk) {
+		if (chunk.type !== "SUBAGENT_STARTED") return;
+		if (this.findSubagentPart(chunk.subagentRunId)) {
+			this.childProcessors.delete(chunk.subagentRunId);
+			this.patchSubagent(chunk.subagentRunId, (subagent) => {
+				subagent.status = "running";
+				delete subagent.interruptIds;
+				delete subagent.error;
+				if (chunk.metadata !== void 0) subagent.metadata = chunk.metadata;
+			});
+			return;
+		}
+		const { messageId } = this.ensureAssistantMessage();
+		const part = {
+			type: "subagent",
+			subagent: {
+				id: chunk.subagentRunId,
+				name: chunk.name,
+				...chunk.description !== void 0 && { description: chunk.description },
+				status: "running",
+				...chunk.parentSubagentRunId !== void 0 && { parentSubagentRunId: chunk.parentSubagentRunId },
+				...chunk.parentToolCallId !== void 0 && { parentToolCallId: chunk.parentToolCallId },
+				...chunk.metadata !== void 0 && { metadata: chunk.metadata },
+				messages: []
+			}
+		};
+		this.messages = this.messages.map((message) => message.id === messageId ? {
+			...message,
+			parts: [...message.parts, part]
+		} : message);
+		this.emitMessagesChange();
+	}
+	handleSubagentFinishedEvent(chunk) {
+		if (chunk.type !== "SUBAGENT_FINISHED") return;
+		this.updateChild(chunk.subagentRunId, (child) => child.finalizeStream());
+		this.patchSubagent(chunk.subagentRunId, (subagent) => {
+			if (subagent.status === "error") return;
+			if (chunk.outcome?.type === "suspended") {
+				subagent.status = "suspended";
+				subagent.interruptIds = chunk.outcome.interruptIds ?? [];
+				return;
+			}
+			subagent.status = "finished";
+		});
+	}
+	handleSubagentErrorEvent(chunk) {
+		if (chunk.type !== "SUBAGENT_ERROR") return;
+		this.updateChild(chunk.subagentRunId, (child) => child.finalizeStream());
+		this.patchSubagent(chunk.subagentRunId, (subagent) => {
+			subagent.status = "error";
+			subagent.error = {
+				message: chunk.message,
+				...chunk.code !== void 0 && { code: chunk.code }
+			};
+		});
+	}
+	patchSubagent(subagentRunId, patch) {
+		this.messages = this.messages.map((message) => {
+			const index = message.parts.findIndex((part) => part.type === "subagent" && part.subagent.id === subagentRunId);
+			if (index === -1) return message;
+			const part = message.parts[index];
+			if (!part || part.type !== "subagent") return message;
+			const next = {
+				type: "subagent",
+				subagent: { ...part.subagent }
+			};
+			patch(next.subagent);
+			const parts = [...message.parts];
+			parts[index] = next;
+			return {
+				...message,
+				parts
+			};
+		});
+		this.emitMessagesChange();
+	}
+	/**
+	* Send a child's chunk to that child's processor, so the card keeps text,
+	* reasoning, tool calls, results, and nested children. A tool event without
+	* `subagentRunId` follows its `TOOL_CALL_START`.
+	*/
+	routeToChild(chunk) {
+		let id;
+		if (chunk.type === "SUBAGENT_STARTED") id = chunk.parentSubagentRunId;
+		else if (chunk.type === "SUBAGENT_FINISHED" || chunk.type === "SUBAGENT_ERROR") {
+			if (this.findSubagentPart(chunk.subagentRunId)) return false;
+			id = chunk.subagentRunId;
+		} else if ("subagentRunId" in chunk && chunk.subagentRunId) id = chunk.subagentRunId;
+		else if ("toolCallId" in chunk && typeof chunk.toolCallId === "string") id = this.childToolCalls.get(chunk.toolCallId);
+		if (id === void 0) return false;
+		const owner = this.childOwning(id);
+		if (owner === void 0) {
+			if (id === this.subagentRunId) return false;
+			console.warn(`[StreamProcessor] Dropped a chunk for unknown subagent ${id}`);
+			return true;
+		}
+		if (this.findSubagentPart(owner)?.part.subagent.status === "error") return true;
+		if (chunk.type === "TOOL_CALL_START") this.childToolCalls.set(chunk.toolCallId, owner);
+		this.updateChild(owner, (child) => child.processChunk(chunk));
+		return true;
+	}
 	/**
 	* Handle TEXT_MESSAGE_START event
 	*/
@@ -2772,9 +3608,15 @@ var StreamProcessor = class StreamProcessor {
 				this.activeMessageIds.add(messageId);
 				for (const [toolCallId, mappedMessageId] of this.toolCallToMessage) if (mappedMessageId === pendingId) this.toolCallToMessage.set(toolCallId, messageId);
 			}
-			if (!this.messageStates.has(messageId)) {
-				this.createMessageState(messageId, uiRole);
+			let pendingState = this.messageStates.get(messageId);
+			if (!pendingState) {
+				pendingState = this.createMessageState(messageId, uiRole);
 				this.activeMessageIds.add(messageId);
+			} else if (pendingState.hasToolCallsSinceTextStart) {
+				if (pendingState.currentSegmentText !== pendingState.lastEmittedText) this.emitTextUpdateForMessage(messageId);
+				pendingState.currentSegmentText = "";
+				pendingState.lastEmittedText = "";
+				pendingState.hasToolCallsSinceTextStart = false;
 			}
 			this.mergeMessageMetadata(messageId, chunk.metadata);
 			this.emitMessagesChange();
@@ -2824,8 +3666,9 @@ var StreamProcessor = class StreamProcessor {
 		this.resetStreamState();
 		const prevMessages = this.messages;
 		const prevById = new Map(prevMessages.map((msg) => [msg.id, msg]));
-		const normalized = this.mergeReasoningFanOut(chunk.messages.map(aguiSnapshotMessageToUIMessage));
-		this.messages = this.reconcileSnapshotToolCalls(normalized, prevMessages).map((msg) => {
+		const { top, groups } = splitSubagentWire(chunk.messages);
+		const normalized = this.mergeReasoningFanOut(top.map(aguiSnapshotMessageToUIMessage));
+		const reconciled = this.reconcileSnapshotToolCalls(normalized, prevMessages).map((msg) => {
 			if (msg.metadata != null) return msg;
 			const prev = prevById.get(msg.id);
 			if (prev?.metadata == null) return msg;
@@ -2834,9 +3677,76 @@ var StreamProcessor = class StreamProcessor {
 				metadata: prev.metadata
 			};
 		});
+		this.messages = this.attachSnapshotSubagents(reconciled, top, groups, prevMessages);
 		this.emitMessagesChange();
 	}
 	/**
+	* Put subagent cards back on a snapshot. Child wire messages (tagged with
+	* `subagentRunId`) become a card on the nearest assistant message before
+	* them, or a new assistant message when there is none. A card that the
+	* snapshot does not carry stays on its message, because a server snapshot
+	* can hold the parent history only.
+	*/
+	attachSnapshotSubagents(messages, top, groups, prevMessages) {
+		const cards = [];
+		const children = /* @__PURE__ */ new Map();
+		for (const group of groups) {
+			const child = new StreamProcessor({ subagentRunId: group.id });
+			child.processChunk({
+				type: EventType.MESSAGES_SNAPSHOT,
+				messages: group.messages,
+				timestamp: Date.now()
+			});
+			children.set(group.id, child);
+			const { placeholder: _placeholder, ...info } = group.info;
+			cards.push({
+				hostId: top.slice(0, group.hostIndex + 1).findLast((message) => message.role === "assistant")?.id,
+				part: {
+					type: "subagent",
+					subagent: {
+						...info,
+						id: group.id,
+						messages: child.getMessages()
+					}
+				},
+				carried: false
+			});
+		}
+		const inSnapshot = new Set(groups.map((group) => group.id));
+		for (const message of prevMessages) for (const part of message.parts) {
+			if (part.type !== "subagent" || inSnapshot.has(part.subagent.id)) continue;
+			cards.push({
+				hostId: message.id,
+				...part.subagent.parentToolCallId !== void 0 && { toolCallId: part.subagent.parentToolCallId },
+				part,
+				carried: true
+			});
+			const kept = this.childProcessors.get(part.subagent.id);
+			if (kept) children.set(part.subagent.id, kept);
+		}
+		this.childProcessors.clear();
+		for (const [id, child] of children) this.childProcessors.set(id, child);
+		let out = messages;
+		for (const card of cards) {
+			let index = out.findIndex((message) => message.id === card.hostId);
+			if (index === -1 && card.toolCallId !== void 0) index = out.findIndex((message) => message.parts.some((part) => part.type === "tool-call" && part.id === card.toolCallId));
+			if (index === -1 && !card.carried) index = out.findLastIndex((message) => message.role === "assistant");
+			if (index === -1) {
+				if (!card.carried) out = [...out, {
+					id: generateMessageId(),
+					role: "assistant",
+					parts: [card.part]
+				}];
+				continue;
+			}
+			out = out.map((message, position) => position !== index || message.parts.some((part) => part.type === "subagent" && part.subagent.id === card.part.subagent.id) ? message : {
+				...message,
+				parts: [...message.parts, card.part]
+			});
+		}
+		return out;
+	}
+	/**
 	* Reconcile a freshly normalized snapshot with the pre-snapshot message
 	* state so unreconstructable tool-call metadata is preserved.
 	*
@@ -2871,7 +3781,7 @@ var StreamProcessor = class StreamProcessor {
 		let pending = [];
 		const thinkingParts = (msg) => msg.parts.filter((part) => part.type === "thinking");
 		const isThinkingOnly = (msg) => msg.role === "assistant" && msg.parts.length > 0 && msg.parts.every((part) => part.type === "thinking");
-		const isToolResultOnly = (msg) => msg.role === "assistant" && msg.parts.length === 1 && msg.parts[0]?.type === "tool-result";
+		const isToolResultOnly = (msg) => msg.role === "assistant" && msg.parts.some((part) => part.type === "tool-result") && msg.parts.every((part) => part.type === "tool-result" || part.type === "ui-resource");
 		const flushPending = () => {
 			out.push(...pending);
 			pending = [];
@@ -2881,16 +3791,23 @@ var StreamProcessor = class StreamProcessor {
 				pending.push(msg);
 				continue;
 			}
+			let next = msg;
 			if (msg.role === "assistant" && pending.length > 0 && !isToolResultOnly(msg)) {
-				out.push({
+				next = {
 					...msg,
 					parts: [...pending.flatMap(thinkingParts), ...msg.parts]
-				});
+				};
 				pending = [];
+			} else flushPending();
+			const prev = out.at(-1);
+			if (prev?.role === "assistant" && next.role === "assistant" && isAssistantSegmentOf(next.id, prev.id)) {
+				out[out.length - 1] = {
+					...prev,
+					parts: [...prev.parts, ...next.parts]
+				};
 				continue;
 			}
-			flushPending();
-			out.push(msg);
+			out.push(next);
 		}
 		flushPending();
 		return out;
@@ -2902,7 +3819,8 @@ var StreamProcessor = class StreamProcessor {
 		for (const msg of snapshot) for (const part of msg.parts) if (part.type === "tool-call") snapshotToolCallIds.add(part.id);
 		const reconciled = [];
 		for (const msg of snapshot) {
-			const toolResultPart = msg.role === "assistant" && msg.parts.length === 1 ? msg.parts.find((p) => p.type === "tool-result") : void 0;
+			const toolResultParts = msg.parts.filter((part) => part.type === "tool-result");
+			const toolResultPart = msg.role === "assistant" && toolResultParts.length === 1 && msg.parts.every((part) => part.type === "tool-result" || part.type === "ui-resource") ? toolResultParts[0] : void 0;
 			if (!toolResultPart) {
 				reconciled.push(msg);
 				continue;
@@ -2921,7 +3839,7 @@ var StreamProcessor = class StreamProcessor {
 					snapshotToolCallIds.add(prev.id);
 				} else console.warn(`[StreamProcessor] MESSAGES_SNAPSHOT contains a tool-result for "${toolResultPart.toolCallId}" but no matching tool-call exists in the snapshot or the pre-snapshot state; addToolResult("${toolResultPart.toolCallId}") will not be able to locate this call`);
 			}
-			parts.push(toolResultPart);
+			parts.push(...msg.parts);
 			target.parts = parts;
 		}
 		return this.enrichSnapshotToolCallsFromResults(reconciled, prevToolCalls);
@@ -2955,7 +3873,7 @@ var StreamProcessor = class StreamProcessor {
 					} catch {
 						output = result.content;
 					}
-					const errorText = result.state === "error" ? this.extractToolResultError(output) : void 0;
+					const errorText = result.state === "error" ? toolResultErrorText(output) : void 0;
 					next = {
 						...next,
 						output: errorText ? { error: errorText } : output,
@@ -3001,6 +3919,7 @@ var StreamProcessor = class StreamProcessor {
 			state.lastEmittedText = "";
 			state.hasToolCallsSinceTextStart = false;
 		}
+		state.hasToolCallsSinceTextStart = false;
 		const currentText = state.currentSegmentText;
 		const delta = chunk.delta || "";
 		const nextText = delta !== "" ? currentText + delta : currentText;
@@ -3092,11 +4011,13 @@ var StreamProcessor = class StreamProcessor {
 	* Handle TOOL_CALL_END event — arguments are finalized (input-complete).
 	* Tool output arrives on TOOL_CALL_RESULT, not on this event.
 	*
-	* If TOOL_CALL_END carries parsed `input`, use it as the canonical arguments:
-	* back-fill the accumulated string when no TOOL_CALL_ARGS deltas were seen
-	* (adapters that deliver the whole input on END — e.g. Anthropic
-	* server_tool_use / web_search — issue #839) and override the rendered part's
-	* `input` with the canonical value.
+	* If TOOL_CALL_END carries parsed `input`, it is the canonical arguments:
+	* write it into the accumulated string and override the rendered part's
+	* `input` with it. That covers adapters that deliver the whole input on END
+	* (e.g. Anthropic server_tool_use / web_search — issue #839) and adapters
+	* that stream the wire arguments and then normalize them (OpenAI strict-mode
+	* null widening, undone by the adapter after #939), so `arguments` and
+	* `input` never disagree on the persisted part.
 	*
 	* @see docs/chat-architecture.md#single-shot-tool-call-response — End-to-end flow
 	*/
@@ -3108,12 +4029,11 @@ var StreamProcessor = class StreamProcessor {
 		const input = chunk.input !== void 0 ? chunk.input : tanstackMetadata(chunk)?.input;
 		const existingToolCall = msgState.toolCalls.get(chunk.toolCallId);
 		if (existingToolCall && existingToolCall.state !== "input-complete") {
-			if (input !== void 0 && !existingToolCall.arguments) try {
-				existingToolCall.arguments = JSON.stringify(input);
-			} catch {}
+			const serializedInput = serializeToolInput(input);
+			if (serializedInput !== void 0) existingToolCall.arguments = serializedInput;
 			const index = msgState.toolCallOrder.indexOf(chunk.toolCallId);
 			this.completeToolCall(messageId, index, existingToolCall);
-			if (input !== void 0) {
+			if (serializedInput !== void 0) {
 				existingToolCall.parsedArguments = input;
 				this.messages = updateToolCallPart(this.messages, messageId, {
 					id: existingToolCall.id,
@@ -3127,10 +4047,6 @@ var StreamProcessor = class StreamProcessor {
 			}
 		}
 	}
-	extractToolResultError(output) {
-		if (output && typeof output === "object" && "error" in output && typeof output.error === "string") return output.error;
-		return typeof output === "string" ? output : "Tool execution failed";
-	}
 	/**
 	* Handle TOOL_CALL_RESULT event (AG-UI spec).
 	*
@@ -3141,16 +4057,19 @@ var StreamProcessor = class StreamProcessor {
 	handleToolCallResultEvent(chunk) {
 		const messageId = this.toolCallToMessage.get(chunk.toolCallId) ?? this.messages.find((m) => m.parts.some((p) => p.type === "tool-call" && p.id === chunk.toolCallId))?.id;
 		if (!messageId) return;
-		const isOutputError = chunk.state === "output-error" || tanstackMetadata(chunk)?.state === "output-error";
+		const extra = chunk;
+		const rawToolResultOutcome = tanstackMetadata(chunk)?.toolResultOutcome;
+		const toolResultOutcome = isToolResultOutcome(rawToolResultOutcome) ? rawToolResultOutcome : void 0;
+		const isOutputError = extra.state === "output-error" || tanstackMetadata(chunk)?.state === "output-error" || toolResultOutcome !== void 0;
 		let output;
 		try {
-			output = JSON.parse(chunk.content);
+			output = typeof chunk.content === "string" ? JSON.parse(chunk.content) : chunk.content;
 		} catch {
 			output = chunk.content;
 		}
 		this.messages = updateToolCallWithOutput(this.messages, chunk.toolCallId, output, isOutputError ? "error" : void 0);
 		const resultState = isOutputError ? "error" : "complete";
-		this.messages = updateToolResultPart(this.messages, messageId, chunk.toolCallId, chunk.content, resultState, resultState === "error" ? this.extractToolResultError(output) : void 0);
+		this.messages = updateToolResultPart(this.messages, messageId, chunk.toolCallId, isContentPartArray(output) ? output : aguiContentToContentParts(chunk.content), resultState, resultState === "error" ? toolResultErrorText(output) : void 0, toolResultOutcome);
 		this.emitMessagesChange();
 	}
 	/**
@@ -3178,26 +4097,44 @@ var StreamProcessor = class StreamProcessor {
 		this.activeRuns.delete(chunk.runId);
 		if (chunk.outcome?.type === "interrupt") this.handleInterrupts(chunk.outcome.interrupts);
 		if (this.activeRuns.size === 0) {
-			this.isDone = true;
 			this.completeAllToolCalls();
+			if (this.finishReason === "tool_calls" && chunk.outcome?.type !== "interrupt") return;
+			this.isDone = true;
 			this.finalizeStream();
 		}
 	}
-	handleInterrupts(interrupts) {
+	/**
+	* Apply interrupt state to tool-call parts, then fire the client events.
+	* A child's interrupt updates the child's card. `emit` is false there, so
+	* the events fire once, from the top processor.
+	*/
+	handleInterrupts(interrupts, emit = true) {
 		const hasGeneric = interruptBatchHasGeneric(interrupts);
 		for (const interrupt of interrupts) {
 			const metadata = interrupt.metadata && typeof interrupt.metadata === "object" ? interrupt.metadata : {};
 			const kind = typeof metadata.kind === "string" ? metadata.kind : void 0;
 			const toolCallId = interrupt.toolCallId;
 			if (!toolCallId) continue;
+			const owner = interrupt.subagentRunId !== void 0 ? this.childOwning(interrupt.subagentRunId) : this.childOwningToolCall((part) => part.id === toolCallId);
+			if (owner !== void 0) this.updateChild(owner, (child) => child.handleInterrupts([interrupt], false));
 			const toolName = typeof metadata.toolName === "string" ? metadata.toolName : this.findToolCallName(toolCallId);
 			const input = Object.hasOwn(metadata, "input") ? metadata.input : {};
 			if (kind === "approval" || interrupt.reason === "approval_required") {
+				if (owner !== void 0) {
+					if (emit) this.events.onApprovalRequest?.({
+						toolCallId,
+						toolName,
+						input,
+						approvalId: interrupt.id
+					});
+					continue;
+				}
 				const resolvedMessageId = this.getActiveAssistantMessageId() ?? this.toolCallToMessage.get(toolCallId) ?? this.messages.find((m) => m.role === "assistant" && m.parts.some((p) => p.type === "tool-call" && p.id === toolCallId))?.id;
 				if (resolvedMessageId) {
 					this.messages = updateToolCallApproval(this.messages, resolvedMessageId, toolCallId, interrupt.id);
 					this.emitMessagesChange();
 				}
+				if (!emit) continue;
 				this.events.onApprovalRequest?.({
 					toolCallId,
 					toolName,
@@ -3207,7 +4144,7 @@ var StreamProcessor = class StreamProcessor {
 				continue;
 			}
 			if (kind === "client_tool" || interrupt.reason === "client_tool_input") {
-				if (hasGeneric) continue;
+				if (hasGeneric || !emit) continue;
 				this.events.onToolCall?.({
 					toolCallId,
 					toolName,
@@ -3498,7 +4435,7 @@ var StreamProcessor = class StreamProcessor {
 		} catch {
 			toolCall.parsedArguments = void 0;
 		}
-		if (this.isToolCallPartErrored(toolCall.id)) return;
+		if (this.isToolCallPartTerminal(toolCall.id)) return;
 		if (this.isToolCallPartAwaitingUserAction(toolCall.id)) return;
 		this.messages = updateToolCallPart(this.messages, messageId, {
 			id: toolCall.id,
@@ -3515,12 +4452,12 @@ var StreamProcessor = class StreamProcessor {
 		return this.messages.some((msg) => msg.parts?.some((part) => part.type === "tool-call" && part.id === toolCallId && (part.state === "approval-requested" || part.state === "approval-responded")));
 	}
 	/**
-	* Whether the rendered tool-call part for the given id has reached the
-	* terminal 'error' state. Used to prevent the completion safety net from
-	* downgrading a failed call back to 'input-complete'.
+	* Whether the rendered tool-call part for the given id has reached a
+	* terminal 'error' or 'complete' state. Used to prevent the completion
+	* safety net from downgrading a finished call back to 'input-complete'.
 	*/
-	isToolCallPartErrored(toolCallId) {
-		return this.messages.some((msg) => msg.parts?.some((part) => part.type === "tool-call" && part.id === toolCallId && part.state === "error"));
+	isToolCallPartTerminal(toolCallId) {
+		return this.messages.some((msg) => msg.parts?.some((part) => part.type === "tool-call" && part.id === toolCallId && (part.state === "error" || part.state === "complete")));
 	}
 	/**
 	* Emit pending text update for a specific message.
@@ -3585,6 +4522,7 @@ var StreamProcessor = class StreamProcessor {
 	* @see docs/chat-architecture.md#single-shot-text-response — Finalization step
 	*/
 	finalizeStream() {
+		this.isDone = true;
 		let lastAssistantMessage;
 		for (const messageId of this.activeMessageIds) {
 			const state = this.getMessageState(messageId);
@@ -3610,7 +4548,10 @@ var StreamProcessor = class StreamProcessor {
 				return;
 			}
 		}
-		if (lastAssistantMessage) this.events.onStreamEnd?.(lastAssistantMessage);
+		if (lastAssistantMessage && !this.streamEndEmitted) {
+			this.streamEndEmitted = true;
+			this.events.onStreamEnd?.(lastAssistantMessage);
+		}
 	}
 	/**
 	* Get completed tool calls in API format (aggregated across all messages)
@@ -3702,6 +4643,7 @@ var StreamProcessor = class StreamProcessor {
 		this.finishReason = null;
 		this.hasError = false;
 		this.isDone = false;
+		this.streamEndEmitted = false;
 		this.chunkStrategy.reset?.();
 	}
 	/**
@@ -3710,6 +4652,8 @@ var StreamProcessor = class StreamProcessor {
 	reset() {
 		this.resetStreamState();
 		this.messages = [];
+		this.childProcessors.clear();
+		this.childToolCalls.clear();
 	}
 	/**
 	* Check if a message contains only whitespace text and no other meaningful parts
@@ -3735,52 +4679,14 @@ function createReplayStream(recording) {
 	} };
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/client.js
-var EventType = /* @__PURE__ */ function(EventType) {
-	EventType["TEXT_MESSAGE_START"] = "TEXT_MESSAGE_START";
-	EventType["TEXT_MESSAGE_CONTENT"] = "TEXT_MESSAGE_CONTENT";
-	EventType["TEXT_MESSAGE_END"] = "TEXT_MESSAGE_END";
-	EventType["TEXT_MESSAGE_CHUNK"] = "TEXT_MESSAGE_CHUNK";
-	EventType["TOOL_CALL_START"] = "TOOL_CALL_START";
-	EventType["TOOL_CALL_ARGS"] = "TOOL_CALL_ARGS";
-	EventType["TOOL_CALL_END"] = "TOOL_CALL_END";
-	EventType["TOOL_CALL_CHUNK"] = "TOOL_CALL_CHUNK";
-	EventType["TOOL_CALL_RESULT"] = "TOOL_CALL_RESULT";
-	EventType["THINKING_START"] = "THINKING_START";
-	EventType["THINKING_END"] = "THINKING_END";
-	EventType["THINKING_TEXT_MESSAGE_START"] = "THINKING_TEXT_MESSAGE_START";
-	EventType["THINKING_TEXT_MESSAGE_CONTENT"] = "THINKING_TEXT_MESSAGE_CONTENT";
-	EventType["THINKING_TEXT_MESSAGE_END"] = "THINKING_TEXT_MESSAGE_END";
-	EventType["STATE_SNAPSHOT"] = "STATE_SNAPSHOT";
-	EventType["STATE_DELTA"] = "STATE_DELTA";
-	EventType["MESSAGES_SNAPSHOT"] = "MESSAGES_SNAPSHOT";
-	EventType["ACTIVITY_SNAPSHOT"] = "ACTIVITY_SNAPSHOT";
-	EventType["ACTIVITY_DELTA"] = "ACTIVITY_DELTA";
-	EventType["RAW"] = "RAW";
-	EventType["CUSTOM"] = "CUSTOM";
-	EventType["RUN_STARTED"] = "RUN_STARTED";
-	EventType["RUN_FINISHED"] = "RUN_FINISHED";
-	EventType["RUN_ERROR"] = "RUN_ERROR";
-	EventType["STEP_STARTED"] = "STEP_STARTED";
-	EventType["STEP_FINISHED"] = "STEP_FINISHED";
-	EventType["REASONING_START"] = "REASONING_START";
-	EventType["REASONING_MESSAGE_START"] = "REASONING_MESSAGE_START";
-	EventType["REASONING_MESSAGE_CONTENT"] = "REASONING_MESSAGE_CONTENT";
-	EventType["REASONING_MESSAGE_END"] = "REASONING_MESSAGE_END";
-	EventType["REASONING_MESSAGE_CHUNK"] = "REASONING_MESSAGE_CHUNK";
-	EventType["REASONING_END"] = "REASONING_END";
-	EventType["REASONING_ENCRYPTED_VALUE"] = "REASONING_ENCRYPTED_VALUE";
-	return EventType;
-}({});
-//#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/byok/providers.js
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/byok/providers.js
 /** `[a-z][a-z0-9-]{0,63}` — lowercase, no underscores, max 64 chars. */
 var BYOK_PROVIDER_ID_PATTERN = /^[a-z][a-z0-9-]{0,63}$/;
 function isProviderId(value) {
 	return typeof value === "string" && BYOK_PROVIDER_ID_PATTERN.test(value);
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/byok/missing.js
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/byok/missing.js
 function isByokMissingBody(value) {
 	if (typeof value !== "object" || value === null) return false;
 	if (!("error" in value)) return false;
@@ -3793,7 +4699,7 @@ function isByokMissingBody(value) {
 	return true;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.49.1/node_modules/@tanstack/ai/dist/esm/byok/errors.js
+//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/byok/errors.js
 var ByokMissingError = class extends Error {
 	provider;
 	constructor(provider) {
@@ -3819,7 +4725,7 @@ var ByokUnresolvedProviderError = class extends Error {
 	}
 };
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.28.0/node_modules/@tanstack/ai-client/dist/esm/connection-adapters.js
+//#region node_modules/.deno/@tanstack+ai-client@0.36.0/node_modules/@tanstack/ai-client/dist/esm/connection-adapters.js
 /**
 * Associates connect-wrapped chunks with the run they were produced under.
 * Content events (TEXT_MESSAGE_CONTENT, TOOL_CALL_*, …) carry no `runId` of
@@ -4088,15 +4994,33 @@ async function assertResponseOk(response) {
 	}
 	throw new Error(`HTTP error! status: ${response.status} ${response.statusText}`);
 }
+function chatHydrationSearchParams(threadId, options) {
+	const values = { threadId };
+	if (options?.limit !== void 0) values.limit = String(options.limit);
+	if (options?.before !== void 0) values.before = options.before;
+	return values;
+}
+function readChatHydrationPage(value) {
+	if (value === null || typeof value !== "object") return { truncated: false };
+	if (!("truncated" in value) || value.truncated !== true) return { truncated: false };
+	if (!("cursor" in value) || typeof value.cursor !== "string" || value.cursor === "") return { truncated: false };
+	return {
+		truncated: true,
+		cursor: value.cursor
+	};
+}
 /**
 * GET the hydration endpoint for a thread and parse its JSON `{ messages,
 * activeRun }` body. This is the transport-agnostic reconnect probe: keyed on
 * the STABLE thread id, it returns the stored transcript and — if a run is still
 * generating — a cursor the caller tails via `joinRun`. Shared by every fetch/
 * XHR adapter so the client never has to know which transport is in use.
+*
+* Pass `limit` / `before` to page. Old servers that omit `page` are treated as
+* a full list (`truncated: false`).
 */
-async function fetchThreadHydration(fetchClient, url, headers, credentials, threadId) {
-	const response = await fetchClient(withSearchParams(url, { threadId }), {
+async function fetchThreadHydration(fetchClient, url, headers, credentials, threadId, options) {
+	const response = await fetchClient(withSearchParams(url, chatHydrationSearchParams(threadId, options)), {
 		method: "GET",
 		headers: {
 			Accept: "application/json",
@@ -4112,9 +5036,10 @@ async function fetchThreadHydration(fetchClient, url, headers, credentials, thre
 		pending: data.interrupts.pending
 	} : null;
 	return {
-		messages: Array.isArray(data.messages) ? data.messages : [],
+		messages: Array.isArray(data.messages) ? normalizeMessagesDates(data.messages) : [],
 		activeRun,
-		interrupts
+		interrupts,
+		page: readChatHydrationPage(data.page)
 	};
 }
 /**
@@ -4248,12 +5173,24 @@ function normalizeConnectionAdapter(connection) {
 	if (!hasConnect) throw new Error("Connection adapter must provide either connect or both subscribe and send");
 	let activeBuffer = [];
 	let activeWaiters = [];
+	let activeSubscriber;
 	function push(chunk, runId) {
 		if (runId) chunkRunIds.set(chunk, runId);
 		const waiter = activeWaiters.shift();
 		if (waiter) waiter(chunk);
 		else activeBuffer.push(chunk);
 	}
+	async function waitUntilSubscriberIdle(abortSignal) {
+		const idle = () => activeSubscriber !== activeWaiters || activeBuffer.length === 0 && (activeWaiters.length > 0 || abortSignal?.aborted);
+		for (let i = 0; i < 16 && !abortSignal?.aborted; i++) {
+			if (idle()) return;
+			await Promise.resolve();
+		}
+		while (!abortSignal?.aborted) {
+			if (idle()) return;
+			await new Promise((resolve) => setTimeout(resolve, 0));
+		}
+	}
 	return {
 		subscribe(abortSignal) {
 			const myBuffer = activeBuffer.splice(0);
@@ -4261,19 +5198,24 @@ function normalizeConnectionAdapter(connection) {
 			activeBuffer = myBuffer;
 			activeWaiters = myWaiters;
 			return (async function* () {
-				while (!abortSignal?.aborted) {
-					let chunk;
-					const buffered = myBuffer.shift();
-					if (buffered !== void 0) chunk = buffered;
-					else chunk = await new Promise((resolve) => {
-						const onAbort = () => resolve(null);
-						myWaiters.push((c) => {
-							abortSignal?.removeEventListener("abort", onAbort);
-							resolve(c);
+				activeSubscriber = myWaiters;
+				try {
+					while (!abortSignal?.aborted) {
+						let chunk;
+						const buffered = myBuffer.shift();
+						if (buffered !== void 0) chunk = buffered;
+						else chunk = await new Promise((resolve) => {
+							const onAbort = () => resolve(null);
+							myWaiters.push((c) => {
+								abortSignal?.removeEventListener("abort", onAbort);
+								resolve(c);
+							});
+							abortSignal?.addEventListener("abort", onAbort, { once: true });
 						});
-						abortSignal?.addEventListener("abort", onAbort, { once: true });
-					});
-					if (chunk !== null) yield chunk;
+						if (chunk !== null) yield chunk;
+					}
+				} finally {
+					if (activeSubscriber === myWaiters) activeSubscriber = void 0;
 				}
 			})();
 		},
@@ -4311,11 +5253,12 @@ function normalizeConnectionAdapter(connection) {
 				} catch {}
 				throw err;
 			}
+			await waitUntilSubscriberIdle(abortSignal);
 		},
 		...typeof connection.joinRun === "function" ? { joinRun: (runId, abortSignal) => connection.joinRun(runId, abortSignal) } : {},
 		...(() => {
 			const hydrate = connection.hydrate;
-			return typeof hydrate === "function" ? { hydrate: (threadId) => hydrate(threadId) } : {};
+			return typeof hydrate === "function" ? { hydrate: (threadId, options) => hydrate(threadId, options) } : {};
 		})()
 	};
 }
@@ -4413,10 +5356,10 @@ function fetchServerSentEvents(url, options = {}) {
 				credentials: resolvedOptions.credentials || "same-origin"
 			}, (response, sseSignal) => responseToSSEEvents(response, sseSignal, { runId })), signal, resolvedOptions.reconnect);
 		},
-		async hydrate(threadId) {
+		async hydrate(threadId, hydrateOptions) {
 			const resolvedUrl = typeof url === "function" ? url() : url;
 			const resolvedOptions = typeof options === "function" ? await options() : options;
-			return fetchThreadHydration(resolvedOptions.fetchClient ?? fetch, resolvedUrl, mergeHeaders(resolvedOptions.headers), resolvedOptions.credentials || "same-origin", threadId);
+			return fetchThreadHydration(resolvedOptions.fetchClient ?? fetch, resolvedUrl, mergeHeaders(resolvedOptions.headers), resolvedOptions.credentials || "same-origin", threadId, hydrateOptions);
 		},
 		async hydrateGeneration(threadId) {
 			const resolvedUrl = typeof url === "function" ? url() : url;
@@ -4477,17 +5420,17 @@ async function* abortableIterable(iterable, signal) {
 	}
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.28.0/node_modules/@tanstack/ai-client/dist/esm/interrupt-manager.js
+//#region node_modules/.deno/@tanstack+ai-client@0.36.0/node_modules/@tanstack/ai-client/dist/esm/interrupt-manager.js
 function isClientOwnedInterrupt(item) {
 	return item.resumable;
 }
 function resolutionWithContinuation(item, resolution) {
 	const continuation = genericInterruptContinuationFromDescriptor(item.descriptor);
-	if (!continuation) return resolution;
-	return {
+	if (continuation) return {
 		...resolution,
 		metadata: wrapGenericInterruptContinuation(continuation)
 	};
+	return resolution;
 }
 function isRootResolvableInterrupt(interrupt) {
 	return "cancel" in interrupt && "clearResolution" in interrupt;
@@ -4807,11 +5750,51 @@ var InterruptManager = class {
 		this.submitBatch(submission);
 	}
 	resolveClientToolOutput(toolCallId, output) {
+		return this.resolveClientToolResult(toolCallId, {
+			state: "output-available",
+			output
+		});
+	}
+	resolveClientToolError(toolCallId, errorText) {
+		return this.resolveClientToolResult(toolCallId, {
+			state: "output-error",
+			errorText
+		});
+	}
+	resolveClientToolResult(toolCallId, result) {
 		const item = this.items.find((candidate) => candidate.kind === "client-tool-execution" && candidate.binding?.kind === "client-tool-execution" && candidate.binding.toolCallId === toolCallId || candidate.kind === "generic" && isClientToolExecutionReason(candidate.descriptor.reason) && candidate.descriptor.toolCallId === toolCallId && isLegacyClientToolMetadata(candidate.descriptor.metadata));
 		if (!item) return false;
-		this.resolveItem(item.descriptor.id, output);
+		if (item.kind !== "client-tool-execution") {
+			this.resolveItem(item.descriptor.id, result.state === "output-error" ? { error: result.errorText } : result.output);
+			return true;
+		}
+		if (result.state === "output-available") {
+			this.resolveItem(item.descriptor.id, result.output);
+			return true;
+		}
+		this.stageClientToolError(item, result.errorText);
 		return true;
 	}
+	stageClientToolError(item, errorText) {
+		this.assertItemMutable();
+		this.invalidateRetry();
+		if (!item.canResolve) {
+			item.status = "error";
+			item.error = this.itemError(item.descriptor.id, "invalid-response-schema", "The interrupt response schema is invalid and cannot be resolved.");
+			this.publish();
+			return;
+		}
+		item.validationGeneration++;
+		item.resolution = cloneAndDeepFreezeJson(withTanstackMetadata(resolutionWithContinuation(item, {
+			interruptId: item.descriptor.id,
+			status: "resolved",
+			payload: { error: errorText }
+		}), { state: "output-error" }));
+		item.status = "staged";
+		item.error = void 0;
+		this.publish();
+		this.maybeSubmit();
+	}
 	resolveToolApprovalDecision(interruptId, approved) {
 		const item = this.items.find((candidate) => candidate.descriptor.id === interruptId && (candidate.kind === "tool-approval" || candidate.kind === "generic" && candidate.descriptor.reason === "approval_required" && isLegacyApprovalMetadata(candidate.descriptor.metadata)));
 		if (!item) return false;
@@ -5124,7 +6107,24 @@ var InterruptManager = class {
 			} : result;
 			return isPromiseLike(validation) ? Promise.resolve(validation).then(preserveInput) : preserveInput(validation);
 		}
-		if (item.kind === "client-tool-execution") return validateWithSchema(item.tool?.outputSchema, payload, "invalid-tool-output");
+		if (item.kind === "client-tool-execution") {
+			const validation = validateWithSchema(item.tool?.outputSchema, payload, "invalid-tool-output");
+			const canonicalize = (result) => {
+				if (!("valid" in result)) return result;
+				try {
+					return {
+						valid: true,
+						payload: cloneAndDeepFreezeJson(result.payload)
+					};
+				} catch (error) {
+					return {
+						code: "invalid-tool-output",
+						message: error instanceof Error ? error.message : String(error)
+					};
+				}
+			};
+			return isPromiseLike(validation) ? Promise.resolve(validation).then(canonicalize) : canonicalize(validation);
+		}
 		return this.validateApprovalCandidate(item, payload);
 	}
 	validateApprovalCandidate(item, payload) {
@@ -5362,7 +6362,20 @@ var InterruptManager = class {
 	}
 };
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.28.0/node_modules/@tanstack/ai-client/dist/esm/byok/resolve.js
+//#region node_modules/.deno/@tanstack+ai-client@0.36.0/node_modules/@tanstack/ai-client/dist/esm/byok/client.js
+var registeredProviderIds = /* @__PURE__ */ new WeakMap();
+/**
+* Provider to stamp when the caller did not pass a slug.
+* One saved key wins. Else the only provider listed in `defineByok({ providers })`.
+*/
+function byokFallbackProviderId(byok) {
+	const savedIds = Object.entries(byok.keys()).filter((entry) => Boolean(entry[1])).map((entry) => entry[0]).filter(isProviderId);
+	if (savedIds.length === 1) return savedIds[0];
+	const registered = registeredProviderIds.get(byok) ?? [];
+	if (registered.length === 1) return registered[0];
+}
+//#endregion
+//#region node_modules/.deno/@tanstack+ai-client@0.36.0/node_modules/@tanstack/ai-client/dist/esm/byok/resolve.js
 function resolveByokProviderId(byokProvider, ...candidates) {
 	const fromFn = byokProvider?.();
 	if (isProviderId(fromFn)) return fromFn;
@@ -5378,7 +6391,7 @@ async function prepareResolvedByokHeaders(byok, provider) {
 	return byok.headers(provider);
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.28.0/node_modules/@tanstack/ai-client/dist/esm/events.js
+//#region node_modules/.deno/@tanstack+ai-client@0.36.0/node_modules/@tanstack/ai-client/dist/esm/events.js
 /**
 * Abstract base class for ChatClient event emission
 */
@@ -5552,7 +6565,7 @@ var ChatClientEventEmitter = class {
 	}
 };
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.28.0/node_modules/@tanstack/ai-client/dist/esm/devtools-noop.js
+//#region node_modules/.deno/@tanstack+ai-client@0.36.0/node_modules/@tanstack/ai-client/dist/esm/devtools-noop.js
 var NoOpChatClientEventEmitter = class extends ChatClientEventEmitter {
 	emitEvent() {}
 };
@@ -5584,6 +6597,9 @@ var NoOpChatDevtoolsBridge = class {
 	}
 	observeChunk(_chunk) {}
 	recordMemoryState(_value) {}
+	recordCompactionEvent(_eventType, _value) {}
+	recordCompactionState(_value) {}
+	recordSkillsState(_value) {}
 	beginRun(_runId, _threadId) {}
 	getCurrentRunEventContext() {}
 	getCurrentOrLastRunEventContext() {}
@@ -5594,7 +6610,7 @@ var NoOpChatDevtoolsBridge = class {
 };
 var createNoOpChatDevtoolsBridge = (options) => new NoOpChatDevtoolsBridge(options);
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.28.0/node_modules/@tanstack/ai-client/dist/esm/client-persistor.js
+//#region node_modules/.deno/@tanstack+ai-client@0.36.0/node_modules/@tanstack/ai-client/dist/esm/client-persistor.js
 /** Normalize a raw `getItem` result (legacy bare array or combined record). */
 function normalizePersistedState(raw) {
 	if (Array.isArray(raw)) return { messages: raw };
@@ -5858,7 +6874,7 @@ var ChatPersistor = class {
 	}
 };
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.28.0/node_modules/@tanstack/ai-client/dist/esm/cleared-stream-tracker.js
+//#region node_modules/.deno/@tanstack+ai-client@0.36.0/node_modules/@tanstack/ai-client/dist/esm/cleared-stream-tracker.js
 function getChunkToolCallId(chunk) {
 	return "toolCallId" in chunk && typeof chunk.toolCallId === "string" ? chunk.toolCallId : void 0;
 }
@@ -5951,7 +6967,13 @@ var ClearedStreamTracker = class {
 	}
 };
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.28.0/node_modules/@tanstack/ai-client/dist/esm/chat-client.js
+//#region node_modules/.deno/@tanstack+ai-client@0.36.0/node_modules/@tanstack/ai-client/dist/esm/chat-client.js
+var STREAM_PROCESSING_BUDGET_MS = 8;
+function yieldToHost() {
+	const { scheduler } = globalThis;
+	if (scheduler?.yield) return scheduler.yield();
+	return new Promise((resolve) => setTimeout(resolve, 0));
+}
 function assertUniqueInterruptDefinitions(interrupts) {
 	const ids = /* @__PURE__ */ new Set();
 	for (const interrupt of interrupts ?? []) {
@@ -5966,6 +6988,16 @@ function resolveTransport(transport) {
 	if (fetcher) return fetcherToConnectionAdapter(fetcher);
 	throw new Error("ChatClient: either `connection` or `fetcher` is required.");
 }
+function connectionDrainsOnSend(connection) {
+	return "connect" in connection;
+}
+function isIntermediateToolTurn(chunk) {
+	if (chunk.type !== "RUN_FINISHED") return false;
+	if (chunk.outcome?.type === "interrupt") return false;
+	const extra = chunk;
+	if (extra.finishReason !== void 0) return extra.finishReason === "tool_calls";
+	return tanstackMetadata(chunk)?.finishReason === "tool_calls";
+}
 function normalizeQueueOption(option) {
 	const base = {
 		whenBusy: "queue",
@@ -6071,11 +7103,42 @@ var REJOIN_CONNECT_DEADLINE_MS = 2e3;
 var REJOIN_REBUILD_TRIGGERS = /* @__PURE__ */ new Set([
 	"TEXT_MESSAGE_START",
 	"TEXT_MESSAGE_CONTENT",
+	"REASONING_MESSAGE_CONTENT",
 	"TOOL_CALL_START",
-	"MESSAGES_SNAPSHOT"
+	"MESSAGES_SNAPSHOT",
+	"SUBAGENT_STARTED"
 ]);
+function rebuildsAssistantMessage(chunk) {
+	if (chunk.type === "REASONING_ENCRYPTED_VALUE") return chunk.subtype === "message" && typeof chunk.encryptedValue === "string" && chunk.encryptedValue.length > 0;
+	if (chunk.type === "STEP_FINISHED") return "signature" in chunk && Boolean(chunk.signature);
+	return REJOIN_REBUILD_TRIGGERS.has(chunk.type);
+}
+/** Every subagent card in the messages, nested cards included. */
+function collectSubagentParts(messages) {
+	const cards = [];
+	for (const message of messages) for (const part of message.parts) {
+		if (part.type !== "subagent") continue;
+		cards.push(part);
+		cards.push(...collectSubagentParts(part.subagent.messages));
+	}
+	return cards;
+}
+function readSubagentRunId(chunk) {
+	if ("subagentRunId" in chunk && typeof chunk.subagentRunId === "string") return chunk.subagentRunId;
+}
+var MAX_RUN_LINEAGE_DEPTH = 64;
+function copyForDevtools(value) {
+	if (Array.isArray(value)) return value.map(copyForDevtools);
+	if (value instanceof Date) return new Date(value.getTime());
+	if (value === null || typeof value !== "object") return value;
+	const out = {};
+	for (const [key, item] of Object.entries(value)) if (typeof item !== "function") out[key] = copyForDevtools(item);
+	return out;
+}
 var ChatClient = class {
 	processor;
+	subagentHandles = /* @__PURE__ */ new Map();
+	stoppedSubagentIds = /* @__PURE__ */ new Set();
 	connection;
 	uniqueId;
 	threadId;
@@ -6083,6 +7146,8 @@ var ChatClient = class {
 	clearedStreamTracker = new ClearedStreamTracker();
 	currentRunId = null;
 	lastResume = null;
+	runParents = /* @__PURE__ */ new Map();
+	supersededInterruptRunIds = /* @__PURE__ */ new Set();
 	rejoinedRunId = null;
 	interruptManager;
 	activeInterruptSubmission;
@@ -6148,19 +7213,39 @@ var ChatClient = class {
 	continuationPending = false;
 	subscriptionAbortController = null;
 	processingResolve = null;
+	/**
+	* `connect()` adapters push the full HTTP body into the subscribe queue, then
+	* wait until that queue is idle. After `send()` returns, every chunk from this
+	* request has been processed. Subscribe/send sockets do not drain that way.
+	*/
+	connectionDrainsOnSend = false;
 	errorReportedGeneration = null;
 	streamGeneration = 0;
+	continuationGeneration = 0;
+	streamContinuationGeneration = 0;
 	continuationSkipped = false;
 	draining = false;
 	sessionGenerating = false;
 	activeRunIds = /* @__PURE__ */ new Set();
 	/** Latched by `dispose()`; stops any late async callback starting new work. */
 	disposed = false;
+	/** The error a failed mount hydration set, cleared by the next successful one. */
+	hydrationError;
 	/** Whether a view is currently watching. See `attach` / `detach`. */
 	tailing = false;
 	/** Constructor inputs `attach()` needs on every re-attach, not just the first. */
 	rejoinRunId;
 	cachesMessages;
+	/**
+	* Newest-window size from `history.pageSize`. Only set when
+	* `persistence === true`.
+	*/
+	historyPageSize;
+	hasOlderMessages = false;
+	olderMessagesCursor;
+	knownServerMessageIds = /* @__PURE__ */ new Set();
+	loadOlderMessagesInFlight = false;
+	historyGeneration = 0;
 	devtoolsMounted = false;
 	callbacksRef;
 	constructor(options) {
@@ -6171,17 +7256,21 @@ var ChatClient = class {
 		if (options.persistence === true) {
 			if (!options.threadId) throw new Error("[TanStack AI] persistence needs a stable `threadId` to key on. Pass a threadId from your app (for example support-42).");
 			cachesMessages = false;
+			this.historyPageSize = options.history?.pageSize;
 		} else if (options.persistence) {
 			if (!options.threadId) throw new Error("[TanStack AI] persistence needs a stable `threadId` to key on. Pass a threadId from your app (for example support-42).");
 			this.persistor = new ChatPersistor(options.persistence, options.threadId, (messages) => this.processor.setMessages(messages), (snapshot) => this.applyPersistedResume(snapshot));
-		}
+			this.historyPageSize = void 0;
+		} else this.historyPageSize = void 0;
 		this.bodyOption = options.body || {};
 		this.forwardedPropsOption = options.forwardedProps || {};
 		this.byok = options.byok;
 		this.byokProvider = options.byokProvider;
 		this.context = options.context;
 		this.queueConfig = normalizeQueueOption(options.queue);
-		this.connection = normalizeConnectionAdapter(resolveTransport(options));
+		const transport = resolveTransport(options);
+		this.connectionDrainsOnSend = connectionDrainsOnSend(transport);
+		this.connection = normalizeConnectionAdapter(transport);
 		this.clientToolsRef = { current: /* @__PURE__ */ new Map() };
 		if (options.tools) for (const tool of options.tools) this.clientToolsRef.current.set(tool.name, tool);
 		this.devtoolsBridge = (options.devtoolsBridgeFactory ?? createNoOpChatDevtoolsBridge)(this.buildDevtoolsBridgeOptions(options.devtools));
@@ -6229,8 +7318,10 @@ var ChatClient = class {
 			...initialMessages ? { initialMessages } : {},
 			events: {
 				onMessagesChange: (messages) => {
+					this.syncSubagentHandles();
 					this.persistor?.notifyMessagesChanged(messages);
 					this.callbacksRef.current.onMessagesChange(messages);
+					this.queueDevtoolsSnapshot();
 				},
 				onStreamStart: () => {
 					this.setStatus("streaming");
@@ -6278,6 +7369,7 @@ var ChatClient = class {
 					const clientTool = (this.activeClientTools ?? this.clientToolsRef.current).get(args.toolName);
 					const executeFunc = clientTool?.execute;
 					if (executeFunc) {
+						const continuationGeneration = this.continuationGeneration;
 						const runEventContext = this.devtoolsBridge.getCurrentRunEventContext();
 						const executionPromise = (async () => {
 							try {
@@ -6292,7 +7384,7 @@ var ChatClient = class {
 									tool: args.toolName,
 									output,
 									state: "output-available"
-								}, clientTool, runEventContext);
+								}, clientTool, continuationGeneration, runEventContext);
 							} catch (error) {
 								await this.addToolResultForClientTool({
 									toolCallId: args.toolCallId,
@@ -6300,7 +7392,7 @@ var ChatClient = class {
 									output: null,
 									state: "output-error",
 									errorText: error.message
-								}, clientTool, runEventContext);
+								}, clientTool, continuationGeneration, runEventContext);
 							} finally {
 								this.pendingToolExecutions.delete(args.toolCallId);
 							}
@@ -6315,10 +7407,13 @@ var ChatClient = class {
 				},
 				onCustomEvent: (eventType, data, context) => {
 					if (eventType === "memory:state") this.devtoolsBridge.recordMemoryState(data);
+					if (eventType === "compaction:started" || eventType === "compaction:state" || eventType === "compaction:ended") this.devtoolsBridge.recordCompactionEvent(eventType, data);
+					if (eventType === "skills:state") this.devtoolsBridge.recordSkillsState(data);
 					this.callbacksRef.current.onCustomEvent(eventType, data, context);
 				}
 			}
 		});
+		this.syncSubagentHandles();
 		this.persistor?.hydrateAsync(persistedState);
 		this.rejoinRunId = rejoinRunId;
 		this.cachesMessages = cachesMessages;
@@ -6427,17 +7522,32 @@ var ChatClient = class {
 		if (!hydrate) return;
 		if (this.isLoading || this.abortController) return;
 		if (this.disposed) return;
+		const pageSize = this.historyPageSize;
+		const hydrateOptions = pageSize === void 0 ? void 0 : { limit: pageSize };
 		(async () => {
 			let result;
+			const generation = this.historyGeneration;
 			try {
-				result = await hydrate(this.threadId);
-			} catch {
+				result = await hydrate(this.threadId, hydrateOptions);
+			} catch (cause) {
+				if (generation === this.historyGeneration) this.failHydration(cause);
 				return;
 			}
+			if (generation !== this.historyGeneration) return;
 			if (this.disposed || !this.tailing) return;
 			if (this.isLoading || this.abortController) return;
-			if (result.messages.length > 0) this.processor.setMessages(result.messages);
-			if (result.interrupts && result.interrupts.pending.length > 0) this.applyResumeSnapshot({
+			if (this.hydrationError && this.error === this.hydrationError) {
+				this.setError(void 0);
+				this.setStatus("ready");
+			}
+			this.hydrationError = void 0;
+			this.applyHydrationPage(result.page);
+			if (result.messages.length > 0) {
+				const windowMessages = normalizeMessagesDates(result.messages);
+				this.processor.setMessages(windowMessages);
+				this.rememberServerMessageIds(windowMessages);
+			}
+			if (result.interrupts && result.interrupts.pending.length > 0 && (!result.activeRun?.runId || result.activeRun.runId === result.interrupts.runId)) this.applyResumeSnapshot({
 				resumeState: {
 					threadId: this.threadId,
 					runId: result.interrupts.runId
@@ -6447,6 +7557,29 @@ var ChatClient = class {
 			else if (result.activeRun?.runId) this.maybeRejoinInFlight(result.activeRun.runId);
 		})();
 	}
+	/**
+	* Surface a mount-hydration failure (`persistence: true`) on the observable
+	* fields, mirroring `GenerationClient.failHydration`, so "this thread failed
+	* to load" is distinguishable from "this thread has no messages" and the app
+	* can show an error / offer a retry. A genuine miss — the server having no
+	* record for a fresh thread — resolves normally and never reaches here; only a
+	* thrown transport / authorize-gate error does.
+	*
+	* Skipped when the view unmounted (`!tailing`) or a `sendMessage` took
+	* ownership while the hydrate GET was in flight, so a live run's state always
+	* wins over a stale mount-time failure — same guard as the success path above.
+	*/
+	failHydration(cause) {
+		if (this.disposed || !this.tailing) return;
+		if (this.isLoading || this.abortController) return;
+		const error = cause instanceof Error ? cause : new Error(String(cause));
+		if (error instanceof ByokMissingError) this.byok?.request(error.provider, "missing");
+		if (error instanceof ByokBlockedError && error.reason === "locked") this.byok?.request(error.provider, "locked");
+		this.hydrationError = error;
+		this.setStatus("error");
+		this.setError(error);
+		this.callbacksRef.current.onError(error);
+	}
 	mountDevtools() {
 		this.ensureThreadId();
 		if (this.devtoolsMounted) return;
@@ -6482,15 +7615,28 @@ var ChatClient = class {
 	updateRunLifecycle(chunk, options) {
 		if (chunk.type === "RUN_STARTED") {
 			const chunkRunId = getChunkRunId$1(chunk) ?? chunk.runId;
+			const parentRunId = "parentRunId" in chunk && typeof chunk.parentRunId === "string" ? chunk.parentRunId : void 0;
+			if (parentRunId) {
+				this.runParents.set(chunkRunId, parentRunId);
+				if (this.supersededInterruptRunIds.has(chunkRunId)) this.markLineageAnswered(parentRunId);
+			}
 			this.activeResumeThreadId = "threadId" in chunk && typeof chunk.threadId === "string" ? chunk.threadId : this.activeResumeThreadId;
 			this.activeResumeRunId = chunkRunId;
-			this.activeRunIds.add(chunkRunId);
-			this.clearedStreamTracker.onRunStarted(chunkRunId);
-			this.setSessionGenerating(true);
-			if (this.persistor && this.connection.joinRun && !this.lastResume) this.persistResumeSnapshot({
+			const isAnsweredReplayStart = this.supersededInterruptRunIds.has(chunkRunId) && !this.isLoading;
+			if (!isAnsweredReplayStart) {
+				this.activeRunIds.add(chunkRunId);
+				this.clearedStreamTracker.onRunStarted(chunkRunId);
+				this.setSessionGenerating(true);
+			}
+			if (this.persistor && this.connection.joinRun && !this.lastResume && !isAnsweredReplayStart) this.persistResumeSnapshot({
 				threadId: this.activeResumeThreadId ?? this.threadId,
 				runId: chunkRunId
 			});
+			if (this.lastResume && this.supersededInterruptRunIds.has(this.lastResume.runId)) {
+				this.lastResume = null;
+				this.persistor?.persistResumeSnapshot(null);
+				this.interruptManager.reset();
+			}
 			return;
 		}
 		if (chunk.type !== "RUN_FINISHED" && chunk.type !== "RUN_ERROR") return;
@@ -6503,7 +7649,8 @@ var ChatClient = class {
 			this.clearedStreamTracker.onSessionRunError();
 		}
 		this.setSessionGenerating(this.activeRunIds.size > 0);
-		if (options?.resolveProcessing !== false) this.resolveProcessing();
+		const skipProcessingResolve = chunk.type === "RUN_FINISHED" && isIntermediateToolTurn(chunk);
+		if (options?.resolveProcessing !== false && !skipProcessingResolve) this.resolveProcessing();
 	}
 	/**
 	* Track interrupt state off the stream's terminal events. A RUN_FINISHED with
@@ -6516,8 +7663,10 @@ var ChatClient = class {
 		if (this.activeInterruptSubmission && chunk.type === "RUN_ERROR") return;
 		const runId = getChunkRunId$1(chunk);
 		const threadId = "threadId" in chunk && typeof chunk.threadId === "string" ? chunk.threadId : this.activeResumeThreadId;
+		if (runId && !isIntermediateToolTurn(chunk) && (chunk.type === "RUN_ERROR" || chunk.type === "RUN_FINISHED" && chunk.outcome?.type !== "interrupt")) this.markLineageAnswered(runId);
 		if (chunk.type === "RUN_FINISHED" && chunk.outcome?.type === "interrupt") {
 			const interruptedRunId = this.currentRunId ?? runId ?? this.activeResumeRunId ?? "";
+			if (interruptedRunId && this.supersededInterruptRunIds.has(interruptedRunId)) return;
 			this.lastResume = {
 				threadId: threadId ?? this.threadId,
 				runId: interruptedRunId
@@ -6536,7 +7685,8 @@ var ChatClient = class {
 		const isActiveStreamRunTerminal = Boolean(this.isLoading && runId && (runId === this.activeResumeRunId || runId === this.currentRunId));
 		const isCurrentStreamTerminal = this.isLoading && chunk.type === "RUN_FINISHED" && !runId;
 		const isActiveInterruptSubmissionTerminal = Boolean(this.activeInterruptSubmission && this.isLoading && chunk.type === "RUN_FINISHED" && chunk.outcome?.type !== "interrupt");
-		if (isRunlessSessionError || isTrackedRunTerminal || isCurrentRunTerminal || isActiveStreamRunTerminal || isCurrentStreamTerminal || isActiveInterruptSubmissionTerminal) {
+		const isLineageDescendantTerminal = Boolean(this.lastResume && this.supersededInterruptRunIds.has(this.lastResume.runId));
+		if (isRunlessSessionError || isTrackedRunTerminal || isCurrentRunTerminal || isActiveStreamRunTerminal || isCurrentStreamTerminal || isActiveInterruptSubmissionTerminal || isLineageDescendantTerminal) {
 			this.lastResume = null;
 			this.persistor?.persistResumeSnapshot(null);
 			this.interruptManager.reset();
@@ -6544,6 +7694,17 @@ var ChatClient = class {
 		}
 		this.notifyResumeStateChange("live");
 	}
+	/** Walk parentRunId links and mark this run plus its ancestors as answered. */
+	markLineageAnswered(runId) {
+		let current = runId;
+		let hops = 0;
+		while (current !== void 0 && hops < MAX_RUN_LINEAGE_DEPTH) {
+			if (this.supersededInterruptRunIds.has(current)) return;
+			this.supersededInterruptRunIds.add(current);
+			current = this.runParents.get(current);
+			hops++;
+		}
+	}
 	/**
 	* The interrupt-resume state for the active/interrupted run (its run/thread
 	* ids), or null when there is nothing to resume. Apps can persist this to
@@ -6594,10 +7755,14 @@ var ChatClient = class {
 	resumeInterruptsUnsafe(resume, state) {
 		const target = state ?? this.lastResume;
 		if (!target) return Promise.resolve(false);
+		return this.resumeInterruptsUnsafeForGeneration(resume, target, this.continuationGeneration);
+	}
+	resumeInterruptsUnsafeForGeneration(resume, target, continuationGeneration) {
+		if (continuationGeneration !== this.continuationGeneration) return Promise.resolve(false);
 		if (this.isLoading) return new Promise((resolve, reject) => {
 			this.queuePostStreamAction(async () => {
 				try {
-					resolve(await this.resumeInterruptsUnsafe(resume, target));
+					resolve(await this.resumeInterruptsUnsafeForGeneration(resume, target, continuationGeneration));
 				} catch (error) {
 					reject(error);
 				}
@@ -6613,6 +7778,7 @@ var ChatClient = class {
 		return this.resumeInterruptsUnsafe(resume, state);
 	}
 	async submitInterruptBatch(submission) {
+		const continuationGeneration = this.continuationGeneration;
 		this.activeInterruptSubmission = submission;
 		this.interruptSubmissionFailure = void 0;
 		for (const resolution of submission.resolutions) {
@@ -6621,12 +7787,13 @@ var ChatClient = class {
 			const approvalId = resolution.interruptId;
 			this.processor.addToolApprovalResponse(approvalId, approved);
 		}
-		const resumed = await this.resumeInterruptsUnsafe([...submission.resolutions], {
+		const resumed = await this.resumeInterruptsUnsafeForGeneration([...submission.resolutions], {
 			threadId: submission.threadId,
 			runId: submission.interruptedRunId
-		}).finally(() => {
-			this.activeInterruptSubmission = void 0;
+		}, continuationGeneration).finally(() => {
+			if (this.activeInterruptSubmission === submission) this.activeInterruptSubmission = void 0;
 		});
+		if (continuationGeneration !== this.continuationGeneration) return;
 		const failure = this.takeInterruptSubmissionFailure();
 		if (failure !== void 0) throw { errors: failure.errors };
 		if (!resumed) throw new Error("Interrupt continuation could not be started.");
@@ -6744,7 +7911,7 @@ var ChatClient = class {
 	}
 	getDevtoolsSnapshot() {
 		return {
-			messages: this.processor.getMessages(),
+			messages: copyForDevtools(this.processor.getMessages()),
 			status: this.status,
 			isLoading: this.isLoading,
 			isSubscribed: this.isSubscribed,
@@ -6809,13 +7976,21 @@ var ChatClient = class {
 		});
 	}
 	/**
-	* Consume chunks from the connection subscription.
+	* Consume chunks from the connection subscription. Chunks are processed in
+	* order; the loop yields to the host after each processing budget.
 	*/
 	async consumeSubscription(signal) {
 		const stream = this.connection.subscribe(signal);
+		let chunkProcessingTime = 0;
 		for await (const chunk of stream) {
 			if (signal.aborted) break;
-			await this.processIncomingChunk(chunk);
+			const startedAt = performance.now();
+			this.processIncomingChunk(chunk);
+			chunkProcessingTime += performance.now() - startedAt;
+			if (chunkProcessingTime < STREAM_PROCESSING_BUDGET_MS) continue;
+			chunkProcessingTime = 0;
+			if (typeof document !== "undefined" && document.hidden) continue;
+			await yieldToHost();
 		}
 	}
 	/**
@@ -6837,7 +8012,7 @@ var ChatClient = class {
 	* give up after {@link REJOIN_CONNECT_DEADLINE_MS} if no chunk arrives and
 	* clear the dead pointer so it does not retry on the next load.
 	*
-	* Replay chunks are processed WITHOUT the per-chunk yield the live path uses,
+	* Replay chunks are processed WITHOUT the time-slice yield the live path uses,
 	* so the buffered prefix snaps in and only the genuinely-live tail streams at
 	* network speed — a reload looks like the run continued, not like it re-typed.
 	*/
@@ -6851,6 +8026,7 @@ var ChatClient = class {
 			threadId: this.threadId,
 			runId
 		};
+		this.streamContinuationGeneration = this.continuationGeneration;
 		this.setIsLoading(true);
 		this.setStatus("streaming");
 		(async () => {
@@ -6867,11 +8043,11 @@ var ChatClient = class {
 						attached = true;
 						clearTimeout(connectTimer);
 					}
-					if (!rebuilt && REJOIN_REBUILD_TRIGGERS.has(chunk.type)) {
+					if (!rebuilt && rebuildsAssistantMessage(chunk)) {
 						rebuilt = true;
 						this.dropTrailingInFlightAssistant();
 					}
-					await this.processIncomingChunk(chunk, { defer: false });
+					this.processIncomingChunk(chunk);
 				}
 				if (this.pendingToolExecutions.size > 0) await Promise.all(this.pendingToolExecutions.values());
 			} catch (error) {
@@ -6904,7 +8080,7 @@ var ChatClient = class {
 		const last = messages[messages.length - 1];
 		if (last && last.role === "assistant") this.processor.setMessages(messages.slice(0, -1));
 	}
-	async processIncomingChunk(chunk, options) {
+	processIncomingChunk(chunk) {
 		chunk = restoreInboundChunk(chunk);
 		if (chunk.type === "RUN_ERROR" && this.isActiveInterruptSubmissionFailure(chunk)) {
 			const interruptErrors = tanstackMetadata(chunk)?.interruptErrors;
@@ -6922,10 +8098,17 @@ var ChatClient = class {
 		}
 		this.callbacksRef.current.onChunk(chunk);
 		this.devtoolsBridge.observeChunk(chunk);
+		const attributedId = readSubagentRunId(chunk);
+		if (attributedId && chunk.type === EventType.SUBAGENT_STARTED) this.stoppedSubagentIds.delete(attributedId);
+		if (attributedId && this.stoppedSubagentIds.has(attributedId)) {
+			this.updateRunLifecycle(chunk);
+			this.resolveJoinedRun(chunk);
+			return;
+		}
 		this.processor.processChunk(chunk);
+		this.syncSubagentHandles();
 		this.updateRunLifecycle(chunk);
 		this.observeInterruptState(chunk);
-		if (options?.defer !== false && (typeof document === "undefined" || !document.hidden)) await new Promise((resolve) => setTimeout(resolve, 0));
 		this.resolveJoinedRun(chunk);
 	}
 	isActiveInterruptSubmissionFailure(chunk) {
@@ -7024,7 +8207,7 @@ var ChatClient = class {
 	async sendMessage(content, body, sendOptions) {
 		this.mountDevtools();
 		if (typeof content === "string" && !content.trim()) return;
-		if (this.hasBlockingInterrupts()) throw new Error("ChatClient: cannot send normal input while pending interrupts exist. Use resumeInterrupts() instead.");
+		if (this.hasPendingInterrupts()) throw new Error("ChatClient: cannot send normal input while pending interrupts exist. Use resumeInterrupts() instead.");
 		const resolvedBody = {
 			...body,
 			...sendOptions?.body
@@ -7051,10 +8234,6 @@ var ChatClient = class {
 	hasPendingInterrupts() {
 		return this.interruptManager.getDescriptors().length > 0;
 	}
-	/** True while an interrupt batch owns the next user turn. */
-	hasBlockingInterrupts() {
-		return this.activeInterruptSubmission !== void 0 || this.hasPendingInterrupts();
-	}
 	/** True while a stream is active, a send is claiming the client, or the queue is draining. */
 	isSendBusy() {
 		return this.isLoading || this.sendInFlight || this.messageQueueDraining;
@@ -7146,7 +8325,7 @@ var ChatClient = class {
 	*/
 	async append(message) {
 		this.mountDevtools();
-		if (this.hasBlockingInterrupts()) throw new Error("ChatClient: cannot append normal input while pending interrupts exist. Use resumeInterrupts() instead.");
+		if (this.hasPendingInterrupts()) throw new Error("ChatClient: cannot append normal input while pending interrupts exist. Use resumeInterrupts() instead.");
 		const normalizedMessage = normalizeToUIMessage(message, generateMessageId);
 		if (normalizedMessage.role === "system") return;
 		const uiMessage = normalizedMessage;
@@ -7169,6 +8348,7 @@ var ChatClient = class {
 	async streamResponse() {
 		if (this.isLoading) return false;
 		const generation = ++this.streamGeneration;
+		this.streamContinuationGeneration = this.continuationGeneration;
 		const resumeThreadId = this.pendingResumeThreadId;
 		const resumeParentRunId = this.pendingResumeParentRunId;
 		const resumeItems = this.pendingResumeItems;
@@ -7191,7 +8371,7 @@ var ChatClient = class {
 		let activeDevtoolsRunId = null;
 		let runTerminalEventEmitted = false;
 		try {
-			const messages = this.processor.getMessages();
+			const messages = this.messagesForSend(this.processor.getMessages());
 			const clientTools = new Map(this.clientToolsRef.current);
 			const runtimeContext = this.context;
 			await this.callbacksRef.current.onResponse();
@@ -7212,7 +8392,7 @@ var ChatClient = class {
 			const processingComplete = this.waitForProcessing();
 			let byokHeaders;
 			if (this.byok) {
-				const provider = resolveByokProviderId(this.byokProvider, mergedBody.provider);
+				const provider = resolveByokProviderId(this.byokProvider, mergedBody.provider, byokFallbackProviderId(this.byok));
 				byokHeaders = await prepareResolvedByokHeaders(this.byok, provider);
 			}
 			const runContext = {
@@ -7235,6 +8415,7 @@ var ChatClient = class {
 			this.devtoolsBridge.emitSnapshot();
 			await this.connection.send(messages, mergedBody, signal, runContext);
 			if (generation !== this.streamGeneration || signal.aborted) return false;
+			if (this.connectionDrainsOnSend) this.resolveProcessing();
 			await processingComplete;
 			if (generation !== this.streamGeneration) return false;
 			if (this.status === "error") {
@@ -7283,6 +8464,7 @@ var ChatClient = class {
 				}
 				await this.drainPostStreamActions();
 				if (streamCompletedSuccessfully) {
+					this.rememberProcessorMessageIds();
 					if (this.status !== "ready") this.setStatus("ready");
 					if (!this.messageQueueDraining) await this.drainQueue();
 				} else this.flushQueue();
@@ -7335,9 +8517,13 @@ var ChatClient = class {
 	* Stop the current stream
 	*/
 	stop() {
+		this.continuationGeneration++;
 		const hadLocalStream = this.abortController !== null;
 		this.cancelInFlightStream({ setReadyStatus: true });
 		this.discardPendingSends();
+		this.lastResume = null;
+		this.activeInterruptSubmission = void 0;
+		this.interruptManager.reset();
 		if (hadLocalStream) this.resetSessionGenerating();
 		this.events.stopped();
 	}
@@ -7357,8 +8543,10 @@ var ChatClient = class {
 		} else if (this.activeRunIds.size > 0) this.resetSessionGenerating({ preserveClearedStreamTracking: true });
 		this.persistor?.beginClear();
 		this.processor.clearMessages();
+		this.resetHistoryPaging();
 		this.discardPendingSends();
 		this.persistor?.remove();
+		this.stoppedSubagentIds.clear();
 		this.lastResume = null;
 		this.interruptManager.reset();
 		this.pendingResumeThreadId = null;
@@ -7372,13 +8560,15 @@ var ChatClient = class {
 	*/
 	async addToolResult(result) {
 		const clientTool = this.clientToolsRef.current.get(result.tool);
-		await this.addToolResultForClientTool(result, clientTool);
+		await this.addToolResultForClientTool(result, clientTool, this.streamContinuationGeneration);
 	}
-	async addToolResultForClientTool(result, clientTool, context) {
-		if (clientTool && result.state !== "output-error") try {
+	async addToolResultForClientTool(result, clientTool, continuationGeneration, context) {
+		if (result.state !== "output-error") try {
+			let output = clientTool?.outputSchema && isStandardSchema(clientTool.outputSchema) ? await this.validateClientToolOutput(clientTool, result.output) : result.output;
+			if (this.interruptManager.getDescriptors().some((interrupt) => interrupt.toolCallId === result.toolCallId)) output = cloneAndDeepFreezeJson(output);
 			result = {
 				...result,
-				output: this.validateClientToolOutput(clientTool, result.output)
+				output
 			};
 		} catch (error) {
 			result = {
@@ -7389,18 +8579,20 @@ var ChatClient = class {
 			};
 		}
 		this.events.toolResultAdded(result.toolCallId, result.tool, result.output, result.state || "output-available", context);
+		if (continuationGeneration !== this.continuationGeneration) return;
 		this.processor.addToolResult(result.toolCallId, result.output, result.state === "output-error" ? result.errorText || "Tool execution failed" : void 0);
 		this.devtoolsBridge.emitSnapshot();
-		if (this.interruptManager.resolveClientToolOutput(result.toolCallId, result.state === "output-error" ? { error: result.errorText || "Tool execution failed" } : result.output)) return;
+		if (result.state === "output-error" ? this.interruptManager.resolveClientToolError(result.toolCallId, result.errorText || "Tool execution failed") : this.interruptManager.resolveClientToolOutput(result.toolCallId, result.output)) return;
 		if (this.isLoading) {
-			this.queuePostStreamAction(() => this.checkForContinuation());
+			this.queuePostStreamAction(() => continuationGeneration === this.continuationGeneration ? this.checkForContinuation() : Promise.resolve());
 			return;
 		}
 		await this.checkForContinuation();
 	}
-	validateClientToolOutput(clientTool, output) {
-		if (clientTool.outputSchema && isStandardSchema(clientTool.outputSchema)) return parseWithStandardSchema(clientTool.outputSchema, output);
-		return output;
+	async validateClientToolOutput(clientTool, output) {
+		const validation = await validateWithStandardSchema(clientTool.outputSchema, output);
+		if (!validation.success) throw new Error(validation.issues.map((issue) => issue.message).join(", "));
+		return validation.data;
 	}
 	/**
 	* Respond to a tool approval request
@@ -7431,7 +8623,11 @@ var ChatClient = class {
 	* Queue an action to be executed after the current stream ends
 	*/
 	queuePostStreamAction(action) {
-		this.postStreamActions.push(action);
+		const continuationGeneration = this.continuationGeneration;
+		this.postStreamActions.push(async () => {
+			if (continuationGeneration !== this.continuationGeneration) return;
+			await action();
+		});
 	}
 	/**
 	* Drain and execute all queued post-stream actions
@@ -7450,6 +8646,7 @@ var ChatClient = class {
 	* Check if we should continue the flow and do so if needed
 	*/
 	async checkForContinuation() {
+		if (this.streamContinuationGeneration !== this.continuationGeneration) return;
 		if (this.hasPendingInterrupts()) return;
 		if (this.continuationPending || this.isLoading) {
 			this.continuationSkipped = true;
@@ -7490,6 +8687,132 @@ var ChatClient = class {
 	getMessages() {
 		return this.processor.getMessages();
 	}
+	getSubagents() {
+		return [...this.subagentHandles.values()];
+	}
+	devtoolsSnapshotQueued = false;
+	/** One devtools snapshot per microtask, however many chunks arrive. */
+	queueDevtoolsSnapshot() {
+		if (this.devtoolsSnapshotQueued) return;
+		this.devtoolsSnapshotQueued = true;
+		queueMicrotask(() => {
+			this.devtoolsSnapshotQueued = false;
+			this.devtoolsBridge.emitSnapshot();
+		});
+	}
+	syncSubagentHandles() {
+		const cards = collectSubagentParts(this.processor.getMessages());
+		const present = new Set(cards.map((part) => part.subagent.id));
+		for (const id of this.subagentHandles.keys()) if (!present.has(id)) this.subagentHandles.delete(id);
+		for (const part of cards) {
+			const id = part.subagent.id;
+			const existing = this.subagentHandles.get(id);
+			if (existing) {
+				if (part.subagent === existing) continue;
+				const { stop } = existing;
+				for (const key of Object.keys(existing)) Reflect.deleteProperty(existing, key);
+				Object.assign(existing, part.subagent, { stop });
+				part.subagent = existing;
+				continue;
+			}
+			const handle = {
+				...part.subagent,
+				stop: () => {
+					this.stopSubagent(id);
+				}
+			};
+			this.subagentHandles.set(id, handle);
+			part.subagent = handle;
+		}
+	}
+	stopSubagent(id) {
+		const handle = this.subagentHandles.get(id);
+		if (!handle || handle.status !== "running") return;
+		this.stoppedSubagentIds.add(id);
+		this.processor.processChunk({
+			type: EventType.SUBAGENT_ERROR,
+			subagentRunId: id,
+			message: "Stopped",
+			timestamp: Date.now()
+		});
+		this.syncSubagentHandles();
+		handle.status = "error";
+		handle.error = { message: "Stopped" };
+		this.abortController?.abort();
+	}
+	/**
+	* True when the last hydrate or older-page response said more messages exist.
+	*/
+	getHasOlderMessages() {
+		return this.hasOlderMessages;
+	}
+	/**
+	* Fetch the next older window and put it in front of the painted messages.
+	*
+	* No-op when there is no older page, no cursor, or a page load is already
+	* running. A network failure rejects and leaves the painted messages as they
+	* are; {@link getHasOlderMessages} stays true.
+	*/
+	async loadOlderMessages() {
+		const hydrate = this.connection.hydrate;
+		if (hydrate === void 0) return;
+		if (this.disposed) return;
+		if (!this.hasOlderMessages) return;
+		const cursor = this.olderMessagesCursor;
+		if (cursor === void 0) return;
+		if (this.loadOlderMessagesInFlight) return;
+		const hydrateOptions = { before: cursor };
+		if (this.historyPageSize !== void 0) hydrateOptions.limit = this.historyPageSize;
+		this.loadOlderMessagesInFlight = true;
+		const generation = this.historyGeneration;
+		try {
+			const result = await hydrate(this.threadId, hydrateOptions);
+			if (this.disposed) return;
+			if (generation !== this.historyGeneration) return;
+			const olderMessages = normalizeMessagesDates(result.messages);
+			if (olderMessages.length === 0) throw new Error("Older page was empty");
+			this.applyHydrationPage(result.page);
+			this.processor.prependMessages(olderMessages);
+			this.rememberServerMessageIds(olderMessages);
+		} finally {
+			this.loadOlderMessagesInFlight = false;
+		}
+	}
+	resetHistoryPaging() {
+		this.hasOlderMessages = false;
+		this.olderMessagesCursor = void 0;
+		this.knownServerMessageIds.clear();
+		this.historyGeneration++;
+	}
+	applyHydrationPage(page) {
+		if (page?.truncated === true) {
+			this.hasOlderMessages = true;
+			this.olderMessagesCursor = page.cursor;
+			return;
+		}
+		this.hasOlderMessages = false;
+		this.olderMessagesCursor = void 0;
+	}
+	rememberServerMessageIds(messages) {
+		const ids = messages.map((message) => message.id);
+		for (const id of ids) this.knownServerMessageIds.add(id);
+	}
+	rememberProcessorMessageIds() {
+		if (this.historyPageSize === void 0) return;
+		this.rememberServerMessageIds(this.processor.getMessages());
+	}
+	messagesForSend(messages) {
+		if (this.historyPageSize === void 0) return messages;
+		const unknownMessages = [];
+		for (const message of messages) {
+			if (this.knownServerMessageIds.has(message.id)) continue;
+			unknownMessages.push(message);
+		}
+		if (unknownMessages.length > 0) return unknownMessages;
+		const lastUserIndex = messages.findLastIndex((message) => message.role === "user");
+		if (lastUserIndex === -1) return [];
+		return messages.slice(lastUserIndex);
+	}
 	/**
 	* True when an interrupt (or another direct send) claimed the client during
 	* a drain. Read via a method so cross-await mutations are not constant-folded
@@ -7633,10 +8956,12 @@ var ChatClient = class {
 			this.resetSessionGenerating();
 			this.setIsSubscribed(false);
 			this.setConnectionStatus("disconnected");
-			this.connection = normalizeConnectionAdapter(resolveTransport({
+			const transport = resolveTransport({
 				connection: options.connection,
 				fetcher: options.fetcher
-			}));
+			});
+			this.connectionDrainsOnSend = connectionDrainsOnSend(transport);
+			this.connection = normalizeConnectionAdapter(transport);
 			if (wasSubscribed) this.subscribe();
 		}
 		if (options.body !== void 0) this.bodyOption = options.body;
@@ -8379,35 +9704,49 @@ function createAstralBeamChat(options, deferStart = false) {
 			throw error instanceof Error && isAstralBeamApiError(error.cause) ? error.cause : error;
 		}
 	};
-	const client = new ChatClient({
-		connection,
-		tools: declareTools(),
-		forwardedProps: forwardedProps(),
-		onMessagesChange: (messages) => {
-			update({
-				messages,
-				sandbox: collectSandboxActivity(messages),
-				error: client.getError()
-			});
-		},
-		onStatusChange: (status) => update({
-			status,
-			error: client.getError()
-		}),
-		onCustomEvent: (eventType, data) => {
-			const value = data?.state;
-			if (eventType === "astralbeam.sandbox.status" && (value === "starting" || value === "ready" || value === "error")) {
-				debug?.("sandbox", `sandbox ${value}`);
-				update({ sandboxStatus: value });
-				return;
-			}
-			debug?.("stream", `custom event "${eventType}"`, data);
-		},
-		onChunk: (chunk) => live.streamCallbacks?.onChunk?.(chunk),
-		onResponse: (response) => live.streamCallbacks?.onResponse?.(response),
-		onFinish: (message) => live.streamCallbacks?.onFinish?.(message),
-		onError: (error) => live.streamCallbacks?.onError?.(error)
-	});
+	const createClient = () => {
+		const next = new ChatClient({
+			connection,
+			tools: declareTools(),
+			forwardedProps: forwardedProps(),
+			onMessagesChange: (messages) => {
+				if (client !== next) return;
+				update({
+					messages,
+					sandbox: collectSandboxActivity(messages),
+					error: next.getError()
+				});
+			},
+			onStatusChange: (status) => {
+				if (client === next) update({
+					status,
+					error: next.getError()
+				});
+			},
+			onCustomEvent: (eventType, data) => {
+				if (client !== next) return;
+				const value = data?.state;
+				if (eventType === "astralbeam.sandbox.status" && (value === "starting" || value === "ready" || value === "error")) {
+					debug?.("sandbox", `sandbox ${value}`);
+					update({ sandboxStatus: value });
+					return;
+				}
+				debug?.("stream", `custom event "${eventType}"`, data);
+			},
+			onChunk: (chunk) => live.streamCallbacks?.onChunk?.(chunk),
+			onResponse: (response) => live.streamCallbacks?.onResponse?.(response),
+			onFinish: (message) => live.streamCallbacks?.onFinish?.(message),
+			onError: (error) => live.streamCallbacks?.onError?.(error)
+		});
+		return next;
+	};
+	let client = createClient();
+	const replaceClient = () => {
+		client.stop();
+		const previous = client;
+		client = createClient();
+		previous.dispose();
+	};
 	const settleDanglingToolCalls = () => {
 		for (const message of state.messages) for (const part of message.parts) {
 			if (part.type !== "tool-call" || isSettledToolCall(part)) continue;
@@ -8438,8 +9777,7 @@ function createAstralBeamChat(options, deferStart = false) {
 		if (auth.status === "ready") {
 			const nextIdentity = authenticationIdentity(auth.currentUser);
 			if (identity !== void 0 && identity !== nextIdentity) {
-				client.stop();
-				client.clear();
+				replaceClient();
 				disposeRenders();
 				update({
 					messages: [],
@@ -8507,10 +9845,11 @@ function createAstralBeamChat(options, deferStart = false) {
 		reload: () => client.reload(),
 		reset: () => {
 			debug?.("status", "conversation reset");
-			client.clear();
+			replaceClient();
 			disposeRenders();
 			update({
 				messages: [],
+				status: "ready",
 				sandbox: {
 					files: [],
 					commands: []