@astralbeam/sdk 0.15.2 → 0.17.0

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

@@ -1,7 +1,17 @@
-import { A as resolveApiUrl, O as astralBeamChatFetch, c as getCurrentUser, i as getChatConfig, k as isAstralBeamApiError, v as getRunChatUrl } from "./api-r11gRy91.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.0/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.0/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.0/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.63.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.63.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,19 @@ let EventType = /* @__PURE__ */ function(EventType) {
 	return EventType;
 }({});
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.63.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/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
+* bytes it holds (ag-ui-protocol/ag-ui#2884), so the id that `entityId` points
+* to says it. AG-UI clients keep message ids, but they drop event metadata.
+*/
+var REDACTED_THINKING_ID_PREFIX = "redacted_thinking-";
+function isRedactedThinkingId(id) {
+	return typeof id === "string" && id.startsWith("redacted_thinking-");
+}
+//#endregion
+//#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,
@@ -386,7 +408,7 @@ function cloneAndDeepFreezeJson(value) {
 	return clone;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.63.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);
@@ -397,7 +419,7 @@ function canonicalizeInterruptResolutions(resolutions) {
 	});
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.63.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
@@ -550,16 +572,17 @@ function makeStructuredOutputCompatible(schema, originalRequired = []) {
 *
 * - Standard JSON Schemas are rebuilt structurally (dropping `$schema`, which
 *   LLM providers ignore) and given the explicit `type`/`properties`/`required`
-*   defaults object shapes need downstream.
+*   defaults object shapes need downstream. `io` picks the `input` (default)
+*   or `output` view.
 * - Plain `JSONSchema` inputs are rebuilt into the typed view; non-object inputs
 *   are surfaced untouched (they can't be widened).
 * - Standard Schema validators lacking a `~standard.jsonSchema` converter throw
 *   with actionable guidance, rather than shipping `{ '~standard': … }` to the
 *   provider and producing an opaque downstream error.
 */
-function toTypedJsonSchema(schema) {
+function toTypedJsonSchema(schema, io = "input") {
 	if (isStandardJSONSchema(schema)) {
-		const result = toJsonSchema$2(schema["~standard"].jsonSchema.input({ target: "draft-07" }));
+		const result = toJsonSchema$2(schema["~standard"].jsonSchema[io]({ target: "draft-07" }));
 		if ("properties" in result && !result.type) result.type = "object";
 		if (result.type === "object" && !("properties" in result)) result.properties = {};
 		if (result.type === "object" && !("required" in result)) result.required = [];
@@ -631,9 +654,9 @@ function toTypedJsonSchema(schema) {
 */
 function convertSchemaToJsonSchema(schema, options = {}) {
 	if (!schema) return void 0;
-	const { forStructuredOutput = false } = options;
+	const { forStructuredOutput = false, io } = options;
 	if (!forStructuredOutput && !isStandardJSONSchema(schema) && !isStandardSchema(schema)) return schema;
-	const base = toTypedJsonSchema(schema);
+	const base = toTypedJsonSchema(schema, io);
 	if (!base || typeof base !== "object") return base;
 	if (!forStructuredOutput) return base;
 	return makeStructuredOutputCompatible(base, base.required || []).schema;
@@ -664,7 +687,7 @@ async function validateWithStandardSchema(schema, data) {
 	};
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.63.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",
@@ -776,7 +799,7 @@ function hashSchemaInput(schema) {
 	return digestInterruptJson(canonicalInterruptJson(schemaToWire(schema).jsonSchema ?? { standardValidator: "unserialized" }));
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.63.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.
@@ -897,7 +920,7 @@ function readInterruptBinding(descriptor) {
 	};
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.63.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.`);
@@ -922,7 +945,7 @@ function hashInterruptDefinitionSchema(schema) {
 	return digestInterruptJson(schemaJson(schema, "Interrupt schema").canonicalJson);
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.63.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.
 *
@@ -961,7 +984,7 @@ function genericInterruptContinuationFromDescriptor(interrupt) {
 	};
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.63.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`.
@@ -991,7 +1014,7 @@ function isAssistantSegmentOf(id, parentId) {
 	return id?.startsWith(`${parentId}-segment-`) === true;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.63.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",
@@ -1052,7 +1075,7 @@ function normalizeToolResult(result) {
 	return JSON.stringify(result);
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.63.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);
 }
@@ -1156,7 +1179,7 @@ function splitSubagentWire(messages) {
 	};
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.63.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);
 }
@@ -1184,6 +1207,10 @@ function encryptedValueFrom(value) {
 	}
 	return nonEmptyString(tanstackMetadata(value)?.signature);
 }
+/** `{ redacted: true }` when a reasoning message's id marks a redacted block. */
+function redactedFrom(value) {
+	return "id" in value && isRedactedThinkingId(value.id) ? { redacted: true } : {};
+}
 /**
 * Collapse an array of ContentParts into the most compact ModelMessage content:
 * - Empty array → null
@@ -1345,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);
 }
@@ -1456,7 +1484,8 @@ function buildAssistantMessages(uiMessage) {
 				if (current.toolCalls.some(isProviderExecutedToolCall)) flushSegment();
 				pendingThinking.push({
 					content: part.content,
-					...part.signature && { signature: part.signature }
+					...part.signature && { signature: part.signature },
+					...part.redacted && { redacted: true }
 				});
 			}
 			break;
@@ -1473,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 !== "") {
@@ -1538,7 +1568,8 @@ function modelMessageToUIMessage(modelMessage, id) {
 		parts.push({
 			type: "thinking",
 			content: thinking.content,
-			...thinking.signature && { signature: thinking.signature }
+			...thinking.signature && { signature: thinking.signature },
+			...thinking.redacted && { redacted: true }
 		});
 	}
 	const structuredOutput = modelMessage.structuredOutput ?? snapshotStructuredOutput(tanstackMetadata(modelMessage)?.structuredOutput);
@@ -1683,10 +1714,20 @@ function aguiSnapshotMessageToUIMessage(message) {
 				parts: content || signature !== void 0 ? [{
 					type: "thinking",
 					content,
-					...signature !== void 0 ? { signature } : {}
+					...signature !== void 0 ? { signature } : {},
+					...redactedFrom(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",
@@ -1732,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.
@@ -1798,7 +1847,7 @@ function generateMessageId() {
 	return `msg-${Date.now()}-${Math.random().toString(36).substring(7)}`;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.63.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);
 }
@@ -1829,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);
@@ -2081,7 +2150,8 @@ function collectToolCalls(parts) {
 	return calls.length > 0 ? calls : void 0;
 }
 function deriveReasoningId(messageId, part) {
-	return `${messageId}-reasoning-${part.id ?? hashContent(part.content)}`;
+	const id = `${messageId}-reasoning-${part.id ?? hashContent(part.content)}`;
+	return part.type === "thinking" && part.redacted ? `${REDACTED_THINKING_ID_PREFIX}${id}` : id;
 }
 function deriveToolMessageId(toolCallId) {
 	return `tool-${toolCallId}`;
@@ -2111,7 +2181,7 @@ function hashContent(s) {
 	return Math.abs(h).toString(36);
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.63.0/node_modules/@tanstack/ai/dist/esm/utilities/restore-inbound-chunk.js
+//#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
@@ -2148,7 +2218,7 @@ function restoreInboundChunk(chunk) {
 	return next;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.63.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
 *
@@ -2246,7 +2316,7 @@ function toolDefinition(config) {
 	};
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.63.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;
 }
@@ -2349,7 +2419,7 @@ var require_options = /* @__PURE__ */ __commonJSMin(((exports) => {
 	exports.default = exports.Allow;
 }));
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.63.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;
@@ -2571,7 +2641,7 @@ function parsePartialJSON(jsonString) {
 	return defaultJSONParser.parse(jsonString);
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.63.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)
 */
@@ -2581,7 +2651,7 @@ var ImmediateStrategy = class {
 	}
 };
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.63.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
@@ -2595,7 +2665,730 @@ function runErrorEventToError(chunk) {
 	return error;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.63.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)
 *
@@ -2880,11 +3673,13 @@ function updateThinkingPart(messages, messageId, stepId, content, signature) {
 			if (candidate?.type === "thinking") adopted = candidate;
 		}
 		const nextSignature = signature ?? adopted?.signature;
+		const redacted = isRedactedThinkingId(stepId) || adopted?.redacted === true;
 		const thinkingPart = {
 			type: "thinking",
 			content,
 			stepId,
-			...nextSignature && { signature: nextSignature }
+			...nextSignature && { signature: nextSignature },
+			...redacted && { redacted: true }
 		};
 		if (thinkingPartIndex >= 0) parts[thinkingPartIndex] = thinkingPart;
 		else parts.push(thinkingPart);
@@ -2895,7 +3690,7 @@ function updateThinkingPart(messages, messageId, stepId, content, signature) {
 	});
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.63.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
 *
@@ -2916,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;
@@ -2941,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.
@@ -2967,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;
@@ -3176,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();
@@ -3196,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
 	*/
@@ -3207,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);
@@ -3266,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
+			}];
 		}
 	}
 	/**
@@ -3343,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) {
@@ -3354,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) {
@@ -3367,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;
@@ -3392,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 {
@@ -3562,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;
@@ -3572,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) {
@@ -3580,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);
@@ -3618,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;
@@ -3632,6 +4657,7 @@ var StreamProcessor = class StreamProcessor {
 				existingState.lastEmittedText = "";
 				existingState.hasToolCallsSinceTextStart = false;
 			}
+			this.applySenderName(messageId, chunk.name);
 			this.mergeMessageMetadata(messageId, chunk.metadata);
 			return;
 		}
@@ -3644,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
 	*/
@@ -3677,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
@@ -3900,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)) {
@@ -3943,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)) {
@@ -3962,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,
@@ -3995,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);
@@ -4002,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);
@@ -4079,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);
 	}
 	/**
@@ -4099,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.
@@ -4145,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,
@@ -4205,10 +5317,28 @@ var StreamProcessor = class StreamProcessor {
 		this.pendingThinkingStepId = stepId;
 	}
 	/**
-	* Handle STEP_FINISHED event.
-	*
-	* Thinking *content* comes from REASONING_MESSAGE_CONTENT, not STEP_FINISHED.
-	* But some adapters (e.g. BytePlus thinking-summary) carry the provider
+	* 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.
+	* But some adapters (e.g. BytePlus thinking-summary) carry the provider
 	* signature blob ONLY on the STEP_FINISHED event, so still extract that here
 	* and attach it to the thinking step the reasoning events already built.
 	*/
@@ -4233,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);
@@ -4345,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,
@@ -4523,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);
@@ -4640,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;
@@ -4679,14 +5814,14 @@ function createReplayStream(recording) {
 	} };
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.63.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.63.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;
@@ -4699,7 +5834,7 @@ function isByokMissingBody(value) {
 	return true;
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai@0.63.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) {
@@ -4725,7 +5860,7 @@ var ByokUnresolvedProviderError = class extends Error {
 	}
 };
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.36.0/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
@@ -4918,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();
 	}
 }
@@ -5420,7 +6558,7 @@ async function* abortableIterable(iterable, signal) {
 	}
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.36.0/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;
 }
@@ -6362,7 +7500,7 @@ var InterruptManager = class {
 	}
 };
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.36.0/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.
@@ -6375,7 +7513,7 @@ function byokFallbackProviderId(byok) {
 	if (registered.length === 1) return registered[0];
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.36.0/node_modules/@tanstack/ai-client/dist/esm/byok/resolve.js
+//#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;
@@ -6391,7 +7529,7 @@ async function prepareResolvedByokHeaders(byok, provider) {
 	return byok.headers(provider);
 }
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.36.0/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
 */
@@ -6565,7 +7703,7 @@ var ChatClientEventEmitter = class {
 	}
 };
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.36.0/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() {}
 };
@@ -6610,7 +7748,7 @@ var NoOpChatDevtoolsBridge = class {
 };
 var createNoOpChatDevtoolsBridge = (options) => new NoOpChatDevtoolsBridge(options);
 //#endregion
-//#region node_modules/.deno/@tanstack+ai-client@0.36.0/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 };
@@ -6709,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;
@@ -6870,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.0/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;
 }
@@ -6963,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.0/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;
@@ -7103,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"
 ]);
@@ -7208,6 +8350,7 @@ var ChatClient = class {
 	currentMessageId = null;
 	postStreamActions = [];
 	pendingToolExecutions = /* @__PURE__ */ new Map();
+	handingOverPendingToolCalls = false;
 	activeClientTools = null;
 	activeContext = void 0;
 	continuationPending = false;
@@ -7233,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;
@@ -7287,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 || (() => {}),
@@ -7368,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();
@@ -7414,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.
@@ -7519,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) {
@@ -7555,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
@@ -7824,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;
@@ -7840,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;
@@ -8105,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);
@@ -8328,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();
@@ -8544,6 +9745,7 @@ var ChatClient = class {
 		this.persistor?.beginClear();
 		this.processor.clearMessages();
 		this.resetHistoryPaging();
+		this.supersedeHydration();
 		this.discardPendingSends();
 		this.persistor?.remove();
 		this.stoppedSubagentIds.clear();
@@ -8802,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
@@ -8933,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() {
@@ -8983,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;
@@ -9043,16 +10256,11 @@ function toJsonSchema(parameters) {
 		properties: {}
 	};
 	if (!("~standard" in parameters)) return parameters;
-	try {
-		return convertSchemaToJsonSchema(parameters);
-	} catch {
-		return { type: "object" };
-	}
+	return "jsonSchema" in parameters["~standard"] ? convertSchemaToJsonSchema(parameters) : { type: "object" };
 }
 async function validateParameters(parameters, input) {
-	if (!parameters || !("~standard" in parameters)) return input;
-	const result = await parameters["~standard"].validate(input);
-	return result.issues ? null : result.value ?? {};
+	const result = await validateWithStandardSchema(parameters, input);
+	return result.success ? result.data ?? {} : null;
 }
 //#endregion
 //#region src/core/agent-tools.ts
@@ -9314,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",
@@ -9445,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,
@@ -9495,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. */
@@ -9558,9 +10772,126 @@ function describeSandboxCommandRun(run) {
 	return parts.join(" · ");
 }
 //#endregion
+//#region src/core/threads.ts
+function newUuid() {
+	const bytes = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(16));
+	bytes[6] = bytes[6] & 15 | 64;
+	bytes[8] = bytes[8] & 63 | 128;
+	const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function threadFromRecord(record, hasMessages = true) {
+	return {
+		id: record.id,
+		title: record.title,
+		agentId: record.agent_id,
+		version: record.version,
+		role: record.role,
+		writerActive: record.writer_active,
+		hasMessages,
+		updatedAt: record.updated_at
+	};
+}
+function savedToolCallId(messageId, partId, targetId) {
+	return `saved:${messageId}:${partId}${targetId ? `:${targetId}` : ""}`;
+}
+async function loadThreadMessages(id, options, pageAfter, liveToolMessageIds = /* @__PURE__ */ new Map()) {
+	const page = await listChatMessages(id, {
+		page_size: 100,
+		...pageAfter ? { page_after: pageAfter } : {}
+	}, options);
+	const pendingInteractions = page.pending_interactions.map((pending) => ({
+		sourceMessageId: pending.source_message_id,
+		sourcePartId: pending.source_part_id,
+		responseTargetId: pending.response_target_id,
+		toolCallId: liveToolMessageIds.get(pending.tool_call_id) === pending.source_message_id ? pending.tool_call_id : savedToolCallId(pending.source_message_id, pending.source_part_id, pending.response_target_id),
+		targetTenantUserId: pending.target_tenant_user_id,
+		targetClientId: pending.target_client_id,
+		executionLocation: pending.execution_location
+	}));
+	return {
+		...page,
+		pendingInteractions
+	};
+}
+function projectThreadMessages(records, pendingInteractions = [], liveToolMessageIds = /* @__PURE__ */ new Map()) {
+	const messages = [];
+	const calls = /* @__PURE__ */ new Map();
+	for (const message of records) {
+		if (message.role === "tool") {
+			for (const part of message.parts) {
+				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";
+			}
+			continue;
+		}
+		const parts = message.parts.flatMap((part) => {
+			const source = part.source;
+			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,
+					type: "url",
+					value: ""
+				},
+				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) => {
+				const savedId = savedToolCallId(message.id, String(part.id), responseTargetId);
+				const call = {
+					...part,
+					id: liveToolMessageIds.get(toolCallId) === message.id ? toolCallId : savedId,
+					upstreamToolCallId: toolCallId,
+					applicationPartId: part.id,
+					sourceMessageId: message.id,
+					responseTargetId
+				};
+				calls.set(savedId, call);
+				return call;
+			});
+		});
+		messages.push({
+			id: message.id,
+			role: message.role,
+			parts,
+			createdAt: new Date(message.created_at),
+			metadata: { astralbeam: {
+				state: message.state,
+				authorTenantUserId: message.author_tenant_user_id
+			} }
+		});
+	}
+	return messages;
+}
+/** Cache selection within this tab. Stored IDs are reauthorized before loading history. */
+function selectedThread(key, id) {
+	try {
+		if (id === void 0) return globalThis.sessionStorage?.getItem(key) ?? void 0;
+		if (id === null) globalThis.sessionStorage?.removeItem(key);
+		else globalThis.sessionStorage?.setItem(key, id);
+	} catch {}
+}
+//#endregion
 //#region src/core/session.ts
 const CORE_OPTION_KEYS = Object.keys({
 	agentId: true,
+	threadId: true,
 	apiUrl: true,
 	fetchAstralBeamToken: true,
 	tools: true,
@@ -9589,10 +10920,19 @@ function createAstralBeamChat(options, deferStart = false) {
 		capabilities: { attachments: true },
 		agentTools: [],
 		sandboxStatus: void 0,
+		usageLimitReached: void 0,
 		sandbox: {
 			files: [],
 			commands: []
-		}
+		},
+		thread: void 0,
+		threadLoading: false,
+		threadLoadFailed: false,
+		messagesCursor: void 0,
+		olderMessagesLoading: false,
+		unsentMessage: void 0,
+		activeToolCallIds: [],
+		pendingInteractions: []
 	};
 	const update = (next) => {
 		state = {
@@ -9610,24 +10950,99 @@ function createAstralBeamChat(options, deferStart = false) {
 	let unsubscribeAuthentication;
 	let identity;
 	let started = false;
+	let selectionGeneration = 0;
+	let navigationGeneration = 0;
+	let historyGeneration = 0;
+	let hydration = Promise.resolve();
+	let requestController = new AbortController();
+	let threadKey;
+	let startWithNewThread = false;
+	let threadRecords = [];
+	const clientId = newUuid();
+	let pendingSend;
+	let sending = false;
+	const pendingSends = /* @__PURE__ */ new Map();
+	const acceptPendingSend = () => {
+		if (!pendingSend || pendingSend.accepted) return;
+		pendingSend.accepted = true;
+		if (state.thread) update({ thread: {
+			...state.thread,
+			hasMessages: true
+		} });
+		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();
+	let toolResults = /* @__PURE__ */ new Map();
+	const threadToolResults = /* @__PURE__ */ new Map();
+	const toolResultKey = (id) => {
+		const messageId = liveToolMessageIds.get(id);
+		return messageId ? `live:${messageId}:${id}` : id;
+	};
+	const retainToolResults = (history) => {
+		const retained = /* @__PURE__ */ new Map();
+		for (const pending of history.pending_interactions) {
+			const nativeKey = `live:${pending.source_message_id}:${pending.tool_call_id}`;
+			const savedKey = savedToolCallId(pending.source_message_id, pending.source_part_id, pending.response_target_id);
+			const result = toolResults.get(nativeKey) ?? toolResults.get(savedKey);
+			if (!result) continue;
+			retained.set(savedKey, result);
+			if (liveToolMessageIds.get(pending.tool_call_id) === pending.source_message_id) retained.set(nativeKey, result);
+		}
+		toolResults.clear();
+		for (const [id, result] of retained) toolResults.set(id, result);
+	};
+	const reportError = (error) => {
+		if (error instanceof Error && error.name === "AbortError") return;
+		const failure = error instanceof Error ? error : new Error(String(error));
+		update({
+			error: failure,
+			status: "error"
+		});
+		if (state.auth.status !== "error" || state.auth.error !== failure) live.streamCallbacks?.onError?.(failure);
+	};
+	const requestOptions = async (conversation = true) => {
+		const generation = selectionGeneration;
+		const authSignal = authentication.session.abortController.signal;
+		const token = await getValidChatAuthToken(authentication);
+		authSignal.throwIfAborted();
+		if (conversation && generation !== selectionGeneration) throw new DOMException("Conversation changed", "AbortError");
+		return {
+			apiUrl: authentication.apiUrl,
+			astralBeamToken: token,
+			cache: "no-store",
+			signal: conversation ? AbortSignal.any([requestController.signal, authSignal]) : authSignal,
+			fetchClient: (input, init) => fetchAuthenticatedChat({
+				...authentication,
+				input,
+				init
+			})
+		};
+	};
 	let capabilitiesGeneration = 0;
 	let capabilityIdentity;
 	const resolveCapabilities = async () => {
 		const generation = ++capabilitiesGeneration;
+		const selection = selectionGeneration;
+		if (state.thread?.agentId === null) {
+			update({ capabilities: { attachments: false } });
+			return;
+		}
+		const agentId = state.thread ? state.thread.agentId : live.agentId;
 		try {
-			const token = await getValidChatAuthToken(authentication);
-			if (generation !== capabilitiesGeneration) return;
-			const body = await getChatConfig(live.agentId ? { agentId: live.agentId } : {}, {
-				apiUrl: authentication.apiUrl,
-				astralBeamToken: token,
-				signal: authentication.session.abortController.signal,
-				fetchClient: (input, init) => fetchAuthenticatedChat({
-					...authentication,
-					input,
-					init
-				})
-			});
-			if (generation !== capabilitiesGeneration) return;
+			const auth = await requestOptions();
+			if (generation !== capabilitiesGeneration || selection !== selectionGeneration) return;
+			const body = await getChatConfig(agentId ? { agentId } : {}, auth);
+			if (generation !== capabilitiesGeneration || selection !== selectionGeneration) return;
 			const attachments = body.capabilities?.attachments !== false;
 			update({ capabilities: { attachments } });
 			debug?.("mount", "agent capabilities resolved", { attachments });
@@ -9636,23 +11051,38 @@ function createAstralBeamChat(options, deferStart = false) {
 		}
 	};
 	const renderCleanups = /* @__PURE__ */ new Map();
+	const restoredWidgets = /* @__PURE__ */ new Set();
+	const restoringWidgets = /* @__PURE__ */ new Set();
 	const disposeRenders = () => {
 		for (const cleanup of renderCleanups.values()) cleanup();
 		renderCleanups.clear();
+		restoredWidgets.clear();
+		restoringWidgets.clear();
 	};
 	const renderWidget = async (input, toolCallId) => {
+		const generation = selectionGeneration;
 		const widgets = live.widgets ?? {};
 		if (!Object.hasOwn(widgets, input.widget)) throw new Error(`Unknown widget "${input.widget}"`);
 		const declaration = widgets[input.widget];
 		const validated = await validateParameters(declaration?.parameters, input.props ?? {});
+		if (generation !== selectionGeneration || state.thread?.role === "viewer") return {
+			widget: input.widget,
+			rendered: false
+		};
+		if (declaration !== live.widgets?.[input.widget]) return renderWidget(input, toolCallId);
 		if (validated == null) throw new Error(`Props for widget "${input.widget}" failed validation`);
+		const onRenderWidget = live.onRenderWidget;
+		if (!onRenderWidget) return {
+			widget: input.widget,
+			rendered: false
+		};
 		renderCleanups.get(toolCallId)?.();
 		renderCleanups.delete(toolCallId);
 		let registered;
 		const release = () => {
 			if (renderCleanups.get(toolCallId) === registered) renderCleanups.delete(toolCallId);
 		};
-		const cleanup = live.onRenderWidget?.({
+		const cleanup = onRenderWidget({
 			widget: input.widget,
 			props: validated,
 			toolCallId,
@@ -9662,12 +11092,68 @@ function createAstralBeamChat(options, deferStart = false) {
 			registered = cleanup;
 			renderCleanups.set(toolCallId, cleanup);
 		}
+		restoredWidgets.add(toolCallId);
 		return {
 			widget: input.widget,
-			rendered: live.onRenderWidget !== void 0
+			rendered: true
 		};
 	};
-	const buildTools = () => buildAgentTools(live.widgets ?? {}, live.tools ?? {}, renderWidget, debug);
+	const restoreCompletedWidgets = (messages) => {
+		if (state.thread?.role === "viewer") return;
+		const renderIds = /* @__PURE__ */ new Map();
+		for (const message of state.messages) for (const part of message.parts) {
+			if (part.type !== "tool-call" || part.name !== "render_widget") continue;
+			const stored = part;
+			if (!stored.widgetRenderId) continue;
+			renderIds.set(savedToolCallId(message.id, part.id), stored.widgetRenderId);
+			if (stored.applicationPartId) renderIds.set(savedToolCallId(message.id, stored.applicationPartId, stored.responseTargetId), stored.widgetRenderId);
+		}
+		for (const message of messages) for (const part of message.parts) {
+			if (part.type !== "tool-call" || part.name !== "render_widget" || part.state !== "complete" || !part.input) continue;
+			const stored = part;
+			const upstream = stored.upstreamToolCallId;
+			const renderId = stored.widgetRenderId ?? renderIds.get(savedToolCallId(message.id, part.id)) ?? (stored.applicationPartId ? renderIds.get(savedToolCallId(message.id, stored.applicationPartId, stored.responseTargetId)) : void 0) ?? (upstream && liveToolMessageIds.get(upstream) === message.id && restoredWidgets.has(upstream) ? upstream : part.id);
+			stored.widgetRenderId = renderId;
+			if (restoredWidgets.has(renderId) || restoringWidgets.has(renderId)) continue;
+			restoringWidgets.add(renderId);
+			const generation = selectionGeneration;
+			const { widgets, onRenderWidget } = live;
+			renderWidget(part.input, renderId).catch((error) => debug?.("error", "Saved widget could not be rendered", error)).finally(() => {
+				if (generation !== selectionGeneration) return;
+				restoringWidgets.delete(renderId);
+				if (widgets !== live.widgets || onRenderWidget !== live.onRenderWidget) restoreCompletedWidgets(state.messages);
+			});
+		}
+	};
+	const buildTools = () => buildAgentTools(live.widgets ?? {}, live.tools ?? {}, renderWidget, debug).map((tool) => {
+		if (!tool.execute) return tool;
+		const execute = tool.execute;
+		return {
+			...tool,
+			execute: async (input, context) => {
+				const toolCallId = context?.toolCallId;
+				if (!toolCallId || !liveToolCalls.has(toolCallId)) throw new Error("A saved tool call cannot execute again. Send a new message to request it.");
+				const results = toolResults;
+				const key = toolResultKey(toolCallId);
+				const resultIdentity = identity;
+				const apiUrl = authentication.apiUrl;
+				try {
+					const output = await execute(input, context);
+					if (identity === resultIdentity && authentication.apiUrl === apiUrl) results.set(key, {
+						outcome: "succeeded",
+						output: output ?? null
+					});
+					return output;
+				} catch (error) {
+					if (identity === resultIdentity && authentication.apiUrl === apiUrl) results.set(key, {
+						outcome: "unknown",
+						output: { error: error instanceof Error ? error.message : String(error) }
+					});
+					throw error;
+				}
+			}
+		};
+	});
 	const declareTools = () => {
 		const tools = buildTools();
 		const agentTools = tools.map((tool) => {
@@ -9680,40 +11166,222 @@ function createAstralBeamChat(options, deferStart = false) {
 		if (!sameAgentTools(state.agentTools, agentTools)) update({ agentTools });
 		return tools;
 	};
-	const forwardedProps = () => ({
-		...live.agentId ? { agentId: live.agentId } : {},
-		...live.debug ? { debug: true } : {}
-	});
+	const forwardedProps = () => live.debug ? { debug: true } : {};
+	const threadRequest = async (init, auth) => {
+		const thread = state.thread;
+		if (!thread || typeof init.body !== "string") throw new Error("Open a conversation before sending.");
+		const generation = selectionGeneration;
+		const body = JSON.parse(init.body);
+		let path = getRunChatUrl();
+		let payload;
+		const submission = body.messages.at(-1)?.role === "user" ? pendingSend : void 0;
+		const previouslyAttempted = submission?.tools !== void 0;
+		if (submission) payload = {
+			...body,
+			threadId: thread.id,
+			resume: void 0,
+			parentRunId: void 0,
+			messages: [body.messages.at(-1)],
+			tools: submission.tools ??= body.tools,
+			forwardedProps: {
+				...body.forwardedProps,
+				clientId
+			}
+		};
+		else {
+			scopeCompletedToolCalls();
+			const history = await loadThreadMessages(thread.id, auth, void 0, liveToolMessageIds);
+			if (generation !== selectionGeneration) throw new DOMException("Conversation changed", "AbortError");
+			update({ thread: threadFromRecord(history.thread, history.messages.length > 0) });
+			retainToolResults(history);
+			const available = history.pendingInteractions.filter((pending) => toolResults.has(toolResultKey(pending.toolCallId)));
+			const source = available.find((pending) => pending.toolCallId === body.messages.at(-1)?.toolCallId) ?? available[0];
+			const results = history.pendingInteractions.flatMap((pending) => {
+				const submitted = toolResults.get(toolResultKey(pending.toolCallId));
+				return submitted && pending.sourceMessageId === source?.sourceMessageId ? [{
+					source_message_id: pending.sourceMessageId,
+					source_part_id: pending.sourcePartId,
+					response_target_id: pending.responseTargetId,
+					...submitted
+				}] : [];
+			});
+			if (results.length === 0) return new Response("", { headers: { "Content-Type": "text/event-stream" } });
+			path = getResolveChatToolResultUrl(thread.id);
+			payload = {
+				client_id: clientId,
+				run_id: body.runId,
+				...body.parentRunId ? { parent_run_id: body.parentRunId } : {},
+				results
+			};
+		}
+		liveToolCalls.clear();
+		update({ activeToolCallIds: [] });
+		const headers = new Headers(init.headers);
+		if (submission) headers.set("Idempotency-Key", submission.key);
+		const response = await astralBeamChatFetch(path, {
+			...auth,
+			...init,
+			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;
+		});
+		if (generation !== selectionGeneration) throw new DOMException("Conversation changed", "AbortError");
+		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
+				},
+				...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;
+	};
 	const connection = fetchServerSentEvents(() => resolveApiUrl(getRunChatUrl(), authentication.apiUrl), async () => {
 		const previousIdentity = identity;
 		const token = await getValidChatAuthToken(authentication);
 		if (previousIdentity !== void 0 && previousIdentity !== identity) throw new DOMException("Identity changed", "AbortError");
-		return { fetchClient: (_input, init) => astralBeamChatFetch(getRunChatUrl(), {
-			...init,
-			apiUrl: authentication.apiUrl,
-			astralBeamToken: token,
-			fetchClient: (input, request) => fetchAuthenticatedChat({
-				...authentication,
-				input,
-				init: request
-			})
-		}) };
+		return { fetchClient: (_input, init) => {
+			const auth = {
+				apiUrl: authentication.apiUrl,
+				astralBeamToken: token,
+				...init?.signal ? { signal: init.signal } : {},
+				cache: "no-store",
+				fetchClient: (input, request) => fetchAuthenticatedChat({
+					...authentication,
+					input,
+					init: request
+				})
+			};
+			return threadRequest(init ?? {}, auth);
+		} };
 	});
 	const connect = connection.connect;
 	connection.connect = async function* (...args) {
 		try {
-			yield* connect(...args);
+			for await (const chunk of connect(...args)) {
+				if (chunk.type === EventType.TOOL_CALL_START && chunk.parentMessageId) liveToolMessageIds.set(chunk.toolCallId, chunk.parentMessageId);
+				if (chunk.type !== EventType.MESSAGES_SNAPSHOT) {
+					yield chunk;
+					continue;
+				}
+				let aliases;
+				yield {
+					...chunk,
+					messages: chunk.messages.map((message) => {
+						if (message.role === "assistant") {
+							aliases = historicalToolIds.get(message.id);
+							return aliases && message.toolCalls ? {
+								...message,
+								toolCalls: message.toolCalls.map((call) => ({
+									...call,
+									id: aliases?.get(call.id) ?? call.id
+								}))
+							} : message;
+						}
+						if (message.role === "tool") return {
+							...message,
+							toolCallId: aliases?.get(message.toolCallId) ?? message.toolCallId
+						};
+						aliases = void 0;
+						return message;
+					})
+				};
+			}
 		} catch (error) {
 			throw error instanceof Error && isAstralBeamApiError(error.cause) ? error.cause : error;
 		}
 	};
-	const createClient = () => {
+	const createClient = (threadId = state.thread?.id) => {
+		const generation = selectionGeneration;
+		const adapter = { ...connection };
+		delete adapter.hydrate;
+		if (threadId) adapter.hydrate = (_id, options) => {
+			const readGeneration = ++historyGeneration;
+			if (!options?.before) update({ threadLoading: true });
+			const read = (async () => {
+				let history = await loadThreadMessages(threadId, await requestOptions(), options?.before, liveToolMessageIds);
+				while (options?.before && history.messages.every((message) => message.role === "tool") && history.page_after) {
+					const earlier = await loadThreadMessages(threadId, await requestOptions(), history.page_after, liveToolMessageIds);
+					history = {
+						...earlier,
+						messages: [...earlier.messages, ...history.messages]
+					};
+				}
+				if (generation !== selectionGeneration || readGeneration !== historyGeneration) throw new DOMException("Conversation changed", "AbortError");
+				retainToolResults(history);
+				threadRecords = options?.before ? [...history.messages, ...threadRecords] : history.messages;
+				const pageIds = new Set(history.messages.map((message) => message.id));
+				const messages = projectThreadMessages(threadRecords, history.pendingInteractions, liveToolMessageIds).filter((message) => pageIds.has(message.id));
+				if (history.thread.role === "viewer") disposeRenders();
+				const agentChanged = state.thread?.agentId !== history.thread.agent_id;
+				update({
+					thread: threadFromRecord(history.thread, history.messages.length > 0),
+					messagesCursor: history.page_after ?? void 0,
+					pendingInteractions: history.pendingInteractions,
+					threadLoadFailed: false
+				});
+				restoreCompletedWidgets(messages);
+				if (!options?.before && agentChanged) resolveCapabilities();
+				if (!options?.before && messages.length === 0) next.setMessagesManually([]);
+				return {
+					messages,
+					activeRun: null,
+					interrupts: null,
+					page: history.page_after ? {
+						truncated: true,
+						cursor: history.page_after
+					} : { truncated: false }
+				};
+			})();
+			if (!options?.before) {
+				hydration = read;
+				const settled = (failed) => queueMicrotask(() => {
+					if (generation === selectionGeneration && readGeneration === historyGeneration) update({
+						threadLoading: false,
+						threadLoadFailed: failed
+					});
+				});
+				read.then(() => settled(false), () => settled(true));
+			}
+			return read;
+		};
 		const next = new ChatClient({
-			connection,
+			connection: adapter,
+			threadId: threadId ?? clientId,
+			persistence: true,
+			history: { pageSize: 100 },
+			queue: "drop",
 			tools: declareTools(),
 			forwardedProps: forwardedProps(),
 			onMessagesChange: (messages) => {
-				if (client !== next) return;
+				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),
@@ -9721,13 +11389,45 @@ function createAstralBeamChat(options, deferStart = false) {
 				});
 			},
 			onStatusChange: (status) => {
-				if (client === next) update({
+				if (client === next && generation === selectionGeneration) update({
 					status,
-					error: next.getError()
+					error: next.getError(),
+					...status === "submitted" ? { usageLimitReached: void 0 } : {}
 				});
 			},
+			onInterruptStateChange: (interrupts) => {
+				if (client === next) debug?.("tool", "interrupt state changed", interrupts);
+			},
 			onCustomEvent: (eventType, data) => {
 				if (client !== next) return;
+				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));
+							liveToolCalls.add(id);
+						}
+						update({
+							thread: {
+								...state.thread,
+								version: event.version
+							},
+							activeToolCallIds: [...liveToolCalls],
+							...event.acceptedMessageId ? { unsentMessage: void 0 } : {}
+						});
+					}
+					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}`);
@@ -9736,72 +11436,381 @@ function createAstralBeamChat(options, deferStart = false) {
 				}
 				debug?.("stream", `custom event "${eventType}"`, data);
 			},
-			onChunk: (chunk) => live.streamCallbacks?.onChunk?.(chunk),
-			onResponse: (response) => live.streamCallbacks?.onResponse?.(response),
-			onFinish: (message) => live.streamCallbacks?.onFinish?.(message),
-			onError: (error) => live.streamCallbacks?.onError?.(error)
+			onChunk: (chunk) => {
+				if (client !== next) return;
+				live.streamCallbacks?.onChunk?.(chunk);
+			},
+			onResponse: (response) => {
+				if (client === next) live.streamCallbacks?.onResponse?.(response);
+			},
+			onFinish: (message) => {
+				if (client === next) live.streamCallbacks?.onFinish?.(message);
+			},
+			onError: (error) => {
+				if (client === next && (state.auth.status !== "error" || state.auth.error !== error)) live.streamCallbacks?.onError?.(error);
+			}
 		});
 		return next;
 	};
 	let client = createClient();
-	const replaceClient = () => {
+	const replaceClient = (threadId = state.thread?.id) => {
 		client.stop();
 		const previous = client;
-		client = createClient();
+		previous.detach();
+		liveToolCalls.clear();
+		liveToolMessageIds.clear();
+		update({ activeToolCallIds: [] });
+		client = createClient(threadId);
+		if (started) client.attach();
 		previous.dispose();
 	};
-	const settleDanglingToolCalls = () => {
-		for (const message of state.messages) for (const part of message.parts) {
-			if (part.type !== "tool-call" || isSettledToolCall(part)) continue;
-			if (part.name === "ask_questionnaire") {
-				debug?.("questionnaire", "skipping pending questionnaire before send", { id: part.id });
-				client.addToolResult({
-					toolCallId: part.id,
-					tool: part.name,
-					output: {
-						answers: [],
-						skipped: true
-					}
-				});
-			} else {
-				debug?.("tool", `settling unimplemented tool call "${part.name}" as error`, { id: part.id });
-				client.addToolResult({
-					toolCallId: part.id,
-					tool: part.name,
-					output: null,
-					state: "output-error",
-					errorText: `The application hosting this chat has no implementation for "${part.name}"`
-				});
+	const scopeCompletedToolCalls = () => {
+		historicalToolIds.clear();
+		client.setMessagesManually(state.messages.map((message) => {
+			const aliases = /* @__PURE__ */ new Map();
+			const parts = message.parts.map((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;
+				const id = savedToolCallId(message.id, stored.applicationPartId ?? upstreamToolCallId, stored.responseTargetId);
+				aliases.set(upstreamToolCallId, id);
+				return {
+					...part,
+					upstreamToolCallId,
+					id,
+					...part.name === "render_widget" && liveToolMessageIds.get(upstreamToolCallId) === message.id ? { widgetRenderId: stored.widgetRenderId ?? part.id } : {}
+				};
+			});
+			if (aliases.size) historicalToolIds.set(message.id, aliases);
+			return {
+				...message,
+				parts
+			};
+		}));
+	};
+	const changeSelection = (threadId) => {
+		const previousId = state.thread?.id;
+		if (previousId) {
+			if (pendingSend && !pendingSend.accepted) pendingSends.set(previousId, pendingSend);
+			else pendingSends.delete(previousId);
+			threadToolResults.set(previousId, toolResults);
+		}
+		selectionGeneration++;
+		historyGeneration++;
+		sending = false;
+		requestController.abort();
+		requestController = new AbortController();
+		pendingSend = void 0;
+		toolResults = threadToolResults.get(threadId ?? "") ?? /* @__PURE__ */ new Map();
+		historicalToolIds.clear();
+		threadRecords = [];
+		disposeRenders();
+		update({
+			thread: void 0,
+			messages: [],
+			unsentMessage: void 0,
+			error: void 0,
+			status: "ready",
+			sandbox: {
+				files: [],
+				commands: []
+			},
+			sandboxStatus: void 0,
+			usageLimitReached: void 0,
+			pendingInteractions: [],
+			threadLoadFailed: false,
+			messagesCursor: void 0,
+			olderMessagesLoading: false
+		});
+		replaceClient(threadId);
+	};
+	const openThread = async (id, restoring = false) => {
+		if (!restoring) navigationGeneration++;
+		changeSelection(id);
+		const generation = selectionGeneration;
+		update({ threadLoading: true });
+		try {
+			pendingSend = pendingSends.get(id);
+			update({ unsentMessage: pendingSend?.content });
+			if (!started) client.attach();
+			await hydration;
+			if (generation !== selectionGeneration) return;
+			if (threadKey) selectedThread(threadKey, id);
+		} catch (error) {
+			if (generation === selectionGeneration) {
+				if (restoring && (live.threadId === void 0 || live.threadId === "auto") && isAstralBeamApiError(error) && error.status === 404) {
+					newThread();
+					return;
+				}
+				update({ threadLoadFailed: true });
+				reportError(error);
+			}
+		} finally {
+			if (generation === selectionGeneration) update({ threadLoading: false });
+		}
+	};
+	const newThread = () => {
+		navigationGeneration++;
+		changeSelection();
+		update({ threadLoading: false });
+		if (started) resolveCapabilities();
+		if (threadKey) selectedThread(threadKey, null);
+		else startWithNewThread = true;
+	};
+	const selectConfiguredThread = (restoring = false) => {
+		let selected = live.threadId;
+		if (selected === void 0 || selected === "auto") {
+			if (!threadKey) return;
+			selected = selectedThread(threadKey);
+		}
+		if (selected && selected !== "new") openThread(selected, restoring);
+		else if (!restoring) newThread();
+	};
+	const ensureThread = async () => {
+		if (state.thread) return;
+		const generation = selectionGeneration;
+		const options = await requestOptions();
+		const record = await createChatThread(live.agentId ? { agent_id: live.agentId } : {}, options);
+		if (generation !== selectionGeneration) throw new DOMException("Conversation changed", "AbortError");
+		const thread = threadFromRecord(record, false);
+		update({ thread });
+		replaceClient();
+		await hydration;
+		resolveCapabilities();
+		if (threadKey) selectedThread(threadKey, thread.id);
+	};
+	const refreshThread = async (preserveError = false, resetClient = true) => {
+		if (!state.thread?.id) return;
+		const generation = selectionGeneration;
+		const previousError = state.error;
+		update({
+			threadLoading: true,
+			olderMessagesLoading: false
+		});
+		try {
+			if (resetClient) replaceClient();
+			else {
+				client.detach();
+				client.attach();
+			}
+			await hydration;
+			if (generation !== selectionGeneration) return;
+			if (preserveError && previousError) update({
+				error: previousError,
+				status: "error"
+			});
+		} catch (error) {
+			if (generation === selectionGeneration) {
+				if (isAstralBeamApiError(error) && error.status === 404) {
+					newThread();
+					return;
+				}
+				reportError(error);
 			}
+		} finally {
+			if (generation === selectionGeneration) update({ threadLoading: false });
+		}
+	};
+	const loadOlderMessages = async () => {
+		if (!client.getHasOlderMessages() || state.olderMessagesLoading || state.threadLoading || sending) return;
+		const generation = selectionGeneration;
+		update({ olderMessagesLoading: true });
+		try {
+			await client.loadOlderMessages();
+		} catch (error) {
+			if (generation === selectionGeneration) reportError(error);
+		} finally {
+			if (generation === selectionGeneration) update({ olderMessagesLoading: false });
+		}
+	};
+	const renameThread = async (title) => {
+		const thread = state.thread;
+		if (!thread || thread.role !== "manager") return false;
+		const generation = selectionGeneration;
+		try {
+			const record = await updateChatThread(thread.id, {
+				title,
+				expected_version: thread.version
+			}, await requestOptions());
+			if (generation !== selectionGeneration) return false;
+			const renamed = threadFromRecord(record, thread.hasMessages);
+			update({
+				thread: renamed,
+				error: client.getError(),
+				status: client.getStatus()
+			});
+			return true;
+		} catch (error) {
+			if (generation === selectionGeneration) reportError(error);
+			return false;
+		}
+	};
+	const deleteThread = async (thread = state.thread) => {
+		if (!thread || thread.role !== "manager") return false;
+		const generation = selectionGeneration;
+		try {
+			await deleteChatThread(thread.id, { expected_version: String(thread.version) }, await requestOptions());
+			if (generation === selectionGeneration && state.thread?.id === thread.id) newThread();
+			return true;
+		} catch (error) {
+			if (generation === selectionGeneration) reportError(error);
+			return false;
+		}
+	};
+	const addToolResult = async (result) => {
+		const generation = selectionGeneration;
+		if (sending || client.getIsLoading()) {
+			reportError(/* @__PURE__ */ new Error("Wait for this client's current request to finish before responding."));
+			return;
+		}
+		const current = authenticationState(authentication);
+		const pending = state.pendingInteractions.find((item) => item.toolCallId === result.toolCallId);
+		const closure = !("tool" in result) && pending && (state.thread?.role === "manager" || current.status === "ready" && pending.targetTenantUserId === current.currentUser.user.id);
+		const questionnaire = "tool" in result && result.tool === "ask_questionnaire" && current.status === "ready" && pending?.targetTenantUserId === current.currentUser.user.id;
+		if (state.thread?.role === "viewer" || !liveToolCalls.has(result.toolCallId) && !questionnaire && !closure && !toolResults.has(toolResultKey(result.toolCallId))) {
+			reportError(/* @__PURE__ */ new Error("This tool call belongs to another session and cannot be executed here."));
+			return;
+		}
+		if (closure && !toolResults.has(toolResultKey(result.toolCallId))) toolResults.set(toolResultKey(result.toolCallId), {
+			outcome: "unknown",
+			output: null
+		});
+		else if (!toolResults.has(toolResultKey(result.toolCallId)) && "tool" in result) {
+			const output = result.output;
+			toolResults.set(toolResultKey(result.toolCallId), {
+				outcome: result.state === "output-error" ? "failed" : "succeeded",
+				output: output ?? null
+			});
+		}
+		scopeCompletedToolCalls();
+		if (pending) {
+			replaceClient();
+			await hydration;
+			if (generation !== selectionGeneration) return;
+			update({ threadLoading: false });
+			await client.append({
+				role: "tool",
+				toolCallId: result.toolCallId,
+				content: JSON.stringify(toolResults.get(toolResultKey(result.toolCallId)))
+			});
+		} else if ("tool" in result) await client.addToolResult(result);
+		if (generation === selectionGeneration) await refreshThread(client.getError() !== void 0, false);
+	};
+	const abandonToolCall = (toolCallId) => addToolResult({ toolCallId });
+	const sendMessage = async (content, callbacks) => {
+		const navigation = navigationGeneration;
+		try {
+			await getValidChatAuthToken(authentication);
+		} catch (error) {
+			if (navigation !== navigationGeneration) return;
+			update({ unsentMessage: content });
+			reportError(error);
+			return;
+		}
+		if (navigation !== navigationGeneration) return;
+		if (sending || state.threadLoading || state.status === "streaming") {
+			reportError(/* @__PURE__ */ new Error("Wait for this client's current request to finish before sending."));
+			return;
+		}
+		if (state.threadLoadFailed) {
+			reportError(/* @__PURE__ */ new Error("Reopen this conversation or start a new one before sending."));
+			return;
+		}
+		const samePendingContent = pendingSend !== void 0 && JSON.stringify(pendingSend.content) === JSON.stringify(content);
+		const uncertainSend = pendingSend?.tools !== void 0 && !pendingSend.accepted ? pendingSend : void 0;
+		const retrying = uncertainSend !== void 0 && samePendingContent;
+		if (state.thread?.agentId === null && !retrying) {
+			reportError(/* @__PURE__ */ new Error("This conversation’s agent is unavailable. Start a new conversation to continue."));
+			return;
+		}
+		if (state.thread?.role === "viewer" && !retrying) {
+			reportError(/* @__PURE__ */ new Error("You have read-only access to this conversation."));
+			return;
+		}
+		if (uncertainSend && !samePendingContent) {
+			update({ unsentMessage: uncertainSend.content });
+			reportError(/* @__PURE__ */ new Error("The previous message’s acceptance is unconfirmed. Retry that message before sending different text, or start a new conversation."));
+			return;
+		}
+		const generation = selectionGeneration;
+		historyGeneration++;
+		update({ olderMessagesLoading: false });
+		sending = true;
+		if (!pendingSend || pendingSend.accepted || !samePendingContent) {
+			pendingSend = {
+				content,
+				accepted: false,
+				key: newUuid(),
+				callbacks
+			};
+			client.stop();
+			liveToolCalls.clear();
+			scopeCompletedToolCalls();
+			liveToolMessageIds.clear();
+			update({ activeToolCallIds: [] });
+		}
+		pendingSend.callbacks ??= callbacks;
+		update({
+			unsentMessage: content,
+			error: void 0,
+			status: "submitted"
+		});
+		try {
+			await ensureThread();
+			if (generation !== selectionGeneration) return;
+			pendingSend.callbacks?.onThreadReady?.(state.thread.id);
+			if (generation !== selectionGeneration) return;
+			scopeCompletedToolCalls();
+			await client.sendMessage(content);
+			if (generation !== selectionGeneration) return;
+			const failed = client.getError() !== void 0;
+			if (pendingSend?.accepted) {
+				pendingSend = void 0;
+				update({ unsentMessage: void 0 });
+			}
+			await refreshThread(failed, false);
+		} catch (error) {
+			if (generation === selectionGeneration) reportError(error);
+		} finally {
+			if (generation === selectionGeneration) sending = 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) {
-				replaceClient();
-				disposeRenders();
-				update({
-					messages: [],
-					sandbox: {
-						files: [],
-						commands: []
-					},
-					sandboxStatus: void 0
-				});
+				navigationGeneration++;
+				pendingSends.clear();
+				threadToolResults.clear();
+				toolResults.clear();
+				pendingSend = void 0;
 			}
 			identity = nextIdentity;
+			const nextThreadKey = `astralbeam:thread:${live.apiUrl ?? "https://astralbeam.ai/api"}:${nextIdentity}`;
+			if (threadKey !== nextThreadKey) {
+				changeSelection();
+				threadKey = nextThreadKey;
+				if (startWithNewThread) {
+					selectedThread(nextThreadKey, null);
+					startWithNewThread = false;
+				} else selectConfiguredThread(true);
+			}
 			if (capabilityIdentity !== nextIdentity) {
 				capabilityIdentity = nextIdentity;
 				resolveCapabilities();
 			}
 		}
 		update({ auth });
+		if (auth.status === "error" && (previous.status !== "error" || previous.error !== auth.error)) live.streamCallbacks?.onError?.(auth.error);
 	};
 	const start = () => {
 		if (started) return;
 		started = true;
+		client.attach();
+		if (requestController.signal.aborted) requestController = new AbortController();
 		unsubscribeAuthentication = subscribeAuthentication(authentication, observeAuthentication);
 		observeAuthentication();
 		stopAuthentication = startAuthentication(authentication);
@@ -9817,6 +11826,8 @@ function createAstralBeamChat(options, deferStart = false) {
 		updateOptions: (next) => {
 			const agent = live.agentId;
 			const apiUrl = live.apiUrl;
+			const selectedId = live.threadId;
+			const { widgets, onRenderWidget } = live;
 			live = {
 				...live,
 				...next
@@ -9831,13 +11842,22 @@ function createAstralBeamChat(options, deferStart = false) {
 				tools: declareTools(),
 				forwardedProps: forwardedProps()
 			});
+			if (live.apiUrl !== apiUrl) {
+				navigationGeneration++;
+				pendingSends.clear();
+				threadToolResults.clear();
+				toolResults.clear();
+				pendingSend = void 0;
+				changeSelection();
+				threadKey = void 0;
+				update({ threadLoading: false });
+				observeAuthentication();
+			} else if (live.threadId !== selectedId) selectConfiguredThread();
+			if (widgets !== live.widgets || onRenderWidget !== live.onRenderWidget) restoreCompletedWidgets(state.messages);
 			if (started && (live.agentId !== agent || live.apiUrl !== apiUrl)) resolveCapabilities();
 		},
-		sendMessage: (content) => {
-			settleDanglingToolCalls();
-			return client.sendMessage(content);
-		},
-		addToolResult: (result) => client.addToolResult(result),
+		sendMessage,
+		addToolResult,
 		stop: () => client.stop(),
 		retryAuthentication: () => {
 			getValidChatAuthToken({
@@ -9845,25 +11865,78 @@ function createAstralBeamChat(options, deferStart = false) {
 				force: true
 			}).catch(() => void 0);
 		},
-		reload: () => client.reload(),
+		reload: async () => {
+			const generation = selectionGeneration;
+			await refreshThread();
+			if (generation !== selectionGeneration || state.error) return;
+			const attempted = /* @__PURE__ */ new Set();
+			while (generation === selectionGeneration) {
+				const pending = state.pendingInteractions.find((item) => !attempted.has(item.sourceMessageId) && toolResults.has(toolResultKey(item.toolCallId)));
+				if (!pending) return;
+				attempted.add(pending.sourceMessageId);
+				await addToolResult({ toolCallId: pending.toolCallId });
+				if (state.error) return;
+			}
+		},
+		searchThreads: async (q = "", cursor, signal) => {
+			const options = await requestOptions();
+			const page = await listChatThreads({
+				q,
+				page_size: 50,
+				...cursor ? { page_after: cursor } : {}
+			}, {
+				...options,
+				signal: AbortSignal.any([options.signal, ...signal ? [signal] : []])
+			});
+			return {
+				items: page.items.map((record) => threadFromRecord(record)),
+				page_after: page.page_after
+			};
+		},
+		openThread,
+		renameThread,
+		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.");
+			return (await getChatAttachment(thread.id, messageId, partId, await requestOptions())).blob();
+		},
+		abandonToolCall,
 		reset: () => {
 			debug?.("status", "conversation reset");
-			replaceClient();
-			disposeRenders();
-			update({
-				messages: [],
-				status: "ready",
-				sandbox: {
-					files: [],
-					commands: []
-				},
-				sandboxStatus: void 0,
-				error: void 0
-			});
+			newThread();
 		},
 		dispose: () => {
+			client.detach();
 			disposeRenders();
 			client.stop();
+			requestController.abort();
+			selectionGeneration++;
+			threadKey = void 0;
 			capabilitiesGeneration++;
 			capabilityIdentity = void 0;
 			stopAuthentication?.();