@astralbeam/sdk 0.21.0 → 0.22.0

package/dist/{core-BkceDZxh.js → core-CWFT6Db_.js}

@@ -1,4 +1,4 @@
-import { Ct as personalMcpDisconnectConnection, Et as personalMcpTestConnection, Ft as uploadChatFile, It as astralBeamChatFetch, Lt as isAstralBeamApiError, Mt as updateChatThread, O as getCurrentUser, Rt as resolveApiUrl, S as getChatConfig, St as personalMcpCreateConnection, Tt as personalMcpSetHeaders, bt as personalMcpBindBrowser, ft as listChatMessages, mt as listChatThreads, nt as getRunChatUrl, st as getThreadAttachment, tt as getResolveChatToolResultUrl, v as createChatThread, wt as personalMcpGetCatalog, x as deleteChatThread, xt as personalMcpCompleteAuthorization, yt as personalMcpAuthorizeConnection } from "./api-qmAF_i2J.js";
+import { Bt as resolveApiUrl, Ct as personalMcpCompleteAuthorization, Dt as personalMcpSetHeaders, Et as personalMcpGetCatalog, Lt as uploadChatFile, O as getCurrentUser, Ot as personalMcpTestConnection, Pt as updateChatThread, Rt as astralBeamChatFetch, S as getChatConfig, St as personalMcpBindBrowser, Tt as personalMcpDisconnectConnection, gt as listChatThreads, lt as getThreadAttachment, mt as listChatMessages, nt as getResolveChatToolResultUrl, rt as getRunChatUrl, v as createChatThread, wt as personalMcpCreateConnection, x as deleteChatThread, xt as personalMcpAuthorizeConnection, zt as isAstralBeamApiError } from "./api-SpkUzEv3.js";
 import { _ as strictDecoder, i as isObject, l as decode, p as JWTInvalid } from "./validate-BOw-BAyv.js";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
@@ -36,7 +36,442 @@ function decodeJwt(jwt) {
 	return result;
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai-client@0.39.2+367daa2260c029d6/node_modules/@tanstack/ai-client/dist/esm/response-stream.js
+//#region ../node_modules/.bun/@tanstack+store@0.11.2/node_modules/@tanstack/store/dist/alien.js
+/* @__NO_SIDE_EFFECTS__ */
+function createReactiveSystem({ update, notify, unwatched }) {
+	return {
+		link,
+		unlink,
+		propagate,
+		checkDirty,
+		shallowPropagate
+	};
+	function link(dep, sub, version) {
+		const prevDep = sub.depsTail;
+		if (prevDep !== void 0 && prevDep.dep === dep) return;
+		const nextDep = prevDep !== void 0 ? prevDep.nextDep : sub.deps;
+		if (nextDep !== void 0 && nextDep.dep === dep) {
+			nextDep.version = version;
+			sub.depsTail = nextDep;
+			return;
+		}
+		const prevSub = dep.subsTail;
+		if (prevSub !== void 0 && prevSub.version === version && prevSub.sub === sub) return;
+		const newLink = sub.depsTail = dep.subsTail = {
+			version,
+			dep,
+			sub,
+			prevDep,
+			nextDep,
+			prevSub,
+			nextSub: void 0
+		};
+		if (nextDep !== void 0) nextDep.prevDep = newLink;
+		if (prevDep !== void 0) prevDep.nextDep = newLink;
+		else sub.deps = newLink;
+		if (prevSub !== void 0) prevSub.nextSub = newLink;
+		else dep.subs = newLink;
+	}
+	function unlink(link, sub = link.sub) {
+		const dep = link.dep;
+		const prevDep = link.prevDep;
+		const nextDep = link.nextDep;
+		const nextSub = link.nextSub;
+		const prevSub = link.prevSub;
+		if (nextDep !== void 0) nextDep.prevDep = prevDep;
+		else sub.depsTail = prevDep;
+		if (prevDep !== void 0) prevDep.nextDep = nextDep;
+		else sub.deps = nextDep;
+		if (nextSub !== void 0) nextSub.prevSub = prevSub;
+		else dep.subsTail = prevSub;
+		if (prevSub !== void 0) prevSub.nextSub = nextSub;
+		else if ((dep.subs = nextSub) === void 0) unwatched(dep);
+		return nextDep;
+	}
+	function propagate(link) {
+		let next = link.nextSub;
+		let stack;
+		top: do {
+			const sub = link.sub;
+			let flags = sub.flags;
+			if (!(flags & 60)) sub.flags = flags | 32;
+			else if (!(flags & 12)) flags = 0;
+			else if (!(flags & 4)) sub.flags = flags & -9 | 32;
+			else if (!(flags & 48) && isValidLink(link, sub)) {
+				sub.flags = flags | 40;
+				flags &= 1;
+			} else flags = 0;
+			if (flags & 2) notify(sub);
+			if (flags & 1) {
+				const subSubs = sub.subs;
+				if (subSubs !== void 0) {
+					const nextSub = (link = subSubs).nextSub;
+					if (nextSub !== void 0) {
+						stack = {
+							value: next,
+							prev: stack
+						};
+						next = nextSub;
+					}
+					continue;
+				}
+			}
+			if ((link = next) !== void 0) {
+				next = link.nextSub;
+				continue;
+			}
+			while (stack !== void 0) {
+				link = stack.value;
+				stack = stack.prev;
+				if (link !== void 0) {
+					next = link.nextSub;
+					continue top;
+				}
+			}
+			break;
+		} while (true);
+	}
+	function checkDirty(link, sub) {
+		let stack;
+		let checkDepth = 0;
+		let dirty = false;
+		top: do {
+			const dep = link.dep;
+			const flags = dep.flags;
+			if (sub.flags & 16) dirty = true;
+			else if ((flags & 17) === 17) {
+				if (update(dep)) {
+					const subs = dep.subs;
+					if (subs.nextSub !== void 0) shallowPropagate(subs);
+					dirty = true;
+				}
+			} else if ((flags & 33) === 33) {
+				if (link.nextSub !== void 0 || link.prevSub !== void 0) stack = {
+					value: link,
+					prev: stack
+				};
+				link = dep.deps;
+				sub = dep;
+				++checkDepth;
+				continue;
+			}
+			if (!dirty) {
+				const nextDep = link.nextDep;
+				if (nextDep !== void 0) {
+					link = nextDep;
+					continue;
+				}
+			}
+			while (checkDepth--) {
+				const firstSub = sub.subs;
+				const hasMultipleSubs = firstSub.nextSub !== void 0;
+				if (hasMultipleSubs) {
+					link = stack.value;
+					stack = stack.prev;
+				} else link = firstSub;
+				if (dirty) {
+					if (update(sub)) {
+						if (hasMultipleSubs) shallowPropagate(firstSub);
+						sub = link.sub;
+						continue;
+					}
+					dirty = false;
+				} else sub.flags &= -33;
+				sub = link.sub;
+				const nextDep = link.nextDep;
+				if (nextDep !== void 0) {
+					link = nextDep;
+					continue top;
+				}
+			}
+			return dirty;
+		} while (true);
+	}
+	function shallowPropagate(link) {
+		do {
+			const sub = link.sub;
+			const flags = sub.flags;
+			if ((flags & 48) === 32) {
+				sub.flags = flags | 16;
+				if ((flags & 6) === 2) notify(sub);
+			}
+		} while ((link = link.nextSub) !== void 0);
+	}
+	function isValidLink(checkLink, sub) {
+		let link = sub.depsTail;
+		while (link !== void 0) {
+			if (link === checkLink) return true;
+			link = link.prevDep;
+		}
+		return false;
+	}
+}
+//#endregion
+//#region ../node_modules/.bun/@tanstack+store@0.11.2/node_modules/@tanstack/store/dist/atom.js
+function toObserver(nextHandler, errorHandler, completionHandler) {
+	const isObserver = typeof nextHandler === "object";
+	const self = isObserver ? nextHandler : void 0;
+	return {
+		next: (isObserver ? nextHandler.next : nextHandler)?.bind(self),
+		error: (isObserver ? nextHandler.error : errorHandler)?.bind(self),
+		complete: (isObserver ? nextHandler.complete : completionHandler)?.bind(self)
+	};
+}
+const queuedEffects = [];
+let cycle = 0;
+const { link, unlink, propagate, checkDirty, shallowPropagate } = /* @__PURE__ */ createReactiveSystem({
+	update(atom) {
+		return atom._update();
+	},
+	notify(effect) {
+		queuedEffects[queuedEffectsLength++] = effect;
+		effect.flags &= -3;
+	},
+	unwatched(atom) {
+		if (atom.depsTail !== void 0) {
+			atom.depsTail = void 0;
+			atom.flags = 17;
+			purgeDeps(atom);
+		}
+	}
+});
+let notifyIndex = 0;
+let queuedEffectsLength = 0;
+let activeSub;
+function purgeDeps(sub) {
+	const depsTail = sub.depsTail;
+	let dep = depsTail !== void 0 ? depsTail.nextDep : sub.deps;
+	while (dep !== void 0) dep = unlink(dep, sub);
+}
+function flush() {
+	while (notifyIndex < queuedEffectsLength) {
+		const effect = queuedEffects[notifyIndex];
+		queuedEffects[notifyIndex++] = void 0;
+		effect.notify();
+	}
+	notifyIndex = 0;
+	queuedEffectsLength = 0;
+}
+function createAtom(valueOrFn, options) {
+	const isComputed = typeof valueOrFn === "function";
+	const getter = valueOrFn;
+	const atom = {
+		_snapshot: isComputed ? void 0 : valueOrFn,
+		subs: void 0,
+		subsTail: void 0,
+		deps: void 0,
+		depsTail: void 0,
+		flags: isComputed ? 0 : 1,
+		get() {
+			if (activeSub !== void 0) link(atom, activeSub, cycle);
+			return atom._snapshot;
+		},
+		subscribe(observerOrFn) {
+			const obs = toObserver(observerOrFn);
+			const observed = { current: false };
+			const e = effect(() => {
+				atom.get();
+				if (!observed.current) observed.current = true;
+				else {
+					activeSub = void 0;
+					obs.next?.(atom._snapshot);
+				}
+			});
+			return { unsubscribe: () => {
+				e.stop();
+			} };
+		},
+		_update(getValue) {
+			const prevSub = activeSub;
+			const compare = options?.compare ?? Object.is;
+			if (isComputed) {
+				activeSub = atom;
+				++cycle;
+				atom.depsTail = void 0;
+			} else if (getValue === void 0) return false;
+			if (isComputed) atom.flags = 5;
+			try {
+				const oldValue = atom._snapshot;
+				const newValue = typeof getValue === "function" ? getValue(oldValue) : getValue === void 0 && isComputed ? getter(oldValue) : getValue;
+				if (oldValue === void 0 || !compare(oldValue, newValue)) {
+					atom._snapshot = newValue;
+					return true;
+				}
+				return false;
+			} finally {
+				activeSub = prevSub;
+				if (isComputed) atom.flags &= -5;
+				purgeDeps(atom);
+			}
+		}
+	};
+	if (isComputed) {
+		atom.flags = 17;
+		atom.get = function() {
+			const flags = atom.flags;
+			if (flags & 16 || flags & 32 && checkDirty(atom.deps, atom)) {
+				if (atom._update()) {
+					const subs = atom.subs;
+					if (subs !== void 0) shallowPropagate(subs);
+				}
+			} else if (flags & 32) atom.flags = flags & -33;
+			if (activeSub !== void 0) link(atom, activeSub, cycle);
+			return atom._snapshot;
+		};
+	} else atom.set = function(valueOrFn) {
+		if (atom._update(valueOrFn)) {
+			const subs = atom.subs;
+			if (subs !== void 0) {
+				propagate(subs);
+				shallowPropagate(subs);
+				flush();
+			}
+		}
+	};
+	return atom;
+}
+function effect(fn) {
+	const run = () => {
+		const prevSub = activeSub;
+		activeSub = effectObj;
+		++cycle;
+		effectObj.depsTail = void 0;
+		effectObj.flags = 6;
+		try {
+			return fn();
+		} finally {
+			activeSub = prevSub;
+			effectObj.flags &= -5;
+			purgeDeps(effectObj);
+		}
+	};
+	const effectObj = {
+		deps: void 0,
+		depsTail: void 0,
+		subs: void 0,
+		subsTail: void 0,
+		flags: 6,
+		notify() {
+			const flags = this.flags;
+			if (flags & 16 || flags & 32 && checkDirty(this.deps, this)) run();
+			else this.flags = 2;
+		},
+		stop() {
+			this.flags = 0;
+			this.depsTail = void 0;
+			purgeDeps(this);
+		}
+	};
+	run();
+	return effectObj;
+}
+//#endregion
+//#region ../node_modules/.bun/@tanstack+ai-client@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai-client/dist/esm/snapshot-atom.js
+function isPlainObject(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+/**
+* Report an error thrown by a listener without stopping the caller. The
+* browser's `reportError` reaches `window.onerror` and error trackers. Other
+* runtimes log it.
+*/
+function reportListenerError(error) {
+	if (typeof globalThis.reportError === "function") globalThis.reportError(error);
+	else console.error(error);
+}
+/** Deep-freeze plain JSON. Class instances stay as they are. */
+function freezePlainData(value) {
+	if (Array.isArray(value)) return Object.freeze(value.map(freezePlainData));
+	if (!isPlainObject(value)) return value;
+	const copy = {};
+	for (const key of Object.keys(value)) copy[key] = freezePlainData(value[key]);
+	return Object.freeze(copy);
+}
+/**
+* Freeze a copy of one message part. Tool `input` / `output`, `source`,
+* `approval`, tool-result `content`, and subagent transcripts are copies.
+* A subagent `stop` function stays the live function.
+*/
+function freezeSnapshotPart(part, cache = /* @__PURE__ */ new WeakMap()) {
+	const record = part;
+	const copy = { ...record };
+	if (isPlainObject(record.source)) copy.source = Object.freeze({ ...record.source });
+	if (record.type === "tool-call" && isPlainObject(record.approval)) copy.approval = Object.freeze({ ...record.approval });
+	if (record.type === "tool-result" && Array.isArray(record.content)) copy.content = Object.freeze(record.content.map((contentPart) => typeof contentPart === "object" && contentPart !== null ? freezeSnapshotPart(contentPart, cache) : contentPart));
+	if ("input" in record) copy.input = freezePlainData(record.input);
+	if ("output" in record) copy.output = freezePlainData(record.output);
+	if (record.type === "subagent" && isPlainObject(record.subagent)) {
+		const sub = record.subagent;
+		copy.subagent = Object.freeze(Array.isArray(sub.messages) ? {
+			...sub,
+			messages: freezeSnapshotMessages(cache, sub.messages)
+		} : { ...sub });
+	}
+	return Object.freeze(copy);
+}
+function cached(cache, value, freeze) {
+	let frozen = cache.get(value);
+	if (!frozen) {
+		frozen = freeze(value);
+		cache.set(value, frozen);
+	}
+	return frozen;
+}
+/**
+* Freeze a copy of each message and its parts. The client replaces a message
+* or a part object when it changes, so `cache` gives an unchanged message or
+* part the same frozen copy. UI memo keys on message identity, and a streamed
+* token copies only the part that changed.
+*/
+function freezeSnapshotMessages(cache, messages) {
+	return Object.freeze(messages.map((message) => cached(cache, message, () => Object.freeze({
+		...message,
+		parts: Object.freeze(message.parts.map((part) => cached(cache, part, () => freezeSnapshotPart(part, cache))))
+	}))));
+}
+/**
+* Merge a partial update into an object atom and freeze the result. Skips
+* notify when every provided field is `Object.is`-equal to the current value.
+*/
+function patchAtom(atom, patch) {
+	atom.set((prev) => {
+		let changed = false;
+		const next = { ...prev };
+		for (const key of Object.keys(patch)) {
+			if (Object.is(prev[key], patch[key])) continue;
+			next[key] = patch[key];
+			changed = true;
+		}
+		return changed ? Object.freeze(next) : prev;
+	});
+}
+var MAX_LISTENER_REENTRY = 8;
+/**
+* Subscribe to an atom with the `() => void` unsubscribe that framework
+* stores expect.
+*/
+function subscribeAtom(atom, listener) {
+	const { unsubscribe } = atom.subscribe(() => {
+		let seen;
+		let spins = 0;
+		do {
+			seen = atom.get();
+			try {
+				listener();
+			} catch (error) {
+				reportListenerError(error);
+			}
+			spins++;
+		} while (atom.get() !== seen && spins < MAX_LISTENER_REENTRY);
+	});
+	return unsubscribe;
+}
+new TextEncoder();
+new TextDecoder();
+//#endregion
+//#region ../node_modules/.bun/@tanstack+ai-client@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai-client/dist/esm/response-stream.js
 var UnsupportedResponseStreamError = class extends Error {
 	missingFeature;
 	constructor(missingFeature) {
@@ -58,14 +493,14 @@ function createResponseStreamTextDecoder() {
 	return new globalThis.TextDecoder();
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai-client@0.39.2+367daa2260c029d6/node_modules/@tanstack/ai-client/dist/esm/sse-utils.js
+//#region ../node_modules/.bun/@tanstack+ai-client@1.0.0+367daa2260c029d6/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/.bun/@tanstack+ai-client@0.39.2+367daa2260c029d6/node_modules/@tanstack/ai-client/dist/esm/message-date-normalizer.js
+//#region ../node_modules/.bun/@tanstack+ai-client@1.0.0+367daa2260c029d6/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;
@@ -97,7 +532,7 @@ function normalizeMessagesDates(messages) {
 	return messages.map(normalizeMessageDates);
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/utilities/ag-ui-usage.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/utilities/ag-ui-usage.js
 function definedDetails(value) {
 	return Object.keys(value).length > 0 ? value : void 0;
 }
@@ -142,7 +577,7 @@ function fromSpecTokenUsage(usage, leftover) {
 	};
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/utilities/merge-metadata.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/utilities/merge-metadata.js
 function isPlainRecord$1(value) {
 	return value != null && typeof value === "object" && !Array.isArray(value);
 }
@@ -221,7 +656,172 @@ let EventType = /* @__PURE__ */ function(EventType) {
 	return EventType;
 }({});
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/utilities/reasoning-encrypted-value.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/utilities/tool-call-arguments.js
+function sameJsonValue(left, right) {
+	if (Object.is(left, right)) return true;
+	if (Array.isArray(left) && Array.isArray(right)) return left.length === right.length && left.every((value, index) => sameJsonValue(value, right[index]));
+	if (left === null || right === null || typeof left !== "object" || typeof right !== "object" || Array.isArray(left) || Array.isArray(right)) return false;
+	const leftKeys = Object.keys(left);
+	const rightKeys = Object.keys(right);
+	return leftKeys.length === rightKeys.length && leftKeys.every((key) => Object.prototype.hasOwnProperty.call(right, key) && sameJsonValue(Reflect.get(left, key), Reflect.get(right, key)));
+}
+function scanJson(raw, parsed) {
+	let cursor = 0;
+	const whitespace = () => {
+		while (raw[cursor] === " " || raw[cursor] === "	" || raw[cursor] === "\r" || raw[cursor] === "\n") cursor++;
+	};
+	const stringToken = () => {
+		const start = cursor++;
+		while (cursor < raw.length) if (raw[cursor] === "\\") cursor += 2;
+		else if (raw[cursor++] === "\"") break;
+		return raw.slice(start, cursor);
+	};
+	const value = (parsedValue) => {
+		whitespace();
+		const start = cursor;
+		if (raw[cursor] === "{") {
+			cursor++;
+			whitespace();
+			const properties = /* @__PURE__ */ new Map();
+			while (raw[cursor] !== "}") {
+				const keyToken = stringToken();
+				const key = JSON.parse(keyToken);
+				whitespace();
+				cursor++;
+				const child = parsedValue !== null && typeof parsedValue === "object" && typeof key === "string" ? Reflect.get(parsedValue, key) : void 0;
+				const childNode = value(child);
+				if (typeof key === "string") properties.set(key, {
+					...childNode,
+					keyToken
+				});
+				whitespace();
+				if (raw[cursor] !== ",") break;
+				cursor++;
+				whitespace();
+			}
+			cursor++;
+			return {
+				start,
+				end: cursor,
+				value: parsedValue,
+				properties
+			};
+		}
+		if (raw[cursor] === "[") {
+			cursor++;
+			whitespace();
+			const items = [];
+			while (raw[cursor] !== "]") {
+				items.push(value(Array.isArray(parsedValue) ? parsedValue[items.length] : void 0));
+				whitespace();
+				if (raw[cursor] !== ",") break;
+				cursor++;
+			}
+			cursor++;
+			return {
+				start,
+				end: cursor,
+				value: parsedValue,
+				items
+			};
+		}
+		if (raw[cursor] === "\"") stringToken();
+		else while (cursor < raw.length && !/[\s,}\]]/.test(raw[cursor] ?? "")) cursor++;
+		return {
+			start,
+			end: cursor,
+			value: parsedValue
+		};
+	};
+	return value(parsed);
+}
+function serializeValue(value, raw, node, seen) {
+	if (node && sameJsonValue(node.value, value)) return raw.slice(node.start, node.end);
+	if (typeof value === "number") {
+		if (Object.is(value, -0)) return "-0";
+		if (value === Infinity) return "1e999";
+		if (value === -Infinity) return "-1e999";
+		return JSON.stringify(value);
+	}
+	if (value === null || typeof value !== "object") return JSON.stringify(value);
+	if (seen.has(value)) throw new TypeError("Cannot serialize circular tool input");
+	seen.add(value);
+	try {
+		if (Array.isArray(value)) return "[" + Array.from(value, (item, index) => serializeValue(item, raw, node?.items?.[index], seen) ?? "null").join(",") + "]";
+		const properties = [];
+		for (const key of Object.keys(value)) {
+			const serialized = serializeValue(Reflect.get(value, key), raw, node?.properties?.get(key), seen);
+			if (serialized !== void 0) properties.push((node?.properties?.get(key)?.keyToken ?? JSON.stringify(key)) + ":" + serialized);
+		}
+		return "{" + properties.join(",") + "}";
+	} finally {
+		seen.delete(value);
+	}
+}
+/**
+* Keep `raw` when it is the same JSON value as `input`. When they differ,
+* write `input` again and keep the raw tokens of the values that did not
+* change. Empty or missing raw arguments use the input.
+*/
+function reconcileToolCallArguments(raw, input) {
+	if (input === void 0) return raw ?? "";
+	if (raw === void 0) return serializeValue(input, "", void 0, /* @__PURE__ */ new Set()) ?? "";
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		if (raw.trim() === "") return serializeValue(input, "", void 0, /* @__PURE__ */ new Set()) ?? raw;
+		return raw;
+	}
+	if (sameJsonValue(parsed, input)) return raw;
+	return serializeValue(input, raw, scanJson(raw, parsed), /* @__PURE__ */ new Set()) ?? raw;
+}
+/**
+* The input of a tool call from its raw arguments: `{}` for an empty string,
+* `undefined` when the arguments are not complete JSON (for example cut off)
+* or are `null`.
+*/
+function parseToolArguments(args) {
+	if (args.trim() === "") return {};
+	try {
+		return JSON.parse(args) ?? void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* The final arguments and input of a tool call at TOOL_CALL_END. `streamed`
+* is the text of its TOOL_CALL_ARGS deltas. The END's raw `args` (the
+* provider's own string) win over it, and stay as they are when they are the
+* same JSON value as the END's `input`. Malformed arguments also stay, so the
+* tool reports the error and the model can repair them. `input` is always
+* the parse of `args`.
+*/
+function finishToolCallArguments(streamed, end) {
+	const metadata = tanstackMetadata(end);
+	const endArgs = end.args ?? metadata?.args;
+	const rawArgs = typeof endArgs === "string" ? endArgs : void 0;
+	const endInput = end.input ?? metadata?.input;
+	const input = endInput !== null && typeof endInput === "object" ? endInput : void 0;
+	let raw = rawArgs ?? streamed;
+	if (rawArgs === void 0 && input !== void 0) try {
+		JSON.parse(raw);
+	} catch {
+		raw = void 0;
+	}
+	let args;
+	try {
+		args = reconcileToolCallArguments(raw, input);
+	} catch {
+		args = raw ?? streamed;
+	}
+	return {
+		args,
+		input: parseToolArguments(args)
+	};
+}
+//#endregion
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/utilities/reasoning-encrypted-value.js
 /**
 * Id prefix for the reasoning message of a redacted thinking block (Anthropic
 * `redacted_thinking`). AG-UI's `encryptedValue` does not say what kind of
@@ -233,7 +833,7 @@ function isRedactedThinkingId(id) {
 	return typeof id === "string" && id.startsWith("redacted_thinking-");
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/interrupt-serialization.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/interrupt-serialization.js
 var SHA256_K = new Uint32Array([
 	1116352408,
 	1899447441,
@@ -408,7 +1008,7 @@ function cloneAndDeepFreezeJson(value) {
 	return clone;
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/interrupts.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/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);
@@ -419,7 +1019,7 @@ function canonicalizeInterruptResolutions(resolutions) {
 	});
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/activities/chat/tools/schema-converter.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/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
@@ -687,7 +1287,7 @@ async function validateWithStandardSchema(schema, data) {
 	};
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/activities/chat/tools/approval-schema.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/activities/chat/tools/approval-schema.js
 var jsonSchemaKeywords = /* @__PURE__ */ new Set([
 	"$schema",
 	"$id",
@@ -801,7 +1401,7 @@ function hashSchemaInput(schema) {
 	return digestInterruptJson(canonicalInterruptJson(schemaToWire(schema).jsonSchema ?? { standardValidator: "unserialized" }));
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/interrupt-resume.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/interrupt-resume.js
 /**
 * The `Interrupt.metadata` key under which this package's resume binding
 * travels.
@@ -922,7 +1522,7 @@ function readInterruptBinding(descriptor) {
 	};
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/interrupt-definition.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/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.`);
@@ -947,7 +1547,7 @@ function hashInterruptDefinitionSchema(schema) {
 	return digestInterruptJson(schemaJson(schema, "Interrupt schema").canonicalJson);
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/generic-interrupt-continuation.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/generic-interrupt-continuation.js
 /**
 * `ResumeEntry.metadata` key for a first-party generic request.
 *
@@ -986,100 +1586,19 @@ function genericInterruptContinuationFromDescriptor(interrupt) {
 	};
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/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;
-}
-/**
-* 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 isProviderExecutedToolCall(toolCall) {
-	return getProviderExecutedMetadata(toolCall) !== null;
-}
-/**
-* 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 isAssistantSegmentOf(id, parentId) {
-	return id?.startsWith(`${parentId}-segment-`) === true;
-}
-//#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/utilities/tool-result.js
-var CONTENT_PART_TYPES = /* @__PURE__ */ new Set([
-	"text",
-	"image",
-	"audio",
-	"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 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;
-	const part = value;
-	if (typeof part.type !== "string" || !CONTENT_PART_TYPES.has(part.type)) return false;
-	if (part.type === "text") return typeof part.content === "string";
-	const source = part.source;
-	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";
-}
-/**
-* True iff `value` is a NON-EMPTY array whose every element is a valid
-* `ContentPart`. Empty arrays and mixed arrays return false so they continue
-* to be treated as ordinary (stringified) data — this keeps the auto-detection
-* footgun narrow.
-*/
-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";
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/utilities/subagent-wire.js
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+/** Key of a child's checked input in `SUBAGENT_STARTED` metadata (`metadata.tanstack`). */
+var SUBAGENT_INPUT_KEY = "subagentInput";
 /**
-* Normalize a tool's return value for transport:
-* - string            → unchanged
-* - ContentPart array → unchanged (multimodal, passed through to the adapter)
-* - anything else     → `JSON.stringify`
+* The checked input of a child that an agent with `inputSchema` got, read
+* from the `metadata` of its card or of its `SUBAGENT_STARTED` event.
 */
-function normalizeToolResult(result) {
-	if (typeof result === "string") return result;
-	if (isContentPartArray(result)) return result;
-	return JSON.stringify(result);
-}
-//#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/utilities/subagent-wire.js
-function isRecord$2(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
+function subagentInputOf(metadata) {
+	if (!isRecord$2(metadata) || !isRecord$2(metadata.tanstack)) return void 0;
+	return metadata.tanstack[SUBAGENT_INPUT_KEY];
 }
 function wireSubagentRunId(message) {
 	if (!isRecord$2(message) || "parts" in message) return void 0;
@@ -1181,7 +1700,186 @@ function splitSubagentWire(messages) {
 	};
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/activities/chat/messages.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/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;
+}
+/**
+* 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 isProviderExecutedToolCall(toolCall) {
+	return getProviderExecutedMetadata(toolCall) !== null;
+}
+/**
+* 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 isAssistantSegmentOf(id, parentId) {
+	return id?.startsWith(`${parentId}-segment-`) === true;
+}
+//#endregion
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/utilities/tool-result.js
+var CONTENT_PART_TYPES = /* @__PURE__ */ new Set([
+	"text",
+	"image",
+	"audio",
+	"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 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;
+	const part = value;
+	if (typeof part.type !== "string" || !CONTENT_PART_TYPES.has(part.type)) return false;
+	if (part.type === "text") return typeof part.content === "string";
+	const source = part.source;
+	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";
+}
+/**
+* True iff `value` is a NON-EMPTY array whose every element is a valid
+* `ContentPart`. Empty arrays and mixed arrays return false so they continue
+* to be treated as ordinary (stringified) data — this keeps the auto-detection
+* footgun narrow.
+*/
+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)
+* - anything else     → `JSON.stringify`
+*/
+function normalizeToolResult(result) {
+	if (typeof result === "string") return result;
+	if (isContentPartArray(result)) return result;
+	return JSON.stringify(result);
+}
+//#endregion
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/utilities/block-order.js
+/**
+* The order map for these entries in produced order, or undefined when they
+* are in the default order (all thinking, then text, then tool calls).
+* Adjacent text entries merge into one, and empty text is left out. The n-th
+* thinking entry gets index n.
+*/
+function buildBlockOrder(entries) {
+	const blocks = [];
+	let thinking = 0;
+	let isDefault = true;
+	for (const entry of entries) {
+		const last = blocks.at(-1);
+		if (entry.type === "thinking") {
+			if (last !== void 0 && last.type !== "thinking") isDefault = false;
+			blocks.push({
+				type: "thinking",
+				index: thinking++
+			});
+		} else if (entry.type === "text") {
+			if (entry.text === "") continue;
+			if (last?.type === "text") {
+				last.length += entry.text.length;
+				continue;
+			}
+			if (last?.type === "tool-call") isDefault = false;
+			blocks.push({
+				type: "text",
+				length: entry.text.length
+			});
+		} else blocks.push({
+			type: "tool-call",
+			id: entry.id
+		});
+	}
+	return isDefault ? void 0 : blocks;
+}
+/**
+* The blocks of an assistant message in map order, or undefined when the
+* message has no map or the map does not match the message. A map matches
+* when it uses each `thinking` entry and each `toolCalls` entry exactly once,
+* and its text lengths add up to the length of the text content (`null`
+* content counts as no text). Readers use the default order when this
+* returns undefined.
+*/
+function orderedAssistantBlocks(message) {
+	const order = message.blockOrder;
+	if (!Array.isArray(order) || order.length === 0) return void 0;
+	const content = message.content ?? "";
+	if (typeof content !== "string") return void 0;
+	const thinking = message.thinking ?? [];
+	const toolCalls = message.toolCalls ?? [];
+	const usedThinking = /* @__PURE__ */ new Set();
+	const usedCalls = /* @__PURE__ */ new Set();
+	const blocks = [];
+	let offset = 0;
+	for (const block of order) {
+		if (typeof block !== "object" || block === null) return void 0;
+		if (block.type === "thinking") {
+			const entry = Number.isInteger(block.index) ? thinking[block.index] : void 0;
+			if (entry === void 0 || usedThinking.has(block.index)) return;
+			usedThinking.add(block.index);
+			blocks.push({
+				type: "thinking",
+				thinking: entry
+			});
+		} else if (block.type === "text") {
+			const end = offset + block.length;
+			if (!Number.isInteger(block.length) || block.length <= 0 || end > content.length) return;
+			blocks.push({
+				type: "text",
+				text: content.slice(offset, end)
+			});
+			offset = end;
+		} else if (block.type === "tool-call") {
+			const toolCall = toolCalls.find((candidate) => candidate.id === block.id);
+			if (toolCall === void 0 || usedCalls.has(block.id)) return void 0;
+			usedCalls.add(block.id);
+			blocks.push({
+				type: "tool-call",
+				toolCall
+			});
+		} else return;
+	}
+	if (offset !== content.length || usedThinking.size !== thinking.length || usedCalls.size !== toolCalls.length) return;
+	return blocks;
+}
+//#endregion
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/activities/chat/messages.js
 function isRecord$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1341,12 +2039,19 @@ function appendUiResources(ui, resources) {
 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;
+	const tanstack = { ...tanstackMetadata(uiMessage) };
+	if (tanstack.run) {
+		tanstack.run = { ...tanstack.run };
+		delete tanstack.run.startedAt;
+		delete tanstack.run.finishedAt;
+	}
+	delete tanstack.createdAt;
+	delete tanstack.continues;
+	delete tanstack.structuredOutput;
+	delete tanstack.toolCallMetadata;
+	delete tanstack.toolResult;
+	delete tanstack.toolResultOutcome;
+	delete tanstack.uiResources;
 	if (fromParts.length > 0) tanstack.uiResources = fromParts;
 	const result = { ...current };
 	if (Object.keys(tanstack).length > 0) result.tanstack = tanstack;
@@ -1397,7 +2102,8 @@ function buildUserOrToolMessage(uiMessage) {
 function createSegment() {
 	return {
 		contentParts: [],
-		toolCalls: []
+		toolCalls: [],
+		order: []
 	};
 }
 function isToolCallIncluded(part) {
@@ -1432,6 +2138,7 @@ function buildAssistantMessages(uiMessage) {
 		const hasContent = content !== null;
 		const hasToolCalls = current.toolCalls.length > 0;
 		const hasThinking = pendingThinking.length > 0;
+		const blockOrder = Array.isArray(content) ? void 0 : buildBlockOrder(current.order);
 		if (force || hasContent || hasToolCalls || hasThinking) {
 			messageList.push({
 				...assistantFields,
@@ -1439,7 +2146,8 @@ function buildAssistantMessages(uiMessage) {
 				content,
 				...hasToolCalls && { toolCalls: current.toolCalls },
 				...hasThinking && { thinking: pendingThinking },
-				...current.structuredOutput && { structuredOutput: current.structuredOutput }
+				...current.structuredOutput && { structuredOutput: current.structuredOutput },
+				...blockOrder && { blockOrder }
 			});
 			pendingThinking = [];
 		}
@@ -1447,6 +2155,12 @@ function buildAssistantMessages(uiMessage) {
 	}
 	for (const part of uiMessage.parts) switch (part.type) {
 		case "text":
+			current.contentParts.push(part);
+			current.order.push({
+				type: "text",
+				text: part.content
+			});
+			break;
 		case "image":
 		case "audio":
 		case "video":
@@ -1454,15 +2168,21 @@ function buildAssistantMessages(uiMessage) {
 			current.contentParts.push(part);
 			break;
 		case "tool-call":
-			if (isToolCallIncluded(part)) current.toolCalls.push({
-				id: part.id,
-				type: "function",
-				function: {
-					name: part.name,
-					arguments: part.arguments
-				},
-				...part.metadata !== void 0 && { metadata: part.metadata }
-			});
+			if (isToolCallIncluded(part)) {
+				current.toolCalls.push({
+					id: part.id,
+					type: "function",
+					function: {
+						name: part.name,
+						arguments: part.arguments
+					},
+					...part.metadata !== void 0 && { metadata: part.metadata }
+				});
+				current.order.push({
+					type: "tool-call",
+					id: part.id
+				});
+			}
 			break;
 		case "tool-result":
 			flushSegment(messageList.length === 0);
@@ -1489,6 +2209,7 @@ function buildAssistantMessages(uiMessage) {
 					...part.signature && { signature: part.signature },
 					...part.redacted && { redacted: true }
 				});
+				current.order.push({ type: "thinking" });
 			}
 			break;
 		case "structured-output":
@@ -1499,6 +2220,10 @@ function buildAssistantMessages(uiMessage) {
 						type: "text",
 						content: serialized
 					});
+					current.order.push({
+						type: "text",
+						text: serialized
+					});
 					current.structuredOutput = part;
 				}
 			}
@@ -1508,10 +2233,14 @@ function buildAssistantMessages(uiMessage) {
 		case "subagent": {
 			const block = part.subagent.parentToolCallId === void 0 ? subagentHistoryText(part) : "";
 			if (block !== "") {
-				const prefix = current.contentParts.length > 0 ? "\n\n" : "";
+				const text = `${current.contentParts.length > 0 ? "\n\n" : ""}${block}`;
 				current.contentParts.push({
 					type: "text",
-					content: `${prefix}${block}`
+					content: text
+				});
+				current.order.push({
+					type: "text",
+					text
 				});
 			}
 			break;
@@ -1550,6 +2279,31 @@ function buildAssistantMessages(uiMessage) {
 	});
 	return messageList;
 }
+function thinkingToPart(thinking) {
+	return {
+		type: "thinking",
+		content: thinking.content,
+		...thinking.signature && { signature: thinking.signature },
+		...thinking.redacted && { redacted: true }
+	};
+}
+function toolCallToPart(toolCall) {
+	let input;
+	try {
+		input = JSON.parse(toolCall.function.arguments);
+	} catch {
+		input = void 0;
+	}
+	return {
+		type: "tool-call",
+		id: toolCall.id,
+		name: toolCall.function.name,
+		arguments: toolCall.function.arguments,
+		state: "input-complete",
+		...input !== void 0 && { input },
+		...toolCall.metadata !== void 0 && { metadata: toolCall.metadata }
+	};
+}
 /**
 * Convert a ModelMessage to UIMessage
 *
@@ -1567,12 +2321,7 @@ function modelMessageToUIMessage(modelMessage, id) {
 	const createdAt = coerceCreatedAt(modelMessage.createdAt);
 	if (modelMessage.role === "assistant" && modelMessage.thinking?.length) for (const thinking of modelMessage.thinking) {
 		if (!thinking.content && !thinking.signature) continue;
-		parts.push({
-			type: "thinking",
-			content: thinking.content,
-			...thinking.signature && { signature: thinking.signature },
-			...thinking.redacted && { redacted: true }
-		});
+		parts.push(thinkingToPart(thinking));
 	}
 	const structuredOutput = modelMessage.structuredOutput ?? snapshotStructuredOutput(tanstackMetadata(modelMessage)?.structuredOutput);
 	if (modelMessage.role === "assistant" && structuredOutput) {
@@ -1609,23 +2358,16 @@ function modelMessageToUIMessage(modelMessage, id) {
 			content: textContent
 		});
 	}
-	if (modelMessage.toolCalls && modelMessage.toolCalls.length > 0) for (const toolCall of modelMessage.toolCalls) {
-		let input;
-		try {
-			input = JSON.parse(toolCall.function.arguments);
-		} catch {
-			input = void 0;
-		}
-		parts.push({
-			type: "tool-call",
-			id: toolCall.id,
-			name: toolCall.function.name,
-			arguments: toolCall.function.arguments,
-			state: "input-complete",
-			...input !== void 0 && { input },
-			...toolCall.metadata !== void 0 && { metadata: toolCall.metadata }
-		});
-	}
+	if (modelMessage.toolCalls && modelMessage.toolCalls.length > 0) for (const toolCall of modelMessage.toolCalls) parts.push(toolCallToPart(toolCall));
+	const ordered = modelMessage.role === "assistant" && structuredOutput === void 0 ? orderedAssistantBlocks(modelMessage) : void 0;
+	if (ordered) parts.splice(0, parts.length, ...ordered.flatMap((block) => {
+		if (block.type === "text") return [{
+			type: "text",
+			content: block.text
+		}];
+		if (block.type === "tool-call") return [toolCallToPart(block.toolCall)];
+		return block.thinking.content || block.thinking.signature ? [thinkingToPart(block.thinking)] : [];
+	}));
 	const ui = {
 		id: id || generateMessageId(),
 		role: modelMessage.role === "tool" ? "assistant" : modelMessage.role,
@@ -1849,7 +2591,7 @@ function generateMessageId() {
 	return `msg-${Date.now()}-${Math.random().toString(36).substring(7)}`;
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/utilities/ag-ui-wire.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/utilities/ag-ui-wire.js
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1882,7 +2624,10 @@ function rebuiltToolMetadata(metadata, createdAt, id, content, anchorOwnsUiResou
 * server consumers. Set `includeSnapshotStructuredOutput` to retain complete
 * structured-output metadata for UI snapshots. Set `includeActivity` to emit
 * AG-UI `ActivityMessage` rows (MESSAGES_SNAPSHOT only — default omit so
-* RunAgentInput never carries activity).
+* RunAgentInput never carries activity). An assistant message whose
+* parts leave the default block order goes out as several rows in the real
+* order (see `TanStackMessageMetadata.continues`). A tool result also ends a
+* row, and its tool row follows that row.
 */
 function uiMessagesToWire(messages, options) {
 	const wire = [];
@@ -1934,20 +2679,72 @@ function uiMessagesToWire(messages, options) {
 			wire.push(toAnchor(uiMessage, "user", { content: parts.length > 0 ? collectUserContent(parts) : msg.content ?? "" }, parts, includeSnapshotStructuredOutput));
 			continue;
 		}
-		let current = {
+		const newSegment = (continues) => ({
 			thinking: [],
-			parts: []
-		};
+			parts: [],
+			continues,
+			closed: false
+		});
+		let current = newSegment(false);
 		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: []
-				};
+		for (const part of parts) {
+			if (current.closed && (part.type === "thinking" || part.type === "text" || part.type === "tool-call")) {
+				current = newSegment(false);
+				segments.push(current);
+			}
+			const afterCall = current.parts.some((p) => p.type === "tool-call");
+			if (part.type === "thinking") {
+				if (current.parts.some((p) => p.type === "tool-call" && isProviderExecutedToolCall(p))) {
+					current = newSegment(false);
+					segments.push(current);
+				} else if (afterCall || current.parts.some((p) => p.type === "text")) {
+					current = newSegment(true);
+					segments.push(current);
+				}
+				current.thinking.push(part);
+			} else if (part.type === "text" && afterCall) {
+				current = newSegment(true);
 				segments.push(current);
-			} else current.thinking.push(part);
-		} else current.parts.push(part);
+				current.parts.push(part);
+			} else {
+				current.parts.push(part);
+				if (part.type === "tool-result") current.closed = true;
+			}
+		}
+		const explicitToolResults = new Set(parts.flatMap((part) => part.type === "tool-result" ? [part.toolCallId] : []));
+		const pushToolRows = (rowParts) => {
+			for (const part of rowParts) 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)
+				});
+			}
+		};
+		let previousAnchorId = uiMessage.id;
+		let toolParts = [];
 		segments.forEach((segment, index) => {
 			for (const part of segment.thinking) {
 				const reasoning = {
@@ -1960,45 +2757,31 @@ function uiMessagesToWire(messages, options) {
 			}
 			const text = collectText(segment.parts);
 			const toolCalls = collectToolCalls(segment.parts);
-			const anchorMessage = index === 0 ? uiMessage : {
+			const anchor = toAnchor(index === 0 ? uiMessage : {
 				...uiMessage,
 				id: uniqueWireId(`${uiMessage.id}-segment-${index}`, usedWireIds)
-			};
-			wire.push(toAnchor(anchorMessage, "assistant", {
+			}, "assistant", {
 				...text !== "" && { content: text },
 				...toolCalls && { toolCalls }
-			}, segment.parts, includeSnapshotStructuredOutput));
+			}, segment.parts, includeSnapshotStructuredOutput);
+			if (segment.continues) {
+				const metadata = anchor.metadata ?? {};
+				anchor.metadata = {
+					...metadata,
+					tanstack: {
+						...isRecord(metadata.tanstack) ? metadata.tanstack : {},
+						continues: previousAnchorId
+					}
+				};
+			}
+			wire.push(anchor);
+			previousAnchorId = anchor.id;
+			toolParts.push(...segment.parts);
+			if (segment.closed || index === segments.length - 1) {
+				pushToolRows(toolParts);
+				toolParts = [];
+			}
 		});
-		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;
@@ -2029,12 +2812,19 @@ function toAnchor(msg, role, extras, parts, includeSnapshotStructuredOutput) {
 }
 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 tanstack = { ...tanstackMetadata(msg) };
+	if (tanstack.run) {
+		tanstack.run = { ...tanstack.run };
+		delete tanstack.run.startedAt;
+		delete tanstack.run.finishedAt;
+	}
+	delete tanstack.createdAt;
+	delete tanstack.continues;
+	delete tanstack.structuredOutput;
+	delete tanstack.toolCallMetadata;
+	delete tanstack.toolResult;
+	delete tanstack.toolResultOutcome;
+	delete tanstack.uiResources;
 	const createdAt = coerceCreatedAt(msg.createdAt);
 	if (createdAt !== void 0) tanstack.createdAt = createdAt.toISOString();
 	const structuredOutput = serializedStructuredOutput(parts, includeSnapshotStructuredOutput);
@@ -2184,11 +2974,11 @@ function hashContent(s) {
 	return Math.abs(h).toString(36);
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/utilities/restore-inbound-chunk.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/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
+* leftover fields in `metadata.tanstack.usage`. Restore the in-process field
+* that the wire does not keep (`TOOL_CALL_END.input`). Mutates
 * in place so WeakMap run-id stamps stay attached.
 */
 function restorePublicUsage(chunk) {
@@ -2196,9 +2986,9 @@ function restorePublicUsage(chunk) {
 		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;
+		const tanstack = tanstackMetadata(chunk);
+		const input = tanstack?.input ?? (typeof tanstack?.args === "string" ? parseToolArguments(tanstack.args) : void 0);
 		if (input !== void 0) chunk.input = input;
 	}
 	return chunk;
@@ -2221,7 +3011,7 @@ function restoreInboundChunk(chunk) {
 	return next;
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/activities/chat/tools/tool-definition.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/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
 *
@@ -2319,7 +3109,7 @@ function toolDefinition(config) {
 	};
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/utilities/chunk-ids.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/utilities/chunk-ids.js
 function stringField(value) {
 	return typeof value === "string" && value !== "" ? value : void 0;
 }
@@ -2422,7 +3212,7 @@ var require_options = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.default = exports.Allow;
 }));
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/json-parser.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/json-parser.js
 var import_dist = (/* @__PURE__ */ __commonJSMin(((exports, module, this$1) => {
 	var __createBinding = this$1 && this$1.__createBinding || (Object.create ? (function(o, m, k, k2) {
 		if (k2 === void 0) k2 = k;
@@ -2644,7 +3434,7 @@ function parsePartialJSON(jsonString) {
 	return defaultJSONParser.parse(jsonString);
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/strategies.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/strategies.js
 /**
 * Immediate Strategy - emit on every chunk (default behavior)
 */
@@ -2654,16 +3444,14 @@ var ImmediateStrategy = class {
 	}
 };
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/utilities/errors.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/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
-* accepting the deprecated nested error payload for backward compatibility.
+* Preserves the provider code and sanitized raw event when available.
 */
 function runErrorEventToError(chunk) {
-	const error = new Error(chunk.message || chunk.error?.message || "An error occurred");
-	const code = chunk.code ?? chunk.error?.code;
-	if (code !== void 0) Object.assign(error, { code });
+	const error = new Error(chunk.message || "An error occurred");
+	if (chunk.code !== void 0) Object.assign(error, { code: chunk.code });
 	if (chunk.rawEvent !== void 0) Object.assign(error, { rawEvent: chunk.rawEvent });
 	return error;
 }
@@ -3317,7 +4105,7 @@ var fast_json_patch_default = Object.assign({}, core_exports, duplex_exports, {
 	unescapePathComponent
 });
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/activities/chat/activity-records.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/activities/chat/activity-records.js
 function isActivityPart(part) {
 	return part.type === "activity";
 }
@@ -3393,7 +4181,7 @@ function applyActivityDeltaToUIMessages(messages, chunk) {
 	}
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/message-updaters.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/message-updaters.js
 /**
 * Message Updaters (Internal)
 *
@@ -3695,7 +4483,7 @@ function updateThinkingPart(messages, messageId, stepId, content, signature) {
 	});
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/processor.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/processor.js
 /**
 * Unified Stream Processor
 *
@@ -3747,35 +4535,6 @@ 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;
-	}
-}
-/**
-* The input of a tool call from its raw arguments: `{}` for an empty string,
-* `undefined` when the arguments are not complete JSON (for example cut off)
-* or are `null`.
-*/
-function parseToolArguments(args) {
-	if (args.trim() === "") return {};
-	try {
-		return JSON.parse(args) ?? void 0;
-	} catch {
-		return;
-	}
-}
-/**
 * StreamProcessor - State machine for processing AI response streams
 *
 * Manages the full UIMessage[] conversation and emits events on changes.
@@ -3801,11 +4560,14 @@ var StreamProcessor = class StreamProcessor {
 	activeMessageIds = /* @__PURE__ */ new Set();
 	toolCallToMessage = /* @__PURE__ */ new Map();
 	pendingManualMessageId = null;
-	pendingThinkingStepId = null;
 	openChunk = null;
 	structuredMessageIds = /* @__PURE__ */ new Set();
 	structuredOutputUpdateBatches = /* @__PURE__ */ new Map();
 	activeRuns = /* @__PURE__ */ new Set();
+	callMessageIds = /* @__PURE__ */ new Map();
+	unassignedCallMessageIds = /* @__PURE__ */ new Set();
+	sealedMessageIds = /* @__PURE__ */ new Set();
+	thinkingOwners = /* @__PURE__ */ new Map();
 	runToolCallIds = [];
 	toolCallsSentToClient = /* @__PURE__ */ new Set();
 	childProcessors = /* @__PURE__ */ new Map();
@@ -3912,16 +4674,6 @@ var StreamProcessor = class StreamProcessor {
 		this.resetStreamState();
 	}
 	/**
-	* @deprecated Use prepareAssistantMessage() instead. This eagerly creates
-	* an assistant message which can cause empty message flicker.
-	*/
-	startAssistantMessage(messageId) {
-		this.prepareAssistantMessage();
-		const { messageId: id } = this.ensureAssistantMessage(messageId);
-		this.pendingManualMessageId = id;
-		return id;
-	}
-	/**
 	* Get the current assistant message ID (if one has been created).
 	* Returns null if prepareAssistantMessage() was called but no content
 	* has arrived yet.
@@ -4000,6 +4752,11 @@ var StreamProcessor = class StreamProcessor {
 		for (const id of this.messageStates.keys()) if (!keptIds.has(id)) this.messageStates.delete(id);
 		for (const [toolCallId, msgId] of this.toolCallToMessage) if (!keptIds.has(msgId)) this.toolCallToMessage.delete(toolCallId);
 		for (const id of this.activeMessageIds) if (!keptIds.has(id)) this.activeMessageIds.delete(id);
+		if (this.pendingManualMessageId && !keptIds.has(this.pendingManualMessageId)) this.pendingManualMessageId = null;
+		for (const ids of this.callMessageIds.values()) for (const id of ids) if (!keptIds.has(id)) ids.delete(id);
+		for (const id of this.unassignedCallMessageIds) if (!keptIds.has(id)) this.unassignedCallMessageIds.delete(id);
+		for (const id of this.sealedMessageIds) if (!keptIds.has(id)) this.sealedMessageIds.delete(id);
+		for (const [key, owner] of this.thinkingOwners) if (!keptIds.has(owner.messageId)) this.thinkingOwners.delete(key);
 		this.messages = this.messages.slice(0, index + 1);
 		this.emitMessagesChange();
 	}
@@ -4007,6 +4764,8 @@ var StreamProcessor = class StreamProcessor {
 	* Clear all messages
 	*/
 	clearMessages() {
+		for (const ids of this.callMessageIds.values()) ids.clear();
+		this.unassignedCallMessageIds.clear();
 		this.messages = [];
 		this.messageStates.clear();
 		this.activeMessageIds.clear();
@@ -4014,6 +4773,8 @@ var StreamProcessor = class StreamProcessor {
 		this.structuredMessageIds.clear();
 		this.structuredOutputUpdateBatches.clear();
 		this.pendingManualMessageId = null;
+		this.sealedMessageIds.clear();
+		this.thinkingOwners.clear();
 		this.openChunk = null;
 		this.childProcessors.clear();
 		this.childToolCalls.clear();
@@ -4084,9 +4845,6 @@ var StreamProcessor = class StreamProcessor {
 			case "RUN_ERROR":
 				this.handleRunErrorEvent(chunk);
 				break;
-			case "STEP_FINISHED":
-				this.handleStepFinishedEvent(chunk);
-				break;
 			case "MESSAGES_SNAPSHOT":
 				this.handleMessagesSnapshotEvent(chunk);
 				break;
@@ -4097,9 +4855,18 @@ var StreamProcessor = class StreamProcessor {
 				this.handleRunStartedEvent(chunk);
 				break;
 			case "REASONING_START":
-			case "REASONING_MESSAGE_START":
 			case "REASONING_MESSAGE_END":
 			case "REASONING_END": break;
+			case "REASONING_MESSAGE_START": {
+				const start = chunk;
+				const target = this.unscopedAssistant(start);
+				const current = target.id ? this.getMessageState(target.id) : void 0;
+				if (current) current.currentThinkingStepId = null;
+				if (start.metadata == null) break;
+				const { messageId } = this.ensureAssistantMessage(target.id ?? void 0, !target.create);
+				this.mergeMessageMetadata(messageId, start.metadata);
+				break;
+			}
 			case "REASONING_MESSAGE_CONTENT":
 				this.handleReasoningMessageContentEvent(chunk);
 				break;
@@ -4109,9 +4876,6 @@ var StreamProcessor = class StreamProcessor {
 			case "TOOL_CALL_RESULT":
 				this.handleToolCallResultEvent(chunk);
 				break;
-			case "STEP_STARTED":
-				this.handleStepStartedEvent(chunk);
-				break;
 			case "ACTIVITY_SNAPSHOT":
 				this.handleActivitySnapshotEvent(chunk);
 				break;
@@ -4293,7 +5057,6 @@ var StreamProcessor = class StreamProcessor {
 			totalTextContent: "",
 			currentSegmentText: "",
 			lastEmittedText: "",
-			hasSeenReasoningEvents: false,
 			thinkingSteps: /* @__PURE__ */ new Map(),
 			thinkingStepSignatures: /* @__PURE__ */ new Map(),
 			thinkingStepOrder: [],
@@ -4309,38 +5072,95 @@ var StreamProcessor = class StreamProcessor {
 	/**
 	* Get the MessageStreamState for a message
 	*/
-	getMessageState(messageId) {
-		return this.messageStates.get(messageId);
-	}
-	/**
-	* Promote a pending stepId from a STEP_STARTED that fired before the
-	* assistant message existed onto the given message state, so the next
-	* thinking event (STEP_FINISHED or REASONING_MESSAGE_CONTENT) attributes
-	* to the correct step.
-	*/
-	consumePendingThinkingStep(state) {
-		if (!this.pendingThinkingStepId) return;
-		const stepId = this.pendingThinkingStepId;
-		state.currentThinkingStepId = stepId;
-		if (!state.thinkingSteps.has(stepId)) {
-			state.thinkingSteps.set(stepId, "");
-			state.thinkingStepOrder.push(stepId);
-		}
-		this.pendingThinkingStepId = null;
+	getMessageState(messageId) {
+		return this.messageStates.get(messageId);
 	}
 	/**
 	* Get the most recent active assistant message ID.
 	* Used as fallback for events that don't include a messageId.
 	*/
 	getActiveAssistantMessageId() {
+		const belongsToCurrentCall = (id) => this.activeRuns.size === 0 || [...this.activeRuns].some((runId) => this.callMessageIds.get(runId)?.has(id)) || this.pendingManualMessageId === id && !this.messageStates.get(id)?.isComplete && !this.isDone;
 		const ids = Array.from(this.activeMessageIds).reverse();
 		for (const id of ids) {
+			if (this.sealedMessageIds.has(id)) continue;
 			const state = this.messageStates.get(id);
-			if (state && state.role === "assistant") return id;
+			if (state && state.role === "assistant" && belongsToCurrentCall(id)) return id;
+		}
+		for (const [id, state] of [...this.messageStates].reverse()) {
+			if (this.sealedMessageIds.has(id)) continue;
+			if (state.role === "assistant" && belongsToCurrentCall(id)) return id;
+		}
+		return null;
+	}
+	/** The run that currently owns `messageId`, if one was recorded. */
+	runOfMessage(messageId) {
+		for (const [runId, ids] of this.callMessageIds) if (ids.has(messageId)) return runId;
+	}
+	/** Latest unsealed assistant message written by `runId`. */
+	openMessageOfRun(runId) {
+		const ids = this.callMessageIds.get(runId);
+		if (!ids) return null;
+		for (const id of [...ids].reverse()) {
+			if (this.sealedMessageIds.has(id)) continue;
+			if (this.messageStates.get(id)?.role === "assistant") return id;
 		}
-		for (const [id, state] of [...this.messageStates].reverse()) if (state.role === "assistant") return id;
 		return null;
 	}
+	/**
+	* Where an event with no assistant message id belongs.
+	* `create` means open a new message. Do not borrow another run's.
+	*/
+	unscopedAssistant(chunk) {
+		const explicit = getChunkRunId(chunk);
+		const onlyRun = this.activeRuns.size === 1 ? [...this.activeRuns][0] : void 0;
+		const runId = explicit ?? onlyRun;
+		if (runId !== void 0) {
+			const open = this.openMessageOfRun(runId);
+			if (open) return {
+				id: open,
+				create: false
+			};
+			if (explicit !== void 0 || this.activeRuns.has(runId)) return {
+				id: null,
+				create: true
+			};
+		}
+		const active = this.getActiveAssistantMessageId();
+		if (active) return {
+			id: active,
+			create: false
+		};
+		return {
+			id: null,
+			create: true
+		};
+	}
+	rememberThinking(messageId, stepId, reasoningMessageId) {
+		const owner = {
+			messageId,
+			stepId
+		};
+		this.thinkingOwners.set(stepId, owner);
+		if (reasoningMessageId !== void 0 && reasoningMessageId !== stepId) this.thinkingOwners.set(reasoningMessageId, owner);
+	}
+	/** Put `signature` on the thinking step `namedId` already belongs to. */
+	applyKnownSignature(namedId, signature) {
+		if (!namedId) return false;
+		const owner = this.thinkingOwners.get(namedId);
+		if (!owner) return false;
+		const state = this.getMessageState(owner.messageId);
+		if (!state) return false;
+		state.thinkingStepSignatures.set(owner.stepId, signature);
+		const content = state.thinkingSteps.get(owner.stepId) ?? "";
+		if (!state.thinkingSteps.has(owner.stepId)) {
+			state.thinkingSteps.set(owner.stepId, content);
+			state.thinkingStepOrder.push(owner.stepId);
+		}
+		this.messages = updateThinkingPart(this.messages, owner.messageId, owner.stepId, content, signature);
+		this.emitMessagesChange();
+		return true;
+	}
 	resumeAssistantState(id, state) {
 		this.activeMessageIds.add(id);
 		if (state.isComplete || this.isDone) {
@@ -4350,7 +5170,8 @@ var StreamProcessor = class StreamProcessor {
 	}
 	/**
 	* Ensure an active assistant message exists, creating one if needed.
-	* Used for backward compat when events arrive without prior TEXT_MESSAGE_START.
+	* Used when content (reasoning, tool calls, errors) arrives without a
+	* prior TEXT_MESSAGE_START.
 	*
 	* On reconnect/resume, a TEXT_MESSAGE_CONTENT may arrive for a message that
 	* already exists in this.messages (e.g. from initialMessages or a prior
@@ -4359,6 +5180,11 @@ var StreamProcessor = class StreamProcessor {
 	*/
 	ensureAssistantMessage(preferredId, fallbackToActive = true) {
 		if (preferredId) {
+			const pendingId = this.pendingManualMessageId;
+			if (pendingId && pendingId !== preferredId && this.messageStates.get(pendingId)?.isComplete === false && !this.messages.some((message) => message.id === preferredId)) {
+				this.renameMessage(pendingId, preferredId);
+				this.pendingManualMessageId = preferredId;
+			}
 			const state = this.getMessageState(preferredId);
 			if (state) {
 				this.resumeAssistantState(preferredId, state);
@@ -4368,7 +5194,7 @@ var StreamProcessor = class StreamProcessor {
 				};
 			}
 		}
-		const activeId = fallbackToActive ? this.getActiveAssistantMessageId() : null;
+		const activeId = fallbackToActive && preferredId === void 0 ? this.getActiveAssistantMessageId() : null;
 		if (activeId) {
 			const state = this.getMessageState(activeId);
 			if (state) {
@@ -4422,6 +5248,12 @@ var StreamProcessor = class StreamProcessor {
 	* Rebuilds `createdAt` when `tanstack.createdAt` is an ISO string.
 	*/
 	mergeMessageMetadata(messageId, incoming) {
+		const runId = tanstackMetadata({ metadata: incoming !== null && typeof incoming === "object" ? { ...incoming } : void 0 })?.runId ?? (this.activeRuns.size === 1 ? [...this.activeRuns][0] : void 0);
+		if (runId !== void 0) {
+			const ids = this.callMessageIds.get(runId) ?? /* @__PURE__ */ new Set();
+			ids.add(messageId);
+			this.callMessageIds.set(runId, ids);
+		} else this.unassignedCallMessageIds.add(messageId);
 		if (incoming == null || typeof incoming !== "object" || Array.isArray(incoming)) return;
 		const message = this.messages.find((msg) => msg.id === messageId);
 		if (!message) return;
@@ -4622,6 +5454,13 @@ var StreamProcessor = class StreamProcessor {
 			this.structuredOutputUpdateBatches.delete(fromId);
 			this.structuredOutputUpdateBatches.set(toId, batch);
 		}
+		for (const ids of this.callMessageIds.values()) if (ids.delete(fromId)) ids.add(toId);
+		if (this.unassignedCallMessageIds.delete(fromId)) this.unassignedCallMessageIds.add(toId);
+		if (this.sealedMessageIds.delete(fromId)) this.sealedMessageIds.add(toId);
+		for (const [key, owner] of this.thinkingOwners) if (owner.messageId === fromId) this.thinkingOwners.set(key, {
+			messageId: toId,
+			stepId: owner.stepId
+		});
 	}
 	/**
 	* Handle TEXT_MESSAGE_START event
@@ -4633,8 +5472,10 @@ var StreamProcessor = class StreamProcessor {
 			return;
 		}
 		const uiRole = role === "user" || role === "system" ? role : "assistant";
-		if (this.pendingManualMessageId) {
-			const pendingId = this.pendingManualMessageId;
+		const pendingId = this.pendingManualMessageId;
+		const pendingRun = pendingId ? this.runOfMessage(pendingId) : void 0;
+		const targetRun = this.runOfMessage(messageId);
+		if (pendingId && !(pendingRun !== void 0 && targetRun !== void 0 && pendingRun !== targetRun)) {
 			this.pendingManualMessageId = null;
 			if (pendingId !== messageId) this.renameMessage(pendingId, messageId);
 			let pendingState = this.messageStates.get(messageId);
@@ -4835,6 +5676,8 @@ var StreamProcessor = class StreamProcessor {
 	* message. Fold leading thinking-only messages into the next real
 	* assistant. Do not fold into a tool-result-only message (`role: 'tool'`
 	* on the wire). `reconcileSnapshotToolCalls` anchors those results.
+	* A `<id>-segment-<n>` row folds into its message, together with the
+	* tool-result rows between them (a tool result ends a wire segment).
 	*/
 	mergeReasoningFanOut(messages) {
 		const out = [];
@@ -4859,12 +5702,19 @@ var StreamProcessor = class StreamProcessor {
 				};
 				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]
-				};
+			let parentIndex = out.length - 1;
+			while (parentIndex >= 0) {
+				const candidate = out[parentIndex];
+				if (!candidate || !isToolResultOnly(candidate)) break;
+				parentIndex--;
+			}
+			const parent = out[parentIndex];
+			if (parent?.role === "assistant" && next.role === "assistant" && isAssistantSegmentOf(next.id, parent.id)) {
+				const folded = out.slice(parentIndex).flatMap((message) => message.parts);
+				out.splice(parentIndex, out.length - parentIndex, {
+					...parent,
+					parts: [...folded, ...next.parts]
+				});
 				continue;
 			}
 			out.push(next);
@@ -5012,10 +5862,13 @@ var StreamProcessor = class StreamProcessor {
 		if (pendingId && parentId && parentId !== pendingId) {
 			const parent = this.messages.find((m) => m.id === parentId);
 			const placeholder = this.messages.find((m) => m.id === pendingId);
+			const pendingRun = this.runOfMessage(pendingId);
+			const parentRun = parent ? this.runOfMessage(parent.id) : void 0;
+			const separateRuns = pendingRun !== void 0 && parentRun !== void 0 && pendingRun !== parentRun;
 			if (!parent) {
 				this.pendingManualMessageId = null;
 				this.renameMessage(pendingId, parentId);
-			} else if (parent.role === "assistant" && placeholder) {
+			} else if (!separateRuns && parent.role === "assistant" && placeholder) {
 				this.pendingManualMessageId = null;
 				this.messages = this.messages.filter((m) => m.id !== pendingId).map((m) => m.id === parentId ? {
 					...m,
@@ -5026,6 +5879,8 @@ var StreamProcessor = class StreamProcessor {
 		}
 		const targetMessageId = chunk.parentMessageId ?? this.getActiveAssistantMessageId();
 		const { messageId, state } = this.ensureAssistantMessage(targetMessageId ?? void 0, chunk.parentMessageId === void 0);
+		const tanstack = tanstackMetadata(chunk);
+		this.mergeMessageMetadata(messageId, tanstack === void 0 ? void 0 : { tanstack });
 		state.hasToolCallsSinceTextStart = true;
 		const toolCallId = chunk.toolCallId;
 		if (!state.toolCalls.get(toolCallId)) {
@@ -5095,9 +5950,9 @@ 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`, 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
+	* The END's raw `args` and parsed `input` replace the streamed arguments
+	* (see `finishToolCallArguments`), and the part's `input` is parsed from
+	* the result. 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
@@ -5110,25 +5965,11 @@ var StreamProcessor = class StreamProcessor {
 		if (!messageId) return;
 		const msgState = this.getMessageState(messageId);
 		if (!msgState) return;
-		const input = chunk.input !== void 0 ? chunk.input : tanstackMetadata(chunk)?.input;
 		const existingToolCall = msgState.toolCalls.get(chunk.toolCallId);
 		if (existingToolCall && existingToolCall.state !== "input-complete") {
-			const serializedInput = serializeToolInput(input);
-			if (serializedInput !== void 0) existingToolCall.arguments = serializedInput;
+			existingToolCall.arguments = finishToolCallArguments(existingToolCall.arguments, chunk).args;
 			const index = msgState.toolCallOrder.indexOf(chunk.toolCallId);
 			this.completeToolCall(messageId, index, existingToolCall);
-			if (serializedInput !== void 0) {
-				existingToolCall.parsedArguments = input;
-				this.messages = updateToolCallPart(this.messages, messageId, {
-					id: existingToolCall.id,
-					name: existingToolCall.name,
-					arguments: existingToolCall.arguments,
-					state: "input-complete",
-					input,
-					...existingToolCall.metadata !== void 0 && { metadata: existingToolCall.metadata }
-				});
-				this.emitMessagesChange();
-			}
 		}
 	}
 	/**
@@ -5166,6 +6007,7 @@ var StreamProcessor = class StreamProcessor {
 		if (this.activeRuns.size === 0) {
 			this.runToolCallIds = [];
 			this.toolCallsSentToClient.clear();
+			this.streamEndEmitted = false;
 		}
 		this.activeRuns.add(chunk.runId);
 	}
@@ -5181,12 +6023,26 @@ var StreamProcessor = class StreamProcessor {
 	*/
 	handleRunFinishedEvent(chunk) {
 		const extra = chunk;
+		const incoming = tanstackMetadata(chunk);
+		const model = chunk.model ?? incoming?.model;
+		const responseId = chunk.responseId ?? incoming?.responseId;
+		const ids = this.callMessageIds.get(chunk.runId) ?? (this.activeRuns.has(chunk.runId) ? /* @__PURE__ */ new Set() : new Set(this.unassignedCallMessageIds));
+		for (const messageId of ids) this.mergeMessageMetadata(messageId, withTanstackMetadata(chunk, {
+			...model !== void 0 ? { model } : {},
+			...responseId !== void 0 ? { responseId } : {}
+		}).metadata);
+		if (this.pendingManualMessageId && ids.has(this.pendingManualMessageId)) this.pendingManualMessageId = null;
+		this.callMessageIds.delete(chunk.runId);
+		for (const id of ids) this.unassignedCallMessageIds.delete(id);
 		this.finishReason = extra.finishReason !== void 0 ? extra.finishReason : tanstackMetadata(chunk)?.finishReason ?? null;
 		this.activeRuns.delete(chunk.runId);
 		if (chunk.outcome?.type === "interrupt") this.handleInterrupts(chunk.outcome.interrupts);
 		if (this.activeRuns.size === 0) {
 			this.completeAllToolCalls();
-			if (this.finishReason === "tool_calls" && chunk.outcome?.type !== "interrupt") return;
+			if (this.finishReason === "tool_calls" && chunk.outcome?.type !== "interrupt") {
+				for (const id of ids) this.sealedMessageIds.add(id);
+				return;
+			}
 			if (!chunk.outcome || chunk.outcome.type === "success") this.handlePendingToolCalls(chunk.outcome?.pendingToolCallIds);
 			this.isDone = true;
 			this.finalizeStream();
@@ -5206,6 +6062,7 @@ var StreamProcessor = class StreamProcessor {
 			if (this.toolCallsSentToClient.has(toolCallId)) continue;
 			const part = parts.find((p) => p.type === "tool-call" && p.id === toolCallId);
 			if (!part || isProviderExecutedToolCall(part) || part.output !== void 0 || parts.some((p) => p.type === "tool-result" && p.toolCallId === toolCallId) || this.isToolCallPartTerminal(toolCallId) || this.isToolCallPartAwaitingUserAction(toolCallId)) continue;
+			if (this.finishReason === "length") continue;
 			const input = part.input ?? parseToolArguments(part.arguments);
 			if (input === void 0) {
 				console.warn(`[StreamProcessor] Did not run tool call ${toolCallId}: the arguments of ${part.name} are not complete JSON`);
@@ -5235,7 +6092,7 @@ var StreamProcessor = class StreamProcessor {
 			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 (kind === "approval") {
 				if (owner !== void 0) {
 					if (emit) this.events.onApprovalRequest?.({
 						toolCallId,
@@ -5259,7 +6116,7 @@ var StreamProcessor = class StreamProcessor {
 				});
 				continue;
 			}
-			if (kind === "client_tool" || interrupt.reason === "client_tool_input") {
+			if (kind === "client_tool") {
 				if (hasGeneric || !emit) continue;
 				this.toolCallsSentToClient.add(toolCallId);
 				this.events.onToolCall?.({
@@ -5282,13 +6139,20 @@ var StreamProcessor = class StreamProcessor {
 	*/
 	handleRunErrorEvent(chunk) {
 		this.hasError = true;
-		const runId = getChunkRunId(chunk);
+		const runId = getChunkRunId(chunk) ?? (this.activeRuns.size === 1 ? [...this.activeRuns][0] : void 0);
+		const currentIds = runId !== void 0 ? this.callMessageIds.get(runId) ?? this.unassignedCallMessageIds : this.unassignedCallMessageIds;
 		if (runId) this.activeRuns.delete(runId);
 		else this.activeRuns.clear();
-		const { messageId } = this.ensureAssistantMessage();
+		const messageId = runId !== void 0 && this.callMessageIds.has(runId) && currentIds.size === 0 ? void 0 : this.ensureAssistantMessage([...currentIds].at(-1) ?? generateMessageId(), false).messageId;
+		const ids = new Set(currentIds);
+		if (messageId !== void 0) ids.add(messageId);
+		for (const id of ids) this.mergeMessageMetadata(id, withTanstackMetadata(chunk, { stopReason: tanstackMetadata(chunk)?.stopReason ?? "error" }).metadata);
+		if (this.pendingManualMessageId && ids.has(this.pendingManualMessageId)) this.pendingManualMessageId = null;
+		if (runId !== void 0) this.callMessageIds.delete(runId);
+		for (const id of ids) this.unassignedCallMessageIds.delete(id);
 		const errorMessage = chunk.message || "An error occurred";
 		if (!chunk.message) console.error("[StreamProcessor] RUN_ERROR with no message; original chunk:", chunk);
-		if (this.structuredMessageIds.has(messageId)) {
+		if (messageId !== void 0 && this.structuredMessageIds.has(messageId)) {
 			this.flushStructuredOutputUpdate(messageId);
 			this.messages = errorStructuredOutputPart(this.messages, messageId, errorMessage);
 			this.structuredMessageIds.delete(messageId);
@@ -5298,30 +6162,6 @@ var StreamProcessor = class StreamProcessor {
 		this.events.onError?.(runErrorEventToError(chunk));
 	}
 	/**
-	* Handle STEP_STARTED event (for thinking/reasoning content).
-	*
-	* Records the stepId so later REASONING_MESSAGE_CONTENT deltas accumulate
-	* into their own ThinkingPart. Does not create a message — the message
-	* is lazily created when the first REASONING_MESSAGE_CONTENT arrives.
-	*/
-	handleStepStartedEvent(chunk) {
-		const stepId = chunk.stepName || generateMessageId();
-		const activeId = this.getActiveAssistantMessageId();
-		if (activeId) {
-			const state = this.getMessageState(activeId);
-			if (state) {
-				state.currentThinkingStepId = stepId;
-				if (!state.thinkingSteps.has(stepId)) {
-					state.thinkingSteps.set(stepId, "");
-					state.thinkingStepOrder.push(stepId);
-				}
-				this.pendingThinkingStepId = null;
-				return;
-			}
-		}
-		this.pendingThinkingStepId = stepId;
-	}
-	/**
 	* Handle ACTIVITY_SNAPSHOT. Creates or replaces a frontend-only activity
 	* message. Does not create MessageStreamState (that path feeds
 	* ProcessorResult.content).
@@ -5340,44 +6180,23 @@ var StreamProcessor = class StreamProcessor {
 		this.emitMessagesChange();
 	}
 	/**
-	* Handle STEP_FINISHED event.
-	*
-	* Thinking *content* comes from REASONING_MESSAGE_CONTENT, not STEP_FINISHED.
-	* But some adapters (e.g. BytePlus thinking-summary) carry the provider
-	* signature blob ONLY on the STEP_FINISHED event, so still extract that here
-	* and attach it to the thinking step the reasoning events already built.
-	*/
-	handleStepFinishedEvent(chunk) {
-		const extra = chunk;
-		const signature = extra.signature;
-		if (!signature) return;
-		const { messageId, state } = this.ensureAssistantMessage(this.getActiveAssistantMessageId() ?? void 0);
-		const stepId = state.currentThinkingStepId ?? extra.stepId;
-		if (!stepId) return;
-		const thinking = state.thinkingSteps.get(stepId);
-		if (thinking === void 0) return;
-		state.thinkingStepSignatures.set(stepId, signature);
-		this.messages = updateThinkingPart(this.messages, messageId, stepId, thinking, signature);
-		this.emitMessagesChange();
-	}
-	/**
 	* Handle REASONING_MESSAGE_CONTENT event (AG-UI reasoning protocol).
 	*
 	* Accumulates reasoning delta into thinking content and updates the
 	* corresponding ThinkingPart in the UIMessage.
 	*/
 	handleReasoningMessageContentEvent(chunk) {
-		const { messageId, state } = this.ensureAssistantMessage(this.getActiveAssistantMessageId() ?? void 0);
+		const target = this.unscopedAssistant(chunk);
+		const { messageId, state } = this.ensureAssistantMessage(target.id ?? void 0, !target.create);
 		this.mergeMessageMetadata(messageId, chunk.metadata);
-		state.hasSeenReasoningEvents = true;
 		const delta = chunk.delta || "";
-		this.consumePendingThinkingStep(state);
 		const stepId = state.currentThinkingStepId ?? chunk.messageId;
 		if (!state.thinkingSteps.has(stepId)) {
 			state.thinkingSteps.set(stepId, "");
 			state.thinkingStepOrder.push(stepId);
 			state.currentThinkingStepId = stepId;
 		}
+		this.rememberThinking(messageId, stepId, chunk.messageId);
 		const nextThinking = (state.thinkingSteps.get(stepId) ?? "") + delta;
 		state.thinkingSteps.set(stepId, nextThinking);
 		this.messages = updateThinkingPart(this.messages, messageId, stepId, nextThinking, state.thinkingStepSignatures.get(stepId));
@@ -5396,8 +6215,12 @@ var StreamProcessor = class StreamProcessor {
 			this.attachToolCallSignature(chunk.entityId, encryptedValue);
 			return;
 		}
-		const { messageId, state } = this.ensureAssistantMessage(this.getActiveAssistantMessageId() ?? void 0);
+		if (this.applyKnownSignature(chunk.entityId, encryptedValue)) return;
+		const target = this.unscopedAssistant(chunk);
+		const { messageId, state } = this.ensureAssistantMessage(target.id ?? void 0, !target.create);
 		const stepId = state.currentThinkingStepId ?? chunk.entityId;
+		this.rememberThinking(messageId, stepId, chunk.entityId);
+		this.mergeMessageMetadata(messageId, chunk.metadata);
 		state.thinkingStepSignatures.set(stepId, encryptedValue);
 		const content = state.thinkingSteps.get(stepId) ?? "";
 		if (!state.thinkingSteps.has(stepId)) {
@@ -5439,23 +6262,15 @@ var StreamProcessor = class StreamProcessor {
 	/**
 	* Handle CUSTOM event.
 	*
-	* Handles custom events consumed by the processor:
-	* - 'tool-input-available': Legacy/replay-compatible input for client tool
-	*   execution. Fires onToolCall.
-	* - 'approval-requested': Legacy/replay-compatible input for tool approval.
-	*   Updates tool-call part state and fires onApprovalRequest.
-	*
-	* Current core streams represent user-actionable waits through
-	* RUN_FINISHED.outcome.type === 'interrupt'; these custom events are not the
-	* source of truth for new emissions.
-	*
-	* @see docs/chat-architecture.md#client-tools-and-approval-flows — Full flow details
+	* Handles structured-output and ui-resource events, and forwards the rest
+	* to onCustomEvent. Client tools and approvals arrive as RUN_FINISHED
+	* interrupt outcomes, not as custom events.
 	*/
 	handleCustomEvent(chunk) {
 		const messageId = this.getActiveAssistantMessageId();
 		if (chunk.name === "structured-output.start" && chunk.value) {
 			const v = chunk.value;
-			const { messageId: targetId } = this.ensureAssistantMessage(v.messageId ?? messageId ?? void 0);
+			const { messageId: targetId } = this.ensureAssistantMessage(v.messageId && this.getMessageState(v.messageId) ? v.messageId : messageId ?? v.messageId);
 			if (targetId) {
 				this.structuredMessageIds.add(targetId);
 				this.structuredOutputUpdateBatches.delete(targetId);
@@ -5470,7 +6285,7 @@ var StreamProcessor = class StreamProcessor {
 		}
 		if (chunk.name === "structured-output.complete" && chunk.value) {
 			const v = chunk.value;
-			const { messageId: targetId } = this.ensureAssistantMessage(v.messageId ?? messageId ?? void 0);
+			const { messageId: targetId } = this.ensureAssistantMessage(v.messageId && this.getMessageState(v.messageId) ? v.messageId : messageId ?? v.messageId);
 			if (targetId) {
 				this.flushStructuredOutputUpdate(targetId);
 				this.messages = completeStructuredOutputPart(this.messages, targetId, v.object, v.raw ?? "", v.reasoning);
@@ -5479,31 +6294,6 @@ var StreamProcessor = class StreamProcessor {
 				this.emitMessagesChange();
 			}
 		}
-		if (chunk.name === "tool-input-available" && chunk.value) {
-			const { toolCallId, toolName, input } = chunk.value;
-			this.toolCallsSentToClient.add(toolCallId);
-			this.events.onToolCall?.({
-				toolCallId,
-				toolName,
-				input
-			});
-			return;
-		}
-		if (chunk.name === "approval-requested" && chunk.value) {
-			const { toolCallId, toolName, input, approval } = chunk.value;
-			const resolvedMessageId = messageId ?? this.toolCallToMessage.get(toolCallId);
-			if (resolvedMessageId) {
-				this.messages = updateToolCallApproval(this.messages, resolvedMessageId, toolCallId, approval.id);
-				this.emitMessagesChange();
-			}
-			this.events.onApprovalRequest?.({
-				toolCallId,
-				toolName,
-				input,
-				approvalId: approval.id
-			});
-			return;
-		}
 		if (chunk.name === "ui-resource" && chunk.value) {
 			const v = chunk.value;
 			const resolvedMessageId = this.toolCallToMessage.get(v.toolCallId) ?? messageId;
@@ -5772,13 +6562,16 @@ var StreamProcessor = class StreamProcessor {
 	*/
 	resetStreamState() {
 		this.messageStates.clear();
+		this.callMessageIds.clear();
+		this.unassignedCallMessageIds.clear();
 		this.activeMessageIds.clear();
 		this.activeRuns.clear();
 		this.toolCallToMessage.clear();
 		this.structuredMessageIds.clear();
 		this.structuredOutputUpdateBatches.clear();
 		this.pendingManualMessageId = null;
-		this.pendingThinkingStepId = null;
+		this.sealedMessageIds.clear();
+		this.thinkingOwners.clear();
 		this.openChunk = null;
 		this.finishReason = null;
 		this.hasError = false;
@@ -5819,27 +6612,7 @@ function createReplayStream(recording) {
 	} };
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/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/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/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;
-	const error = value.error;
-	if (typeof error !== "object" || error === null) return false;
-	if (!("type" in error) || error.type !== "byok_missing") return false;
-	if (!("provider" in error) || typeof error.provider !== "string") return false;
-	if (!isProviderId(error.provider)) return false;
-	if (!("message" in error) || typeof error.message !== "string") return false;
-	return true;
-}
-//#endregion
-//#region ../node_modules/.bun/@tanstack+ai@0.68.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/byok/errors.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai/dist/esm/byok/errors.js
 var ByokMissingError = class extends Error {
 	provider;
 	constructor(provider) {
@@ -5865,7 +6638,27 @@ var ByokUnresolvedProviderError = class extends Error {
 	}
 };
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai-client@0.39.2+367daa2260c029d6/node_modules/@tanstack/ai-client/dist/esm/connection-adapters.js
+//#region ../node_modules/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/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/.bun/@tanstack+ai@1.0.0+367daa2260c029d6/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;
+	const error = value.error;
+	if (typeof error !== "object" || error === null) return false;
+	if (!("type" in error) || error.type !== "byok_missing") return false;
+	if (!("provider" in error) || typeof error.provider !== "string") return false;
+	if (!isProviderId(error.provider)) return false;
+	if (!("message" in error) || typeof error.message !== "string") return false;
+	return true;
+}
+//#endregion
+//#region ../node_modules/.bun/@tanstack+ai-client@1.0.0+367daa2260c029d6/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
@@ -5917,19 +6710,59 @@ var DurableStreamIncompleteError = class extends Error {
 * reconnecting without end.
 */
 var StreamReconnectLimitError = class extends Error {
-	constructor(attempts) {
-		super(`Durable run exceeded its reconnect ceiling of ${attempts} attempts — giving up.`);
+	constructor(attempts, budgetMs) {
+		super(budgetMs === void 0 ? `Durable run exceeded its reconnect ceiling of ${attempts} attempts — giving up.` : `Durable run did not reconnect within its budget of ${budgetMs} ms (${attempts} attempts) — giving up.`);
 		this.name = "StreamReconnectLimitError";
 	}
 };
+/** HTTP statuses that a proxy or server sends while it restarts or sheds load. */
+var TEMPORARY_HTTP_STATUSES = /* @__PURE__ */ new Set([
+	408,
+	429,
+	502,
+	503,
+	504
+]);
+/**
+* A non-2xx response. A reconnect retries it when the status is temporary
+* (408, 429, 502, 503, 504), and waits for its `Retry-After` when present.
+*/
+var StreamHttpError = class extends Error {
+	status;
+	retryAfterMs;
+	constructor(message, status, retryAfter) {
+		super(message);
+		this.status = status;
+		this.name = "StreamHttpError";
+		this.retryAfterMs = parseRetryAfterMs(retryAfter);
+	}
+};
+/** `Retry-After` in seconds or as an HTTP date, in ms. */
+function parseRetryAfterMs(value) {
+	if (!value) return void 0;
+	const seconds = Number(value);
+	if (Number.isFinite(seconds)) return seconds >= 0 ? seconds * 1e3 : void 0;
+	const date = Date.parse(value);
+	return Number.isNaN(date) ? void 0 : Math.max(0, date - Date.now());
+}
+function isTemporaryHttpError(error) {
+	return error instanceof StreamHttpError && TEMPORARY_HTTP_STATUSES.has(error.status);
+}
 function resolveReconnectOptions(options) {
-	const maxAttempts = options?.maxAttempts ?? 5;
-	const delayMs = options?.delayMs ?? 250;
-	if (!Number.isInteger(maxAttempts) || maxAttempts < 0) throw new Error(`Invalid reconnect.maxAttempts: ${maxAttempts}. Must be a non-negative integer.`);
-	if (!Number.isFinite(delayMs) || delayMs < 0) throw new Error(`Invalid reconnect.delayMs: ${delayMs}. Must be a non-negative finite number.`);
+	const budgetMs = options?.budgetMs;
+	const maxAttempts = options?.maxAttempts ?? (budgetMs === void 0 ? 5 : Infinity);
+	const initialDelayMs = options?.initialDelayMs ?? options?.delayMs ?? 250;
+	const maxDelayMs = options?.maxDelayMs ?? Math.max(5e3, initialDelayMs);
+	if (options?.maxAttempts !== void 0) {
+		if (!Number.isInteger(maxAttempts) || maxAttempts < 0) throw new Error(`Invalid reconnect.maxAttempts: ${maxAttempts}. Must be a non-negative integer.`);
+	}
+	for (const [name, value] of [["initialDelayMs", initialDelayMs], ["maxDelayMs", maxDelayMs]]) if (!Number.isFinite(value) || value < 0) throw new Error(`Invalid reconnect.${name}: ${value}. Must be a non-negative finite number.`);
+	if (budgetMs !== void 0 && (!Number.isFinite(budgetMs) || budgetMs <= 0)) throw new Error(`Invalid reconnect.budgetMs: ${budgetMs}. Must be a positive finite number.`);
 	return {
 		maxAttempts,
-		delayMs
+		initialDelayMs,
+		maxDelayMs,
+		budgetMs
 	};
 }
 /** Create a {@link ReconnectTracker} bound to the given reconnect bounds. */
@@ -5938,6 +6771,7 @@ function createReconnectTracker(options) {
 	const seen = /* @__PURE__ */ new Set();
 	let lastEventId;
 	let reconnectAttempts = 0;
+	let failingSince;
 	return {
 		get lastEventId() {
 			return lastEventId;
@@ -5954,13 +6788,19 @@ function createReconnectTracker(options) {
 			lastEventId = id;
 			return "new";
 		},
-		async waitBeforeReconnect(madeProgress, signal) {
-			if (madeProgress) reconnectAttempts = 0;
-			else {
+		async waitBeforeReconnect(madeProgress, signal, retryAfterMs) {
+			if (madeProgress) {
+				reconnectAttempts = 0;
+				failingSince = void 0;
+			} else {
 				reconnectAttempts += 1;
+				failingSince ??= Date.now();
 				if (reconnectAttempts > reconnect.maxAttempts) throw new StreamReconnectLimitError(reconnect.maxAttempts);
 			}
-			await abortableDelay(reconnect.delayMs, signal);
+			const backoff = reconnect.initialDelayMs === 0 ? 0 : Math.min(reconnect.maxDelayMs, reconnect.initialDelayMs * 2 ** Math.max(0, reconnectAttempts - 1));
+			const delayMs = retryAfterMs === void 0 ? backoff * (.5 + Math.random() / 2) : Math.min(retryAfterMs, reconnect.maxDelayMs);
+			if (reconnect.budgetMs !== void 0 && failingSince !== void 0 && Date.now() - failingSince + delayMs > reconnect.budgetMs) throw new StreamReconnectLimitError(reconnectAttempts - 1, reconnect.budgetMs);
+			await abortableDelay(delayMs, signal);
 		}
 	};
 }
@@ -5979,19 +6819,6 @@ function abortableDelay(ms, signal) {
 		signal?.addEventListener("abort", onAbort, { once: true });
 	});
 }
-function generateRunId(prefix) {
-	return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-}
-/**
-* Asserts an id is present when synthesizing a terminal event. The chat
-* client always supplies `runContext.threadId` / `runContext.runId`, so an
-* absent id at this layer indicates the adapter was wired up by a caller
-* that bypassed that contract — surface it rather than fabricating one.
-*/
-function requireSyntheticId(value, field) {
-	if (!value) throw new Error(`Cannot synthesize terminal event: ${field} not supplied via runContext and not observed in the upstream stream.`);
-	return value;
-}
 /**
 * Merge custom headers into request headers
 */
@@ -6017,7 +6844,7 @@ function mergeHeaders(customHeaders) {
 */
 var RUN_ID_HEADER = "X-Run-Id";
 function runIdHeader(runId) {
-	return runId === void 0 ? {} : { [RUN_ID_HEADER]: runId };
+	return { [RUN_ID_HEADER]: runId };
 }
 function withSearchParams(url, values) {
 	const hashIndex = url.indexOf("#");
@@ -6064,19 +6891,6 @@ async function* readStreamLines(reader, abortSignal) {
 		reader.releaseLock();
 	}
 }
-/** Rebuild pre-wire extras after SSE/NDJSON ingest. */
-function restoreInboundUsage(chunk) {
-	return restoreInboundChunk(chunk);
-}
-function sseChunkModel(chunk) {
-	const tanstackModel = tanstackMetadata(chunk)?.model;
-	if (typeof tanstackModel === "string") return tanstackModel;
-	const usage = "usage" in chunk ? chunk.usage : void 0;
-	if (Array.isArray(usage)) {
-		const model = usage[0]?.model;
-		if (typeof model === "string") return model;
-	}
-}
 /**
 * Parse SSE-format lines into stream events, pairing each chunk with the `id:`
 * offset of the event it arrived on. Shared by the fetch- and XHR-backed SSE
@@ -6084,17 +6898,11 @@ function sseChunkModel(chunk) {
 *
 * Accepts either `data: {...}` lines or bare JSON lines. Skips comments
 * starting with `:` (proxies and CDNs inject these as keepalives) and the
-* `event:` / `retry:` SSE control fields. A `[DONE]` sentinel is treated as a
-* terminal event: a synthesized RUN_FINISHED is yielded using the most recent
-* upstream `threadId` / `runId` (falling back to `fallbackIds`), so the
-* consumer sees a clean terminal event with real correlation ids.
+* `event:` / `retry:` SSE control fields.
 *
 * A JSON parse failure throws — the consumer surfaces it as an error.
 */
-async function* linesToSSEEvents(lines, fallbackIds) {
-	let lastThreadId;
-	let lastRunId;
-	let lastModel;
+async function* linesToSSEEvents(lines) {
 	let pendingId;
 	for await (const line of lines) {
 		if (line === "id" || line.startsWith("id:")) {
@@ -6104,23 +6912,7 @@ async function* linesToSSEEvents(lines, fallbackIds) {
 		}
 		if (line.startsWith(":") || line.startsWith("event:") || line.startsWith("retry:")) continue;
 		const data = parseSseDataLine(line);
-		if (data === "[DONE]") {
-			yield { chunk: withTanstackMetadata({
-				type: EventType.RUN_FINISHED,
-				threadId: lastThreadId ?? fallbackIds?.threadId ?? "",
-				runId: lastRunId ?? fallbackIds?.runId ?? "",
-				timestamp: Date.now()
-			}, {
-				finishReason: "stop",
-				...lastModel !== void 0 ? { model: lastModel } : {}
-			}) };
-			return;
-		}
-		const chunk = restoreInboundUsage(JSON.parse(data));
-		if ("threadId" in chunk && typeof chunk.threadId === "string") lastThreadId = chunk.threadId;
-		if ("runId" in chunk && typeof chunk.runId === "string") lastRunId = chunk.runId;
-		const model = sseChunkModel(chunk);
-		if (model !== void 0) lastModel = model;
+		const chunk = restoreInboundChunk(JSON.parse(data));
 		const id = pendingId;
 		pendingId = void 0;
 		yield {
@@ -6135,7 +6927,7 @@ async function assertResponseOk(response) {
 		const body = await response.clone().json().catch(() => null);
 		if (isByokMissingBody(body)) throw new ByokMissingError(body.error.provider);
 	}
-	throw new Error(`HTTP error! status: ${response.status} ${response.statusText}`);
+	throw new StreamHttpError(`HTTP error! status: ${response.status} ${response.statusText}`, response.status, response.headers.get("retry-after"));
 }
 function chatHydrationSearchParams(threadId, options) {
 	const values = { threadId };
@@ -6216,9 +7008,9 @@ async function fetchGenerationHydration(fetchClient, url, headers, credentials,
 	};
 }
 /** Yield SSE stream events (chunk + offset) from a fetch Response body. */
-async function* responseToSSEEvents(response, abortSignal, fallbackIds) {
+async function* responseToSSEEvents(response, abortSignal) {
 	await assertResponseOk(response);
-	yield* linesToSSEEvents(readStreamLines(getResponseStreamReader(response), abortSignal), fallbackIds);
+	yield* linesToSSEEvents(readStreamLines(getResponseStreamReader(response), abortSignal));
 }
 async function* responseToSSEChunks(response, abortSignal) {
 	for await (const { chunk } of responseToSSEEvents(response, abortSignal)) yield chunk;
@@ -6273,8 +7065,8 @@ async function* resumableStream(openEventSource, abortSignal, reconnectOptions)
 			}
 		} catch (error) {
 			if (abortSignal?.aborted) return;
-			if ((error instanceof StreamTruncatedError || error instanceof StreamReadError) && tracker.lastEventId !== void 0) {
-				await tracker.waitBeforeReconnect(progressed, abortSignal);
+			if ((error instanceof StreamTruncatedError || error instanceof StreamReadError || isTemporaryHttpError(error)) && tracker.lastEventId !== void 0) {
+				await tracker.waitBeforeReconnect(progressed, abortSignal, isTemporaryHttpError(error) ? error.retryAfterMs : void 0);
 				continue;
 			}
 			throw error;
@@ -6372,28 +7164,28 @@ function normalizeConnectionAdapter(connection) {
 					if ("threadId" in chunk && typeof chunk.threadId === "string") upstreamThreadId = chunk.threadId;
 					if ("runId" in chunk && typeof chunk.runId === "string") upstreamRunId = chunk.runId;
 					if (chunk.type === "RUN_FINISHED" || chunk.type === "RUN_ERROR") hasTerminalEvent = true;
-					push(chunk, runContext?.runId);
+					push(chunk, runContext.runId);
 				}
 				if (!abortSignal?.aborted && !hasTerminalEvent) push(withTanstackMetadata({
 					type: EventType.RUN_FINISHED,
-					threadId: requireSyntheticId(upstreamThreadId ?? runContext?.threadId, "threadId"),
-					runId: requireSyntheticId(upstreamRunId ?? runContext?.runId, "runId"),
+					threadId: upstreamThreadId ?? runContext.threadId,
+					runId: upstreamRunId ?? runContext.runId,
 					timestamp: Date.now()
 				}, {
 					finishReason: "stop",
 					model: "connect-wrapper"
-				}), runContext?.runId);
+				}), runContext.runId);
 			} catch (err) {
-				if (!abortSignal?.aborted && !hasTerminalEvent) try {
+				if (!abortSignal?.aborted && !hasTerminalEvent) {
 					const message = err instanceof Error ? err.message : "Unknown error in connect()";
 					push({
 						type: EventType.RUN_ERROR,
-						threadId: requireSyntheticId(upstreamThreadId ?? runContext?.threadId, "threadId"),
-						runId: requireSyntheticId(upstreamRunId ?? runContext?.runId, "runId"),
+						threadId: upstreamThreadId ?? runContext.threadId,
+						runId: upstreamRunId ?? runContext.runId,
 						timestamp: Date.now(),
 						message
-					}, runContext?.runId);
-				} catch {}
+					}, runContext.runId);
+				}
 				throw err;
 			}
 			await waitUntilSubscriberIdle(abortSignal);
@@ -6406,23 +7198,23 @@ function normalizeConnectionAdapter(connection) {
 	};
 }
 function buildRunAgentInputBody(messages, data, runContext, options) {
+	if (!runContext) throw new Error("Connection adapter: connect() and send() need a run context with a threadId. ChatClient and the generation clients pass one. Pass it when you call the adapter yourself.");
 	const wireMessages = uiMessagesToWire(messages);
 	const forwardedProps = {
 		...options.body,
-		...runContext?.forwardedProps ?? {},
+		...runContext.forwardedProps,
 		...data
 	};
 	return {
-		threadId: runContext?.threadId ?? generateRunId("thread"),
-		runId: runContext?.runId ?? generateRunId("run"),
-		...runContext?.parentRunId !== void 0 && { parentRunId: runContext.parentRunId },
-		...runContext?.resume !== void 0 && { resume: runContext.resume },
+		threadId: runContext.threadId,
+		runId: runContext.runId,
+		...runContext.parentRunId !== void 0 && { parentRunId: runContext.parentRunId },
+		...runContext.resume !== void 0 && { resume: runContext.resume },
 		state: {},
 		messages: wireMessages,
-		tools: runContext?.clientTools ?? [],
+		tools: runContext.clientTools ?? [],
 		context: [],
-		forwardedProps,
-		data: { ...forwardedProps }
+		forwardedProps
 	};
 }
 /**
@@ -6467,8 +7259,8 @@ function fetchServerSentEvents(url, options = {}) {
 			const requestHeaders = {
 				"Content-Type": "application/json",
 				...mergeHeaders(resolvedOptions.headers),
-				...mergeHeaders(runContext?.headers),
-				...runIdHeader(runContext?.runId)
+				...mergeHeaders(runContext.headers),
+				...runIdHeader(runContext.runId)
 			};
 			const requestBody = buildRunAgentInputBody(messages, data, runContext, resolvedOptions);
 			const fetchClient = resolvedOptions.fetchClient ?? fetch;
@@ -6478,10 +7270,7 @@ function fetchServerSentEvents(url, options = {}) {
 				headers: requestHeaders,
 				body: JSON.stringify(requestBody),
 				credentials: resolvedOptions.credentials || "same-origin"
-			}, (response, sseSignal) => responseToSSEEvents(response, sseSignal, {
-				...runContext?.threadId !== void 0 ? { threadId: runContext.threadId } : {},
-				...runContext?.runId !== void 0 ? { runId: runContext.runId } : {}
-			})), signal, resolvedOptions.reconnect);
+			}, responseToSSEEvents), signal, resolvedOptions.reconnect);
 		},
 		async *joinRun(runId, abortSignal) {
 			const resolvedUrl = typeof url === "function" ? url() : url;
@@ -6497,7 +7286,7 @@ function fetchServerSentEvents(url, options = {}) {
 				method: "GET",
 				headers: requestHeaders,
 				credentials: resolvedOptions.credentials || "same-origin"
-			}, (response, sseSignal) => responseToSSEEvents(response, sseSignal, { runId })), signal, resolvedOptions.reconnect);
+			}, responseToSSEEvents), signal, resolvedOptions.reconnect);
 		},
 		async hydrate(threadId, hydrateOptions) {
 			const resolvedUrl = typeof url === "function" ? url() : url;
@@ -6563,7 +7352,7 @@ async function* abortableIterable(iterable, signal) {
 	}
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai-client@0.39.2+367daa2260c029d6/node_modules/@tanstack/ai-client/dist/esm/interrupt-manager.js
+//#region ../node_modules/.bun/@tanstack+ai-client@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai-client/dist/esm/interrupt-manager.js
 function isClientOwnedInterrupt(item) {
 	return item.resumable;
 }
@@ -6586,8 +7375,7 @@ var itemErrorCodes = /* @__PURE__ */ new Set([
 	"unknown-interrupt",
 	"expired",
 	"stale",
-	"conflict",
-	"legacy-unsupported"
+	"conflict"
 ]);
 var batchErrorCodes = /* @__PURE__ */ new Set([
 	"incomplete-batch",
@@ -6602,27 +7390,11 @@ var batchErrorCodes = /* @__PURE__ */ new Set([
 	"invalid-response-schema",
 	"expired",
 	"stale",
-	"conflict",
-	"legacy-submit-failed"
+	"conflict"
 ]);
 function isUnknownObject(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function isLegacyApprovalMetadata(value) {
-	return isUnknownObject(value) && value["kind"] === "approval" && typeof value["toolName"] === "string" && "input" in value;
-}
-function isLegacyClientToolMetadata(value) {
-	return isUnknownObject(value) && value["kind"] === "client_tool" && typeof value["toolName"] === "string" && "input" in value;
-}
-/**
-* Does this descriptor carry the pre-binding TanStack metadata marker?
-*
-* Descriptors emitted before the resume binding existed are still ours to
-* resume, so they must not be mistaken for another producer's interrupt.
-*/
-function isLegacyInterruptMetadata(interrupt) {
-	return isLegacyApprovalMetadata(interrupt.metadata) || isLegacyClientToolMetadata(interrupt.metadata);
-}
 function getDescriptorBinding(interrupt) {
 	return readInterruptBinding(interrupt);
 }
@@ -6642,13 +7414,6 @@ function hasFirstPartyGenericMarker(interrupt) {
 function getInterruptPayload(interrupt) {
 	return interrupt.metadata?.["tanstack:interruptPayload"];
 }
-/**
-* Only used to route *legacy* (pre-binding) descriptors, which have no binding
-* to classify off. Current descriptors are classified by their binding alone.
-*/
-function isClientToolExecutionReason(reason) {
-	return reason === "tanstack:client_tool_execution" || reason === "client_tool_input";
-}
 function responseSchemaHash(interrupt) {
 	if (interrupt.responseSchema === void 0) return void 0;
 	try {
@@ -6752,7 +7517,6 @@ function genericBinding(interrupt, hydration, candidate) {
 function baseSnapshot(item, hydration) {
 	const descriptor = cloneAndDeepFreezeJson(item.descriptor);
 	const errors = item.error === void 0 ? Object.freeze([]) : Object.freeze([cloneAndDeepFreezeJson(item.error)]);
-	const error = errors[0];
 	return {
 		id: descriptor.id,
 		interruptId: descriptor.id,
@@ -6766,7 +7530,6 @@ function baseSnapshot(item, hydration) {
 		generation: hydration.generation,
 		status: item.status,
 		errors,
-		...error !== void 0 ? { error } : {},
 		canResolve: item.canResolve
 	};
 }
@@ -6779,7 +7542,6 @@ var InterruptManager = class {
 	submissionRootErrors = Object.freeze([]);
 	state = Object.freeze({
 		interrupts: this.snapshot,
-		pendingInterrupts: this.snapshot,
 		interruptErrors: this.rootErrors,
 		resuming: false
 	});
@@ -6787,6 +7549,7 @@ var InterruptManager = class {
 	activeSubmissionOperation;
 	retrySubmission;
 	resuming = false;
+	warnedSchemaMismatches = /* @__PURE__ */ new Set();
 	tools;
 	interruptDefinitions;
 	constructor(options) {
@@ -6847,7 +7610,6 @@ var InterruptManager = class {
 		this.resuming = false;
 		this.state = Object.freeze({
 			interrupts: this.snapshot,
-			pendingInterrupts: this.snapshot,
 			interruptErrors: this.rootErrors,
 			resuming: false
 		});
@@ -6905,12 +7667,8 @@ var InterruptManager = class {
 		});
 	}
 	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));
+		const item = this.items.find((candidate) => candidate.kind === "client-tool-execution" && candidate.binding?.kind === "client-tool-execution" && candidate.binding.toolCallId === toolCallId) ?? this.items.find((candidate) => candidate.kind === "generic" && candidate.canResolve && candidate.descriptor.toolCallId === toolCallId);
 		if (!item) return false;
-		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;
@@ -6938,17 +7696,20 @@ var InterruptManager = class {
 		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;
-		this.resolveItem(item.descriptor.id, { approved });
-		return true;
+	/**
+	* The local tool exists, but its schemas differ from the hashes the server
+	* put in the binding, so the interrupt falls back to generic. Warn once per
+	* interrupt so the fallback is not silent.
+	*/
+	warnSchemaMismatch(interruptId, toolName, error) {
+		if (this.warnedSchemaMismatches.has(interruptId)) return;
+		this.warnedSchemaMismatches.add(interruptId);
+		console.warn(`[TanStack AI] Interrupt "${interruptId}" for tool "${toolName}": the server and client tool schemas differ, so it is handled as a generic interrupt. Use the same tool definition on the server and the client.`, ...error === void 0 ? [] : [error]);
 	}
 	hydrateInterrupt(descriptor, hydration, firstPartyIndexes) {
 		const interrupt = cloneAndDeepFreezeJson(descriptor);
 		const candidate = getDescriptorBinding(interrupt);
-		const legacyResumable = candidate === void 0 && isLegacyInterruptMetadata(interrupt);
-		if (candidate === void 0 && !legacyResumable) {
+		if (candidate === void 0) {
 			if (hasReservedFirstPartyBindingMarker(interrupt)) return {
 				descriptor: interrupt,
 				binding: genericBinding(interrupt, hydration, void 0),
@@ -6969,9 +7730,9 @@ var InterruptManager = class {
 				validationGeneration: 0
 			};
 		}
-		const correlated = candidate !== void 0 && candidate.interruptId === interrupt.id && candidate.interruptedRunId === hydration.interruptedRunId && candidate.generation === hydration.generation && responseSchemaHash(interrupt) === candidate.responseSchemaHash;
-		const structurallyCorrelated = candidate !== void 0 && candidate.interruptId === interrupt.id && candidate.interruptedRunId === hydration.interruptedRunId && candidate.generation === hydration.generation && candidate.responseSchemaHash === (responseSchemaHash(interrupt) ?? candidate.responseSchemaHash);
-		if (candidate !== void 0 && hasFirstPartyGenericMarker(interrupt) && (!structurallyCorrelated || candidate.kind !== "generic" || candidate.definitionId === void 0 || candidate.key === void 0 || candidate.batchIndex === void 0)) return {
+		const correlated = candidate.interruptId === interrupt.id && candidate.interruptedRunId === hydration.interruptedRunId && candidate.generation === hydration.generation && responseSchemaHash(interrupt) === candidate.responseSchemaHash;
+		const structurallyCorrelated = candidate.interruptId === interrupt.id && candidate.interruptedRunId === hydration.interruptedRunId && candidate.generation === hydration.generation && candidate.responseSchemaHash === (responseSchemaHash(interrupt) ?? candidate.responseSchemaHash);
+		if (hasFirstPartyGenericMarker(interrupt) && (!structurallyCorrelated || candidate.kind !== "generic" || candidate.definitionId === void 0 || candidate.key === void 0 || candidate.batchIndex === void 0)) return {
 			descriptor: interrupt,
 			binding: genericBinding(interrupt, hydration, candidate),
 			kind: "generic",
@@ -6995,22 +7756,28 @@ var InterruptManager = class {
 					tool,
 					validationGeneration: 0
 				};
-			} catch {}
+				this.warnSchemaMismatch(interrupt.id, candidate.toolName);
+			} catch (error) {
+				this.warnSchemaMismatch(interrupt.id, candidate.toolName, error);
+			}
 		}
 		if (structurallyCorrelated && candidate.kind === "client-tool-execution") {
 			const tool = this.tools?.find((configured) => configured.name === candidate.toolName);
-			if (tool !== void 0 && interrupt.toolCallId === candidate.toolCallId && hashSchemaInput(tool.outputSchema) === candidate.outputSchemaHash) return {
-				descriptor: interrupt,
-				binding: cloneAndDeepFreezeJson(candidate),
-				kind: "client-tool-execution",
-				status: "pending",
-				canResolve: true,
-				resumable: true,
-				tool,
-				validationGeneration: 0
-			};
+			if (tool !== void 0 && interrupt.toolCallId === candidate.toolCallId) {
+				if (hashSchemaInput(tool.outputSchema) === candidate.outputSchemaHash) return {
+					descriptor: interrupt,
+					binding: cloneAndDeepFreezeJson(candidate),
+					kind: "client-tool-execution",
+					status: "pending",
+					canResolve: true,
+					resumable: true,
+					tool,
+					validationGeneration: 0
+				};
+				this.warnSchemaMismatch(interrupt.id, candidate.toolName);
+			}
 		}
-		if (candidate !== void 0 && candidate.kind === "generic" && candidate.definitionId !== void 0 && candidate.key !== void 0 && candidate.batchIndex !== void 0 && candidate.key.length > 0 && firstPartyIndexes.get(candidate.batchIndex) !== 1) return {
+		if (candidate.kind === "generic" && candidate.definitionId !== void 0 && candidate.key !== void 0 && candidate.batchIndex !== void 0 && candidate.key.length > 0 && firstPartyIndexes.get(candidate.batchIndex) !== 1) return {
 			descriptor: interrupt,
 			binding: cloneAndDeepFreezeJson(candidate),
 			kind: "generic",
@@ -7037,7 +7804,7 @@ var InterruptManager = class {
 				};
 			}
 		}
-		const resumable = legacyResumable || candidate !== void 0 && candidate.interruptId === interrupt.id && candidate.interruptedRunId === hydration.interruptedRunId && candidate.generation === hydration.generation && (candidate.kind !== "generic" || responseSchemaHash(interrupt) === void 0 || candidate.responseSchemaHash === responseSchemaHash(interrupt));
+		const resumable = candidate.interruptId === interrupt.id && candidate.interruptedRunId === hydration.interruptedRunId && candidate.generation === hydration.generation && (candidate.kind !== "generic" || responseSchemaHash(interrupt) === void 0 || candidate.responseSchemaHash === responseSchemaHash(interrupt));
 		return {
 			descriptor: interrupt,
 			binding: genericBinding(interrupt, hydration, candidate),
@@ -7121,7 +7888,6 @@ var InterruptManager = class {
 			this.snapshot = Object.freeze([]);
 			this.state = Object.freeze({
 				interrupts: this.snapshot,
-				pendingInterrupts: this.snapshot,
 				interruptErrors: this.rootErrors,
 				resuming: this.resuming
 			});
@@ -7131,7 +7897,6 @@ var InterruptManager = class {
 		this.snapshot = this.buildSnapshot();
 		this.state = Object.freeze({
 			interrupts: this.snapshot,
-			pendingInterrupts: this.snapshot,
 			interruptErrors: this.rootErrors,
 			resuming: this.resuming
 		});
@@ -7505,7 +8270,7 @@ var InterruptManager = class {
 	}
 };
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai-client@0.39.2+367daa2260c029d6/node_modules/@tanstack/ai-client/dist/esm/byok/client.js
+//#region ../node_modules/.bun/@tanstack+ai-client@1.0.0+367daa2260c029d6/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.
@@ -7518,7 +8283,7 @@ function byokFallbackProviderId(byok) {
 	if (registered.length === 1) return registered[0];
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai-client@0.39.2+367daa2260c029d6/node_modules/@tanstack/ai-client/dist/esm/byok/resolve.js
+//#region ../node_modules/.bun/@tanstack+ai-client@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai-client/dist/esm/byok/resolve.js
 function resolveByokProviderId(byokProvider, ...candidates) {
 	const fromFn = byokProvider?.();
 	if (isProviderId(fromFn)) return fromFn;
@@ -7534,7 +8299,7 @@ async function prepareResolvedByokHeaders(byok, provider) {
 	return byok.headers(provider);
 }
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai-client@0.39.2+367daa2260c029d6/node_modules/@tanstack/ai-client/dist/esm/events.js
+//#region ../node_modules/.bun/@tanstack+ai-client@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai-client/dist/esm/events.js
 /**
 * Abstract base class for ChatClient event emission
 */
@@ -7690,17 +8455,6 @@ var ChatClientEventEmitter = class {
 		});
 	}
 	/**
-	* Emit tool approval responded event
-	*/
-	toolApprovalResponded(approvalId, toolCallId, approved, context) {
-		this.emitEvent("tools:approval:responded", {
-			approvalId,
-			toolCallId,
-			approved,
-			...context
-		});
-	}
-	/**
 	* Emit tool fixture applied event.
 	*/
 	toolFixtureApplied(fixture) {
@@ -7708,7 +8462,7 @@ var ChatClientEventEmitter = class {
 	}
 };
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai-client@0.39.2+367daa2260c029d6/node_modules/@tanstack/ai-client/dist/esm/devtools-noop.js
+//#region ../node_modules/.bun/@tanstack+ai-client@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai-client/dist/esm/devtools-noop.js
 var NoOpChatClientEventEmitter = class extends ChatClientEventEmitter {
 	emitEvent() {}
 };
@@ -7753,12 +8507,7 @@ var NoOpChatDevtoolsBridge = class {
 };
 var createNoOpChatDevtoolsBridge = (options) => new NoOpChatDevtoolsBridge(options);
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai-client@0.39.2+367daa2260c029d6/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 };
-	if (raw && Array.isArray(raw.messages)) return raw;
-}
+//#region ../node_modules/.bun/@tanstack+ai-client@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai-client/dist/esm/client-persistor.js
 function getChunkToolCallId$1(chunk) {
 	return "toolCallId" in chunk && typeof chunk.toolCallId === "string" ? chunk.toolCallId : void 0;
 }
@@ -7800,6 +8549,7 @@ var ChatPersistor = class {
 	messagesGeneration = 0;
 	lastMessages = [];
 	lastResume = null;
+	legacyStored = false;
 	clearedMessageIds = /* @__PURE__ */ new Set();
 	clearedRunIds = /* @__PURE__ */ new Set();
 	ignoredActiveRunIds = /* @__PURE__ */ new Set();
@@ -7813,6 +8563,7 @@ var ChatPersistor = class {
 	}
 	/** Persist the current state as one combined `{ messages, resume? }` record. */
 	writeState() {
+		if (this.legacyStored) return;
 		const messages = [...this.lastMessages];
 		if (messages.length === 0 && !this.lastResume) {
 			const generation = this.generation;
@@ -7832,6 +8583,15 @@ var ChatPersistor = class {
 			return this.adapter.setItem(this.id, state);
 		});
 	}
+	/** Validate a raw `getItem` result. */
+	normalize(raw) {
+		if (Array.isArray(raw)) {
+			this.legacyStored = true;
+			console.error(`[TanStack AI] The stored chat for threadId "${this.id}" is in the 0.x format (a bare message array). TanStack AI 1.0 does not read this format, so the chat starts empty and the stored value is not overwritten. Clear the chat or the stored value to start saving again.`);
+			return;
+		}
+		if (raw && Array.isArray(raw.messages)) return raw;
+	}
 	/**
 	* Synchronously read the persisted state for constructor-time hydration.
 	* Returns the normalized combined record, or a promise of it for async stores.
@@ -7839,8 +8599,8 @@ var ChatPersistor = class {
 	readInitial() {
 		try {
 			const raw = this.adapter.getItem(this.id);
-			if (raw instanceof Promise) return raw.then(normalizePersistedState).catch(() => void 0);
-			const state = normalizePersistedState(raw);
+			if (raw instanceof Promise) return raw.then((value) => this.normalize(value)).catch(() => void 0);
+			const state = this.normalize(raw);
 			if (state) {
 				this.lastMessages = state.messages;
 				this.lastResume = state.resume ?? null;
@@ -7892,6 +8652,7 @@ var ChatPersistor = class {
 	}
 	/** Remove the persisted conversation. Invalidates any queued writes. */
 	remove() {
+		this.legacyStored = false;
 		this.lastMessages = [];
 		this.lastResume = null;
 		const generation = ++this.generation;
@@ -8018,7 +8779,7 @@ var ChatPersistor = class {
 	}
 };
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai-client@0.39.2+367daa2260c029d6/node_modules/@tanstack/ai-client/dist/esm/cleared-stream-tracker.js
+//#region ../node_modules/.bun/@tanstack+ai-client@1.0.0+367daa2260c029d6/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;
 }
@@ -8111,7 +8872,7 @@ var ClearedStreamTracker = class {
 	}
 };
 //#endregion
-//#region ../node_modules/.bun/@tanstack+ai-client@0.39.2+367daa2260c029d6/node_modules/@tanstack/ai-client/dist/esm/chat-client.js
+//#region ../node_modules/.bun/@tanstack+ai-client@1.0.0+367daa2260c029d6/node_modules/@tanstack/ai-client/dist/esm/chat-client.js
 var STREAM_PROCESSING_BUDGET_MS = 8;
 function yieldToHost() {
 	const { scheduler } = globalThis;
@@ -8257,9 +9018,30 @@ var REJOIN_REBUILD_TRIGGERS = /* @__PURE__ */ new Set([
 ]);
 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);
 }
+/**
+* Snapshot messages are frozen, and a host can pass them back in
+* (`setMessagesManually(snapshot.messages)`, `initialMessages`). The client
+* writes subagent handles into message parts, nested cards included, so copy
+* each frozen part down through subagent transcripts.
+*/
+function thawMessages(messages) {
+	return messages.map((message) => ({
+		...message,
+		parts: message.parts.map((part) => {
+			if (!Object.isFrozen(part)) return part;
+			if (part.type !== "subagent") return { ...part };
+			return {
+				...part,
+				subagent: {
+					...part.subagent,
+					messages: thawMessages(part.subagent.messages)
+				}
+			};
+		})
+	}));
+}
 /** Every subagent card in the messages, nested cards included. */
 function collectSubagentParts(messages) {
 	const cards = [];
@@ -8287,11 +9069,54 @@ var ChatClient = class {
 	subagentHandles = /* @__PURE__ */ new Map();
 	stoppedSubagentIds = /* @__PURE__ */ new Set();
 	connection;
-	uniqueId;
 	threadId;
 	persistor;
 	clearedStreamTracker = new ClearedStreamTracker();
-	currentRunId = null;
+	snapshotAtom = createAtom({
+		messages: [],
+		status: "ready",
+		isLoading: false,
+		error: void 0,
+		isSubscribed: false,
+		connectionStatus: "disconnected",
+		sessionGenerating: false,
+		queue: [],
+		runId: null,
+		hasOlderMessages: false,
+		isHydrating: false,
+		interruptState: {
+			interrupts: Object.freeze([]),
+			interruptErrors: Object.freeze([]),
+			resuming: false
+		}
+	});
+	get status() {
+		return this.snapshotAtom.get().status;
+	}
+	get isLoading() {
+		return this.snapshotAtom.get().isLoading;
+	}
+	get error() {
+		return this.snapshotAtom.get().error;
+	}
+	get isSubscribed() {
+		return this.snapshotAtom.get().isSubscribed;
+	}
+	get connectionStatus() {
+		return this.snapshotAtom.get().connectionStatus;
+	}
+	get sessionGenerating() {
+		return this.snapshotAtom.get().sessionGenerating;
+	}
+	get hasOlderMessages() {
+		return this.snapshotAtom.get().hasOlderMessages;
+	}
+	get isHydrating() {
+		return this.snapshotAtom.get().isHydrating;
+	}
+	get currentRunId() {
+		return this.snapshotAtom.get().runId;
+	}
 	lastResume = null;
 	runParents = /* @__PURE__ */ new Map();
 	supersededInterruptRunIds = /* @__PURE__ */ new Set();
@@ -8305,7 +9130,6 @@ var ChatClient = class {
 	pendingResumeItems = null;
 	activeResumeThreadId = null;
 	activeResumeRunId = null;
-	bodyOption = {};
 	forwardedPropsOption = {};
 	byok;
 	byokProvider;
@@ -8336,11 +9160,6 @@ var ChatClient = class {
 	* deliverers cannot both append a user message before only one stream runs.
 	*/
 	deliverClaim = false;
-	isLoading = false;
-	isSubscribed = false;
-	error = void 0;
-	status = "ready";
-	connectionStatus = "disconnected";
 	abortController = null;
 	clientToolsRef;
 	devtoolsBridge;
@@ -8373,7 +9192,6 @@ var ChatClient = class {
 	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;
@@ -8385,8 +9203,6 @@ var ChatClient = class {
 	hydrationInFlight;
 	/** An async storage adapter is still reading the persisted transcript. */
 	storeHydrating = false;
-	/** See {@link getIsHydrating}. */
-	isHydrating = false;
 	/** Constructor inputs `attach()` needs on every re-attach, not just the first. */
 	rejoinRunId;
 	cachesMessages;
@@ -8395,7 +9211,6 @@ var ChatClient = class {
 	* `persistence === true`.
 	*/
 	historyPageSize;
-	hasOlderMessages = false;
 	olderMessagesCursor;
 	knownServerMessageIds = /* @__PURE__ */ new Set();
 	loadOlderMessagesInFlight = false;
@@ -8404,19 +9219,16 @@ var ChatClient = class {
 	callbacksRef;
 	constructor(options) {
 		assertUniqueInterruptDefinitions(options.interrupts);
-		this.threadId = options.threadId || "";
-		this.uniqueId = this.threadId;
+		if (typeof options.threadId !== "string" || options.threadId === "") throw new Error("ChatClient: threadId is required (a non-empty string).");
+		this.threadId = options.threadId;
 		let cachesMessages = true;
 		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;
@@ -8457,7 +9269,7 @@ var ChatClient = class {
 		if (options.initialResumeSnapshot) this.applyResumeSnapshot(options.initialResumeSnapshot);
 		const persistedState = this.persistor?.readInitial();
 		const syncPersistedState = persistedState instanceof Promise ? void 0 : persistedState;
-		const initialMessages = syncPersistedState ? syncPersistedState.messages : options.initialMessages;
+		const initialMessages = syncPersistedState ? syncPersistedState.messages : options.initialMessages && thawMessages(options.initialMessages);
 		let rejoinRunId = null;
 		if (syncPersistedState?.resume) {
 			const snapshot = syncPersistedState.resume;
@@ -8475,6 +9287,7 @@ var ChatClient = class {
 				onMessagesChange: (messages) => {
 					this.syncSubagentHandles();
 					this.persistor?.notifyMessagesChanged(messages);
+					patchAtom(this.snapshotAtom, { messages: freezeSnapshotMessages(this.frozenMessages, messages) });
 					this.callbacksRef.current.onMessagesChange(messages);
 					this.queueDevtoolsSnapshot();
 				},
@@ -8535,6 +9348,7 @@ var ChatClient = class {
 								const context = this.activeClientTools === null ? this.context : this.activeContext;
 								const output = await executeFunc(args.input, {
 									toolCallId: args.toolCallId,
+									threadId: this.threadId,
 									context,
 									emitCustomEvent: () => {}
 								});
@@ -8583,7 +9397,7 @@ var ChatClient = class {
 		}
 		this.rejoinRunId = rejoinRunId;
 		this.cachesMessages = cachesMessages;
-		this.isHydrating = this.storeHydrating || !cachesMessages && !!this.connection.hydrate;
+		this.snapshotAtom.set(this.readSnapshot(this.storeHydrating || !cachesMessages && !!this.connection.hydrate));
 	}
 	/**
 	* START TAILING: re-attach to an in-flight run so its chunks arrive here.
@@ -8602,7 +9416,6 @@ var ChatClient = class {
 	*/
 	attach() {
 		if (this.disposed || this.tailing) return;
-		this.ensureThreadId();
 		this.tailing = true;
 		if (this.rejoinRunId) this.maybeRejoinInFlight(this.rejoinRunId);
 		if (!this.cachesMessages && this.connection.hydrate) this.hydrateFromServer();
@@ -8757,16 +9570,10 @@ var ChatClient = class {
 		this.callbacksRef.current.onError(error);
 	}
 	mountDevtools() {
-		this.ensureThreadId();
 		if (this.devtoolsMounted) return;
 		this.devtoolsMounted = true;
 		this.devtoolsBridge.mountWithTools(this.processor.getMessages().length);
 	}
-	ensureThreadId() {
-		if (!this.threadId) this.threadId = this.generateUniqueId("thread");
-		this.uniqueId = this.threadId;
-		return this.threadId;
-	}
 	/**
 	* Drain a runId-less RUN_ERROR that belongs to a cleared run the client is
 	* still tracking. The persistor owns the cleared-run bookkeeping; the client
@@ -8901,7 +9708,7 @@ var ChatClient = class {
 	}
 	setCurrentRunId(runId) {
 		if (this.currentRunId === runId) return;
-		this.currentRunId = runId;
+		patchAtom(this.snapshotAtom, { runId });
 		this.callbacksRef.current.onRunIdChange(runId);
 	}
 	getInterruptState() {
@@ -8910,10 +9717,6 @@ var ChatClient = class {
 	getInterrupts() {
 		return this.interruptManager.getInterrupts();
 	}
-	/** @deprecated Use getInterrupts(). */
-	getPendingInterrupts() {
-		return this.interruptManager.getInterrupts();
-	}
 	resolveInterrupts(resolution) {
 		if (typeof resolution === "boolean") {
 			this.interruptManager.resolve(resolution);
@@ -8949,10 +9752,6 @@ var ChatClient = class {
 		this.pendingResumeItems = [...resume];
 		return this.streamResponse();
 	}
-	/** @deprecated Use bound interrupt methods or resumeInterruptsUnsafe(). */
-	resumeInterrupts(resume, state) {
-		return this.resumeInterruptsUnsafe(resume, state);
-	}
 	async submitInterruptBatch(submission) {
 		const continuationGeneration = this.continuationGeneration;
 		this.activeInterruptSubmission = submission;
@@ -8996,8 +9795,45 @@ var ChatClient = class {
 	generateUniqueId(prefix) {
 		return `${prefix}-${Date.now()}-${Math.random().toString(36).substring(7)}`;
 	}
+	/** Frozen copies of unchanged messages and parts, keyed by the live object. */
+	frozenMessages = /* @__PURE__ */ new WeakMap();
+	freezeSnapshotQueue(queue) {
+		return Object.freeze(queue.map((item) => {
+			if (typeof item.content !== "object") return Object.freeze({ ...item });
+			const content = Array.isArray(item.content.content) ? Object.freeze(item.content.content.map((part) => freezeSnapshotPart(part))) : item.content.content;
+			return Object.freeze({
+				...item,
+				content: Object.freeze({
+					...item.content,
+					content
+				})
+			});
+		}));
+	}
+	/** The atom with messages, queue, and interrupt state read fresh. */
+	readSnapshot(isHydrating) {
+		return Object.freeze({
+			...this.snapshotAtom.get(),
+			messages: freezeSnapshotMessages(this.frozenMessages, this.processor.getMessages()),
+			queue: this.freezeSnapshotQueue(this.getQueue()),
+			isHydrating,
+			interruptState: this.interruptManager.getState()
+		});
+	}
+	/**
+	* Subscribe to UI snapshot changes. Does not fire with the current value;
+	* read {@link getSnapshot} first.
+	*
+	* Named separately from {@link subscribe} (the live connection loop).
+	*/
+	subscribeSnapshot = (listener) => subscribeAtom(this.snapshotAtom, listener);
+	/**
+	* Current UI snapshot. The snapshot, `messages`, `queue`, and their entries
+	* are frozen copies. `interruptState` is the interrupt manager's own state.
+	*/
+	getSnapshot = () => this.snapshotAtom.get();
 	setIsLoading(isLoading) {
-		this.isLoading = isLoading;
+		patchAtom(this.snapshotAtom, { isLoading });
 		this.callbacksRef.current.onLoadingChange(isLoading);
 		this.events.loadingChanged(isLoading);
 		if (isLoading) this.supersedeHydration();
@@ -9013,35 +9849,36 @@ var ChatClient = class {
 		this.syncIsHydrating();
 	}
 	setStatus(status) {
-		this.status = status;
+		patchAtom(this.snapshotAtom, { status });
 		this.callbacksRef.current.onStatusChange(status);
 		this.devtoolsBridge.emitSnapshot();
 	}
 	setIsSubscribed(isSubscribed) {
-		this.isSubscribed = isSubscribed;
+		patchAtom(this.snapshotAtom, { isSubscribed });
 		this.callbacksRef.current.onSubscriptionChange(isSubscribed);
 		this.devtoolsBridge.emitSnapshot();
 	}
 	setConnectionStatus(status) {
-		this.connectionStatus = status;
+		patchAtom(this.snapshotAtom, { connectionStatus: status });
 		this.callbacksRef.current.onConnectionStatusChange(status);
 		this.devtoolsBridge.emitSnapshot();
 	}
 	syncIsHydrating() {
 		const isHydrating = this.hydrationInFlight !== void 0 || this.storeHydrating;
 		if (this.isHydrating === isHydrating) return;
-		this.isHydrating = isHydrating;
+		patchAtom(this.snapshotAtom, { isHydrating });
 		this.callbacksRef.current.onHydratingChange(isHydrating);
 	}
 	setSessionGenerating(isGenerating) {
 		if (this.sessionGenerating === isGenerating) return;
-		this.sessionGenerating = isGenerating;
+		patchAtom(this.snapshotAtom, { sessionGenerating: isGenerating });
 		this.callbacksRef.current.onSessionGeneratingChange(isGenerating);
 		this.devtoolsBridge.emitSnapshot();
 	}
 	notifyResumeStateChange(source) {
 		const resumeState = this.getResumeState();
 		const interruptState = this.interruptManager.getState();
+		patchAtom(this.snapshotAtom, { interruptState });
 		this.persistResumeSnapshot(resumeState);
 		this.callbacksRef.current.onResumeStateChange(resumeState, interruptState.interrupts);
 		this.callbacksRef.current.onInterruptStateChange(interruptState, { source });
@@ -9068,22 +9905,15 @@ var ChatClient = class {
 		this.setSessionGenerating(false);
 	}
 	setError(error) {
-		this.error = error;
+		patchAtom(this.snapshotAtom, { error });
 		this.callbacksRef.current.onErrorChange(error);
 		this.events.errorChanged(error?.message || null);
 	}
 	buildDevtoolsBridgeOptions(devtools) {
-		const client = this;
 		return {
-			get hookId() {
-				return client.uniqueId;
-			},
-			get clientId() {
-				return client.uniqueId;
-			},
-			get threadId() {
-				return client.threadId;
-			},
+			hookId: this.threadId,
+			clientId: this.threadId,
+			threadId: this.threadId,
 			metadata: {
 				hookName: devtools?.hookName ?? "useChat",
 				outputKind: devtools?.outputKind ?? "chat",
@@ -9357,12 +10187,13 @@ var ChatClient = class {
 	* @param content - The message content. Can be:
 	*   - A simple string for text-only messages
 	*   - A MultimodalContent object with content array and optional custom ID
-	* @param body - Optional body parameters to merge with the client's base body for this request.
-	*               Uses shallow merge with per-message body taking priority.
+	* @param body - Optional body parameters to merge into this request's
+	*               forwardedProps, over the forwardedProps option. Uses
+	*               shallow merge with per-message body taking priority.
 	* @param sendOptions - Per-call overrides. `{ whenBusy }` overrides the
 	*                      queue policy for this one send. `{ body }`
 	*                      shallow-merges with `body` and with the chat-level
-	*                      `body` / `forwardedProps`. `sendOptions.body` wins
+	*                      `forwardedProps`. `sendOptions.body` wins
 	*                      on key collisions. Framework hooks forward this
 	*                      object as their second argument.
 	*
@@ -9405,7 +10236,7 @@ var ChatClient = class {
 	async sendMessage(content, body, sendOptions) {
 		this.mountDevtools();
 		if (typeof content === "string" && !content.trim()) return;
-		if (this.hasPendingInterrupts()) 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. Resolve the interrupts first.");
 		const resolvedBody = {
 			...body,
 			...sendOptions?.body
@@ -9523,7 +10354,7 @@ var ChatClient = class {
 	*/
 	async append(message) {
 		this.mountDevtools();
-		if (this.hasPendingInterrupts()) 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. Resolve the interrupts first.");
 		const normalizedMessage = normalizeToUIMessage(message, generateMessageId);
 		if (normalizedMessage.role === "system") return;
 		if (normalizedMessage.role === "activity") {
@@ -9583,7 +10414,6 @@ var ChatClient = class {
 			await this.callbacksRef.current.onResponse();
 			if (signal.aborted) return false;
 			const mergedBody = {
-				...this.bodyOption,
 				...this.forwardedPropsOption,
 				...this.pendingMessageBody
 			};
@@ -9802,31 +10632,6 @@ var ChatClient = class {
 		return validation.data;
 	}
 	/**
-	* Respond to a tool approval request
-	*/
-	async addToolApprovalResponse(response) {
-		this.processor.addToolApprovalResponse(response.id, response.approved);
-		this.devtoolsBridge.emitSnapshot();
-		if (this.interruptManager.resolveToolApprovalDecision(response.id, response.approved)) return;
-		const messages = this.processor.getMessages();
-		let foundToolCallId;
-		for (const msg of messages) {
-			const toolCallPart = msg.parts.find((p) => p.type === "tool-call" && p.approval?.id === response.id);
-			if (toolCallPart) {
-				foundToolCallId = toolCallPart.id;
-				break;
-			}
-		}
-		if (foundToolCallId) this.events.toolApprovalResponded(response.id, foundToolCallId, response.approved);
-		this.processor.addToolApprovalResponse(response.id, response.approved);
-		this.devtoolsBridge.emitSnapshot();
-		if (this.isLoading) {
-			this.queuePostStreamAction(() => this.checkForContinuation());
-			return;
-		}
-		await this.checkForContinuation();
-	}
-	/**
 	* Queue an action to be executed after the current stream ends
 	*/
 	queuePostStreamAction(action) {
@@ -9908,6 +10713,14 @@ var ChatClient = class {
 		});
 	}
 	syncSubagentHandles() {
+		const fieldsOf = (subagent) => {
+			const { input: _old, ...card } = subagent;
+			const input = subagentInputOf(card.metadata);
+			return input === void 0 ? card : {
+				...card,
+				input
+			};
+		};
 		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);
@@ -9918,12 +10731,12 @@ var ChatClient = class {
 				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 });
+				Object.assign(existing, fieldsOf(part.subagent), { stop });
 				part.subagent = existing;
 				continue;
 			}
 			const handle = {
-				...part.subagent,
+				...fieldsOf(part.subagent),
 				stop: () => {
 					this.stopSubagent(id);
 				}
@@ -9985,19 +10798,22 @@ var ChatClient = class {
 			this.loadOlderMessagesInFlight = false;
 		}
 	}
+	setHasOlderMessages(hasOlderMessages) {
+		patchAtom(this.snapshotAtom, { hasOlderMessages });
+	}
 	resetHistoryPaging() {
-		this.hasOlderMessages = false;
+		this.setHasOlderMessages(false);
 		this.olderMessagesCursor = void 0;
 		this.knownServerMessageIds.clear();
 		this.historyGeneration++;
 	}
 	applyHydrationPage(page) {
 		if (page?.truncated === true) {
-			this.hasOlderMessages = true;
+			this.setHasOlderMessages(true);
 			this.olderMessagesCursor = page.cursor;
 			return;
 		}
-		this.hasOlderMessages = false;
+		this.setHasOlderMessages(false);
 		this.olderMessagesCursor = void 0;
 	}
 	rememberServerMessageIds(messages) {
@@ -10085,7 +10901,9 @@ var ChatClient = class {
 		}));
 	}
 	emitQueueChange() {
-		this.callbacksRef.current.onQueueChange(this.getQueue());
+		const queue = this.getQueue();
+		patchAtom(this.snapshotAtom, { queue: this.freezeSnapshotQueue(queue) });
+		this.callbacksRef.current.onQueueChange(queue);
 		this.devtoolsBridge.emitSnapshot();
 	}
 	/**
@@ -10159,7 +10977,7 @@ var ChatClient = class {
 	* Manually set messages
 	*/
 	setMessagesManually(messages) {
-		this.processor.setMessages(messages);
+		this.processor.setMessages(thawMessages(messages));
 		this.devtoolsBridge.emitSnapshot();
 	}
 	updateOptions(options) {
@@ -10181,7 +10999,6 @@ var ChatClient = class {
 			this.connection = normalizeConnectionAdapter(transport);
 			if (wasSubscribed) this.subscribe();
 		}
-		if (options.body !== void 0) this.bodyOption = options.body;
 		if (options.forwardedProps !== void 0) this.forwardedPropsOption = options.forwardedProps;
 		if (options.byok !== void 0) this.byok = options.byok;
 		if (options.byokProvider !== void 0) this.byokProvider = options.byokProvider;
@@ -10269,12 +11086,13 @@ async function validateParameters(parameters, input) {
 }
 //#endregion
 //#region src/core/agent-tools.ts
+const HOST_TOOL_NOT_EXECUTED = Symbol("Host tool was not executed");
 /** The full tool set declared to the agent; `render_widget` only when widgets are registered. */
-function buildAgentTools(widgets, hostTools, renderWidget, debug) {
+function buildAgentTools(widgets, hostTools, renderWidget, debug, guardHostExecution) {
 	return [
 		...Object.keys(widgets).length > 0 ? [buildRenderWidgetTool(widgets, renderWidget)] : [],
 		buildAskQuestionnaireTool(),
-		...buildHostTools(hostTools, debug)
+		...buildHostTools(hostTools, debug, guardHostExecution)
 	];
 }
 function buildRenderWidgetTool(widgets, render) {
@@ -10367,21 +11185,26 @@ function buildAskQuestionnaireTool() {
 	}).client();
 }
 /** Wraps the host's mount-time tools as client tools the agent can call. */
-function buildHostTools(tools, debug) {
+function buildHostTools(tools, debug, guardHostExecution) {
 	return Object.entries(tools).map(([name, tool]) => toolDefinition({
 		name,
 		description: tool.description,
 		inputSchema: toJsonSchema(tool.parameters),
 		...tool.metadata ? { metadata: tool.metadata } : {}
-	}).client(async (input) => {
-		debug?.("tool", `executing host tool "${name}"`, { input });
-		const validated = await validateParameters(tool.parameters, input ?? {});
-		if (validated == null) {
-			debug?.("error", `input for host tool "${name}" failed schema validation`, { input });
-			throw new Error(`Input for tool "${name}" failed schema validation`);
-		}
+	}).client(async (input, context) => {
+		let started = false;
 		try {
-			const output = await tool.execute(validated);
+			const resolve = guardHostExecution?.(name, tool, context?.toolCallId);
+			debug?.("tool", `executing host tool "${name}"`, { input });
+			const validated = await validateParameters(tool.parameters, input ?? {});
+			if (validated == null) {
+				debug?.("error", `input for host tool "${name}" failed schema validation`, { input });
+				throw new Error(`Input for tool "${name}" failed schema validation`);
+			}
+			context?.abortSignal?.throwIfAborted();
+			const current = resolve?.() ?? tool;
+			started = true;
+			const output = await current.execute(validated);
 			try {
 				canonicalInterruptJson(output);
 			} catch {
@@ -10391,6 +11214,7 @@ function buildHostTools(tools, debug) {
 			return output;
 		} catch (error) {
 			debug?.("error", `host tool "${name}" threw`, { error });
+			if (!started && error instanceof Error) Object.assign(error, { [HOST_TOOL_NOT_EXECUTED]: true });
 			throw error;
 		}
 	}));
@@ -11086,6 +11910,7 @@ function createAstralBeamChat(options, deferStart = false) {
 	let identity;
 	let started = false;
 	let selectionGeneration = 0;
+	let toolExecutionGeneration = 0;
 	let historyGeneration = 0;
 	let hydration = Promise.resolve();
 	let requestController = new AbortController();
@@ -11258,35 +12083,48 @@ function createAstralBeamChat(options, deferStart = false) {
 			});
 		}
 	};
-	const buildTools = () => buildAgentTools(live.widgets ?? {}, live.tools ?? {}, renderWidget, debug).map((tool) => {
-		if (!tool.execute) return tool;
-		const execute = tool.execute;
-		return {
-			...tool,
-			execute: async (input, context) => {
-				const toolCallId = context?.toolCallId;
-				if (!toolCallId || !liveToolCalls.has(toolCallId)) throw new Error("A saved tool call cannot execute again. Send a new message to request it.");
-				const results = toolResults;
-				const key = toolResultKey(toolCallId);
-				const resultIdentity = identity;
-				const apiUrl = authentication.apiUrl;
-				try {
-					const output = await execute(input, context);
-					if (identity === resultIdentity && authentication.apiUrl === apiUrl) results.set(key, {
-						outcome: "succeeded",
-						output: output ?? null
-					});
-					return output;
-				} catch (error) {
-					if (identity === resultIdentity && authentication.apiUrl === apiUrl) results.set(key, {
-						outcome: "unknown",
-						output: { error: error instanceof Error ? error.message : String(error) }
-					});
-					throw error;
+	const buildTools = () => {
+		const selection = selectionGeneration;
+		return buildAgentTools(live.widgets ?? {}, live.tools ?? {}, renderWidget, debug, (name, declaration, toolCallId) => {
+			const execution = toolExecutionGeneration;
+			const executingClient = client;
+			const executingIdentity = identity;
+			const apiUrl = authentication.apiUrl;
+			return () => {
+				const current = live.tools && Object.hasOwn(live.tools, name) ? live.tools[name] : void 0;
+				if (selection !== selectionGeneration || execution !== toolExecutionGeneration || executingClient !== client || executingIdentity !== identity || apiUrl !== authentication.apiUrl || state.thread?.role === "viewer" || !toolCallId || !liveToolCalls.has(toolCallId) || !current || current.parameters !== declaration.parameters) throw new DOMException("Host tool authority changed", "AbortError");
+				return current;
+			};
+		}).map((tool) => {
+			if (!tool.execute) return tool;
+			const execute = tool.execute;
+			return {
+				...tool,
+				execute: async (input, context) => {
+					const toolCallId = context?.toolCallId;
+					if (!toolCallId || !liveToolCalls.has(toolCallId)) throw new Error("A saved tool call cannot execute again. Send a new message to request it.");
+					const results = toolResults;
+					const key = toolResultKey(toolCallId);
+					const resultIdentity = identity;
+					const apiUrl = authentication.apiUrl;
+					try {
+						const output = await execute(input, context);
+						if (identity === resultIdentity && authentication.apiUrl === apiUrl) results.set(key, {
+							outcome: "succeeded",
+							output: output ?? null
+						});
+						return output;
+					} catch (error) {
+						if (!(error instanceof Error && HOST_TOOL_NOT_EXECUTED in error) && identity === resultIdentity && authentication.apiUrl === apiUrl) results.set(key, {
+							outcome: "unknown",
+							output: { error: error instanceof Error ? error.message : String(error) }
+						});
+						throw error;
+					}
 				}
-			}
-		};
-	});
+			};
+		});
+	};
 	const declareTools = () => {
 		const tools = buildTools();
 		const agentTools = tools.map((tool) => {
@@ -11907,6 +12745,7 @@ function createAstralBeamChat(options, deferStart = false) {
 	const start = () => {
 		if (started) return;
 		started = true;
+		client.updateOptions({ tools: declareTools() });
 		client.attach();
 		if (requestController.signal.aborted) requestController = new AbortController();
 		unsubscribeAuthentication = subscribeAuthentication(authentication, observeAuthentication);
@@ -11956,6 +12795,7 @@ function createAstralBeamChat(options, deferStart = false) {
 		retry,
 		addToolResult,
 		stop: () => {
+			toolExecutionGeneration++;
 			if (submission?.phase === "submitting") endUnaccepted(submission);
 			client.stop();
 		},