@astralbeam/sdk 0.16.0 → 0.17.0

package/dist/{core-D84VNYWJ.js → core-DeMY6_wQ.js}

@@ -1,7 +1,17 @@
-import { $ as listChatMessages, C as getCurrentUser, U as getResolveChatToolResultUrl, W as getRunChatUrl, _ as getChatConfig, dt as updateChatThread, f as createChatThread, g as getChatAttachment, gt as resolveApiUrl, h as deleteChatThread, ht as isAstralBeamApiError, mt as astralBeamChatFetch, tt as listChatThreads } from "./api-DzeMhfHU.js";
+import { Ct as isAstralBeamApiError, O as getCurrentUser, S as getChatFile, St as astralBeamChatFetch, X as getRunChatUrl, Y as getResolveChatToolResultUrl, b as getChatAttachment, ct as listChatThreads, g as createChatThread, ot as listChatMessages, vt as updateChatThread, wt as resolveApiUrl, x as getChatConfig, xt as uploadChatFile, y as deleteChatThread } from "./api-BaIPbj-Q.js";
 import { d as JWTInvalid, h as strictDecoder, r as isObject, s as decode } from "./type_checks-C-WTHaWs.js";
 //#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
 var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
 //#endregion
 //#region node_modules/.deno/jose@6.2.9/node_modules/jose/dist/webapi/util/decode_jwt.js
 function decodeJwt(jwt) {
@@ -26,7 +36,7 @@ function decodeJwt(jwt) {
 	return result;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.36.1/node_modules/@tanstack/ai-client/dist/esm/response-stream.js
+//#region node_modules/.deno/@tanstack+ai-client@0.39.2/node_modules/@tanstack/ai-client/dist/esm/response-stream.js
 var UnsupportedResponseStreamError = class extends Error {
 	missingFeature;
 	constructor(missingFeature) {
@@ -48,14 +58,14 @@ function createResponseStreamTextDecoder() {
 	return new globalThis.TextDecoder();
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.36.1/node_modules/@tanstack/ai-client/dist/esm/sse-utils.js
+//#region node_modules/.deno/@tanstack+ai-client@0.39.2/node_modules/@tanstack/ai-client/dist/esm/sse-utils.js
 function parseSseDataLine(line) {
 	if (!line.startsWith("data:")) return line;
 	const data = line.slice(5);
 	return data.startsWith(" ") ? data.slice(1) : data;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.36.1/node_modules/@tanstack/ai-client/dist/esm/message-date-normalizer.js
+//#region node_modules/.deno/@tanstack+ai-client@0.39.2/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;
@@ -87,7 +97,7 @@ function normalizeMessagesDates(messages) {
 	return messages.map(normalizeMessageDates);
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/utilities/ag-ui-usage.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/utilities/ag-ui-usage.js
 function definedDetails(value) {
 	return Object.keys(value).length > 0 ? value : void 0;
 }
@@ -132,7 +142,7 @@ function fromSpecTokenUsage(usage, leftover) {
 	};
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/utilities/merge-metadata.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/utilities/merge-metadata.js
 function isPlainRecord$1(value) {
 	return value != null && typeof value === "object" && !Array.isArray(value);
 }
@@ -211,7 +221,7 @@ let EventType = /* @__PURE__ */ function(EventType) {
 	return EventType;
 }({});
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/utilities/reasoning-encrypted-value.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/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
@@ -223,7 +233,7 @@ function isRedactedThinkingId(id) {
 	return typeof id === "string" && id.startsWith("redacted_thinking-");
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/interrupt-serialization.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/interrupt-serialization.js
 var SHA256_K = new Uint32Array([
 	1116352408,
 	1899447441,
@@ -398,7 +408,7 @@ function cloneAndDeepFreezeJson(value) {
 	return clone;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/interrupts.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/interrupts.js
 function canonicalizeInterruptResolutions(resolutions) {
 	const frozen = cloneAndDeepFreezeJson([...resolutions].sort((left, right) => left.interruptId.localeCompare(right.interruptId)));
 	const canonicalResolutions = canonicalInterruptJson(frozen);
@@ -409,7 +419,7 @@ function canonicalizeInterruptResolutions(resolutions) {
 	});
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/activities/chat/tools/schema-converter.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/activities/chat/tools/schema-converter.js
 /**
 * Build a JSONSchema object from any plain key/value source. The `JSONSchema`
 * interface's `[key: string]: any` index signature makes every property
@@ -677,7 +687,7 @@ async function validateWithStandardSchema(schema, data) {
 	};
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/activities/chat/tools/approval-schema.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/activities/chat/tools/approval-schema.js
 var jsonSchemaKeywords = /* @__PURE__ */ new Set([
 	"$schema",
 	"$id",
@@ -789,7 +799,7 @@ function hashSchemaInput(schema) {
 	return digestInterruptJson(canonicalInterruptJson(schemaToWire(schema).jsonSchema ?? { standardValidator: "unserialized" }));
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/interrupt-resume.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/interrupt-resume.js
 /**
 * The `Interrupt.metadata` key under which this package's resume binding
 * travels.
@@ -910,7 +920,7 @@ function readInterruptBinding(descriptor) {
 	};
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/interrupt-definition.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/interrupt-definition.js
 var INTERRUPT_PAYLOAD_METADATA_KEY = "tanstack:interruptPayload";
 function schemaJson(schema, name) {
 	if (!isStandardJSONSchema(schema)) throw new TypeError(`${name} must be a Standard Schema with a JSON Schema converter.`);
@@ -935,7 +945,7 @@ function hashInterruptDefinitionSchema(schema) {
 	return digestInterruptJson(schemaJson(schema, "Interrupt schema").canonicalJson);
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/generic-interrupt-continuation.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/generic-interrupt-continuation.js
 /**
 * `ResumeEntry.metadata` key for a first-party generic request.
 *
@@ -974,7 +984,7 @@ function genericInterruptContinuationFromDescriptor(interrupt) {
 	};
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/utilities/provider-executed.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/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`.
@@ -1004,7 +1014,7 @@ function isAssistantSegmentOf(id, parentId) {
 	return id?.startsWith(`${parentId}-segment-`) === true;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/utilities/tool-result.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/utilities/tool-result.js
 var CONTENT_PART_TYPES = /* @__PURE__ */ new Set([
 	"text",
 	"image",
@@ -1065,7 +1075,7 @@ function normalizeToolResult(result) {
 	return JSON.stringify(result);
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/utilities/subagent-wire.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/utilities/subagent-wire.js
 function isRecord$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1169,7 +1179,7 @@ function splitSubagentWire(messages) {
 	};
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/activities/chat/messages.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/activities/chat/messages.js
 function isRecord$1(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1362,6 +1372,7 @@ function assistantMetadata(uiMessage) {
 */
 function uiMessageToModelMessages(uiMessage) {
 	if (uiMessage.role === "system") return [];
+	if (uiMessage.role === "activity") return [];
 	if (uiMessage.role !== "assistant") return [buildUserOrToolMessage(uiMessage)];
 	return buildAssistantMessages(uiMessage);
 }
@@ -1491,6 +1502,7 @@ function buildAssistantMessages(uiMessage) {
 			}
 			break;
 		case "ui-resource": break;
+		case "activity": break;
 		case "subagent": {
 			const block = part.subagent.parentToolCallId === void 0 ? subagentHistoryText(part) : "";
 			if (block !== "") {
@@ -1707,6 +1719,15 @@ function aguiSnapshotMessageToUIMessage(message) {
 				}] : []
 			});
 		}
+		case "activity": return applySnapshotMetadata(message, {
+			id,
+			role: "activity",
+			parts: [{
+				type: "activity",
+				activityType: message.activityType,
+				content: structuredClone(message.content)
+			}]
+		});
 		default: return applySnapshotMetadata(message, {
 			id,
 			role: "assistant",
@@ -1752,15 +1773,23 @@ function applySnapshotMetadata(source, ui) {
 }
 function snapshotStructuredOutput(value) {
 	if (value == null || value.status !== "streaming" && value.status !== "complete" && value.status !== "error" || typeof value.raw !== "string") return;
-	return {
+	const base = {
 		type: "structured-output",
-		status: value.status,
 		raw: value.raw,
 		...value.partial !== void 0 ? { partial: value.partial } : {},
-		...value.data !== void 0 ? { data: value.data } : {},
 		...value.reasoning ? { reasoning: value.reasoning } : {},
 		...value.errorMessage !== void 0 ? { errorMessage: value.errorMessage } : {}
 	};
+	if (value.status !== "complete") return {
+		...base,
+		status: value.status
+	};
+	if (value.data === void 0) return void 0;
+	return {
+		...base,
+		status: "complete",
+		data: value.data
+	};
 }
 /**
 * Convert AG-UI user message content into `UIMessage` parts.
@@ -1818,7 +1847,7 @@ function generateMessageId() {
 	return `msg-${Date.now()}-${Math.random().toString(36).substring(7)}`;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/utilities/ag-ui-wire.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/utilities/ag-ui-wire.js
 function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -1849,15 +1878,35 @@ function rebuiltToolMetadata(metadata, createdAt, id, content, anchorOwnsUiResou
 * on assistant messages are additionally emitted as fan-out
 * `{role:'tool',...}` and `{role:'reasoning',...}` entries for strict AG-UI
 * server consumers. Set `includeSnapshotStructuredOutput` to retain complete
-* structured-output metadata for UI snapshots.
+* structured-output metadata for UI snapshots. Set `includeActivity` to emit
+* AG-UI `ActivityMessage` rows (MESSAGES_SNAPSHOT only — default omit so
+* RunAgentInput never carries activity).
 */
 function uiMessagesToWire(messages, options) {
 	const wire = [];
 	const usedWireIds = new Set(messages.flatMap((message) => "id" in message && message.id && message.role !== "tool" ? [message.id] : []));
 	const includeSnapshotStructuredOutput = options?.includeSnapshotStructuredOutput ?? false;
+	const includeActivity = options?.includeActivity ?? false;
 	const assistantIds = /* @__PURE__ */ new Set();
 	for (const msg of messages) if (msg.role === "assistant" && msg.id !== void 0) assistantIds.add(msg.id);
 	for (const msg of messages) {
+		if (msg.role === "activity") {
+			if (includeActivity && "parts" in msg) {
+				const part = msg.parts.find((p) => p.type === "activity");
+				if (part) {
+					const activity = {
+						id: msg.id,
+						role: "activity",
+						activityType: part.activityType,
+						content: structuredClone(part.content),
+						...msg.metadata != null && { metadata: msg.metadata },
+						...part.subagentRunId !== void 0 && { subagentRunId: part.subagentRunId }
+					};
+					wire.push(activity);
+				}
+			}
+			continue;
+		}
 		if (!("parts" in msg) && msg.role === "tool" && msg.toolCallId) {
 			const id = uniqueToolWireId(toolWireId(msg.id, msg.toolCallId, assistantIds), usedWireIds);
 			const metadata = rebuiltToolMetadata(msg.metadata, msg.createdAt, msg.id, msg.content);
@@ -2132,7 +2181,7 @@ function hashContent(s) {
 	return Math.abs(h).toString(36);
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/utilities/restore-inbound-chunk.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/utilities/restore-inbound-chunk.js
 /**
 * Rebuild TanStack `TokenUsage` (`promptTokens`) from spec `usage[]` plus
 * leftover fields in `metadata.tanstack.usage`. Restore in-process aliases
@@ -2169,7 +2218,7 @@ function restoreInboundChunk(chunk) {
 	return next;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/activities/chat/tools/tool-definition.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/activities/chat/tools/tool-definition.js
 /**
 * Create an isomorphic tool definition that can be used directly or instantiated for server/client
 *
@@ -2267,7 +2316,7 @@ function toolDefinition(config) {
 	};
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/utilities/chunk-ids.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/utilities/chunk-ids.js
 function stringField(value) {
 	return typeof value === "string" && value !== "" ? value : void 0;
 }
@@ -2370,7 +2419,7 @@ var require_options = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.default = exports.Allow;
 }));
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/json-parser.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/json-parser.js
 var import_dist = (/* @__PURE__ */ __commonJSMin(((exports) => {
 	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
 		if (k2 === void 0) k2 = k;
@@ -2592,7 +2641,7 @@ function parsePartialJSON(jsonString) {
 	return defaultJSONParser.parse(jsonString);
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/strategies.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/strategies.js
 /**
 * Immediate Strategy - emit on every chunk (default behavior)
 */
@@ -2602,7 +2651,7 @@ var ImmediateStrategy = class {
 	}
 };
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/utilities/errors.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/utilities/errors.js
 /**
 * Convert an AG-UI RUN_ERROR event to the Error shape exposed to consumers.
 * Preserves the provider code and sanitized raw event when available, while
@@ -2616,7 +2665,730 @@ function runErrorEventToError(chunk) {
 	return error;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/message-updaters.js
+//#region node_modules/.deno/fast-json-patch@3.1.1/node_modules/fast-json-patch/module/helpers.mjs
+/*!
+* https://github.com/Starcounter-Jack/JSON-Patch
+* (c) 2017-2022 Joachim Wester
+* MIT licensed
+*/
+var __extends = (function() {
+	var extendStatics = function(d, b) {
+		extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d, b) {
+			d.__proto__ = b;
+		} || function(d, b) {
+			for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+		};
+		return extendStatics(d, b);
+	};
+	return function(d, b) {
+		extendStatics(d, b);
+		function __() {
+			this.constructor = d;
+		}
+		d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+	};
+})();
+var _hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwnProperty(obj, key) {
+	return _hasOwnProperty.call(obj, key);
+}
+function _objectKeys(obj) {
+	if (Array.isArray(obj)) {
+		var keys_1 = new Array(obj.length);
+		for (var k = 0; k < keys_1.length; k++) keys_1[k] = "" + k;
+		return keys_1;
+	}
+	if (Object.keys) return Object.keys(obj);
+	var keys = [];
+	for (var i in obj) if (hasOwnProperty(obj, i)) keys.push(i);
+	return keys;
+}
+/**
+* Deeply clone the object.
+* https://jsperf.com/deep-copy-vs-json-stringify-json-parse/25 (recursiveDeepCopy)
+* @param  {any} obj value to clone
+* @return {any} cloned obj
+*/
+function _deepClone(obj) {
+	switch (typeof obj) {
+		case "object": return JSON.parse(JSON.stringify(obj));
+		case "undefined": return null;
+		default: return obj;
+	}
+}
+function isInteger(str) {
+	var i = 0;
+	var len = str.length;
+	var charCode;
+	while (i < len) {
+		charCode = str.charCodeAt(i);
+		if (charCode >= 48 && charCode <= 57) {
+			i++;
+			continue;
+		}
+		return false;
+	}
+	return true;
+}
+/**
+* Escapes a json pointer path
+* @param path The raw pointer
+* @return the Escaped path
+*/
+function escapePathComponent(path) {
+	if (path.indexOf("/") === -1 && path.indexOf("~") === -1) return path;
+	return path.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+/**
+* Unescapes a json pointer path
+* @param path The escaped pointer
+* @return The unescaped path
+*/
+function unescapePathComponent(path) {
+	return path.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+/**
+* Recursively checks whether an object has any undefined values inside.
+*/
+function hasUndefined(obj) {
+	if (obj === void 0) return true;
+	if (obj) {
+		if (Array.isArray(obj)) {
+			for (var i_1 = 0, len = obj.length; i_1 < len; i_1++) if (hasUndefined(obj[i_1])) return true;
+		} else if (typeof obj === "object") {
+			var objKeys = _objectKeys(obj);
+			var objKeysLength = objKeys.length;
+			for (var i = 0; i < objKeysLength; i++) if (hasUndefined(obj[objKeys[i]])) return true;
+		}
+	}
+	return false;
+}
+function patchErrorMessageFormatter(message, args) {
+	var messageParts = [message];
+	for (var key in args) {
+		var value = typeof args[key] === "object" ? JSON.stringify(args[key], null, 2) : args[key];
+		if (typeof value !== "undefined") messageParts.push(key + ": " + value);
+	}
+	return messageParts.join("\n");
+}
+var PatchError = function(_super) {
+	__extends(PatchError, _super);
+	function PatchError(message, name, index, operation, tree) {
+		var _newTarget = this.constructor;
+		var _this = _super.call(this, patchErrorMessageFormatter(message, {
+			name,
+			index,
+			operation,
+			tree
+		})) || this;
+		_this.name = name;
+		_this.index = index;
+		_this.operation = operation;
+		_this.tree = tree;
+		Object.setPrototypeOf(_this, _newTarget.prototype);
+		_this.message = patchErrorMessageFormatter(message, {
+			name,
+			index,
+			operation,
+			tree
+		});
+		return _this;
+	}
+	return PatchError;
+}(Error);
+//#endregion
+//#region node_modules/.deno/fast-json-patch@3.1.1/node_modules/fast-json-patch/module/core.mjs
+var core_exports = /* @__PURE__ */ __exportAll({
+	JsonPatchError: () => JsonPatchError,
+	_areEquals: () => _areEquals,
+	applyOperation: () => applyOperation,
+	applyPatch: () => applyPatch,
+	applyReducer: () => applyReducer,
+	deepClone: () => deepClone,
+	getValueByPointer: () => getValueByPointer,
+	validate: () => validate,
+	validator: () => validator
+});
+var JsonPatchError = PatchError;
+var deepClone = _deepClone;
+var objOps = {
+	add: function(obj, key, document) {
+		obj[key] = this.value;
+		return { newDocument: document };
+	},
+	remove: function(obj, key, document) {
+		var removed = obj[key];
+		delete obj[key];
+		return {
+			newDocument: document,
+			removed
+		};
+	},
+	replace: function(obj, key, document) {
+		var removed = obj[key];
+		obj[key] = this.value;
+		return {
+			newDocument: document,
+			removed
+		};
+	},
+	move: function(obj, key, document) {
+		var removed = getValueByPointer(document, this.path);
+		if (removed) removed = _deepClone(removed);
+		var originalValue = applyOperation(document, {
+			op: "remove",
+			path: this.from
+		}).removed;
+		applyOperation(document, {
+			op: "add",
+			path: this.path,
+			value: originalValue
+		});
+		return {
+			newDocument: document,
+			removed
+		};
+	},
+	copy: function(obj, key, document) {
+		var valueToCopy = getValueByPointer(document, this.from);
+		applyOperation(document, {
+			op: "add",
+			path: this.path,
+			value: _deepClone(valueToCopy)
+		});
+		return { newDocument: document };
+	},
+	test: function(obj, key, document) {
+		return {
+			newDocument: document,
+			test: _areEquals(obj[key], this.value)
+		};
+	},
+	_get: function(obj, key, document) {
+		this.value = obj[key];
+		return { newDocument: document };
+	}
+};
+var arrOps = {
+	add: function(arr, i, document) {
+		if (isInteger(i)) arr.splice(i, 0, this.value);
+		else arr[i] = this.value;
+		return {
+			newDocument: document,
+			index: i
+		};
+	},
+	remove: function(arr, i, document) {
+		return {
+			newDocument: document,
+			removed: arr.splice(i, 1)[0]
+		};
+	},
+	replace: function(arr, i, document) {
+		var removed = arr[i];
+		arr[i] = this.value;
+		return {
+			newDocument: document,
+			removed
+		};
+	},
+	move: objOps.move,
+	copy: objOps.copy,
+	test: objOps.test,
+	_get: objOps._get
+};
+/**
+* Retrieves a value from a JSON document by a JSON pointer.
+* Returns the value.
+*
+* @param document The document to get the value from
+* @param pointer an escaped JSON pointer
+* @return The retrieved value
+*/
+function getValueByPointer(document, pointer) {
+	if (pointer == "") return document;
+	var getOriginalDestination = {
+		op: "_get",
+		path: pointer
+	};
+	applyOperation(document, getOriginalDestination);
+	return getOriginalDestination.value;
+}
+/**
+* Apply a single JSON Patch Operation on a JSON document.
+* Returns the {newDocument, result} of the operation.
+* It modifies the `document` and `operation` objects - it gets the values by reference.
+* If you would like to avoid touching your values, clone them:
+* `jsonpatch.applyOperation(document, jsonpatch._deepClone(operation))`.
+*
+* @param document The document to patch
+* @param operation The operation to apply
+* @param validateOperation `false` is without validation, `true` to use default jsonpatch's validation, or you can pass a `validateOperation` callback to be used for validation.
+* @param mutateDocument Whether to mutate the original document or clone it before applying
+* @param banPrototypeModifications Whether to ban modifications to `__proto__`, defaults to `true`.
+* @return `{newDocument, result}` after the operation
+*/
+function applyOperation(document, operation, validateOperation, mutateDocument, banPrototypeModifications, index) {
+	if (validateOperation === void 0) validateOperation = false;
+	if (mutateDocument === void 0) mutateDocument = true;
+	if (banPrototypeModifications === void 0) banPrototypeModifications = true;
+	if (index === void 0) index = 0;
+	if (validateOperation) if (typeof validateOperation == "function") validateOperation(operation, 0, document, operation.path);
+	else validator(operation, 0);
+	if (operation.path === "") {
+		var returnValue = { newDocument: document };
+		if (operation.op === "add") {
+			returnValue.newDocument = operation.value;
+			return returnValue;
+		} else if (operation.op === "replace") {
+			returnValue.newDocument = operation.value;
+			returnValue.removed = document;
+			return returnValue;
+		} else if (operation.op === "move" || operation.op === "copy") {
+			returnValue.newDocument = getValueByPointer(document, operation.from);
+			if (operation.op === "move") returnValue.removed = document;
+			return returnValue;
+		} else if (operation.op === "test") {
+			returnValue.test = _areEquals(document, operation.value);
+			if (returnValue.test === false) throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document);
+			returnValue.newDocument = document;
+			return returnValue;
+		} else if (operation.op === "remove") {
+			returnValue.removed = document;
+			returnValue.newDocument = null;
+			return returnValue;
+		} else if (operation.op === "_get") {
+			operation.value = document;
+			return returnValue;
+		} else if (validateOperation) throw new JsonPatchError("Operation `op` property is not one of operations defined in RFC-6902", "OPERATION_OP_INVALID", index, operation, document);
+		else return returnValue;
+	} else {
+		if (!mutateDocument) document = _deepClone(document);
+		var keys = (operation.path || "").split("/");
+		var obj = document;
+		var t = 1;
+		var len = keys.length;
+		var existingPathFragment = void 0;
+		var key = void 0;
+		var validateFunction = void 0;
+		if (typeof validateOperation == "function") validateFunction = validateOperation;
+		else validateFunction = validator;
+		while (true) {
+			key = keys[t];
+			if (key && key.indexOf("~") != -1) key = unescapePathComponent(key);
+			if (banPrototypeModifications && (key == "__proto__" || key == "prototype" && t > 0 && keys[t - 1] == "constructor")) throw new TypeError("JSON-Patch: modifying `__proto__` or `constructor/prototype` prop is banned for security reasons, if this was on purpose, please set `banPrototypeModifications` flag false and pass it to this function. More info in fast-json-patch README");
+			if (validateOperation) {
+				if (existingPathFragment === void 0) {
+					if (obj[key] === void 0) existingPathFragment = keys.slice(0, t).join("/");
+					else if (t == len - 1) existingPathFragment = operation.path;
+					if (existingPathFragment !== void 0) validateFunction(operation, 0, document, existingPathFragment);
+				}
+			}
+			t++;
+			if (Array.isArray(obj)) {
+				if (key === "-") key = obj.length;
+				else if (validateOperation && !isInteger(key)) throw new JsonPatchError("Expected an unsigned base-10 integer value, making the new referenced value the array element with the zero-based index", "OPERATION_PATH_ILLEGAL_ARRAY_INDEX", index, operation, document);
+				else if (isInteger(key)) key = ~~key;
+				if (t >= len) {
+					if (validateOperation && operation.op === "add" && key > obj.length) throw new JsonPatchError("The specified index MUST NOT be greater than the number of elements in the array", "OPERATION_VALUE_OUT_OF_BOUNDS", index, operation, document);
+					var returnValue = arrOps[operation.op].call(operation, obj, key, document);
+					if (returnValue.test === false) throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document);
+					return returnValue;
+				}
+			} else if (t >= len) {
+				var returnValue = objOps[operation.op].call(operation, obj, key, document);
+				if (returnValue.test === false) throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document);
+				return returnValue;
+			}
+			obj = obj[key];
+			if (validateOperation && t < len && (!obj || typeof obj !== "object")) throw new JsonPatchError("Cannot perform operation at the desired path", "OPERATION_PATH_UNRESOLVABLE", index, operation, document);
+		}
+	}
+}
+/**
+* Apply a full JSON Patch array on a JSON document.
+* Returns the {newDocument, result} of the patch.
+* It modifies the `document` object and `patch` - it gets the values by reference.
+* If you would like to avoid touching your values, clone them:
+* `jsonpatch.applyPatch(document, jsonpatch._deepClone(patch))`.
+*
+* @param document The document to patch
+* @param patch The patch to apply
+* @param validateOperation `false` is without validation, `true` to use default jsonpatch's validation, or you can pass a `validateOperation` callback to be used for validation.
+* @param mutateDocument Whether to mutate the original document or clone it before applying
+* @param banPrototypeModifications Whether to ban modifications to `__proto__`, defaults to `true`.
+* @return An array of `{newDocument, result}` after the patch
+*/
+function applyPatch(document, patch, validateOperation, mutateDocument, banPrototypeModifications) {
+	if (mutateDocument === void 0) mutateDocument = true;
+	if (banPrototypeModifications === void 0) banPrototypeModifications = true;
+	if (validateOperation) {
+		if (!Array.isArray(patch)) throw new JsonPatchError("Patch sequence must be an array", "SEQUENCE_NOT_AN_ARRAY");
+	}
+	if (!mutateDocument) document = _deepClone(document);
+	var results = new Array(patch.length);
+	for (var i = 0, length_1 = patch.length; i < length_1; i++) {
+		results[i] = applyOperation(document, patch[i], validateOperation, true, banPrototypeModifications, i);
+		document = results[i].newDocument;
+	}
+	results.newDocument = document;
+	return results;
+}
+/**
+* Apply a single JSON Patch Operation on a JSON document.
+* Returns the updated document.
+* Suitable as a reducer.
+*
+* @param document The document to patch
+* @param operation The operation to apply
+* @return The updated document
+*/
+function applyReducer(document, operation, index) {
+	var operationResult = applyOperation(document, operation);
+	if (operationResult.test === false) throw new JsonPatchError("Test operation failed", "TEST_OPERATION_FAILED", index, operation, document);
+	return operationResult.newDocument;
+}
+/**
+* Validates a single operation. Called from `jsonpatch.validate`. Throws `JsonPatchError` in case of an error.
+* @param {object} operation - operation object (patch)
+* @param {number} index - index of operation in the sequence
+* @param {object} [document] - object where the operation is supposed to be applied
+* @param {string} [existingPathFragment] - comes along with `document`
+*/
+function validator(operation, index, document, existingPathFragment) {
+	if (typeof operation !== "object" || operation === null || Array.isArray(operation)) throw new JsonPatchError("Operation is not an object", "OPERATION_NOT_AN_OBJECT", index, operation, document);
+	else if (!objOps[operation.op]) throw new JsonPatchError("Operation `op` property is not one of operations defined in RFC-6902", "OPERATION_OP_INVALID", index, operation, document);
+	else if (typeof operation.path !== "string") throw new JsonPatchError("Operation `path` property is not a string", "OPERATION_PATH_INVALID", index, operation, document);
+	else if (operation.path.indexOf("/") !== 0 && operation.path.length > 0) throw new JsonPatchError("Operation `path` property must start with \"/\"", "OPERATION_PATH_INVALID", index, operation, document);
+	else if ((operation.op === "move" || operation.op === "copy") && typeof operation.from !== "string") throw new JsonPatchError("Operation `from` property is not present (applicable in `move` and `copy` operations)", "OPERATION_FROM_REQUIRED", index, operation, document);
+	else if ((operation.op === "add" || operation.op === "replace" || operation.op === "test") && operation.value === void 0) throw new JsonPatchError("Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)", "OPERATION_VALUE_REQUIRED", index, operation, document);
+	else if ((operation.op === "add" || operation.op === "replace" || operation.op === "test") && hasUndefined(operation.value)) throw new JsonPatchError("Operation `value` property is not present (applicable in `add`, `replace` and `test` operations)", "OPERATION_VALUE_CANNOT_CONTAIN_UNDEFINED", index, operation, document);
+	else if (document) {
+		if (operation.op == "add") {
+			var pathLen = operation.path.split("/").length;
+			var existingPathLen = existingPathFragment.split("/").length;
+			if (pathLen !== existingPathLen + 1 && pathLen !== existingPathLen) throw new JsonPatchError("Cannot perform an `add` operation at the desired path", "OPERATION_PATH_CANNOT_ADD", index, operation, document);
+		} else if (operation.op === "replace" || operation.op === "remove" || operation.op === "_get") {
+			if (operation.path !== existingPathFragment) throw new JsonPatchError("Cannot perform the operation at a path that does not exist", "OPERATION_PATH_UNRESOLVABLE", index, operation, document);
+		} else if (operation.op === "move" || operation.op === "copy") {
+			var error = validate([{
+				op: "_get",
+				path: operation.from,
+				value: void 0
+			}], document);
+			if (error && error.name === "OPERATION_PATH_UNRESOLVABLE") throw new JsonPatchError("Cannot perform the operation from a path that does not exist", "OPERATION_FROM_UNRESOLVABLE", index, operation, document);
+		}
+	}
+}
+/**
+* Validates a sequence of operations. If `document` parameter is provided, the sequence is additionally validated against the object document.
+* If error is encountered, returns a JsonPatchError object
+* @param sequence
+* @param document
+* @returns {JsonPatchError|undefined}
+*/
+function validate(sequence, document, externalValidator) {
+	try {
+		if (!Array.isArray(sequence)) throw new JsonPatchError("Patch sequence must be an array", "SEQUENCE_NOT_AN_ARRAY");
+		if (document) applyPatch(_deepClone(document), _deepClone(sequence), externalValidator || true);
+		else {
+			externalValidator = externalValidator || validator;
+			for (var i = 0; i < sequence.length; i++) externalValidator(sequence[i], i, document, void 0);
+		}
+	} catch (e) {
+		if (e instanceof JsonPatchError) return e;
+		else throw e;
+	}
+}
+function _areEquals(a, b) {
+	if (a === b) return true;
+	if (a && b && typeof a == "object" && typeof b == "object") {
+		var arrA = Array.isArray(a), arrB = Array.isArray(b), i, length, key;
+		if (arrA && arrB) {
+			length = a.length;
+			if (length != b.length) return false;
+			for (i = length; i-- !== 0;) if (!_areEquals(a[i], b[i])) return false;
+			return true;
+		}
+		if (arrA != arrB) return false;
+		var keys = Object.keys(a);
+		length = keys.length;
+		if (length !== Object.keys(b).length) return false;
+		for (i = length; i-- !== 0;) if (!b.hasOwnProperty(keys[i])) return false;
+		for (i = length; i-- !== 0;) {
+			key = keys[i];
+			if (!_areEquals(a[key], b[key])) return false;
+		}
+		return true;
+	}
+	return a !== a && b !== b;
+}
+//#endregion
+//#region node_modules/.deno/fast-json-patch@3.1.1/node_modules/fast-json-patch/module/duplex.mjs
+/*!
+* https://github.com/Starcounter-Jack/JSON-Patch
+* (c) 2017-2021 Joachim Wester
+* MIT license
+*/
+var duplex_exports = /* @__PURE__ */ __exportAll({
+	compare: () => compare,
+	generate: () => generate,
+	observe: () => observe,
+	unobserve: () => unobserve
+});
+var beforeDict = /* @__PURE__ */ new WeakMap();
+var Mirror = function() {
+	function Mirror(obj) {
+		this.observers = /* @__PURE__ */ new Map();
+		this.obj = obj;
+	}
+	return Mirror;
+}();
+var ObserverInfo = function() {
+	function ObserverInfo(callback, observer) {
+		this.callback = callback;
+		this.observer = observer;
+	}
+	return ObserverInfo;
+}();
+function getMirror(obj) {
+	return beforeDict.get(obj);
+}
+function getObserverFromMirror(mirror, callback) {
+	return mirror.observers.get(callback);
+}
+function removeObserverFromMirror(mirror, observer) {
+	mirror.observers.delete(observer.callback);
+}
+/**
+* Detach an observer from an object
+*/
+function unobserve(root, observer) {
+	observer.unobserve();
+}
+/**
+* Observes changes made to an object, which can then be retrieved using generate
+*/
+function observe(obj, callback) {
+	var patches = [];
+	var observer;
+	var mirror = getMirror(obj);
+	if (!mirror) {
+		mirror = new Mirror(obj);
+		beforeDict.set(obj, mirror);
+	} else {
+		var observerInfo = getObserverFromMirror(mirror, callback);
+		observer = observerInfo && observerInfo.observer;
+	}
+	if (observer) return observer;
+	observer = {};
+	mirror.value = _deepClone(obj);
+	if (callback) {
+		observer.callback = callback;
+		observer.next = null;
+		var dirtyCheck = function() {
+			generate(observer);
+		};
+		var fastCheck = function() {
+			clearTimeout(observer.next);
+			observer.next = setTimeout(dirtyCheck);
+		};
+		if (typeof window !== "undefined") {
+			window.addEventListener("mouseup", fastCheck);
+			window.addEventListener("keyup", fastCheck);
+			window.addEventListener("mousedown", fastCheck);
+			window.addEventListener("keydown", fastCheck);
+			window.addEventListener("change", fastCheck);
+		}
+	}
+	observer.patches = patches;
+	observer.object = obj;
+	observer.unobserve = function() {
+		generate(observer);
+		clearTimeout(observer.next);
+		removeObserverFromMirror(mirror, observer);
+		if (typeof window !== "undefined") {
+			window.removeEventListener("mouseup", fastCheck);
+			window.removeEventListener("keyup", fastCheck);
+			window.removeEventListener("mousedown", fastCheck);
+			window.removeEventListener("keydown", fastCheck);
+			window.removeEventListener("change", fastCheck);
+		}
+	};
+	mirror.observers.set(callback, new ObserverInfo(callback, observer));
+	return observer;
+}
+/**
+* Generate an array of patches from an observer
+*/
+function generate(observer, invertible) {
+	if (invertible === void 0) invertible = false;
+	var mirror = beforeDict.get(observer.object);
+	_generate(mirror.value, observer.object, observer.patches, "", invertible);
+	if (observer.patches.length) applyPatch(mirror.value, observer.patches);
+	var temp = observer.patches;
+	if (temp.length > 0) {
+		observer.patches = [];
+		if (observer.callback) observer.callback(temp);
+	}
+	return temp;
+}
+function _generate(mirror, obj, patches, path, invertible) {
+	if (obj === mirror) return;
+	if (typeof obj.toJSON === "function") obj = obj.toJSON();
+	var newKeys = _objectKeys(obj);
+	var oldKeys = _objectKeys(mirror);
+	var deleted = false;
+	for (var t = oldKeys.length - 1; t >= 0; t--) {
+		var key = oldKeys[t];
+		var oldVal = mirror[key];
+		if (hasOwnProperty(obj, key) && !(obj[key] === void 0 && oldVal !== void 0 && Array.isArray(obj) === false)) {
+			var newVal = obj[key];
+			if (typeof oldVal == "object" && oldVal != null && typeof newVal == "object" && newVal != null && Array.isArray(oldVal) === Array.isArray(newVal)) _generate(oldVal, newVal, patches, path + "/" + escapePathComponent(key), invertible);
+			else if (oldVal !== newVal) {
+				if (invertible) patches.push({
+					op: "test",
+					path: path + "/" + escapePathComponent(key),
+					value: _deepClone(oldVal)
+				});
+				patches.push({
+					op: "replace",
+					path: path + "/" + escapePathComponent(key),
+					value: _deepClone(newVal)
+				});
+			}
+		} else if (Array.isArray(mirror) === Array.isArray(obj)) {
+			if (invertible) patches.push({
+				op: "test",
+				path: path + "/" + escapePathComponent(key),
+				value: _deepClone(oldVal)
+			});
+			patches.push({
+				op: "remove",
+				path: path + "/" + escapePathComponent(key)
+			});
+			deleted = true;
+		} else {
+			if (invertible) patches.push({
+				op: "test",
+				path,
+				value: mirror
+			});
+			patches.push({
+				op: "replace",
+				path,
+				value: obj
+			});
+		}
+	}
+	if (!deleted && newKeys.length == oldKeys.length) return;
+	for (var t = 0; t < newKeys.length; t++) {
+		var key = newKeys[t];
+		if (!hasOwnProperty(mirror, key) && obj[key] !== void 0) patches.push({
+			op: "add",
+			path: path + "/" + escapePathComponent(key),
+			value: _deepClone(obj[key])
+		});
+	}
+}
+/**
+* Create an array of patches from the differences in two objects
+*/
+function compare(tree1, tree2, invertible) {
+	if (invertible === void 0) invertible = false;
+	var patches = [];
+	_generate(tree1, tree2, patches, "", invertible);
+	return patches;
+}
+//#endregion
+//#region node_modules/.deno/fast-json-patch@3.1.1/node_modules/fast-json-patch/index.mjs
+/**
+* Default export for backwards compat
+*/
+var fast_json_patch_default = Object.assign({}, core_exports, duplex_exports, {
+	JsonPatchError: PatchError,
+	deepClone: _deepClone,
+	escapePathComponent,
+	unescapePathComponent
+});
+//#endregion
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/activities/chat/activity-records.js
+function isActivityPart(part) {
+	return part.type === "activity";
+}
+function isActivityContent(value) {
+	return value != null && typeof value === "object" && !Array.isArray(value);
+}
+function applyActivitySnapshotToUIMessages(messages, chunk) {
+	const { messageId, activityType, content } = chunk;
+	const replace = chunk.replace ?? true;
+	const existingIndex = messages.findIndex((m) => m.id === messageId);
+	const existing = existingIndex >= 0 ? messages[existingIndex] : void 0;
+	if (existing && existing.role !== "activity") {
+		console.warn(`ACTIVITY_SNAPSHOT: Message '${messageId}' is not an activity message`);
+		return messages;
+	}
+	if (existing && !replace) return messages;
+	const metadata = mergeMetadata(existing?.role === "activity" ? existing.metadata : void 0, chunk.metadata);
+	const next = {
+		id: messageId,
+		role: "activity",
+		parts: [{
+			type: "activity",
+			activityType,
+			content: structuredClone(content ?? {})
+		}],
+		...metadata != null ? { metadata } : {},
+		...existing?.role === "activity" && existing.createdAt != null ? { createdAt: existing.createdAt } : {},
+		...existing?.role === "activity" && existing.name != null ? { name: existing.name } : {}
+	};
+	if (existingIndex === -1) return [...messages, next];
+	return messages.map((msg, index) => index === existingIndex ? next : msg);
+}
+function applyActivityDeltaToUIMessages(messages, chunk) {
+	const { messageId, activityType, patch } = chunk;
+	const existingIndex = messages.findIndex((m) => m.id === messageId);
+	if (existingIndex === -1) {
+		console.warn(`ACTIVITY_DELTA: No activity message '${messageId}'`);
+		return messages;
+	}
+	const existing = messages[existingIndex];
+	if (existing == null || existing.role !== "activity") {
+		console.warn(`ACTIVITY_DELTA: Message '${messageId}' is not an activity message`);
+		return messages;
+	}
+	const activityPart = existing.parts.find(isActivityPart);
+	if (activityPart && activityPart.activityType !== activityType) {
+		console.warn(`ACTIVITY_DELTA: activityType '${activityType}' does not match '${activityPart.activityType}' for '${messageId}'`);
+		return messages;
+	}
+	const baseContent = structuredClone(activityPart?.content ?? {});
+	try {
+		const result = fast_json_patch_default.applyPatch(baseContent, patch ?? [], true, false);
+		if (!isActivityContent(result.newDocument)) {
+			console.warn(`ACTIVITY_DELTA: patched content for '${messageId}' is not an object`);
+			return messages;
+		}
+		const nextPart = {
+			type: "activity",
+			activityType,
+			content: structuredClone(result.newDocument)
+		};
+		const parts = activityPart ? existing.parts.map((part) => part.type === "activity" ? nextPart : part) : [nextPart];
+		const metadata = mergeMetadata(existing.metadata, chunk.metadata);
+		return messages.map((msg, index) => index === existingIndex ? {
+			...msg,
+			parts,
+			...metadata != null ? { metadata } : {}
+		} : msg);
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		console.warn(`Failed to apply activity patch for '${messageId}': ${errorMessage}`);
+		return messages;
+	}
+}
+//#endregion
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/message-updaters.js
 /**
 * Message Updaters (Internal)
 *
@@ -2918,7 +3690,7 @@ function updateThinkingPart(messages, messageId, stepId, content, signature) {
 	});
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/processor.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/processor.js
 /**
 * Unified Stream Processor
 *
@@ -2939,6 +3711,28 @@ function updateThinkingPart(messages, messageId, stepId, content, signature) {
 *   adapter contract, single-shot flows, and expected UIMessage output.
 */
 var STRUCTURED_OUTPUT_UPDATE_BATCH_SIZE = 12;
+/**
+* Events that leave this processor's open *_CHUNK stream open.
+* RAW, activity events, and REASONING_ENCRYPTED_VALUE match the AG-UI client.
+* Subagent lifecycle events stay here too: the child processor owns that
+* lane, and SUBAGENT_FINISHED or SUBAGENT_ERROR finalizes the child.
+*/
+var CHUNK_PASS_THROUGH = /* @__PURE__ */ new Set([
+	"RAW",
+	"ACTIVITY_SNAPSHOT",
+	"ACTIVITY_DELTA",
+	"REASONING_ENCRYPTED_VALUE",
+	"SUBAGENT_STARTED",
+	"SUBAGENT_FINISHED",
+	"SUBAGENT_ERROR"
+]);
+/** A run-level event closes every open shorthand lane, including children. */
+var RUN_LEVEL_CLOSES_LANES = /* @__PURE__ */ new Set([
+	"RUN_STARTED",
+	"RUN_FINISHED",
+	"RUN_ERROR",
+	"MESSAGES_SNAPSHOT"
+]);
 function interruptBatchHasGeneric(interrupts) {
 	return interrupts.some((interrupt) => {
 		const metadata = interrupt.metadata;
@@ -2964,6 +3758,19 @@ function serializeToolInput(input) {
 	}
 }
 /**
+* 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.
@@ -2990,9 +3797,12 @@ var StreamProcessor = class StreamProcessor {
 	toolCallToMessage = /* @__PURE__ */ new Map();
 	pendingManualMessageId = null;
 	pendingThinkingStepId = null;
+	openChunk = null;
 	structuredMessageIds = /* @__PURE__ */ new Set();
 	structuredOutputUpdateBatches = /* @__PURE__ */ new Map();
 	activeRuns = /* @__PURE__ */ new Set();
+	runToolCallIds = [];
+	toolCallsSentToClient = /* @__PURE__ */ new Set();
 	childProcessors = /* @__PURE__ */ new Map();
 	childToolCalls = /* @__PURE__ */ new Map();
 	finishReason = null;
@@ -3199,6 +4009,7 @@ var StreamProcessor = class StreamProcessor {
 		this.structuredMessageIds.clear();
 		this.structuredOutputUpdateBatches.clear();
 		this.pendingManualMessageId = null;
+		this.openChunk = null;
 		this.childProcessors.clear();
 		this.childToolCalls.clear();
 		this.emitMessagesChange();
@@ -3219,7 +4030,7 @@ var StreamProcessor = class StreamProcessor {
 	*
 	* Central dispatch for all AG-UI events. Each event type maps to a specific
 	* handler. Events not listed in the switch are intentionally ignored
-	* (STEP_STARTED, STATE_SNAPSHOT, STATE_DELTA).
+	* (STATE_SNAPSHOT, STATE_DELTA).
 	*
 	* @see docs/chat-architecture.md#adapter-contract — Expected event types and ordering
 	*/
@@ -3230,6 +4041,10 @@ var StreamProcessor = class StreamProcessor {
 			index: this.recording.chunks.length
 		});
 		if (this.routeToChild(chunk)) return;
+		for (const event of this.expandChunk(chunk)) this.dispatchChunk(event);
+	}
+	/** Send one event, after expandChunk(), to its handler. */
+	dispatchChunk(chunk) {
 		switch (chunk.type) {
 			case "SUBAGENT_STARTED":
 				this.handleSubagentStartedEvent(chunk);
@@ -3289,7 +4104,178 @@ var StreamProcessor = class StreamProcessor {
 			case "TOOL_CALL_RESULT":
 				this.handleToolCallResultEvent(chunk);
 				break;
-			case "STEP_STARTED": this.handleStepStartedEvent(chunk);
+			case "STEP_STARTED":
+				this.handleStepStartedEvent(chunk);
+				break;
+			case "ACTIVITY_SNAPSHOT":
+				this.handleActivitySnapshotEvent(chunk);
+				break;
+			case "ACTIVITY_DELTA": this.handleActivityDeltaEvent(chunk);
+		}
+	}
+	/**
+	* AG-UI lets a producer send one TEXT_MESSAGE_CHUNK, TOOL_CALL_CHUNK or
+	* REASONING_MESSAGE_CHUNK in place of the START / CONTENT (ARGS) / END
+	* events. A chunk with a new id opens a stream. A chunk with the same id or
+	* no id continues it. Any other event closes it, except the ones in
+	* CHUNK_PASS_THROUGH. Expand the shorthand into the START / CONTENT (ARGS)
+	* / END events, so both forms build the same message.
+	*/
+	expandChunk(chunk) {
+		const open = this.openChunk;
+		const timestamp = chunk.timestamp;
+		switch (chunk.type) {
+			case "TEXT_MESSAGE_CHUNK": {
+				const id = this.chunkStreamId("TEXT_MESSAGE", chunk.messageId, chunk.type);
+				if (id === void 0) return this.closeChunk();
+				const events = [];
+				if (open?.family !== "TEXT_MESSAGE" || open.id !== id) {
+					events.push(...this.closeChunk(), {
+						type: EventType.TEXT_MESSAGE_START,
+						messageId: id,
+						role: chunk.role ?? "assistant",
+						...chunk.name !== void 0 ? { name: chunk.name } : {},
+						timestamp
+					});
+					this.openChunk = {
+						family: "TEXT_MESSAGE",
+						id
+					};
+				}
+				if (chunk.delta !== void 0 || chunk.metadata !== void 0) events.push({
+					type: EventType.TEXT_MESSAGE_CONTENT,
+					messageId: id,
+					delta: chunk.delta ?? "",
+					metadata: chunk.metadata,
+					timestamp
+				});
+				return events;
+			}
+			case "TOOL_CALL_CHUNK": {
+				const id = this.chunkStreamId("TOOL_CALL", chunk.toolCallId, chunk.type);
+				if (id === void 0) return this.closeChunk();
+				const events = [];
+				if (open?.family !== "TOOL_CALL" || open.id !== id) {
+					if (chunk.toolCallName === void 0) {
+						console.warn(`[StreamProcessor] Dropped TOOL_CALL_CHUNK ${id}: the first chunk of a tool call needs a toolCallName`);
+						return this.closeChunk();
+					}
+					events.push(...this.closeChunk(), {
+						type: EventType.TOOL_CALL_START,
+						toolCallId: id,
+						toolCallName: chunk.toolCallName,
+						parentMessageId: chunk.parentMessageId,
+						metadata: chunk.metadata,
+						timestamp
+					});
+					this.openChunk = {
+						family: "TOOL_CALL",
+						id
+					};
+				}
+				if (chunk.delta !== void 0 || chunk.metadata !== void 0) events.push({
+					type: EventType.TOOL_CALL_ARGS,
+					toolCallId: id,
+					delta: chunk.delta ?? "",
+					...chunk.metadata !== void 0 ? { metadata: chunk.metadata } : {},
+					timestamp
+				});
+				return events;
+			}
+			case "REASONING_MESSAGE_CHUNK": {
+				const id = this.chunkStreamId("REASONING_MESSAGE", chunk.messageId, chunk.type);
+				if (id === void 0) return this.closeChunk();
+				const events = [];
+				if (open?.family !== "REASONING_MESSAGE" || open.id !== id) {
+					events.push(...this.closeChunk(), {
+						type: EventType.REASONING_MESSAGE_START,
+						messageId: id,
+						role: "reasoning",
+						timestamp
+					});
+					this.openChunk = {
+						family: "REASONING_MESSAGE",
+						id
+					};
+				}
+				if (chunk.delta !== void 0 || chunk.metadata !== void 0) events.push({
+					type: EventType.REASONING_MESSAGE_CONTENT,
+					messageId: id,
+					delta: chunk.delta ?? "",
+					...chunk.metadata !== void 0 ? { metadata: chunk.metadata } : {},
+					timestamp
+				});
+				return events;
+			}
+			default: {
+				const events = open && !CHUNK_PASS_THROUGH.has(chunk.type) ? this.closeChunk() : [];
+				if (RUN_LEVEL_CLOSES_LANES.has(chunk.type)) this.closeChildChunkLanes();
+				return [...events, chunk];
+			}
+		}
+	}
+	/** Synthesize *_END on every nested shorthand lane and apply those events there. */
+	closeChildChunkLanes() {
+		for (const child of this.childProcessors.values()) {
+			for (const event of child.closeChunk()) child.dispatchChunk(event);
+			child.closeChildChunkLanes();
+		}
+	}
+	/**
+	* The child an untagged chunk with no id continues: the only child whose
+	* subtree has an open chunk stream of its kind, when this processor has
+	* none. The AG-UI client resolves a chunk that tags only its opener the
+	* same way.
+	*/
+	childContinuing(chunk) {
+		let family;
+		if (chunk.type === "TEXT_MESSAGE_CHUNK" && chunk.messageId === void 0) family = "TEXT_MESSAGE";
+		else if (chunk.type === "REASONING_MESSAGE_CHUNK" && chunk.messageId === void 0) family = "REASONING_MESSAGE";
+		else if (chunk.type === "TOOL_CALL_CHUNK" && chunk.toolCallId === void 0) family = "TOOL_CALL";
+		else return;
+		if (this.openChunkCount(family) !== 1) return void 0;
+		for (const [id, child] of this.childProcessors) if (child.openChunkCount(family) === 1) return id;
+	}
+	/**
+	* How many open chunk streams of a kind this processor and all its nested
+	* children hold.
+	*/
+	openChunkCount(family) {
+		let count = this.openChunk?.family === family ? 1 : 0;
+		for (const child of this.childProcessors.values()) count += child.openChunkCount(family);
+		return count;
+	}
+	/**
+	* The id a chunk opens or continues. A chunk with no id continues. If it
+	* continues nothing, the caller drops it and closes the open stream, so a
+	* later chunk with no id cannot continue that stream either.
+	*/
+	chunkStreamId(family, id, type) {
+		if (id !== void 0) return id;
+		if (this.openChunk?.family === family) return this.openChunk.id;
+		console.warn(`[StreamProcessor] Dropped ${type}: it has no id and continues nothing`);
+	}
+	closeChunk() {
+		const open = this.openChunk;
+		if (!open) return [];
+		this.openChunk = null;
+		const timestamp = Date.now();
+		switch (open.family) {
+			case "TEXT_MESSAGE": return [{
+				type: EventType.TEXT_MESSAGE_END,
+				messageId: open.id,
+				timestamp
+			}];
+			case "TOOL_CALL": return [{
+				type: EventType.TOOL_CALL_END,
+				toolCallId: open.id,
+				timestamp
+			}];
+			case "REASONING_MESSAGE": return [{
+				type: EventType.REASONING_MESSAGE_END,
+				messageId: open.id,
+				timestamp
+			}];
 		}
 	}
 	/**
@@ -3366,7 +4352,7 @@ var StreamProcessor = class StreamProcessor {
 	* MESSAGES_SNAPSHOT) but whose transient state was cleared. In that case we
 	* hydrate state from the existing message rather than creating a duplicate.
 	*/
-	ensureAssistantMessage(preferredId) {
+	ensureAssistantMessage(preferredId, fallbackToActive = true) {
 		if (preferredId) {
 			const state = this.getMessageState(preferredId);
 			if (state) {
@@ -3377,7 +4363,7 @@ var StreamProcessor = class StreamProcessor {
 				};
 			}
 		}
-		const activeId = this.getActiveAssistantMessageId();
+		const activeId = fallbackToActive ? this.getActiveAssistantMessageId() : null;
 		if (activeId) {
 			const state = this.getMessageState(activeId);
 			if (state) {
@@ -3390,7 +4376,8 @@ var StreamProcessor = class StreamProcessor {
 		}
 		if (preferredId) {
 			const existingMsg = this.messages.find((m) => m.id === preferredId);
-			if (existingMsg) {
+			if (existingMsg?.role === "activity") preferredId = void 0;
+			else if (existingMsg) {
 				const state = this.createMessageState(preferredId, existingMsg.role);
 				this.activeMessageIds.add(preferredId);
 				const lastPart = existingMsg.parts.length > 0 ? existingMsg.parts[existingMsg.parts.length - 1] : null;
@@ -3415,7 +4402,7 @@ var StreamProcessor = class StreamProcessor {
 		this.messages = [...this.messages, assistantMessage];
 		const state = this.createMessageState(id, "assistant");
 		this.activeMessageIds.add(id);
-		this.pendingManualMessageId = id;
+		if (!preferredId) this.pendingManualMessageId = id;
 		this.events.onStreamStart?.();
 		this.emitMessagesChange();
 		return {
@@ -3585,7 +4572,9 @@ var StreamProcessor = class StreamProcessor {
 	/**
 	* Send a child's chunk to that child's processor, so the card keeps text,
 	* reasoning, tool calls, results, and nested children. A tool event without
-	* `subagentRunId` follows its `TOOL_CALL_START`.
+	* `subagentRunId` follows its `TOOL_CALL_START` or `TOOL_CALL_CHUNK`. An
+	* untagged chunk with no id follows a child's open chunk stream (see
+	* childContinuing()).
 	*/
 	routeToChild(chunk) {
 		let id;
@@ -3595,6 +4584,7 @@ var StreamProcessor = class StreamProcessor {
 			id = chunk.subagentRunId;
 		} else if ("subagentRunId" in chunk && chunk.subagentRunId) id = chunk.subagentRunId;
 		else if ("toolCallId" in chunk && typeof chunk.toolCallId === "string") id = this.childToolCalls.get(chunk.toolCallId);
+		else id = this.childContinuing(chunk);
 		if (id === void 0) return false;
 		const owner = this.childOwning(id);
 		if (owner === void 0) {
@@ -3603,34 +4593,45 @@ var StreamProcessor = class StreamProcessor {
 			return true;
 		}
 		if (this.findSubagentPart(owner)?.part.subagent.status === "error") return true;
-		if (chunk.type === "TOOL_CALL_START") this.childToolCalls.set(chunk.toolCallId, owner);
+		if ((chunk.type === "TOOL_CALL_START" || chunk.type === "TOOL_CALL_CHUNK") && chunk.toolCallId !== void 0) this.childToolCalls.set(chunk.toolCallId, owner);
 		this.updateChild(owner, (child) => child.processChunk(chunk));
 		return true;
 	}
+	renameMessage(fromId, toId) {
+		this.messages = this.messages.map((msg) => msg.id === fromId ? {
+			...msg,
+			id: toId
+		} : msg);
+		const existingState = this.messageStates.get(fromId);
+		if (existingState) {
+			existingState.id = toId;
+			this.messageStates.delete(fromId);
+			this.messageStates.set(toId, existingState);
+		}
+		this.activeMessageIds.delete(fromId);
+		this.activeMessageIds.add(toId);
+		for (const [toolCallId, mappedMessageId] of this.toolCallToMessage) if (mappedMessageId === fromId) this.toolCallToMessage.set(toolCallId, toId);
+		if (this.structuredMessageIds.delete(fromId)) this.structuredMessageIds.add(toId);
+		const batch = this.structuredOutputUpdateBatches.get(fromId);
+		if (batch) {
+			this.structuredOutputUpdateBatches.delete(fromId);
+			this.structuredOutputUpdateBatches.set(toId, batch);
+		}
+	}
 	/**
 	* Handle TEXT_MESSAGE_START event
 	*/
 	handleTextMessageStartEvent(chunk) {
 		const { messageId, role } = chunk;
+		if (this.messages.some((m) => m.id === messageId && m.role === "activity")) {
+			console.warn(`TEXT_MESSAGE_START: Dropped text for '${messageId}', the id of an activity message`);
+			return;
+		}
 		const uiRole = role === "user" || role === "system" ? role : "assistant";
 		if (this.pendingManualMessageId) {
 			const pendingId = this.pendingManualMessageId;
 			this.pendingManualMessageId = null;
-			if (pendingId !== messageId) {
-				this.messages = this.messages.map((msg) => msg.id === pendingId ? {
-					...msg,
-					id: messageId
-				} : msg);
-				const existingState = this.messageStates.get(pendingId);
-				if (existingState) {
-					existingState.id = messageId;
-					this.messageStates.delete(pendingId);
-					this.messageStates.set(messageId, existingState);
-				}
-				this.activeMessageIds.delete(pendingId);
-				this.activeMessageIds.add(messageId);
-				for (const [toolCallId, mappedMessageId] of this.toolCallToMessage) if (mappedMessageId === pendingId) this.toolCallToMessage.set(toolCallId, messageId);
-			}
+			if (pendingId !== messageId) this.renameMessage(pendingId, messageId);
 			let pendingState = this.messageStates.get(messageId);
 			if (!pendingState) {
 				pendingState = this.createMessageState(messageId, uiRole);
@@ -3641,6 +4642,7 @@ var StreamProcessor = class StreamProcessor {
 				pendingState.lastEmittedText = "";
 				pendingState.hasToolCallsSinceTextStart = false;
 			}
+			this.applySenderName(messageId, chunk.name);
 			this.mergeMessageMetadata(messageId, chunk.metadata);
 			this.emitMessagesChange();
 			return;
@@ -3655,6 +4657,7 @@ var StreamProcessor = class StreamProcessor {
 				existingState.lastEmittedText = "";
 				existingState.hasToolCallsSinceTextStart = false;
 			}
+			this.applySenderName(messageId, chunk.name);
 			this.mergeMessageMetadata(messageId, chunk.metadata);
 			return;
 		}
@@ -3667,10 +4670,18 @@ var StreamProcessor = class StreamProcessor {
 		this.messages = [...this.messages, newMessage];
 		this.createMessageState(messageId, uiRole);
 		this.activeMessageIds.add(messageId);
+		this.applySenderName(messageId, chunk.name);
 		this.mergeMessageMetadata(messageId, chunk.metadata);
 		this.events.onStreamStart?.();
 		this.emitMessagesChange();
 	}
+	applySenderName(messageId, name) {
+		if (name === void 0) return;
+		this.messages = this.messages.map((msg) => msg.id === messageId ? {
+			...msg,
+			name
+		} : msg);
+	}
 	/**
 	* Handle TEXT_MESSAGE_END event
 	*/
@@ -3700,10 +4711,31 @@ var StreamProcessor = class StreamProcessor {
 				metadata: prev.metadata
 			};
 		});
-		this.messages = this.attachSnapshotSubagents(reconciled, top, groups, prevMessages);
+		this.messages = this.mergeOmittedActivity(prevMessages, this.attachSnapshotSubagents(reconciled, top, groups, prevMessages));
 		this.emitMessagesChange();
 	}
 	/**
+	* Snapshot is authoritative for user/assistant/system. Activity omitted
+	* from the snapshot (TanStack chat() still builds snapshots from
+	* ModelMessage[]) stays in the transcript so persist/reconnect cannot
+	* wipe it. Snapshot activity rows win when the id is present.
+	*
+	* Keep every snapshot row, including two assistants that share an id
+	* (agent-loop retry reuses `currentMessageId`). A Map keyed by id would
+	* drop the earlier error tool-call (#1192).
+	*/
+	mergeOmittedActivity(prevMessages, snapshot) {
+		const snapshotIds = new Set(snapshot.map((msg) => msg.id));
+		const omitted = prevMessages.filter((msg) => msg.role === "activity" && !snapshotIds.has(msg.id));
+		if (omitted.length === 0) return snapshot;
+		const out = [...snapshot];
+		for (const activity of omitted) {
+			const prevIndex = prevMessages.findIndex((msg) => msg.id === activity.id);
+			out.splice(Math.min(Math.max(prevIndex, 0), out.length), 0, activity);
+		}
+		return out;
+	}
+	/**
 	* Put subagent cards back on a snapshot. Child wire messages (tagged with
 	* `subagentRunId`) become a card on the nearest assistant message before
 	* them, or a new assistant message when there is none. A card that the
@@ -3923,6 +4955,10 @@ var StreamProcessor = class StreamProcessor {
 	* @see docs/chat-architecture.md#uimessage-part-ordering-invariants — Replace vs. push logic
 	*/
 	handleTextMessageContentEvent(chunk) {
+		if (this.messages.some((m) => m.id === chunk.messageId && m.role === "activity")) {
+			console.warn(`TEXT_MESSAGE_CONTENT: Dropped text for '${chunk.messageId}', the id of an activity message`);
+			return;
+		}
 		const { messageId, state } = this.ensureAssistantMessage(chunk.messageId);
 		this.mergeMessageMetadata(messageId, chunk.metadata);
 		if (this.structuredMessageIds.has(messageId)) {
@@ -3966,8 +5002,25 @@ var StreamProcessor = class StreamProcessor {
 	* @see docs/chat-architecture.md#adapter-contract — Ordering requirements
 	*/
 	handleToolCallStartEvent(chunk) {
+		const pendingId = this.pendingManualMessageId;
+		const parentId = chunk.parentMessageId;
+		if (pendingId && parentId && parentId !== pendingId) {
+			const parent = this.messages.find((m) => m.id === parentId);
+			const placeholder = this.messages.find((m) => m.id === pendingId);
+			if (!parent) {
+				this.pendingManualMessageId = null;
+				this.renameMessage(pendingId, parentId);
+			} else if (parent.role === "assistant" && placeholder) {
+				this.pendingManualMessageId = null;
+				this.messages = this.messages.filter((m) => m.id !== pendingId).map((m) => m.id === parentId ? {
+					...m,
+					parts: [...m.parts, ...placeholder.parts]
+				} : m);
+				this.renameMessage(pendingId, parentId);
+			}
+		}
 		const targetMessageId = chunk.parentMessageId ?? this.getActiveAssistantMessageId();
-		const { messageId, state } = this.ensureAssistantMessage(targetMessageId ?? void 0);
+		const { messageId, state } = this.ensureAssistantMessage(targetMessageId ?? void 0, chunk.parentMessageId === void 0);
 		state.hasToolCallsSinceTextStart = true;
 		const toolCallId = chunk.toolCallId;
 		if (!state.toolCalls.get(toolCallId)) {
@@ -3985,6 +5038,7 @@ var StreamProcessor = class StreamProcessor {
 			};
 			state.toolCalls.set(toolCallId, newToolCall);
 			state.toolCallOrder.push(toolCallId);
+			this.runToolCallIds.push(toolCallId);
 			this.toolCallToMessage.set(toolCallId, messageId);
 			this.messages = updateToolCallPart(this.messages, messageId, {
 				id: chunk.toolCallId,
@@ -4018,6 +5072,7 @@ var StreamProcessor = class StreamProcessor {
 		const existingToolCall = state.toolCalls.get(toolCallId);
 		if (!existingToolCall) return;
 		const wasAwaitingInput = existingToolCall.state === "awaiting-input";
+		if (chunk.metadata !== void 0) existingToolCall.metadata = mergeMetadata(existingToolCall.metadata, chunk.metadata);
 		existingToolCall.arguments += chunk.delta || "";
 		if (wasAwaitingInput && chunk.delta) existingToolCall.state = "input-streaming";
 		existingToolCall.parsedArguments = this.jsonParser.parse(existingToolCall.arguments);
@@ -4025,7 +5080,8 @@ var StreamProcessor = class StreamProcessor {
 			id: existingToolCall.id,
 			name: existingToolCall.name,
 			arguments: existingToolCall.arguments,
-			state: existingToolCall.state
+			state: existingToolCall.state,
+			...existingToolCall.metadata !== void 0 && { metadata: existingToolCall.metadata }
 		});
 		this.emitMessagesChange();
 		this.events.onToolCallStateChange?.(messageId, existingToolCall.id, existingToolCall.state, existingToolCall.arguments);
@@ -4102,6 +5158,10 @@ var StreamProcessor = class StreamProcessor {
 	* runs are still active before finalizing.
 	*/
 	handleRunStartedEvent(chunk) {
+		if (this.activeRuns.size === 0) {
+			this.runToolCallIds = [];
+			this.toolCallsSentToClient.clear();
+		}
 		this.activeRuns.add(chunk.runId);
 	}
 	/**
@@ -4122,11 +5182,39 @@ var StreamProcessor = class StreamProcessor {
 		if (this.activeRuns.size === 0) {
 			this.completeAllToolCalls();
 			if (this.finishReason === "tool_calls" && chunk.outcome?.type !== "interrupt") return;
+			if (!chunk.outcome || chunk.outcome.type === "success") this.handlePendingToolCalls(chunk.outcome?.pendingToolCallIds);
 			this.isDone = true;
 			this.finalizeStream();
 		}
 	}
 	/**
+	* AG-UI ends a run that calls a frontend tool with a success outcome and
+	* leaves the call unanswered. The pending calls are the ones named in
+	* `pendingToolCallIds` that this run started, or else every call this run
+	* started that has no result. Fire onToolCall once for each, so the client
+	* runs it and continues.
+	*/
+	handlePendingToolCalls(pendingToolCallIds) {
+		const ids = pendingToolCallIds?.length ? pendingToolCallIds.filter((id) => this.runToolCallIds.includes(id)) : this.runToolCallIds;
+		const parts = this.messages.flatMap((msg) => msg.parts ?? []);
+		for (const toolCallId of ids) {
+			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;
+			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`);
+				continue;
+			}
+			this.toolCallsSentToClient.add(toolCallId);
+			this.events.onToolCall?.({
+				toolCallId,
+				toolName: part.name,
+				input
+			});
+		}
+	}
+	/**
 	* Apply interrupt state to tool-call parts, then fire the client events.
 	* A child's interrupt updates the child's card. `emit` is false there, so
 	* the events fire once, from the top processor.
@@ -4168,6 +5256,7 @@ var StreamProcessor = class StreamProcessor {
 			}
 			if (kind === "client_tool" || interrupt.reason === "client_tool_input") {
 				if (hasGeneric || !emit) continue;
+				this.toolCallsSentToClient.add(toolCallId);
 				this.events.onToolCall?.({
 					toolCallId,
 					toolName,
@@ -4228,6 +5317,24 @@ var StreamProcessor = class StreamProcessor {
 		this.pendingThinkingStepId = stepId;
 	}
 	/**
+	* Handle ACTIVITY_SNAPSHOT. Creates or replaces a frontend-only activity
+	* message. Does not create MessageStreamState (that path feeds
+	* ProcessorResult.content).
+	*/
+	handleActivitySnapshotEvent(chunk) {
+		this.messages = applyActivitySnapshotToUIMessages(this.messages, chunk);
+		this.emitMessagesChange();
+	}
+	/**
+	* Handle ACTIVITY_DELTA. Applies RFC 6902 patches to an existing activity
+	* `content`. Missing or non-activity ids are no-ops. Patch failure leaves
+	* the previous content in place.
+	*/
+	handleActivityDeltaEvent(chunk) {
+		this.messages = applyActivityDeltaToUIMessages(this.messages, chunk);
+		this.emitMessagesChange();
+	}
+	/**
 	* Handle STEP_FINISHED event.
 	*
 	* Thinking *content* comes from REASONING_MESSAGE_CONTENT, not STEP_FINISHED.
@@ -4256,6 +5363,7 @@ var StreamProcessor = class StreamProcessor {
 	*/
 	handleReasoningMessageContentEvent(chunk) {
 		const { messageId, state } = this.ensureAssistantMessage(this.getActiveAssistantMessageId() ?? void 0);
+		this.mergeMessageMetadata(messageId, chunk.metadata);
 		state.hasSeenReasoningEvents = true;
 		const delta = chunk.delta || "";
 		this.consumePendingThinkingStep(state);
@@ -4368,6 +5476,7 @@ var StreamProcessor = class StreamProcessor {
 		}
 		if (chunk.name === "tool-input-available" && chunk.value) {
 			const { toolCallId, toolName, input } = chunk.value;
+			this.toolCallsSentToClient.add(toolCallId);
 			this.events.onToolCall?.({
 				toolCallId,
 				toolName,
@@ -4546,6 +5655,8 @@ var StreamProcessor = class StreamProcessor {
 	*/
 	finalizeStream() {
 		this.isDone = true;
+		for (const event of this.closeChunk()) this.dispatchChunk(event);
+		this.closeChildChunkLanes();
 		let lastAssistantMessage;
 		for (const messageId of this.activeMessageIds) {
 			const state = this.getMessageState(messageId);
@@ -4663,6 +5774,7 @@ var StreamProcessor = class StreamProcessor {
 		this.structuredOutputUpdateBatches.clear();
 		this.pendingManualMessageId = null;
 		this.pendingThinkingStepId = null;
+		this.openChunk = null;
 		this.finishReason = null;
 		this.hasError = false;
 		this.isDone = false;
@@ -4702,14 +5814,14 @@ function createReplayStream(recording) {
 	} };
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/byok/providers.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/byok/providers.js
 /** `[a-z][a-z0-9-]{0,63}` — lowercase, no underscores, max 64 chars. */
 var BYOK_PROVIDER_ID_PATTERN = /^[a-z][a-z0-9-]{0,63}$/;
 function isProviderId(value) {
 	return typeof value === "string" && BYOK_PROVIDER_ID_PATTERN.test(value);
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/byok/missing.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/byok/missing.js
 function isByokMissingBody(value) {
 	if (typeof value !== "object" || value === null) return false;
 	if (!("error" in value)) return false;
@@ -4722,7 +5834,7 @@ function isByokMissingBody(value) {
 	return true;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.64.0/node_modules/@tanstack/ai/dist/esm/byok/errors.js
+//#region node_modules/.deno/@tanstack+ai@0.68.0/node_modules/@tanstack/ai/dist/esm/byok/errors.js
 var ByokMissingError = class extends Error {
 	provider;
 	constructor(provider) {
@@ -4748,7 +5860,7 @@ var ByokUnresolvedProviderError = class extends Error {
 	}
 };
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.36.1/node_modules/@tanstack/ai-client/dist/esm/connection-adapters.js
+//#region node_modules/.deno/@tanstack+ai-client@0.39.2/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
@@ -4941,6 +6053,9 @@ async function* readStreamLines(reader, abortSignal) {
 		buffer += decoder.decode();
 		if (buffer.trim() && !abortSignal?.aborted) throw new StreamTruncatedError();
 	} finally {
+		try {
+			reader.cancel().catch(() => {});
+		} catch {}
 		reader.releaseLock();
 	}
 }
@@ -5443,7 +6558,7 @@ async function* abortableIterable(iterable, signal) {
 	}
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.36.1/node_modules/@tanstack/ai-client/dist/esm/interrupt-manager.js
+//#region node_modules/.deno/@tanstack+ai-client@0.39.2/node_modules/@tanstack/ai-client/dist/esm/interrupt-manager.js
 function isClientOwnedInterrupt(item) {
 	return item.resumable;
 }
@@ -6385,7 +7500,7 @@ var InterruptManager = class {
 	}
 };
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.36.1/node_modules/@tanstack/ai-client/dist/esm/byok/client.js
+//#region node_modules/.deno/@tanstack+ai-client@0.39.2/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.
@@ -6398,7 +7513,7 @@ function byokFallbackProviderId(byok) {
 	if (registered.length === 1) return registered[0];
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.36.1/node_modules/@tanstack/ai-client/dist/esm/byok/resolve.js
+//#region node_modules/.deno/@tanstack+ai-client@0.39.2/node_modules/@tanstack/ai-client/dist/esm/byok/resolve.js
 function resolveByokProviderId(byokProvider, ...candidates) {
 	const fromFn = byokProvider?.();
 	if (isProviderId(fromFn)) return fromFn;
@@ -6414,7 +7529,7 @@ async function prepareResolvedByokHeaders(byok, provider) {
 	return byok.headers(provider);
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.36.1/node_modules/@tanstack/ai-client/dist/esm/events.js
+//#region node_modules/.deno/@tanstack+ai-client@0.39.2/node_modules/@tanstack/ai-client/dist/esm/events.js
 /**
 * Abstract base class for ChatClient event emission
 */
@@ -6588,7 +7703,7 @@ var ChatClientEventEmitter = class {
 	}
 };
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.36.1/node_modules/@tanstack/ai-client/dist/esm/devtools-noop.js
+//#region node_modules/.deno/@tanstack+ai-client@0.39.2/node_modules/@tanstack/ai-client/dist/esm/devtools-noop.js
 var NoOpChatClientEventEmitter = class extends ChatClientEventEmitter {
 	emitEvent() {}
 };
@@ -6633,7 +7748,7 @@ var NoOpChatDevtoolsBridge = class {
 };
 var createNoOpChatDevtoolsBridge = (options) => new NoOpChatDevtoolsBridge(options);
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.36.1/node_modules/@tanstack/ai-client/dist/esm/client-persistor.js
+//#region node_modules/.deno/@tanstack+ai-client@0.39.2/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 };
@@ -6732,12 +7847,13 @@ var ChatPersistor = class {
 	}
 	/**
 	* Apply state from an async `getItem` once it resolves, unless the message
-	* list has already changed since hydration began.
+	* list has already changed since hydration began. Returns a promise that
+	* settles (never rejects) when it is done, or `undefined` for sync state.
 	*/
 	hydrateAsync(persistedState) {
 		if (!(persistedState instanceof Promise)) return;
 		const hydrationGeneration = this.messagesGeneration;
-		persistedState.then((state) => {
+		return persistedState.then((state) => {
 			if (!state || this.messagesGeneration !== hydrationGeneration) return;
 			this.lastResume = state.resume ?? null;
 			this.lastMessages = state.messages;
@@ -6893,11 +8009,11 @@ var ChatPersistor = class {
 	isRunlessChunkFromIgnoredRun(chunk) {
 		if (getChunkRunId$1(chunk) || !this.currentRunlessRunId) return false;
 		if (!this.ignoredActiveRunIds.has(this.currentRunlessRunId) && !this.clearedRunIds.has(this.currentRunlessRunId)) return false;
-		return chunk.type === "TEXT_MESSAGE_START" || chunk.type === "TEXT_MESSAGE_CONTENT" || chunk.type === "TOOL_CALL_START" || chunk.type === "TOOL_CALL_ARGS" || chunk.type === "TOOL_CALL_END" || chunk.type === "TOOL_CALL_RESULT" || chunk.type === "MESSAGES_SNAPSHOT" || chunk.type === "RUN_ERROR";
+		return chunk.type === "TEXT_MESSAGE_START" || chunk.type === "TEXT_MESSAGE_CONTENT" || chunk.type === "TEXT_MESSAGE_CHUNK" || chunk.type === "TOOL_CALL_START" || chunk.type === "TOOL_CALL_ARGS" || chunk.type === "TOOL_CALL_END" || chunk.type === "TOOL_CALL_RESULT" || chunk.type === "TOOL_CALL_CHUNK" || chunk.type === "MESSAGES_SNAPSHOT" || chunk.type === "RUN_ERROR";
 	}
 };
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.36.1/node_modules/@tanstack/ai-client/dist/esm/cleared-stream-tracker.js
+//#region node_modules/.deno/@tanstack+ai-client@0.39.2/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;
 }
@@ -6986,11 +8102,11 @@ var ClearedStreamTracker = class {
 	isRunlessChunkFromIgnoredRun(chunk) {
 		if (getChunkRunId$1(chunk) || !this.currentRunlessRunId) return false;
 		if (!this.ignoredActiveRunIds.has(this.currentRunlessRunId) && !this.clearedRunIds.has(this.currentRunlessRunId)) return false;
-		return chunk.type === "TEXT_MESSAGE_START" || chunk.type === "TEXT_MESSAGE_CONTENT" || chunk.type === "TOOL_CALL_START" || chunk.type === "TOOL_CALL_ARGS" || chunk.type === "TOOL_CALL_END" || chunk.type === "TOOL_CALL_RESULT" || chunk.type === "MESSAGES_SNAPSHOT" || chunk.type === "RUN_ERROR";
+		return chunk.type === "TEXT_MESSAGE_START" || chunk.type === "TEXT_MESSAGE_CONTENT" || chunk.type === "TEXT_MESSAGE_CHUNK" || chunk.type === "TOOL_CALL_START" || chunk.type === "TOOL_CALL_ARGS" || chunk.type === "TOOL_CALL_END" || chunk.type === "TOOL_CALL_RESULT" || chunk.type === "TOOL_CALL_CHUNK" || chunk.type === "MESSAGES_SNAPSHOT" || chunk.type === "RUN_ERROR";
 	}
 };
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.36.1/node_modules/@tanstack/ai-client/dist/esm/chat-client.js
+//#region node_modules/.deno/@tanstack+ai-client@0.39.2/node_modules/@tanstack/ai-client/dist/esm/chat-client.js
 var STREAM_PROCESSING_BUDGET_MS = 8;
 function yieldToHost() {
 	const { scheduler } = globalThis;
@@ -7126,8 +8242,11 @@ var REJOIN_CONNECT_DEADLINE_MS = 2e3;
 var REJOIN_REBUILD_TRIGGERS = /* @__PURE__ */ new Set([
 	"TEXT_MESSAGE_START",
 	"TEXT_MESSAGE_CONTENT",
+	"TEXT_MESSAGE_CHUNK",
 	"REASONING_MESSAGE_CONTENT",
+	"REASONING_MESSAGE_CHUNK",
 	"TOOL_CALL_START",
+	"TOOL_CALL_CHUNK",
 	"MESSAGES_SNAPSHOT",
 	"SUBAGENT_STARTED"
 ]);
@@ -7231,6 +8350,7 @@ var ChatClient = class {
 	currentMessageId = null;
 	postStreamActions = [];
 	pendingToolExecutions = /* @__PURE__ */ new Map();
+	handingOverPendingToolCalls = false;
 	activeClientTools = null;
 	activeContext = void 0;
 	continuationPending = false;
@@ -7256,6 +8376,12 @@ var ChatClient = class {
 	hydrationError;
 	/** Whether a view is currently watching. See `attach` / `detach`. */
 	tailing = false;
+	/** `historyGeneration` of the mount hydration GET still in flight, if any. */
+	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;
@@ -7310,6 +8436,7 @@ var ChatClient = class {
 			onSubscriptionChange: options.onSubscriptionChange || (() => {}),
 			onConnectionStatusChange: options.onConnectionStatusChange || (() => {}),
 			onSessionGeneratingChange: options.onSessionGeneratingChange || (() => {}),
+			onHydratingChange: options.onHydratingChange || (() => {}),
 			onQueueChange: options.onQueueChange || (() => {}),
 			onResumeStateChange: options.onResumeStateChange || (() => {}),
 			onRunIdChange: options.onRunIdChange || (() => {}),
@@ -7391,6 +8518,10 @@ var ChatClient = class {
 				onToolCall: (args) => {
 					const clientTool = (this.activeClientTools ?? this.clientToolsRef.current).get(args.toolName);
 					const executeFunc = clientTool?.execute;
+					if (this.handingOverPendingToolCalls && clientTool?.needsApproval === true) {
+						console.warn(`[ChatClient] Did not run tool call ${args.toolCallId}: ${args.toolName} needs approval, and the server did not ask for it`);
+						return;
+					}
 					if (executeFunc) {
 						const continuationGeneration = this.continuationGeneration;
 						const runEventContext = this.devtoolsBridge.getCurrentRunEventContext();
@@ -7437,9 +8568,17 @@ var ChatClient = class {
 			}
 		});
 		this.syncSubagentHandles();
-		this.persistor?.hydrateAsync(persistedState);
+		const storeHydration = this.persistor?.hydrateAsync(persistedState);
+		if (storeHydration) {
+			this.storeHydrating = true;
+			storeHydration.finally(() => {
+				this.storeHydrating = false;
+				this.syncIsHydrating();
+			});
+		}
 		this.rejoinRunId = rejoinRunId;
 		this.cachesMessages = cachesMessages;
+		this.isHydrating = this.storeHydrating || !cachesMessages && !!this.connection.hydrate;
 	}
 	/**
 	* START TAILING: re-attach to an in-flight run so its chunks arrive here.
@@ -7542,21 +8681,30 @@ var ChatClient = class {
 	*/
 	hydrateFromServer() {
 		const hydrate = this.connection.hydrate;
-		if (!hydrate) return;
-		if (this.isLoading || this.abortController) return;
-		if (this.disposed) return;
+		if (!hydrate || this.isLoading || this.abortController || this.disposed) {
+			this.syncIsHydrating();
+			return;
+		}
+		if (this.hydrationInFlight === this.historyGeneration) return;
 		const pageSize = this.historyPageSize;
 		const hydrateOptions = pageSize === void 0 ? void 0 : { limit: pageSize };
 		(async () => {
 			let result;
 			const generation = this.historyGeneration;
+			this.hydrationInFlight = generation;
+			this.syncIsHydrating();
+			const isCurrent = () => this.hydrationInFlight === generation && generation === this.historyGeneration;
+			let current;
 			try {
 				result = await hydrate(this.threadId, hydrateOptions);
 			} catch (cause) {
-				if (generation === this.historyGeneration) this.failHydration(cause);
+				if (isCurrent()) this.failHydration(cause);
 				return;
+			} finally {
+				current = isCurrent();
+				if (this.hydrationInFlight === generation) this.hydrationInFlight = void 0;
 			}
-			if (generation !== this.historyGeneration) return;
+			if (!current) return;
 			if (this.disposed || !this.tailing) return;
 			if (this.isLoading || this.abortController) return;
 			if (this.hydrationError && this.error === this.hydrationError) {
@@ -7578,7 +8726,7 @@ var ChatClient = class {
 				pendingInterrupts: result.interrupts.pending
 			});
 			else if (result.activeRun?.runId) this.maybeRejoinInFlight(result.activeRun.runId);
-		})();
+		})().finally(() => this.syncIsHydrating());
 	}
 	/**
 	* Surface a mount-hydration failure (`persistence: true`) on the observable
@@ -7847,6 +8995,17 @@ var ChatClient = class {
 		this.isLoading = isLoading;
 		this.callbacksRef.current.onLoadingChange(isLoading);
 		this.events.loadingChanged(isLoading);
+		if (isLoading) this.supersedeHydration();
+	}
+	/**
+	* A send or a clear now owns the transcript. A load that is still pending can
+	* no longer paint it (the generation guards drop its result), so it no longer
+	* counts as hydrating.
+	*/
+	supersedeHydration() {
+		this.hydrationInFlight = void 0;
+		this.storeHydrating = false;
+		this.syncIsHydrating();
 	}
 	setStatus(status) {
 		this.status = status;
@@ -7863,6 +9022,12 @@ var ChatClient = class {
 		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;
+		this.callbacksRef.current.onHydratingChange(isHydrating);
+	}
 	setSessionGenerating(isGenerating) {
 		if (this.sessionGenerating === isGenerating) return;
 		this.sessionGenerating = isGenerating;
@@ -8128,7 +9293,12 @@ var ChatClient = class {
 			this.resolveJoinedRun(chunk);
 			return;
 		}
-		this.processor.processChunk(chunk);
+		this.handingOverPendingToolCalls = chunk.type === "RUN_FINISHED" && chunk.outcome?.type !== "interrupt";
+		try {
+			this.processor.processChunk(chunk);
+		} finally {
+			this.handingOverPendingToolCalls = false;
+		}
 		this.syncSubagentHandles();
 		this.updateRunLifecycle(chunk);
 		this.observeInterruptState(chunk);
@@ -8351,6 +9521,14 @@ var ChatClient = class {
 		if (this.hasPendingInterrupts()) throw new Error("ChatClient: cannot append normal input while pending interrupts exist. Use resumeInterrupts() instead.");
 		const normalizedMessage = normalizeToUIMessage(message, generateMessageId);
 		if (normalizedMessage.role === "system") return;
+		if (normalizedMessage.role === "activity") {
+			const uiMessage = normalizedMessage;
+			this.events.messageAppended(uiMessage);
+			const messages = this.processor.getMessages();
+			this.processor.setMessages([...messages, uiMessage]);
+			this.devtoolsBridge.emitSnapshot();
+			return;
+		}
 		const uiMessage = normalizedMessage;
 		this.events.messageAppended(uiMessage);
 		const messages = this.processor.getMessages();
@@ -8567,6 +9745,7 @@ var ChatClient = class {
 		this.persistor?.beginClear();
 		this.processor.clearMessages();
 		this.resetHistoryPaging();
+		this.supersedeHydration();
 		this.discardPendingSends();
 		this.persistor?.remove();
 		this.stoppedSubagentIds.clear();
@@ -8825,16 +10004,17 @@ var ChatClient = class {
 		this.rememberServerMessageIds(this.processor.getMessages());
 	}
 	messagesForSend(messages) {
-		if (this.historyPageSize === void 0) return messages;
+		const forModel = messages.filter((message) => message.role !== "activity");
+		if (this.historyPageSize === void 0) return forModel;
 		const unknownMessages = [];
-		for (const message of messages) {
+		for (const message of forModel) {
 			if (this.knownServerMessageIds.has(message.id)) continue;
 			unknownMessages.push(message);
 		}
 		if (unknownMessages.length > 0) return unknownMessages;
-		const lastUserIndex = messages.findLastIndex((message) => message.role === "user");
+		const lastUserIndex = forModel.findLastIndex((message) => message.role === "user");
 		if (lastUserIndex === -1) return [];
-		return messages.slice(lastUserIndex);
+		return forModel.slice(lastUserIndex);
 	}
 	/**
 	* True when an interrupt (or another direct send) claimed the client during
@@ -8956,6 +10136,15 @@ var ChatClient = class {
 		return this.sessionGenerating;
 	}
 	/**
+	* Whether the client is rebuilding the chat from persistence: the server
+	* hydrate (`persistence: true`) or an async storage adapter. Turns false once
+	* the transcript is applied and any in-flight run is re-joined (from then on
+	* `isLoading` covers the stream), or when the load fails.
+	*/
+	getIsHydrating() {
+		return this.isHydrating;
+	}
+	/**
 	* Get current error
 	*/
 	getError() {
@@ -9006,6 +10195,7 @@ var ChatClient = class {
 		if (options.onSubscriptionChange !== void 0) this.callbacksRef.current.onSubscriptionChange = options.onSubscriptionChange;
 		if (options.onConnectionStatusChange !== void 0) this.callbacksRef.current.onConnectionStatusChange = options.onConnectionStatusChange;
 		if (options.onSessionGeneratingChange !== void 0) this.callbacksRef.current.onSessionGeneratingChange = options.onSessionGeneratingChange;
+		if (options.onHydratingChange !== void 0) this.callbacksRef.current.onHydratingChange = options.onHydratingChange;
 		if (options.onQueueChange !== void 0) this.callbacksRef.current.onQueueChange = options.onQueueChange;
 		if (options.onResumeStateChange !== void 0) this.callbacksRef.current.onResumeStateChange = options.onResumeStateChange;
 		if (options.onRunIdChange !== void 0) this.callbacksRef.current.onRunIdChange = options.onRunIdChange;
@@ -9332,6 +10522,7 @@ async function loadChatAuthToken(options) {
 	} catch (cause) {
 		signal.throwIfAborted();
 		const error = cause instanceof Error ? cause : /* @__PURE__ */ new Error("Authentication failed");
+		if (isAstralBeamApiError(error) && error.status === 401) error.message = "AstralBeam rejected the chat token after renewal. Check that apiUrl matches the deployment that issued your API key. If the key was revoked or expired, create a replacement in API Keys and update your server's secret.";
 		session.cached = void 0;
 		publishAuthentication(options, {
 			status: "error",
@@ -9463,6 +10654,11 @@ function hasPendingToolRun(messages, toolNames) {
 	return messages.some((message) => message.parts.some((part) => part.type === "tool-call" && !isSettledToolCall(part) && part.name !== "ask_questionnaire" && toolNames.has(part.name)));
 }
 //#endregion
+//#region src/core/web.ts
+function webPartMetadata(part) {
+	return part.metadata ?? {};
+}
+//#endregion
 //#region src/core/sandbox.ts
 const SANDBOX_TOOLS = [
 	SANDBOX_WRITE_FILE_TOOL,
@@ -9513,19 +10709,19 @@ function sandboxPathLabel(part) {
 	if (relative !== void 0 && relative !== ".") return relative;
 	return text(part.output, "path") ?? text(part.input, "path");
 }
-/** A `sandbox_publish_artifact` call whose output carries the download ticket. */
+/** A `sandbox_publish_artifact` call whose output carries a durable file reference. */
 function readSandboxArtifact(part) {
 	if (part.name !== "sandbox_publish_artifact") return void 0;
 	const path = text(part.output, "path") ?? text(part.input, "path");
-	const ticket = text(part.output, "ticket");
+	const fileId = text(part.output, "fileId");
 	return {
 		toolCallId: part.id,
 		path: path ?? "",
 		label: sandboxPathLabel(part) ?? path ?? "",
 		mimeType: text(part.output, "mimeType"),
 		size: count(part.output, "size"),
-		ticket,
-		published: ticket !== void 0 && sandboxRefusal(part) === void 0
+		fileId,
+		published: fileId !== void 0 && sandboxRefusal(part) === void 0
 	};
 }
 /** A `sandbox_run_command` call. `stdout` holds combined output on providers with no stderr. */
@@ -9627,6 +10823,10 @@ function projectThreadMessages(records, pendingInteractions = [], liveToolMessag
 				const call = calls.get(savedToolCallId(message.source_assistant_message_id, message.source_tool_part_id, message.response_target_id));
 				if (!call) continue;
 				call.output = part.output ?? null;
+				if (call.name === "sandbox_publish_artifact") {
+					call.artifactMessageId = message.id;
+					call.artifactPartId = String(part.id);
+				}
 				Object.assign(call, { resultOutcome: part.outcome });
 				call.state = part.outcome === "succeeded" ? "complete" : "error";
 			}
@@ -9634,7 +10834,12 @@ function projectThreadMessages(records, pendingInteractions = [], liveToolMessag
 		}
 		const parts = message.parts.flatMap((part) => {
 			const source = part.source;
-			if ((part.type === "image" || part.type === "document") && source && typeof source === "object" && !Array.isArray(source) && "type" in source && source.type === "attachment") return [{
+			if (typeof part.type === "string" && [
+				"image",
+				"document",
+				"audio",
+				"video"
+			].includes(part.type) && source && typeof source === "object" && !Array.isArray(source) && "type" in source && source.type === "attachment") return [{
 				...part,
 				source: {
 					...source,
@@ -9644,6 +10849,7 @@ function projectThreadMessages(records, pendingInteractions = [], liveToolMessag
 				savedAttachmentId: part.id
 			}];
 			if (part.type !== "tool-call") return [part];
+			if (part.executionLocation === "provider") return [part];
 			const toolCallId = String(part.toolCallId);
 			const targets = Array.isArray(part.targets) ? part.targets.flatMap((target) => target && typeof target === "object" && !Array.isArray(target) && "id" in target && typeof target.id === "string" ? [target.id] : []) : pendingInteractions.filter((pending) => pending.sourceMessageId === message.id && pending.sourcePartId === part.id).map((pending) => pending.responseTargetId);
 			return (targets.length ? targets : [void 0]).map((responseTargetId) => {
@@ -9714,6 +10920,7 @@ function createAstralBeamChat(options, deferStart = false) {
 		capabilities: { attachments: true },
 		agentTools: [],
 		sandboxStatus: void 0,
+		usageLimitReached: void 0,
 		sandbox: {
 			files: [],
 			commands: []
@@ -9764,6 +10971,14 @@ function createAstralBeamChat(options, deferStart = false) {
 		} });
 		pendingSend.callbacks?.onAccepted?.();
 	};
+	const replaceAcceptedMessage = (record) => {
+		const messages = [...client.getMessages()];
+		const index = messages.findLastIndex((message) => message.role === "user");
+		if (index !== -1) {
+			messages[index] = projectThreadMessages([record])[0];
+			client.setMessagesManually(messages);
+		}
+	};
 	const liveToolCalls = /* @__PURE__ */ new Set();
 	const liveToolMessageIds = /* @__PURE__ */ new Map();
 	const historicalToolIds = /* @__PURE__ */ new Map();
@@ -9793,17 +11008,19 @@ function createAstralBeamChat(options, deferStart = false) {
 			error: failure,
 			status: "error"
 		});
-		live.streamCallbacks?.onError?.(failure);
+		if (state.auth.status !== "error" || state.auth.error !== failure) live.streamCallbacks?.onError?.(failure);
 	};
-	const requestOptions = async () => {
+	const requestOptions = async (conversation = true) => {
 		const generation = selectionGeneration;
+		const authSignal = authentication.session.abortController.signal;
 		const token = await getValidChatAuthToken(authentication);
-		if (generation !== selectionGeneration) throw new DOMException("Conversation changed", "AbortError");
+		authSignal.throwIfAborted();
+		if (conversation && generation !== selectionGeneration) throw new DOMException("Conversation changed", "AbortError");
 		return {
 			apiUrl: authentication.apiUrl,
 			astralBeamToken: token,
 			cache: "no-store",
-			signal: AbortSignal.any([requestController.signal, authentication.session.abortController.signal]),
+			signal: conversation ? AbortSignal.any([requestController.signal, authSignal]) : authSignal,
 			fetchClient: (input, init) => fetchAuthenticatedChat({
 				...authentication,
 				input,
@@ -10007,6 +11224,11 @@ function createAstralBeamChat(options, deferStart = false) {
 			headers,
 			body: JSON.stringify(payload)
 		}).catch((error) => {
+			const limit = isAstralBeamApiError(error) ? error.body?.usage_limit : void 0;
+			if (limit) update({ usageLimitReached: {
+				name: limit.name,
+				resetsAt: limit.resets_at
+			} });
 			if (submission && !previouslyAttempted && isAstralBeamApiError(error) && (error.status === 400 || error.status === 413 || error.status === 429)) delete submission.tools;
 			throw error;
 		});
@@ -10014,11 +11236,23 @@ function createAstralBeamChat(options, deferStart = false) {
 		if (response.headers.get("Content-Type")?.includes("application/json")) {
 			const receipt = await response.json();
 			if (generation !== selectionGeneration) throw new DOMException("Conversation changed", "AbortError");
-			update({ thread: {
-				...state.thread,
-				version: receipt.thread_version
-			} });
-			if (submission) acceptPendingSend();
+			update({
+				thread: {
+					...state.thread,
+					version: receipt.thread_version
+				},
+				...receipt.usage_limit ? { usageLimitReached: {
+					name: receipt.usage_limit.name,
+					resetsAt: receipt.usage_limit.resets_at
+				} } : {}
+			});
+			if (submission) {
+				const history = await loadThreadMessages(thread.id, auth, void 0, liveToolMessageIds);
+				if (generation !== selectionGeneration) throw new DOMException("Conversation changed", "AbortError");
+				const accepted = history.messages.find((message) => message.id === receipt.accepted_message_id);
+				if (accepted) replaceAcceptedMessage(accepted);
+				acceptPendingSend();
+			}
 			return new Response("", { headers: { "Content-Type": "text/event-stream" } });
 		}
 		return response;
@@ -10143,6 +11377,11 @@ function createAstralBeamChat(options, deferStart = false) {
 			onMessagesChange: (messages) => {
 				if (client !== next || generation !== selectionGeneration) return;
 				restoreCompletedWidgets(messages);
+				for (const message of messages) {
+					if (message.role !== "user") continue;
+					const saved = state.messages.find((previous) => previous.id === message.id);
+					if (saved?.parts.some((part) => "savedAttachmentId" in part)) message.parts = saved.parts;
+				}
 				update({
 					messages,
 					sandbox: collectSandboxActivity(messages),
@@ -10152,7 +11391,8 @@ function createAstralBeamChat(options, deferStart = false) {
 			onStatusChange: (status) => {
 				if (client === next && generation === selectionGeneration) update({
 					status,
-					error: next.getError()
+					error: next.getError(),
+					...status === "submitted" ? { usageLimitReached: void 0 } : {}
 				});
 			},
 			onInterruptStateChange: (interrupts) => {
@@ -10163,6 +11403,7 @@ function createAstralBeamChat(options, deferStart = false) {
 				if (eventType === "astralbeam_thread") {
 					const event = data;
 					if (state.thread?.id === event.threadId) {
+						if (event.acceptedMessage && pendingSend && !pendingSend.accepted) replaceAcceptedMessage(event.acceptedMessage);
 						if (event.acceptedMessageId) acceptPendingSend();
 						if (event.saved) for (const id of event.executableToolCallIds ?? []) {
 							if (!liveToolCalls.has(id)) toolResults.delete(toolResultKey(id));
@@ -10179,6 +11420,14 @@ function createAstralBeamChat(options, deferStart = false) {
 					}
 					return;
 				}
+				const limit = data;
+				if (eventType === "astralbeam.usage_limit.reached" && typeof limit?.name === "string" && typeof limit.resetsAt === "string") {
+					update({ usageLimitReached: {
+						name: limit.name,
+						resetsAt: limit.resetsAt
+					} });
+					return;
+				}
 				const value = data?.state;
 				if (eventType === "astralbeam.sandbox.status" && (value === "starting" || value === "ready" || value === "error")) {
 					debug?.("sandbox", `sandbox ${value}`);
@@ -10198,7 +11447,7 @@ function createAstralBeamChat(options, deferStart = false) {
 				if (client === next) live.streamCallbacks?.onFinish?.(message);
 			},
 			onError: (error) => {
-				if (client === next) live.streamCallbacks?.onError?.(error);
+				if (client === next && (state.auth.status !== "error" || state.auth.error !== error)) live.streamCallbacks?.onError?.(error);
 			}
 		});
 		return next;
@@ -10220,7 +11469,7 @@ function createAstralBeamChat(options, deferStart = false) {
 		client.setMessagesManually(state.messages.map((message) => {
 			const aliases = /* @__PURE__ */ new Map();
 			const parts = message.parts.map((part) => {
-				if (part.type !== "tool-call") return part;
+				if (part.type !== "tool-call" || webPartMetadata(part).providerExecuted) return part;
 				const stored = part;
 				const upstreamToolCallId = stored.upstreamToolCallId ?? part.id;
 				if (liveToolMessageIds.get(upstreamToolCallId) === message.id && !isSettledToolCall(part)) return part;
@@ -10268,6 +11517,7 @@ function createAstralBeamChat(options, deferStart = false) {
 				commands: []
 			},
 			sandboxStatus: void 0,
+			usageLimitReached: void 0,
 			pendingInteractions: [],
 			threadLoadFailed: false,
 			messagesCursor: void 0,
@@ -10434,7 +11684,7 @@ function createAstralBeamChat(options, deferStart = false) {
 			});
 		}
 		scopeCompletedToolCalls();
-		if (pending && (!("tool" in result) || result.toolCallId === savedToolCallId(pending.sourceMessageId, pending.sourcePartId, pending.responseTargetId))) {
+		if (pending) {
 			replaceClient();
 			await hydration;
 			if (generation !== selectionGeneration) return;
@@ -10528,6 +11778,7 @@ function createAstralBeamChat(options, deferStart = false) {
 	};
 	const observeAuthentication = () => {
 		const auth = authenticationState(authentication);
+		const previous = state.auth;
 		if (auth.status === "ready") {
 			const nextIdentity = authenticationIdentity(auth.currentUser);
 			if (identity !== void 0 && identity !== nextIdentity) {
@@ -10553,6 +11804,7 @@ function createAstralBeamChat(options, deferStart = false) {
 			}
 		}
 		update({ auth });
+		if (auth.status === "error" && (previous.status !== "error" || previous.error !== auth.error)) live.streamCallbacks?.onError?.(auth.error);
 	};
 	const start = () => {
 		if (started) return;
@@ -10646,6 +11898,28 @@ function createAstralBeamChat(options, deferStart = false) {
 		deleteThread,
 		refreshThread,
 		loadOlderMessages,
+		uploadAttachment: async ({ data, filename, mimeType }) => {
+			const agentId = state.thread ? state.thread.agentId : live.agentId;
+			const [encoded, options] = await Promise.all([data, requestOptions(false)]);
+			return uploadChatFile({
+				...agentId ? { agentId } : {},
+				type: mimeType.startsWith("image/") ? "image" : "document",
+				source: {
+					type: "data",
+					value: encoded,
+					mimeType
+				},
+				metadata: { filename }
+			}, options);
+		},
+		getFile: async (fileId) => {
+			const thread = state.thread;
+			if (!thread) throw new Error("Open a conversation before downloading files.");
+			return (await getChatFile({
+				threadId: thread.id,
+				fileId
+			}, await requestOptions())).blob();
+		},
 		getAttachment: async (messageId, partId) => {
 			const thread = state.thread;
 			if (!thread) throw new Error("Open a conversation before downloading attachments.");