experimental-a2 0.14.1 → 0.16.0

package/dist/ai-CrLYwNEx.js

@@ -0,0 +1,2431 @@
+import { n as validateSync, t as assertSyncSchema } from "./validate-XKT4FSNn.js";
+import { t as clientStateProjection } from "./reducer-DEMjEY_O.js";
+import { t as contract } from "./contract-CKRg_E4q.js";
+import { t as idempotentId } from "./idempotent-id-BRJVeylj.js";
+import { l as ambientToolScopeStorage } from "./internal-Dq2qYxou.js";
+//#region src/ai-client-state.ts
+const isQueueCommand = (command) => command.action === "send" || command.action === "edit" || command.action === "move" || command.action === "remove" || command.action === "send-now" || command.action === "steer" || command.action === "pause" || command.action === "resume";
+const moveItem = ({ items, inputId, beforeId }) => {
+	const from = items.findIndex((item) => item.id === inputId);
+	if (from < 0 || inputId === beforeId || beforeId !== null && !items.some((item) => item.id === beforeId)) return items;
+	const next = [...items];
+	const [item] = next.splice(from, 1);
+	const to = beforeId === null ? next.length : next.findIndex((entry) => entry.id === beforeId);
+	next.splice(to, 0, item);
+	return next;
+};
+function projectAIClientState(state) {
+	const pending = state.pendingQueueCommands ?? [];
+	if (state.status === "closed") return state;
+	if (pending.length === 0 && !state.inbox.items.some((item) => item.afterStepOf !== void 0)) return state;
+	let messages = state.messages;
+	let { items, paused } = state.inbox;
+	let turnId = state.active?.turnId ?? null;
+	let starting = false;
+	let suspended = state.active?.phase === "paused" || state.active?.phase === "pausing";
+	let messageIds;
+	const show = (message) => {
+		messageIds ??= new Set(messages.map((item) => item.id));
+		if (messageIds.has(message.id)) return;
+		if (messages === state.messages) messages = state.messages.slice();
+		messages.push(message);
+		messageIds.add(message.id);
+	};
+	const admit = () => {
+		if (turnId !== null || paused || items.length === 0) return;
+		let count = 0;
+		for (const item of items) {
+			count += 1;
+			show(item.message);
+			if (item.generate) {
+				turnId = item.id;
+				starting = true;
+				suspended = false;
+				break;
+			}
+		}
+		if (count > 0) items = items.slice(count);
+	};
+	for (const { command } of pending) {
+		switch (command.action) {
+			case "send":
+			case "steer": {
+				if (items.some((item) => item.id === command.message.id) || turnId === command.message.id) break;
+				const item = {
+					...command.action === "steer" ? { afterStepOf: command.turnId } : {},
+					id: command.message.id,
+					message: command.message,
+					generate: command.message.role === "user" && (command.action === "steer" || command.generate !== false)
+				};
+				items = command.action === "steer" ? [item, ...items] : [...items, item];
+				break;
+			}
+			case "edit":
+				items = items.map((item) => item.id === command.message.id && item.message.role === command.message.role ? {
+					...item,
+					message: command.message
+				} : item);
+				break;
+			case "move":
+				items = moveItem({
+					items,
+					inputId: command.inputId,
+					beforeId: command.beforeId
+				});
+				break;
+			case "remove":
+				items = items.filter((item) => item.id !== command.inputId);
+				break;
+			case "send-now": {
+				if (turnId !== command.turnId) break;
+				const selected = items.find((item) => item.id === command.inputId);
+				if (!selected || selected.message.role !== "user") break;
+				items = items.map((item) => item.id === selected.id ? {
+					...item,
+					generate: true,
+					...turnId === null ? {} : { afterStepOf: turnId }
+				} : item);
+				items = moveItem({
+					items,
+					inputId: command.inputId,
+					beforeId: items[0]?.id ?? null
+				});
+				break;
+			}
+			case "pause":
+				paused = true;
+				if (command.when === "now") suspended = true;
+				break;
+			case "resume":
+				paused = false;
+				suspended = false;
+		}
+		admit();
+	}
+	items = items.filter((item) => {
+		if (item.afterStepOf === void 0) return true;
+		show(item.message);
+		return false;
+	});
+	return {
+		...state,
+		messages,
+		inbox: {
+			items,
+			paused
+		},
+		starting: starting && !suspended
+	};
+}
+//#endregion
+//#region src/ai-control-state.ts
+const container = (value) => typeof value === "object" && value !== null;
+const same = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+const controlChanges = ({ before, after }) => {
+	const changes = [];
+	const visit = (left, right, path) => {
+		if (same(left, right)) return;
+		if (Array.isArray(left) && Array.isArray(right)) {
+			let prefix = 0;
+			while (prefix < Math.min(left.length, right.length) && same(left[prefix], right[prefix])) prefix += 1;
+			let suffix = 0;
+			while (suffix < Math.min(left.length, right.length) - prefix && same(left[left.length - 1 - suffix], right[right.length - 1 - suffix])) suffix += 1;
+			if (left.length === right.length) for (let index = prefix; index < left.length - suffix; index += 1) visit(left[index], right[index], [...path, index]);
+			else changes.push({
+				path,
+				splice: {
+					index: prefix,
+					deleteCount: left.length - prefix - suffix,
+					items: right.slice(prefix, right.length - suffix)
+				}
+			});
+			return;
+		}
+		if (container(left) && container(right) && !Array.isArray(left) && !Array.isArray(right)) {
+			if (Object.keys(right).length === 0) {
+				changes.push({
+					path,
+					value: right
+				});
+				return;
+			}
+			for (const key of Object.keys(left)) if (!Object.hasOwn(right, key)) changes.push({
+				path: [...path, key],
+				remove: true
+			});
+			for (const key of Object.keys(right)) visit(Object.hasOwn(left, key) ? left[key] : void 0, right[key], [...path, key]);
+			return;
+		}
+		changes.push({
+			path,
+			value: right
+		});
+	};
+	visit(before, after, []);
+	return changes;
+};
+const applyControlChanges = ({ state, changes }) => {
+	if (changes.length === 0) return state;
+	let next = structuredClone(state);
+	for (const change of changes) {
+		const path = change.path;
+		if (path.length === 0) {
+			next = structuredClone(change.value);
+			continue;
+		}
+		let target = next;
+		for (const key of path.slice(0, -1)) {
+			if (!container(target) || !Object.hasOwn(target, key)) throw new TypeError("Invalid AI control change path");
+			target = target[key];
+		}
+		if (!container(target)) throw new TypeError("Invalid AI control change target");
+		const parent = target;
+		const key = path.at(-1);
+		if (change.remove) delete parent[key];
+		else if (change.splice) {
+			const items = parent[key];
+			Object.defineProperty(parent, key, {
+				value: [
+					...items.slice(0, change.splice.index),
+					...structuredClone(change.splice.items),
+					...items.slice(change.splice.index + change.splice.deleteCount)
+				],
+				enumerable: true,
+				configurable: true,
+				writable: true
+			});
+		} else if (change.move) {
+			const items = parent[key];
+			const [item] = items.splice(change.move.from, 1);
+			items.splice(change.move.to, 0, item);
+		} else Object.defineProperty(parent, key, {
+			value: structuredClone(change.value),
+			enumerable: true,
+			configurable: true,
+			writable: true
+		});
+	}
+	return next;
+};
+const controlCommit = (options) => {
+	const active = options.after.active;
+	const response = options.after.coordinator.response;
+	return {
+		changes: [...options.moves, ...controlChanges({
+			before: options.before,
+			after: options.after
+		})],
+		view: {
+			turnId: active?.turnId ?? null,
+			version: active?.version ?? null,
+			phase: active?.phase ?? null,
+			paused: options.after.inbox.paused,
+			closed: options.after.coordinator.closed,
+			requestId: response?.activeRequestId ?? null,
+			requestReason: response?.requestReason ?? null,
+			sourceGenerationId: response?.sourceGenerationId ?? null,
+			responseMessageId: response?.responseMessageId ?? null
+		}
+	};
+};
+//#endregion
+//#region src/ai-control.ts
+const initialControlState = () => ({
+	inbox: {
+		paused: false,
+		items: []
+	},
+	active: null,
+	coordinator: {
+		closed: false,
+		queued: []
+	}
+});
+//#endregion
+//#region src/ai-id.ts
+const AI_EVENT_ID_PREFIX = "a2.ai:";
+const aiEventId = async (...parts) => `${AI_EVENT_ID_PREFIX}${await idempotentId(...parts)}`;
+//#endregion
+//#region src/parse-partial-json.ts
+/*!
+* Adapted from AI SDK 7.0.58, packages/ai/src/util/fix-json.ts.
+* Source: https://github.com/vercel/ai, packages/ai/src/util/fix-json.ts.
+* Modified to expose a synchronous partial parser with strict TypeScript types.
+* Also preserves positive exponents in unfinished containers.
+* Copyright 2023 Vercel, Inc.
+* @license Apache-2.0. See src/licenses/Apache-2.0.txt.
+*/
+function parsePartialJSON(text) {
+	if (text === void 0 || text.trim() === "") return void 0;
+	try {
+		return JSON.parse(text);
+	} catch {
+		try {
+			return JSON.parse(repairPartialJSON(text));
+		} catch {
+			return;
+		}
+	}
+}
+const isHexDigit = (char) => char >= "0" && char <= "9" || char >= "A" && char <= "F" || char >= "a" && char <= "f";
+function repairPartialJSON(input) {
+	const stack = ["ROOT"];
+	let lastValidIndex = -1;
+	let literalStart = null;
+	let unicodeEscapeDigits = 0;
+	function processValueStart(char, i, swapState) {
+		switch (char) {
+			case "\"":
+				lastValidIndex = i;
+				stack.pop();
+				stack.push(swapState);
+				stack.push("INSIDE_STRING");
+				break;
+			case "f":
+			case "t":
+			case "n":
+				lastValidIndex = i;
+				literalStart = i;
+				stack.pop();
+				stack.push(swapState);
+				stack.push("INSIDE_LITERAL");
+				break;
+			case "-":
+				stack.pop();
+				stack.push(swapState);
+				stack.push("INSIDE_NUMBER");
+				break;
+			case "0":
+			case "1":
+			case "2":
+			case "3":
+			case "4":
+			case "5":
+			case "6":
+			case "7":
+			case "8":
+			case "9":
+				lastValidIndex = i;
+				stack.pop();
+				stack.push(swapState);
+				stack.push("INSIDE_NUMBER");
+				break;
+			case "{":
+				lastValidIndex = i;
+				stack.pop();
+				stack.push(swapState);
+				stack.push("INSIDE_OBJECT_START");
+				break;
+			case "[":
+				lastValidIndex = i;
+				stack.pop();
+				stack.push(swapState);
+				stack.push("INSIDE_ARRAY_START");
+		}
+	}
+	function processAfterObjectValue(char, i) {
+		switch (char) {
+			case ",":
+				stack.pop();
+				stack.push("INSIDE_OBJECT_AFTER_COMMA");
+				break;
+			case "}":
+				lastValidIndex = i;
+				stack.pop();
+		}
+	}
+	function processAfterArrayValue(char, i) {
+		switch (char) {
+			case ",":
+				stack.pop();
+				stack.push("INSIDE_ARRAY_AFTER_COMMA");
+				break;
+			case "]":
+				lastValidIndex = i;
+				stack.pop();
+		}
+	}
+	for (let i = 0; i < input.length; i++) {
+		const char = input[i];
+		switch (stack[stack.length - 1]) {
+			case "ROOT":
+				processValueStart(char, i, "FINISH");
+				break;
+			case "INSIDE_OBJECT_START":
+				switch (char) {
+					case "\"":
+						stack.pop();
+						stack.push("INSIDE_OBJECT_KEY");
+						break;
+					case "}":
+						lastValidIndex = i;
+						stack.pop();
+				}
+				break;
+			case "INSIDE_OBJECT_AFTER_COMMA":
+				switch (char) {
+					case "\"":
+						stack.pop();
+						stack.push("INSIDE_OBJECT_KEY");
+				}
+				break;
+			case "INSIDE_OBJECT_KEY":
+				switch (char) {
+					case "\"":
+						stack.pop();
+						stack.push("INSIDE_OBJECT_AFTER_KEY");
+				}
+				break;
+			case "INSIDE_OBJECT_AFTER_KEY":
+				switch (char) {
+					case ":":
+						stack.pop();
+						stack.push("INSIDE_OBJECT_BEFORE_VALUE");
+				}
+				break;
+			case "INSIDE_OBJECT_BEFORE_VALUE":
+				processValueStart(char, i, "INSIDE_OBJECT_AFTER_VALUE");
+				break;
+			case "INSIDE_OBJECT_AFTER_VALUE":
+				processAfterObjectValue(char, i);
+				break;
+			case "INSIDE_STRING":
+				switch (char) {
+					case "\"":
+						stack.pop();
+						lastValidIndex = i;
+						break;
+					case "\\":
+						stack.push("INSIDE_STRING_ESCAPE");
+						break;
+					default: lastValidIndex = i;
+				}
+				break;
+			case "INSIDE_ARRAY_START":
+				switch (char) {
+					case "]":
+						lastValidIndex = i;
+						stack.pop();
+						break;
+					default:
+						lastValidIndex = i;
+						processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
+				}
+				break;
+			case "INSIDE_ARRAY_AFTER_VALUE":
+				switch (char) {
+					case ",":
+						stack.pop();
+						stack.push("INSIDE_ARRAY_AFTER_COMMA");
+						break;
+					case "]":
+						lastValidIndex = i;
+						stack.pop();
+						break;
+					default: lastValidIndex = i;
+				}
+				break;
+			case "INSIDE_ARRAY_AFTER_COMMA":
+				processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
+				break;
+			case "INSIDE_STRING_ESCAPE":
+				stack.pop();
+				if (char === "u") {
+					unicodeEscapeDigits = 0;
+					stack.push("INSIDE_STRING_UNICODE_ESCAPE");
+				} else lastValidIndex = i;
+				break;
+			case "INSIDE_STRING_UNICODE_ESCAPE":
+				if (isHexDigit(char)) {
+					unicodeEscapeDigits++;
+					if (unicodeEscapeDigits === 4) {
+						stack.pop();
+						lastValidIndex = i;
+					}
+				}
+				break;
+			case "INSIDE_NUMBER":
+				switch (char) {
+					case "0":
+					case "1":
+					case "2":
+					case "3":
+					case "4":
+					case "5":
+					case "6":
+					case "7":
+					case "8":
+					case "9":
+						lastValidIndex = i;
+						break;
+					case "e":
+					case "E":
+					case "-":
+					case "+":
+					case ".": break;
+					case ",":
+						stack.pop();
+						if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") processAfterArrayValue(char, i);
+						if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") processAfterObjectValue(char, i);
+						break;
+					case "}":
+						stack.pop();
+						if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") processAfterObjectValue(char, i);
+						break;
+					case "]":
+						stack.pop();
+						if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") processAfterArrayValue(char, i);
+						break;
+					default: stack.pop();
+				}
+				break;
+			case "INSIDE_LITERAL": {
+				const partialLiteral = input.substring(literalStart, i + 1);
+				if (!"false".startsWith(partialLiteral) && !"true".startsWith(partialLiteral) && !"null".startsWith(partialLiteral)) {
+					stack.pop();
+					if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") processAfterObjectValue(char, i);
+					else if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") processAfterArrayValue(char, i);
+				} else lastValidIndex = i;
+				break;
+			}
+		}
+	}
+	let result = input.slice(0, lastValidIndex + 1);
+	for (let i = stack.length - 1; i >= 0; i--) switch (stack[i]) {
+		case "INSIDE_STRING":
+			result += "\"";
+			break;
+		case "INSIDE_OBJECT_KEY":
+		case "INSIDE_OBJECT_AFTER_KEY":
+		case "INSIDE_OBJECT_AFTER_COMMA":
+		case "INSIDE_OBJECT_START":
+		case "INSIDE_OBJECT_BEFORE_VALUE":
+		case "INSIDE_OBJECT_AFTER_VALUE":
+			result += "}";
+			break;
+		case "INSIDE_ARRAY_START":
+		case "INSIDE_ARRAY_AFTER_COMMA":
+		case "INSIDE_ARRAY_AFTER_VALUE":
+			result += "]";
+			break;
+		case "INSIDE_LITERAL": {
+			const partialLiteral = input.substring(literalStart, input.length);
+			if ("true".startsWith(partialLiteral)) result += "true".slice(partialLiteral.length);
+			else if ("false".startsWith(partialLiteral)) result += "false".slice(partialLiteral.length);
+			else if ("null".startsWith(partialLiteral)) result += "null".slice(partialLiteral.length);
+		}
+	}
+	return result;
+}
+//#endregion
+//#region src/ai-projector.ts
+const isRecord$3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const cloneMessage = (messageId, base) => base === void 0 ? {
+	id: messageId,
+	role: "assistant",
+	parts: []
+} : {
+	...base,
+	id: messageId,
+	parts: base.parts.map((part) => ({ ...part }))
+};
+const currentStepParts = (parts) => {
+	let start = parts.length - 1;
+	while (start >= 0 && parts[start]?.["type"] !== "step-start") start -= 1;
+	return parts.slice(start + 1);
+};
+const isToolPart = (part) => typeof part["toolCallId"] === "string" && (part["type"] === "dynamic-tool" || typeof part["type"] === "string" && part["type"].startsWith("tool-"));
+const findToolPart = (parts, toolCallId) => {
+	const current = currentStepParts(parts).find((part) => isToolPart(part) && part["toolCallId"] === toolCallId);
+	if (current) return current;
+	return parts.findLast((part) => isToolPart(part) && part["toolCallId"] === toolCallId);
+};
+const findApprovalPart = (parts, approvalId) => parts.find((part) => {
+	const approval = part["approval"];
+	return isToolPart(part) && isRecord$3(approval) && approval["id"] === approvalId;
+});
+const setOptional = (target, key, value) => {
+	if (value !== void 0) target[key] = value;
+};
+const setToolPart = (options) => {
+	let part = findToolPart(options.parts, options.toolCallId);
+	if (!part) {
+		part = {
+			type: options.dynamic ? "dynamic-tool" : `tool-${options.toolName}`,
+			...options.dynamic ? { toolName: options.toolName } : {},
+			toolCallId: options.toolCallId
+		};
+		options.parts.push(part);
+	}
+	part["state"] = options.state;
+	part["input"] = options.input;
+	delete part["output"];
+	delete part["rawInput"];
+	delete part["errorText"];
+	delete part["preliminary"];
+	setOptional(part, "rawInput", options.rawInput);
+	setOptional(part, "output", options.output);
+	setOptional(part, "errorText", options.errorText);
+	setOptional(part, "preliminary", options.preliminary);
+	setOptional(part, "providerExecuted", options.providerExecuted);
+	setOptional(part, "title", options.title);
+	setOptional(part, "toolMetadata", options.toolMetadata);
+	if (options.dynamic) part["toolName"] = options.toolName;
+	if (options.providerMetadata !== void 0) part[options.state === "output-available" || options.state === "output-error" ? "resultProviderMetadata" : "callProviderMetadata"] = options.providerMetadata;
+	return part;
+};
+const mergeMetadata = (current, update) => {
+	if (update === void 0 || update === null) return current;
+	return isRecord$3(current) && isRecord$3(update) ? {
+		...current,
+		...update
+	} : update;
+};
+function projectUIMessage(options) {
+	return projectUIMessageStream(options).message;
+}
+function projectUIMessageStream(options) {
+	const message = cloneMessage(options.messageId, options.base);
+	const record = message;
+	const parts = message.parts;
+	const activeText = new Map(Object.entries(options.cursor?.text ?? {}).map(([id, index]) => [id, parts[index]]));
+	const activeReasoning = new Map(Object.entries(options.cursor?.reasoning ?? {}).map(([id, index]) => [id, parts[index]]));
+	const partialTools = new Map(Object.entries(options.cursor?.tools ?? {}).map(([id, partial]) => [id, { ...partial }]));
+	for (const chunk of options.chunks) switch (chunk.type) {
+		case "text-start": {
+			const part = {
+				type: "text",
+				text: "",
+				state: "streaming",
+				...chunk.providerMetadata === void 0 ? {} : { providerMetadata: chunk.providerMetadata }
+			};
+			activeText.set(chunk.id, part);
+			parts.push(part);
+			break;
+		}
+		case "text-delta": {
+			let part = activeText.get(chunk.id);
+			if (!part) {
+				part = {
+					type: "text",
+					text: "",
+					state: "streaming"
+				};
+				activeText.set(chunk.id, part);
+				parts.push(part);
+			}
+			part["text"] = `${typeof part["text"] === "string" ? part["text"] : ""}${chunk.delta}`;
+			setOptional(part, "providerMetadata", chunk.providerMetadata);
+			break;
+		}
+		case "text-end": {
+			const part = activeText.get(chunk.id);
+			if (part) {
+				part["state"] = "done";
+				setOptional(part, "providerMetadata", chunk.providerMetadata);
+				activeText.delete(chunk.id);
+			}
+			break;
+		}
+		case "reasoning-start": {
+			const part = {
+				type: "reasoning",
+				text: "",
+				state: "streaming",
+				...chunk.providerMetadata === void 0 ? {} : { providerMetadata: chunk.providerMetadata }
+			};
+			activeReasoning.set(chunk.id, part);
+			parts.push(part);
+			break;
+		}
+		case "reasoning-delta": {
+			let part = activeReasoning.get(chunk.id);
+			if (!part) {
+				part = {
+					type: "reasoning",
+					text: "",
+					state: "streaming"
+				};
+				activeReasoning.set(chunk.id, part);
+				parts.push(part);
+			}
+			part["text"] = `${typeof part["text"] === "string" ? part["text"] : ""}${chunk.delta}`;
+			setOptional(part, "providerMetadata", chunk.providerMetadata);
+			break;
+		}
+		case "reasoning-end": {
+			const part = activeReasoning.get(chunk.id);
+			if (part) {
+				part["state"] = "done";
+				setOptional(part, "providerMetadata", chunk.providerMetadata);
+				activeReasoning.delete(chunk.id);
+			}
+			break;
+		}
+		case "custom":
+			parts.push({
+				type: "custom",
+				kind: chunk.kind,
+				...chunk.providerMetadata === void 0 ? {} : { providerMetadata: chunk.providerMetadata }
+			});
+			break;
+		case "file":
+		case "reasoning-file":
+			parts.push({
+				type: chunk.type,
+				mediaType: chunk.mediaType,
+				url: chunk.url,
+				...chunk.providerMetadata === void 0 ? {} : { providerMetadata: chunk.providerMetadata }
+			});
+			break;
+		case "source-url":
+			parts.push({
+				type: chunk.type,
+				sourceId: chunk.sourceId,
+				url: chunk.url,
+				...chunk.title === void 0 ? {} : { title: chunk.title },
+				...chunk.providerMetadata === void 0 ? {} : { providerMetadata: chunk.providerMetadata }
+			});
+			break;
+		case "source-document":
+			parts.push({
+				type: chunk.type,
+				sourceId: chunk.sourceId,
+				mediaType: chunk.mediaType,
+				title: chunk.title,
+				...chunk.filename === void 0 ? {} : { filename: chunk.filename },
+				...chunk.providerMetadata === void 0 ? {} : { providerMetadata: chunk.providerMetadata }
+			});
+			break;
+		case "tool-input-start":
+			partialTools.set(chunk.toolCallId, {
+				text: "",
+				toolName: chunk.toolName,
+				dynamic: chunk.dynamic === true,
+				...chunk.providerExecuted === void 0 ? {} : { providerExecuted: chunk.providerExecuted },
+				...chunk.providerMetadata === void 0 ? {} : { providerMetadata: chunk.providerMetadata },
+				...chunk.toolMetadata === void 0 ? {} : { toolMetadata: chunk.toolMetadata },
+				...chunk.title === void 0 ? {} : { title: chunk.title }
+			});
+			setToolPart({
+				parts,
+				toolCallId: chunk.toolCallId,
+				toolName: chunk.toolName,
+				dynamic: chunk.dynamic === true,
+				state: "input-streaming",
+				providerExecuted: chunk.providerExecuted,
+				providerMetadata: chunk.providerMetadata,
+				toolMetadata: chunk.toolMetadata,
+				title: chunk.title
+			});
+			break;
+		case "tool-input-delta": {
+			const partial = partialTools.get(chunk.toolCallId);
+			if (!partial) break;
+			partial.text += chunk.inputTextDelta;
+			setToolPart({
+				parts,
+				toolCallId: chunk.toolCallId,
+				toolName: partial.toolName,
+				dynamic: partial.dynamic,
+				state: "input-streaming",
+				input: parsePartialJSON(partial.text),
+				providerExecuted: partial.providerExecuted,
+				providerMetadata: partial.providerMetadata,
+				toolMetadata: partial.toolMetadata,
+				title: partial.title
+			});
+			break;
+		}
+		case "tool-input-available":
+			setToolPart({
+				parts,
+				toolCallId: chunk.toolCallId,
+				toolName: chunk.toolName,
+				dynamic: chunk.dynamic === true,
+				state: "input-available",
+				input: chunk.input,
+				providerExecuted: chunk.providerExecuted,
+				providerMetadata: chunk.providerMetadata,
+				toolMetadata: chunk.toolMetadata,
+				title: chunk.title
+			});
+			partialTools.delete(chunk.toolCallId);
+			break;
+		case "tool-input-error": {
+			const dynamic = findToolPart(parts, chunk.toolCallId)?.["type"] === "dynamic-tool" || chunk.dynamic;
+			setToolPart({
+				parts,
+				toolCallId: chunk.toolCallId,
+				toolName: chunk.toolName,
+				dynamic: dynamic === true,
+				state: "output-error",
+				input: dynamic ? chunk.input : void 0,
+				rawInput: dynamic ? void 0 : chunk.input,
+				errorText: chunk.errorText,
+				providerExecuted: chunk.providerExecuted,
+				providerMetadata: chunk.providerMetadata,
+				toolMetadata: chunk.toolMetadata,
+				title: chunk.title
+			});
+			partialTools.delete(chunk.toolCallId);
+			break;
+		}
+		case "tool-approval-request": {
+			const part = findToolPart(parts, chunk.toolCallId);
+			if (!part) break;
+			part["state"] = "approval-requested";
+			part["approval"] = {
+				id: chunk.approvalId,
+				...chunk.isAutomatic === true ? { isAutomatic: true } : {},
+				...chunk.signature === void 0 ? {} : { signature: chunk.signature }
+			};
+			break;
+		}
+		case "tool-approval-response": {
+			const part = findApprovalPart(parts, chunk.approvalId);
+			if (!part) break;
+			const approval = isRecord$3(part["approval"]) ? part["approval"] : {};
+			part["state"] = "approval-responded";
+			part["approval"] = {
+				id: chunk.approvalId,
+				approved: chunk.approved,
+				...chunk.reason === void 0 ? {} : { reason: chunk.reason },
+				...approval["isAutomatic"] === true ? { isAutomatic: true } : {},
+				...typeof approval["signature"] === "string" ? { signature: approval["signature"] } : {}
+			};
+			setOptional(part, "providerExecuted", chunk.providerExecuted);
+			setOptional(part, "callProviderMetadata", chunk.providerMetadata);
+			break;
+		}
+		case "tool-output-available": {
+			const part = findToolPart(parts, chunk.toolCallId);
+			if (!part) break;
+			setToolPart({
+				parts,
+				toolCallId: chunk.toolCallId,
+				toolName: part["type"] === "dynamic-tool" && typeof part["toolName"] === "string" ? part["toolName"] : String(part["type"]).slice(5),
+				dynamic: part["type"] === "dynamic-tool",
+				state: "output-available",
+				input: part["input"],
+				output: chunk.output,
+				preliminary: chunk.preliminary,
+				providerExecuted: chunk.providerExecuted,
+				providerMetadata: chunk.providerMetadata,
+				toolMetadata: chunk.toolMetadata ?? part["toolMetadata"],
+				title: typeof part["title"] === "string" ? part["title"] : void 0
+			});
+			break;
+		}
+		case "tool-output-error": {
+			const part = findToolPart(parts, chunk.toolCallId);
+			if (!part) break;
+			setToolPart({
+				parts,
+				toolCallId: chunk.toolCallId,
+				toolName: part["type"] === "dynamic-tool" && typeof part["toolName"] === "string" ? part["toolName"] : String(part["type"]).slice(5),
+				dynamic: part["type"] === "dynamic-tool",
+				state: "output-error",
+				input: part["input"],
+				rawInput: part["rawInput"],
+				errorText: chunk.errorText,
+				providerExecuted: chunk.providerExecuted,
+				providerMetadata: chunk.providerMetadata,
+				toolMetadata: chunk.toolMetadata ?? part["toolMetadata"],
+				title: typeof part["title"] === "string" ? part["title"] : void 0
+			});
+			break;
+		}
+		case "tool-output-denied": {
+			const part = findToolPart(parts, chunk.toolCallId);
+			if (part) part["state"] = "output-denied";
+			break;
+		}
+		case "start-step":
+			parts.push({ type: "step-start" });
+			break;
+		case "finish-step":
+			activeText.clear();
+			activeReasoning.clear();
+			break;
+		case "start":
+			if (chunk.messageMetadata !== void 0 && chunk.messageMetadata !== null) record["metadata"] = mergeMetadata(record["metadata"], chunk.messageMetadata);
+			break;
+		case "finish":
+			if (chunk.messageMetadata !== void 0 && chunk.messageMetadata !== null) record["metadata"] = mergeMetadata(record["metadata"], chunk.messageMetadata);
+			break;
+		case "message-metadata":
+			if (chunk.messageMetadata !== void 0 && chunk.messageMetadata !== null) record["metadata"] = mergeMetadata(record["metadata"], chunk.messageMetadata);
+			break;
+		case "abort":
+		case "error": break;
+		default: {
+			if (!chunk.type.startsWith("data-") || chunk.transient) break;
+			const existing = chunk.id === void 0 ? void 0 : parts.find((part) => part["type"] === chunk.type && part["id"] === chunk.id);
+			if (existing) existing["data"] = chunk.data;
+			else parts.push({
+				type: chunk.type,
+				...chunk.id === void 0 ? {} : { id: chunk.id },
+				data: chunk.data
+			});
+		}
+	}
+	const indexes = new Map(parts.map((part, index) => [part, index]));
+	return {
+		message,
+		cursor: {
+			text: Object.fromEntries([...activeText].map(([id, part]) => [id, indexes.get(part)])),
+			reasoning: Object.fromEntries([...activeReasoning].map(([id, part]) => [id, indexes.get(part)])),
+			tools: Object.fromEntries(partialTools)
+		}
+	};
+}
+function pauseUIMessage(options) {
+	const next = structuredClone(options.message);
+	next.parts = next.parts.filter((part) => !("toolCallId" in part && !options.toolCallIds.has(part.toolCallId)));
+	for (const part of next.parts) if ((part.type === "text" || part.type === "reasoning") && part.state === "streaming") part.state = "done";
+	return next;
+}
+function interruptUIMessage(message, toolError = "Tool execution was interrupted.") {
+	const next = structuredClone(message);
+	next.parts = next.parts.filter((value) => {
+		const part = value;
+		return !isToolPart(part) || part["state"] !== "input-streaming";
+	});
+	for (const value of next.parts) {
+		if (value["type"] === "text" || value["type"] === "reasoning") {
+			if (value["state"] === "streaming") value["state"] = "done";
+			continue;
+		}
+		if (!isToolPart(value)) continue;
+		const state = value["state"];
+		if (state === "approval-responded") {
+			const approval = value["approval"];
+			if (isRecord$3(approval) && approval["approved"] === false) {
+				value["state"] = "output-denied";
+				continue;
+			}
+		}
+		if (state === "output-available" && value["preliminary"] === true) {
+			delete value["output"];
+			delete value["preliminary"];
+			value["state"] = "output-error";
+			value["errorText"] = toolError;
+			continue;
+		}
+		if (state === "input-available" || state === "approval-requested" || state === "approval-responded") {
+			if (state === "approval-requested") delete value["approval"];
+			value["state"] = "output-error";
+			value["errorText"] = toolError;
+		}
+	}
+	return next;
+}
+//#endregion
+//#region src/ai-progress-batches.ts
+const PAGE_SIZE = 64;
+const appendProgressBatch = ({ batches, batch }) => {
+	if (batches.tail.length < PAGE_SIZE) return {
+		...batches,
+		length: batches.length + 1,
+		tail: [...batches.tail, batch]
+	};
+	const blocks = [...batches.blocks];
+	let block = batches.tail;
+	let level = 0;
+	for (;;) {
+		const left = blocks[level];
+		if (left == null) break;
+		block = {
+			left,
+			right: block
+		};
+		blocks[level] = null;
+		level += 1;
+	}
+	blocks[level] = block;
+	return {
+		length: batches.length + 1,
+		tail: [batch],
+		blocks
+	};
+};
+const progressBatches = (items = []) => {
+	let batches = {
+		length: 0,
+		tail: [],
+		blocks: []
+	};
+	for (const batch of items) batches = appendProgressBatch({
+		batches,
+		batch
+	});
+	return batches;
+};
+const flattenProgressBatches = (batches) => {
+	const items = [];
+	const visit = (block) => {
+		if (Array.isArray(block)) items.push(...block);
+		else {
+			visit(block.left);
+			visit(block.right);
+		}
+	};
+	for (let level = batches.blocks.length - 1; level >= 0; level -= 1) {
+		const block = batches.blocks[level];
+		if (block) visit(block);
+	}
+	items.push(...batches.tail);
+	return items;
+};
+//#endregion
+//#region src/ai-message-projection.ts
+const isRecord$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const upsertMessage = (messages, message) => {
+	const index = messages.findIndex((candidate) => candidate.id === message.id);
+	if (index === -1) return [...messages, message];
+	const next = [...messages];
+	next[index] = message;
+	return next;
+};
+const upsertResponse = (options) => {
+	const { messages, message, inputId } = options;
+	if (messages.some((item) => item.id === message.id)) return upsertMessage(messages, message);
+	const inputIndex = messages.findIndex((item) => item.id === inputId);
+	if (inputIndex === -1) return [...messages, message];
+	return [
+		...messages.slice(0, inputIndex + 1),
+		message,
+		...messages.slice(inputIndex + 1)
+	];
+};
+const answerApproval = (messages, response) => messages.map((message) => {
+	if (message.id !== response.messageId) return message;
+	let changed = false;
+	const parts = message.parts.map((part) => {
+		const candidate = part;
+		if (!isRecord$2(candidate) || candidate["state"] !== "approval-requested" || !isRecord$2(candidate["approval"]) || candidate["approval"]["id"] !== response.approvalId) return part;
+		changed = true;
+		return {
+			...part,
+			state: "approval-responded",
+			approval: {
+				...candidate["approval"],
+				approved: response.approved,
+				...response.reason === void 0 ? {} : { reason: response.reason }
+			}
+		};
+	});
+	return changed ? {
+		...message,
+		parts
+	} : message;
+});
+const approvalRequestedChunk = (payload) => ({
+	type: "tool-approval-request",
+	approvalId: payload.approvalId,
+	toolCallId: payload.toolCallId,
+	...payload.isAutomatic === void 0 ? {} : { isAutomatic: payload.isAutomatic },
+	...payload.signature === void 0 ? {} : { signature: payload.signature }
+});
+const approvalRespondedChunk = (payload) => ({
+	type: "tool-approval-response",
+	approvalId: payload.approvalId,
+	approved: payload.approved,
+	...payload.reason === void 0 ? {} : { reason: payload.reason }
+});
+const toolResultChunk = (payload) => {
+	if (payload.phase === "input") return {
+		type: "tool-input-error",
+		toolCallId: payload.toolCallId,
+		toolName: payload.toolName ?? "unknown",
+		input: payload.rawInput ?? payload.input,
+		errorText: payload.error ?? "Invalid tool input",
+		...payload.dynamic === void 0 ? {} : { dynamic: payload.dynamic },
+		...payload.providerExecuted === void 0 ? {} : { providerExecuted: payload.providerExecuted },
+		...payload.providerMetadata === void 0 ? {} : { providerMetadata: payload.providerMetadata },
+		...payload.toolMetadata === void 0 ? {} : { toolMetadata: payload.toolMetadata }
+	};
+	if (payload.denied === true) return {
+		type: "tool-output-denied",
+		toolCallId: payload.toolCallId
+	};
+	if (payload.error !== void 0) return {
+		type: "tool-output-error",
+		toolCallId: payload.toolCallId,
+		errorText: payload.error,
+		...payload.dynamic === void 0 ? {} : { dynamic: payload.dynamic },
+		...payload.providerExecuted === void 0 ? {} : { providerExecuted: payload.providerExecuted },
+		...payload.providerMetadata === void 0 ? {} : { providerMetadata: payload.providerMetadata },
+		...payload.toolMetadata === void 0 ? {} : { toolMetadata: payload.toolMetadata }
+	};
+	return {
+		type: "tool-output-available",
+		toolCallId: payload.toolCallId,
+		output: payload.output,
+		...payload.preliminary === void 0 ? {} : { preliminary: payload.preliminary },
+		...payload.dynamic === void 0 ? {} : { dynamic: payload.dynamic },
+		...payload.providerExecuted === void 0 ? {} : { providerExecuted: payload.providerExecuted },
+		...payload.providerMetadata === void 0 ? {} : { providerMetadata: payload.providerMetadata },
+		...payload.toolMetadata === void 0 ? {} : { toolMetadata: payload.toolMetadata }
+	};
+};
+const projectedMessageStream = (projection) => {
+	const projectionEvents = flattenProgressBatches(projection.batches);
+	for (const event of projection.toolEvents) if (event.type === "ai.tool.result") projectionEvents.push({
+		index: event.index,
+		chunks: [toolResultChunk(event.payload)]
+	});
+	for (const event of projection.approvalEvents) projectionEvents.push({
+		index: event.index,
+		chunks: [event.type === "ai.approval.requested" ? approvalRequestedChunk(event.payload) : approvalRespondedChunk(event.payload)]
+	});
+	return projectUIMessageStream({
+		messageId: projection.responseMessageId,
+		...projection.baseMessage === void 0 ? {} : { base: projection.baseMessage },
+		chunks: projectionEvents.toSorted((left, right) => left.index - right.index).flatMap((event) => event.chunks)
+	});
+};
+const projectedMessage = (projection) => projectedMessageStream(projection).message;
+const reduceToolActivity = (tools, event) => {
+	if (event.type === "ai.tool.called") {
+		const payload = event.payload;
+		const { providerMetadata, ...called } = payload;
+		const activity = {
+			...called,
+			...providerMetadata === void 0 ? {} : { callProviderMetadata: providerMetadata },
+			status: "running"
+		};
+		return [...tools.filter((candidate) => candidate.generationId !== payload.generationId || candidate.toolCallId !== payload.toolCallId), activity];
+	}
+	const payload = event.payload;
+	const existing = tools.find((candidate) => candidate.generationId === payload.generationId && candidate.toolCallId === payload.toolCallId);
+	const toolName = payload.toolName ?? existing?.toolName;
+	const input = payload.input === void 0 ? existing?.input : payload.input;
+	const dynamic = payload.dynamic ?? existing?.dynamic;
+	const providerExecuted = payload.providerExecuted ?? existing?.providerExecuted;
+	const toolMetadata = payload.toolMetadata ?? existing?.toolMetadata;
+	const resultProviderMetadata = payload.providerMetadata ?? existing?.resultProviderMetadata;
+	const activity = {
+		requestId: payload.requestId,
+		messageId: payload.messageId,
+		generationId: payload.generationId,
+		toolCallId: payload.toolCallId,
+		...toolName === void 0 ? {} : { toolName },
+		...input === void 0 ? {} : { input },
+		...payload.rawInput === void 0 ? {} : { rawInput: payload.rawInput },
+		...payload.output === void 0 ? {} : { output: payload.output },
+		...payload.error === void 0 ? {} : { error: payload.error },
+		...payload.preliminary === void 0 ? {} : { preliminary: payload.preliminary },
+		...payload.phase === void 0 ? {} : { phase: payload.phase },
+		...dynamic === void 0 ? {} : { dynamic },
+		...providerExecuted === void 0 ? {} : { providerExecuted },
+		...existing?.callProviderMetadata === void 0 ? {} : { callProviderMetadata: existing.callProviderMetadata },
+		...resultProviderMetadata === void 0 ? {} : { resultProviderMetadata },
+		...toolMetadata === void 0 ? {} : { toolMetadata },
+		...existing?.title === void 0 ? {} : { title: existing.title },
+		status: payload.denied ? "denied" : payload.error ? "failed" : payload.preliminary ? "running" : "completed"
+	};
+	return [...tools.filter((candidate) => candidate.generationId !== payload.generationId || candidate.toolCallId !== payload.toolCallId), activity];
+};
+const advanceProjection = ({ projection, base, chunks, index }) => {
+	const batches = index > (projection.batches.tail.at(-1)?.index ?? -1) ? appendProgressBatch({
+		batches: projection.batches,
+		batch: {
+			index,
+			chunks
+		}
+	}) : progressBatches([...flattenProgressBatches(projection.batches).filter((batch) => batch.index !== index), {
+		index,
+		chunks
+	}].toSorted((left, right) => left.index - right.index));
+	const incremental = base !== void 0 && projection.cursor != null && index > projection.cursor.throughIndex;
+	const projected = incremental ? projectUIMessageStream({
+		messageId: projection.responseMessageId,
+		base,
+		cursor: projection.cursor.stream,
+		chunks
+	}) : projectedMessageStream({
+		...projection,
+		batches
+	});
+	return {
+		message: projected.message,
+		batches,
+		cursor: {
+			throughIndex: incremental ? index : Math.max(index, batches.tail.at(-1)?.index ?? 0, projection.toolEvents.reduce((latest, event) => Math.max(latest, event.index), 0), projection.approvalEvents.reduce((latest, event) => Math.max(latest, event.index), 0)),
+			stream: projected.cursor
+		}
+	};
+};
+//#endregion
+//#region src/ai-stored-state.ts
+const aiStateReducer = Symbol("a2.ai.stateReducer");
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const hasKeys = (value, { required, optional = [] }) => isRecord$1(value) && required.every((key) => Object.hasOwn(value, key)) && Object.keys(value).every((key) => required.includes(key) || optional.includes(key));
+const reference = (value) => {
+	if (!isRecord$1(value) || !Object.hasOwn(value, "$a2Value")) return void 0;
+	const id = value["$a2Value"];
+	if (typeof id !== "number" || !Number.isSafeInteger(id) || id < 0 || Object.keys(value).length !== 1) throw new TypeError("invalid AI payload reference");
+	return id;
+};
+const payloadFields = /* @__PURE__ */ new Set([
+	"input",
+	"output",
+	"rawInput",
+	"metadata",
+	"providerMetadata",
+	"callProviderMetadata",
+	"resultProviderMetadata",
+	"toolMetadata",
+	"data"
+]);
+const keyFor = (value) => value === void 0 ? "undefined" : JSON.stringify(value);
+const sameValue = (left, right) => {
+	if (Object.is(left, right)) return true;
+	if (typeof left !== "object" || left === null || typeof right !== "object" || right === null) return false;
+	const prototype = Object.getPrototypeOf(left);
+	if (prototype !== Object.getPrototypeOf(right) || prototype !== Object.prototype && prototype !== Array.prototype && prototype !== null) return false;
+	if (Array.isArray(left) && (!Array.isArray(right) || left.length !== right.length)) return false;
+	const keys = Reflect.ownKeys(left);
+	return keys.length === Reflect.ownKeys(right).length && keys.every((key) => Object.hasOwn(right, key) && sameValue(Reflect.get(left, key), Reflect.get(right, key)));
+};
+const restore = (current, undo) => {
+	if (undo === void 0) return current;
+	if (!isRecord$1(undo)) throw new TypeError("invalid AI recovery change");
+	if ("value" in undo) {
+		if (!hasKeys(undo, { required: ["value"] })) throw new TypeError("invalid AI replacement recovery");
+		return undo.value;
+	}
+	if ("length" in undo) {
+		if (!hasKeys(undo, { required: ["length", "items"] }) || !Number.isSafeInteger(undo.length) || undo.length < 0 || undo.length > 4294967295 || !isRecord$1(undo.items) || !Array.isArray(current)) throw new TypeError("invalid AI array recovery");
+		const items = Object.entries(undo.items);
+		let added = 0;
+		for (const [key, patch] of items) {
+			const index = Number(key);
+			if (!Number.isSafeInteger(index) || index < 0 || index >= undo.length || String(index) !== key || patch === void 0) throw new TypeError("invalid AI array recovery index");
+			if (index >= current.length) added += 1;
+		}
+		if (added !== Math.max(0, undo.length - current.length)) throw new TypeError("incomplete AI array recovery");
+		const result = current.slice(0, undo.length);
+		result.length = undo.length;
+		for (const [index, patch] of items) result[Number(index)] = restore(current[Number(index)] ?? null, patch);
+		return result;
+	}
+	if (!hasKeys(undo, { required: ["fields", "remove"] }) || !isRecord$1(undo.fields) || !Array.isArray(undo.remove) || Object.keys(undo.remove).length !== undo.remove.length || Array.from(undo.remove).some((key) => typeof key !== "string") || new Set(undo.remove).size !== undo.remove.length || !isRecord$1(current) || reference(current) !== void 0) throw new TypeError("invalid AI object recovery");
+	const result = { ...current };
+	for (const key of undo.remove) delete result[key];
+	for (const [key, patch] of Object.entries(undo.fields)) {
+		if (patch === void 0 || undo.remove.includes(key)) throw new TypeError("invalid AI object recovery field");
+		Object.defineProperty(result, key, {
+			value: restore(Object.hasOwn(result, key) ? result[key] : null, patch),
+			enumerable: true,
+			configurable: true,
+			writable: true
+		});
+	}
+	return result;
+};
+const difference = (current, before) => {
+	if (current === before) return void 0;
+	if (reference(current) !== void 0 || reference(before) !== void 0) return reference(current) === reference(before) ? void 0 : { value: before };
+	if (Array.isArray(current) && Array.isArray(before)) {
+		const items = {};
+		for (const [index, value] of before.entries()) {
+			const patch = index < current.length ? difference(current[index], value) : { value };
+			if (patch !== void 0) items[index] = patch;
+		}
+		return current.length === before.length && Object.keys(items).length === 0 ? void 0 : {
+			length: before.length,
+			items
+		};
+	}
+	if (isRecord$1(current) && isRecord$1(before)) {
+		const fields = {};
+		const remove = Object.keys(current).filter((key) => !Object.hasOwn(before, key));
+		for (const [key, value] of Object.entries(before)) {
+			const patch = Object.hasOwn(current, key) ? difference(current[key], value) : { value };
+			if (patch !== void 0) Object.defineProperty(fields, key, {
+				value: patch,
+				enumerable: true,
+				configurable: true,
+				writable: true
+			});
+		}
+		return remove.length === 0 && Object.keys(fields).length === 0 ? void 0 : {
+			fields,
+			remove
+		};
+	}
+	return { value: before };
+};
+const storeState = (state) => {
+	const packed = /* @__PURE__ */ new WeakMap();
+	const values = [];
+	const ids = /* @__PURE__ */ new Map();
+	const contents = /* @__PURE__ */ new Map();
+	const intern = (value) => {
+		let id = ids.get(value);
+		if (id !== void 0) return { $a2Value: id };
+		const key = typeof value === "object" && value !== null ? keyFor(value) : void 0;
+		const candidates = key === void 0 ? void 0 : contents.get(key);
+		if (candidates !== void 0) id = candidates.find((candidate) => sameValue(values[candidate].value, value));
+		if (id === void 0) {
+			id = values.length;
+			values.push(value === void 0 ? {} : { value });
+		}
+		ids.set(value, id);
+		if (key !== void 0 && !candidates?.includes(id)) contents.set(key, [...candidates ?? [], id]);
+		return { $a2Value: id };
+	};
+	const pack = (value, field) => {
+		if (value === void 0 || typeof value === "string" && value.length > 80 || field !== void 0 && payloadFields.has(field) && !(field === "input" && isRecord$1(value) && "message" in value) || isRecord$1(value) && Object.hasOwn(value, "$a2Value")) return intern(value);
+		if (value === null || typeof value === "string" || typeof value === "boolean" || typeof value === "number") return value;
+		if (typeof value !== "object") throw new TypeError("AI state must contain JSON values");
+		const cached = packed.get(value);
+		if (cached !== void 0) return cached;
+		const result = Array.isArray(value) ? value.map((item) => pack(item)) : Object.fromEntries(Object.entries(value).toSorted(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => [key, pack(item, key)]));
+		packed.set(value, result);
+		return result;
+	};
+	const saveProjection = (projection, messages, tools) => {
+		const { baseMessage, baseTools, ...fields } = projection;
+		const current = messages.find((message) => message.id === projection.responseMessageId);
+		const message = baseMessage === void 0 ? void 0 : difference(pack(current), pack(baseMessage));
+		const toolPatch = baseTools === void 0 ? void 0 : difference(pack(tools), pack(baseTools));
+		return {
+			fields: pack(fields),
+			hasMessage: baseMessage !== void 0,
+			...message === void 0 ? {} : { message },
+			...toolPatch === void 0 ? {} : { tools: toolPatch }
+		};
+	};
+	const { activeProjection, ...fields } = state;
+	const projection = activeProjection === null ? null : saveProjection(activeProjection, state.messages, state.tools);
+	return {
+		version: 2,
+		fields: pack(fields),
+		projection,
+		values
+	};
+};
+const loadState = (stored) => {
+	const unpack = (value) => {
+		const id = reference(value);
+		if (id !== void 0) {
+			if (!Object.hasOwn(stored.values, id)) throw new TypeError("missing AI payload");
+			return stored.values[id].value;
+		}
+		if (Array.isArray(value)) {
+			if (Object.keys(value).length !== value.length) throw new TypeError("invalid AI stored array");
+			return Array.from(value, unpack);
+		}
+		if (isRecord$1(value)) return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, unpack(item)]));
+		if (value === null || typeof value === "boolean" || typeof value === "string" || typeof value === "number" && Number.isFinite(value)) return value;
+		throw new TypeError("invalid AI stored value");
+	};
+	const fields = stored.fields;
+	const state = unpack(stored.fields);
+	const loadProjection = (saved, messages, tools) => {
+		if (!hasKeys(saved, {
+			required: ["fields", "hasMessage"],
+			optional: ["message", "tools"]
+		}) || typeof saved.hasMessage !== "boolean" || !isRecord$1(saved.fields) || "message" in saved && (!saved.hasMessage || saved.message === void 0) || "tools" in saved && saved.tools === void 0) throw new TypeError("invalid AI projection recovery");
+		const projection = unpack(saved.fields);
+		const index = unpack(messages).findIndex((message) => message.id === projection.responseMessageId);
+		if (saved.hasMessage) {
+			const current = index === -1 ? null : messages[index];
+			projection.baseMessage = unpack(restore(current, saved.message));
+		}
+		if (tools !== void 0) projection.baseTools = unpack(restore(tools, saved.tools));
+		else if (saved.tools !== void 0) throw new TypeError("missing AI recovery tools");
+		return projection;
+	};
+	state.activeProjection = stored.projection === null ? null : loadProjection(stored.projection, fields["messages"], fields["tools"]);
+	return state;
+};
+const storedAIReducer = (source) => {
+	const views = /* @__PURE__ */ new WeakMap();
+	const view = (state) => {
+		let result = views.get(state);
+		if (result === void 0) {
+			result = loadState(state);
+			views.set(state, result);
+		}
+		return result;
+	};
+	const defer = (next) => {
+		let stored;
+		const read = () => stored ??= storeState(next);
+		const state = {
+			version: 2,
+			get fields() {
+				return read().fields;
+			},
+			get projection() {
+				return read().projection;
+			},
+			get values() {
+				return read().values;
+			}
+		};
+		views.set(state, next);
+		return state;
+	};
+	return {
+		...source,
+		name: `${source.name}:records-v2`,
+		initialState: storeState(source.initialState),
+		[aiStateReducer]: source,
+		view,
+		fromView: (state) => storeState(state),
+		[clientStateProjection]: (state) => source[clientStateProjection]?.(view(state)) ?? view(state),
+		stateSchema: { "~standard": {
+			version: 1,
+			vendor: "a2-ai",
+			validate(value) {
+				try {
+					if (!hasKeys(value, { required: [
+						"version",
+						"fields",
+						"projection",
+						"values"
+					] }) || value["version"] !== 2 || !Array.isArray(value["values"]) || !isRecord$1(value["fields"]) || value["projection"] !== null && !isRecord$1(value["projection"])) return { issues: [{ message: "invalid AI stored state" }] };
+					const state = value;
+					if (Object.keys(state.values).length !== state.values.length) return { issues: [{ message: "invalid AI payload table" }] };
+					for (const payload of state.values) if (!hasKeys(payload, {
+						required: [],
+						optional: ["value"]
+					})) return { issues: [{ message: "invalid AI payload table" }] };
+					const decoded = loadState(state);
+					if (source.stateSchema) {
+						const result = validateSync(source.stateSchema, decoded, "AI view stateSchema");
+						if (result.issues) return result;
+						return { value: storeState(result.value) };
+					}
+					return { value: state };
+				} catch {
+					return { issues: [{ message: "invalid AI stored state" }] };
+				}
+			}
+		} },
+		fold(state, event) {
+			const current = view(state);
+			const next = source.fold(current, event);
+			if (next === current) return state;
+			return defer(next);
+		}
+	};
+};
+//#endregion
+//#region src/ai.ts
+const issue = (message) => ({ issues: [{ message }] });
+const schema = (label, parse) => ({ "~standard": {
+	version: 1,
+	vendor: "a2",
+	validate(value) {
+		try {
+			return parse(value);
+		} catch (error) {
+			return issue(`${label}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+} });
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isJSONCompatible = (value, seen = /* @__PURE__ */ new Set()) => {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (typeof value === "undefined") return true;
+	if (typeof value !== "object") return false;
+	if (seen.has(value)) return false;
+	seen.add(value);
+	const valid = Array.isArray(value) ? value.every((item) => isJSONCompatible(item, seen)) : Object.getPrototypeOf(value) === Object.prototype && Object.values(value).every((item) => isJSONCompatible(item, seen));
+	seen.delete(value);
+	return valid;
+};
+const jsonObject = (label, check) => schema(label, (value) => {
+	if (!isRecord(value) || !isJSONCompatible(value) || !check(value)) return issue(`invalid ${label}`);
+	return { value };
+});
+const stringField = (value, key) => typeof value[key] === "string" && value[key].length > 0;
+const optionalIndexField = (value, key) => value[key] === void 0 || typeof value[key] === "number" && Number.isSafeInteger(value[key]) && value[key] >= 0;
+const optionalStringField = (value, key) => value[key] === void 0 || typeof value[key] === "string";
+const messageValue = (value) => isRecord(value) && typeof value["id"] === "string" && (value["role"] === "user" || value["role"] === "assistant" || value["role"] === "system") && Array.isArray(value["parts"]) && value["parts"].every((part) => isRecord(part) && typeof part["type"] === "string") && isJSONCompatible(value);
+const validateMessage = (value, messageSchema) => {
+	if (!messageValue(value)) return issue("invalid AI SDK UIMessage");
+	if (!messageSchema) return { value };
+	return validateSync(messageSchema, value, "the AI message");
+};
+const messagePayloadSchema = (messageSchema) => schema("ai.message.created", (value) => {
+	if (!isRecord(value)) return issue("invalid ai.message.created payload");
+	const message = validateMessage(value["message"], messageSchema);
+	if (message.issues) return { issues: message.issues };
+	const generate = value["generate"];
+	if (generate !== void 0 && typeof generate !== "boolean") return issue("invalid ai.message.created generate flag");
+	return { value: {
+		message: message.value,
+		...generate === false ? { generate: false } : {}
+	} };
+});
+const progressPayloadSchema = schema("ai.generation.progress", (value) => {
+	if (!isRecord(value) || !isJSONCompatible(value) || !stringField(value, "requestId") || !stringField(value, "messageId") || !stringField(value, "generationId") || !stringField(value, "responseMessageId") || typeof value["sequence"] !== "number" || !Number.isInteger(value["sequence"]) || value["sequence"] < 0 || !Array.isArray(value["chunks"]) || !value["chunks"].every((chunk) => isRecord(chunk) && typeof chunk["type"] === "string")) return issue("invalid ai.generation.progress payload");
+	return { value };
+});
+const completedPayloadSchema = schema("ai.generation.completed", (value) => {
+	if (!isRecord(value) || !isJSONCompatible(value) || !stringField(value, "requestId") || !stringField(value, "messageId") || !stringField(value, "generationId") || !stringField(value, "responseMessageId") || !optionalIndexField(value, "inputTokenEstimate") || !optionalStringField(value, "finishReason")) return issue("invalid ai.generation.completed payload");
+	return { value };
+});
+const compactionPayloadSchema = (messageSchema) => schema("ai.compaction.completed", (value) => {
+	if (!isRecord(value) || !isJSONCompatible(value) || !stringField(value, "generationId") || !stringField(value, "throughMessageId") || !optionalIndexField(value, "throughIndex") || !optionalStringField(value, "summary") || !Array.isArray(value["messages"]) || value["retainedMessageIds"] !== void 0 && (!Array.isArray(value["retainedMessageIds"]) || !value["retainedMessageIds"].every((candidate) => typeof candidate === "string"))) return issue("invalid ai.compaction.completed payload");
+	const messages = [];
+	for (const candidate of value["messages"]) {
+		const result = validateMessage(candidate, messageSchema);
+		if (result.issues) return { issues: result.issues };
+		messages.push(result.value);
+	}
+	return { value: {
+		generationId: value["generationId"],
+		throughMessageId: value["throughMessageId"],
+		...value["throughIndex"] === void 0 ? {} : { throughIndex: value["throughIndex"] },
+		messages,
+		...value["summary"] === void 0 ? {} : { summary: value["summary"] },
+		...value["usage"] === void 0 ? {} : { usage: value["usage"] },
+		...value["retainedMessageIds"] === void 0 ? {} : { retainedMessageIds: value["retainedMessageIds"] }
+	} };
+});
+function createEvents(options) {
+	const messageSchema = options?.messageSchema;
+	if (messageSchema) assertSyncSchema(messageSchema, "the AI message schema");
+	const definition = {
+		"ai.control.requested": schema("ai.control.requested", (value) => {
+			if (!isRecord(value) || !isJSONCompatible(value)) return issue("invalid AI command");
+			const action = value["action"];
+			const forwarded = {
+				approval: ["ai.approval.responded", "response"],
+				"tool-result": ["ai.tool.result", "result"],
+				input: ["ai.input.responded", "response"],
+				"request-input": ["ai.input.requested", "request"],
+				retry: ["ai.retry.requested", "request"],
+				interrupt: ["ai.message.interrupted", "request"]
+			};
+			if (typeof action === "string" && Object.hasOwn(forwarded, action)) {
+				const [type, key] = forwarded[action];
+				const payload = validateSync(definition[type], value[key], "AI command");
+				if (payload.issues) return { issues: payload.issues };
+				return { value: {
+					action,
+					[key]: payload.value
+				} };
+			}
+			if (action === "send" || action === "edit" || action === "steer") {
+				const parsed = validateMessage(value["message"], messageSchema);
+				if (parsed.issues) return parsed;
+				if ((action === "send" || action === "steer") && (parsed.value.id.length === 0 || parsed.value.id.startsWith("a2.ai:"))) return issue("AI input IDs must be nonempty and outside the reserved internal prefix");
+				if (action === "steer" && (!stringField(value, "turnId") || !optionalIndexField(value, "lastSeenIndex")) || action === "send" && value["generate"] !== void 0 && typeof value["generate"] !== "boolean") return issue("invalid AI command");
+				return { value: {
+					...value,
+					message: parsed.value
+				} };
+			}
+			if (action === "remove" && stringField(value, "inputId") || action === "send-now" && stringField(value, "inputId") && (value["turnId"] === null || stringField(value, "turnId")) && optionalIndexField(value, "lastSeenIndex") || action === "move" && stringField(value, "inputId") && (value["beforeId"] === null || stringField(value, "beforeId")) || action === "stop" && stringField(value, "turnId") && optionalIndexField(value, "lastSeenIndex") || action === "pause" && (value["when"] === "now" || value["when"] === "after-turn") || action === "resume") return { value };
+			return issue("invalid AI command");
+		}),
+		"ai.control.committed": jsonObject("ai.control.committed", (value) => Array.isArray(value["changes"]) && isRecord(value["view"])),
+		"ai.control.decided": jsonObject("ai.control.decided", (value) => stringField(value, "commandId") && (value["outcome"] === "applied" || value["outcome"] === "rejected")),
+		"ai.work.reported": schema("ai.work.reported", (value) => {
+			if (!isRecord(value) || !isJSONCompatible(value) || !stringField(value, "workId") || !stringField(value, "turnId") || typeof value["version"] !== "number" || !optionalIndexField(value, "version") || typeof value["attempt"] !== "number" || !Number.isSafeInteger(value["attempt"]) || value["attempt"] < 1 || typeof value["settled"] !== "boolean" || value["kind"] !== "model" && value["kind"] !== "tool" || !Array.isArray(value["events"])) return issue("invalid AI work report");
+			const allowed = /* @__PURE__ */ new Set([
+				"ai.generation.started",
+				"ai.generation.completed",
+				"ai.generation.failed",
+				"ai.tool.called",
+				"ai.tool.result",
+				"ai.approval.requested",
+				"ai.approval.responded",
+				"ai.compaction.requested",
+				"ai.compaction.completed",
+				"ai.model.metadata.requested"
+			]);
+			const events = [];
+			for (const event of value["events"]) {
+				if (!isRecord(event) || !stringField(event, "id") || typeof event["type"] !== "string" || !allowed.has(event["type"]) || value["kind"] === "tool" && event["type"] !== "ai.tool.result") return issue("invalid AI work fact");
+				const parsed = validateSync(definition[event["type"]], event["payload"], "AI work fact");
+				if (parsed.issues) return { issues: parsed.issues };
+				events.push({
+					id: event["id"],
+					type: event["type"],
+					payload: parsed.value
+				});
+			}
+			return { value: {
+				...value,
+				events
+			} };
+		}),
+		"ai.tool.execution.requested": jsonObject("ai.tool.execution.requested", (value) => stringField(value, "turnId") && optionalIndexField(value, "version") && isRecord(value["call"]) && isRecord(value["generation"])),
+		"ai.generation.paused": jsonObject("ai.generation.paused", (value) => stringField(value, "generationId") && stringField(value, "messageId")),
+		"ai.session.created": jsonObject("ai.session.created", () => true),
+		"ai.session.closed": jsonObject("ai.session.closed", (value) => optionalStringField(value, "reason")),
+		"ai.message.created": messagePayloadSchema(messageSchema),
+		"ai.message.completed": jsonObject("ai.message.completed", (value) => stringField(value, "messageId")),
+		"ai.message.interrupted": jsonObject("ai.message.interrupted", (value) => stringField(value, "messageId") && (stringField(value, "generationId") && value["requestId"] === void 0 || stringField(value, "requestId") && value["generationId"] === void 0) && optionalStringField(value, "reason") && (value["lastSeenIndex"] === void 0 || typeof value["lastSeenIndex"] === "number" && Number.isInteger(value["lastSeenIndex"]) && value["lastSeenIndex"] >= 0)),
+		"ai.generation.requested": jsonObject("ai.generation.requested", (value) => stringField(value, "messageId") && stringField(value, "responseMessageId") && optionalStringField(value, "sourceGenerationId") && (value["reason"] !== "tool" || stringField(value, "sourceGenerationId")) && (value["reason"] === "message" || value["reason"] === "tool" || value["reason"] === "input" || value["reason"] === "retry" || value["reason"] === "resume")),
+		"ai.retry.requested": jsonObject("ai.retry.requested", (value) => stringField(value, "messageId") && stringField(value, "responseMessageId") && stringField(value, "retryId")),
+		"ai.generation.started": jsonObject("ai.generation.started", (value) => stringField(value, "requestId") && stringField(value, "messageId") && stringField(value, "generationId") && stringField(value, "responseMessageId") && typeof value["attempt"] === "number" && Number.isInteger(value["attempt"]) && value["attempt"] > 0 && stringField(value, "model") && optionalIndexField(value, "promptThroughIndex")),
+		"ai.generation.progress": progressPayloadSchema,
+		"ai.generation.completed": completedPayloadSchema,
+		"ai.generation.failed": jsonObject("ai.generation.failed", (value) => stringField(value, "requestId") && stringField(value, "messageId") && stringField(value, "generationId") && stringField(value, "responseMessageId") && stringField(value, "error") && (value["superseded"] === void 0 || typeof value["superseded"] === "boolean") && (value["stepLimit"] === void 0 || typeof value["stepLimit"] === "boolean")),
+		"ai.tool.called": jsonObject("ai.tool.called", (value) => stringField(value, "requestId") && stringField(value, "messageId") && stringField(value, "generationId") && stringField(value, "toolCallId") && stringField(value, "toolName") && (value["dynamic"] === void 0 || typeof value["dynamic"] === "boolean") && (value["providerExecuted"] === void 0 || typeof value["providerExecuted"] === "boolean") && (value["supportsDeferredResults"] === void 0 || typeof value["supportsDeferredResults"] === "boolean") && optionalStringField(value, "title")),
+		"ai.tool.result": jsonObject("ai.tool.result", (value) => stringField(value, "requestId") && stringField(value, "messageId") && stringField(value, "generationId") && stringField(value, "toolCallId") && optionalStringField(value, "toolName") && optionalStringField(value, "error") && (value["denied"] === void 0 || typeof value["denied"] === "boolean") && (value["preliminary"] === void 0 || typeof value["preliminary"] === "boolean") && (value["phase"] === void 0 || value["phase"] === "input" || value["phase"] === "execution") && (value["dynamic"] === void 0 || typeof value["dynamic"] === "boolean") && (value["providerExecuted"] === void 0 || typeof value["providerExecuted"] === "boolean")),
+		"ai.approval.requested": jsonObject("ai.approval.requested", (value) => stringField(value, "requestId") && stringField(value, "messageId") && stringField(value, "generationId") && stringField(value, "approvalId") && stringField(value, "toolCallId") && (value["isAutomatic"] === void 0 || typeof value["isAutomatic"] === "boolean") && optionalStringField(value, "signature")),
+		"ai.approval.responded": jsonObject("ai.approval.responded", (value) => stringField(value, "requestId") && stringField(value, "messageId") && stringField(value, "generationId") && stringField(value, "approvalId") && typeof value["approved"] === "boolean" && optionalStringField(value, "reason")),
+		"ai.input.requested": jsonObject("ai.input.requested", (value) => stringField(value, "requestId") && stringField(value, "messageId") && stringField(value, "generationId") && stringField(value, "inputId") && stringField(value, "name")),
+		"ai.input.responded": jsonObject("ai.input.responded", (value) => stringField(value, "requestId") && stringField(value, "messageId") && stringField(value, "generationId") && stringField(value, "inputId") && stringField(value, "name")),
+		"ai.compaction.requested": jsonObject("ai.compaction.requested", (value) => stringField(value, "generationId") && stringField(value, "throughMessageId") && optionalIndexField(value, "throughIndex") && optionalIndexField(value, "inputTokenEstimate") && optionalIndexField(value, "inputTokens") && optionalIndexField(value, "thresholdTokens")),
+		"ai.compaction.completed": compactionPayloadSchema(messageSchema),
+		"ai.model.metadata.requested": jsonObject("ai.model.metadata.requested", (value) => stringField(value, "modelId")),
+		"ai.model.metadata.resolved": jsonObject("ai.model.metadata.resolved", (value) => stringField(value, "modelId") && (value["limits"] === null || isRecord(value["limits"]) && typeof value["limits"]["contextWindow"] === "number" && Number.isSafeInteger(value["limits"]["contextWindow"]) && value["limits"]["contextWindow"] > 0 && typeof value["limits"]["maxOutputTokens"] === "number" && Number.isSafeInteger(value["limits"]["maxOutputTokens"]) && value["limits"]["maxOutputTokens"] > 0))
+	};
+	return definition;
+}
+const events = createEvents();
+const initialState = () => ({
+	inbox: initialControlState().inbox,
+	pendingQueueCommands: [],
+	active: null,
+	starting: false,
+	receipt: null,
+	session: { created: false },
+	messages: [],
+	status: "idle",
+	activeGeneration: null,
+	activeRequestId: null,
+	activeRequestReason: null,
+	activeRequestSourceGenerationId: null,
+	activeResponseMessageId: null,
+	activeProjection: null,
+	responseOwners: {},
+	pendingApprovals: [],
+	pendingInputs: [],
+	tools: [],
+	compaction: null,
+	modelMetadata: {},
+	usage: [],
+	error: null
+});
+const projectMessageChunks = (messages, messageId, chunks) => messages.map((message) => message.id === messageId ? projectUIMessage({
+	messageId,
+	base: message,
+	chunks
+}) : message);
+const waitingStatus = (state) => {
+	if (state.pendingApprovals.length > 0 || state.pendingInputs.length > 0) return "waiting";
+	return state.activeGeneration !== null || state.tools.some((activity) => activity.status === "running") ? "generating" : "idle";
+};
+const lifecycleStatus = (previous, next) => previous.status === "failed" ? "failed" : waitingStatus(next);
+const isStaleGeneration = (state, messageId, owner) => {
+	const current = state.responseOwners[messageId];
+	return current !== void 0 && (current.generationId !== owner.generationId || current.requestId !== owner.requestId);
+};
+const projectedResponse = (options) => {
+	const message = projectedMessage(options.projection);
+	return options.state.pausedGenerationIds?.[options.projection.generationId] ? pauseUIMessage({
+		message,
+		toolCallIds: new Set(options.state.tools.map((tool) => tool.toolCallId))
+	}) : message;
+};
+const projectedTools = (projection) => projection.toolEvents.reduce((tools, event) => reduceToolActivity(tools, event), projection.baseTools);
+const restoreGenerationBase = (state, generationId, responseMessageId, reason) => {
+	const projection = state.activeProjection?.generationId === generationId ? state.activeProjection : null;
+	return {
+		...state,
+		messages: projection?.baseMessage === void 0 ? state.messages.filter((message) => message.id !== responseMessageId) : upsertMessage(state.messages, projection.baseMessage),
+		tools: projection === null ? state.tools.filter((activity) => activity.generationId !== generationId) : projection.baseTools,
+		pendingApprovals: state.pendingApprovals.filter((approval) => approval.generationId !== generationId),
+		pendingInputs: state.pendingInputs.filter((input) => input.generationId !== generationId),
+		activeGeneration: null,
+		activeProjection: null,
+		terminalGenerations: {
+			...state.terminalGenerations,
+			[generationId]: reason
+		},
+		compaction: projection === null ? state.compaction?.generationId === generationId ? null : state.compaction : projection.baseCompaction ?? null
+	};
+};
+const stopGenerationTools = (tools, generationId, responseMessageId, error) => tools.map((activity) => activity.status === "running" && (generationId === void 0 ? activity.messageId === responseMessageId : activity.generationId === generationId) ? {
+	...activity,
+	status: "failed",
+	error,
+	preliminary: false
+} : activity);
+const interruptGenerationProjection = (state, generationId, responseMessageId, cutoff) => {
+	const projection = state.activeProjection?.generationId === generationId ? state.activeProjection : null;
+	if (projection === null) return null;
+	const retained = {
+		...projection,
+		batches: progressBatches(flattenProgressBatches(projection.batches).filter((batch) => batch.index <= cutoff)),
+		toolEvents: projection.toolEvents.filter((toolEvent) => toolEvent.index <= cutoff),
+		approvalEvents: projection.approvalEvents.filter((approvalEvent) => approvalEvent.index <= cutoff)
+	};
+	const shouldProject = retained.baseMessage !== void 0 || retained.batches.length > 0;
+	const restored = restoreGenerationBase(state, generationId, responseMessageId, "interrupted");
+	return {
+		...restored,
+		messages: shouldProject ? upsertMessage(state.messages, interruptUIMessage(projectedMessage(retained))) : restored.messages,
+		tools: stopGenerationTools(projectedTools(retained), generationId, responseMessageId, "Tool execution was interrupted."),
+		usage: projection.completionIndex === void 0 || projection.completionIndex <= cutoff ? restored.usage : restored.usage.filter((entry) => entry.generationId !== generationId)
+	};
+};
+const terminalGenerationReason = (state, generationId, requestId) => {
+	const terminal = state.terminalGenerations?.[generationId];
+	if (terminal !== void 0) return terminal;
+	return requestId !== void 0 && state.terminalRequestIds?.[requestId] === true ? "interrupted" : void 0;
+};
+/** Pure projection of the built-in AI protocol. Unknown extension events are ignored. */
+function reduceAIState(state, event) {
+	if (state.status === "closed") return state;
+	switch (event.type) {
+		case "ai.control.requested": {
+			const command = event.payload;
+			if (!event.id || !isQueueCommand(command)) return state;
+			const pending = state.pendingQueueCommands ?? [];
+			if (pending.some((item) => item.commandId === event.id)) return state;
+			if ((command.action === "send" || command.action === "steer") && (state.messages.some((message) => message.id === command.message.id) || state.inbox.items.some((item) => item.id === command.message.id))) return state;
+			return {
+				...state,
+				pendingQueueCommands: [...pending, {
+					commandId: event.id,
+					command
+				}]
+			};
+		}
+		case "ai.control.committed": {
+			const commit = event.payload;
+			const visible = applyControlChanges({
+				state: {
+					inbox: state.inbox,
+					active: state.active
+				},
+				changes: commit.changes.filter((change) => change.path[0] === "inbox" || change.path[0] === "active")
+			});
+			const { phase } = commit.view;
+			const status = commit.view.closed ? "closed" : phase === "paused" || phase === "pausing" || commit.view.paused && phase === null ? "paused" : phase === "failed" ? "failed" : phase === "starting" || phase === "generating" ? "generating" : phase ? "waiting" : "idle";
+			return {
+				...state,
+				...visible,
+				status,
+				activeRequestId: commit.view.requestId,
+				activeRequestReason: commit.view.requestReason,
+				activeRequestSourceGenerationId: commit.view.sourceGenerationId,
+				activeResponseMessageId: commit.view.responseMessageId
+			};
+		}
+		case "ai.control.decided": {
+			const receipt = event.payload;
+			if (receipt.work) return state;
+			const pending = state.pendingQueueCommands ?? [];
+			const settled = pending.find((item) => item.commandId === receipt.commandId);
+			return {
+				...state,
+				receipt,
+				...settled === void 0 ? {} : { pendingQueueCommands: pending.filter((item) => item.commandId !== receipt.commandId) }
+			};
+		}
+		case "ai.generation.paused": {
+			const payload = event.payload;
+			const toolCallIds = new Set(state.tools.filter((tool) => tool.messageId === payload.messageId).map((tool) => tool.toolCallId));
+			const projection = state.activeProjection;
+			return {
+				...state,
+				activeGeneration: null,
+				activeProjection: projection?.generationId === payload.generationId ? {
+					...projection,
+					cursor: null,
+					batches: progressBatches(flattenProgressBatches(projection.batches).map((batch) => ({
+						index: batch.index,
+						chunks: batch.chunks.filter((chunk) => !("toolCallId" in chunk) || toolCallIds.has(chunk.toolCallId))
+					})))
+				} : projection,
+				compaction: state.compaction?.status === "running" ? projection?.baseCompaction ?? null : state.compaction,
+				messages: state.messages.map((message) => message.id === payload.messageId ? pauseUIMessage({
+					message,
+					toolCallIds
+				}) : message),
+				pausedGenerationIds: {
+					...state.pausedGenerationIds,
+					[payload.generationId]: true
+				}
+			};
+		}
+		case "ai.model.metadata.requested": {
+			const { modelId } = event.payload;
+			if (Object.hasOwn(state.modelMetadata, modelId)) return state;
+			return {
+				...state,
+				modelMetadata: {
+					...state.modelMetadata,
+					[modelId]: { status: "pending" }
+				}
+			};
+		}
+		case "ai.model.metadata.resolved": {
+			const { modelId, limits } = event.payload;
+			return {
+				...state,
+				modelMetadata: {
+					...state.modelMetadata,
+					[modelId]: limits === null ? { status: "unavailable" } : {
+						status: "resolved",
+						limits
+					}
+				}
+			};
+		}
+		case "ai.session.created": {
+			const payload = event.payload;
+			return {
+				...state,
+				session: {
+					created: true,
+					...payload.metadata === void 0 ? state.session.metadata === void 0 ? {} : { metadata: state.session.metadata } : { metadata: payload.metadata }
+				}
+			};
+		}
+		case "ai.session.closed": return {
+			...state,
+			active: null,
+			inbox: {
+				paused: true,
+				items: []
+			},
+			pendingQueueCommands: [],
+			status: "closed",
+			compaction: state.compaction?.status === "running" ? state.activeProjection?.baseCompaction ?? null : state.compaction,
+			activeGeneration: null,
+			activeRequestId: null,
+			activeRequestReason: null,
+			activeRequestSourceGenerationId: null,
+			activeResponseMessageId: null,
+			activeProjection: null
+		};
+		case "ai.message.created": {
+			const { message } = event.payload;
+			return {
+				...state,
+				messages: upsertMessage(state.messages, message),
+				activeProjection: state.activeProjection?.responseMessageId === message.id ? {
+					...state.activeProjection,
+					cursor: null
+				} : state.activeProjection
+			};
+		}
+		case "ai.message.completed": {
+			const { messageId } = event.payload;
+			const owner = state.responseOwners[messageId];
+			const generationId = owner?.generationId;
+			const requestId = owner?.requestId;
+			if (generationId === void 0 || terminalGenerationReason(state, generationId, requestId) !== void 0) return state;
+			return {
+				...state,
+				activeRequestId: null,
+				activeRequestReason: null,
+				activeRequestSourceGenerationId: null,
+				activeResponseMessageId: null,
+				activeProjection: state.activeProjection?.generationId === generationId ? null : state.activeProjection,
+				terminalGenerations: {
+					...state.terminalGenerations,
+					[generationId]: "completed"
+				},
+				...requestId === void 0 ? {} : { terminalRequestIds: {
+					...state.terminalRequestIds,
+					[requestId]: true
+				} }
+			};
+		}
+		case "ai.generation.requested": {
+			const payload = event.payload;
+			const schedulesToolContinuation = payload.reason === "tool";
+			const responseMessageId = payload.responseMessageId;
+			const owner = state.responseOwners[responseMessageId];
+			const ownerGenerationId = owner?.generationId;
+			const ownerRequestId = owner?.requestId;
+			const requestId = event.id;
+			if (requestId !== void 0 && state.terminalRequestIds?.[requestId] === true) return state;
+			if (!(payload.control !== void 0 && state.activeRequestId === event.id || payload.reason === "message" || (payload.reason === "tool" ? ownerGenerationId !== void 0 && payload.sourceGenerationId === ownerGenerationId && state.activeRequestId === ownerRequestId && state.status !== "failed" : payload.reason === "retry" ? state.status === "failed" : ownerGenerationId !== void 0 && payload.sourceGenerationId === ownerGenerationId && state.activeRequestId === ownerRequestId && state.status !== "failed"))) return state;
+			return {
+				...payload.reason === "retry" && state.activeProjection && state.activeProjection.completionIndex === void 0 ? restoreGenerationBase(state, state.activeProjection.generationId, responseMessageId, "failed") : state,
+				activeProjection: payload.reason === "retry" ? null : state.activeProjection,
+				status: schedulesToolContinuation ? state.status : "generating",
+				activeRequestId: requestId ?? null,
+				activeRequestReason: payload.reason,
+				activeRequestSourceGenerationId: payload.sourceGenerationId ?? null,
+				activeResponseMessageId: responseMessageId,
+				error: schedulesToolContinuation ? state.error : null
+			};
+		}
+		case "ai.generation.started": {
+			const payload = event.payload;
+			if (state.terminalRequestIds?.[payload.requestId] === true || terminalGenerationReason(state, payload.generationId, payload.requestId) !== void 0) return state;
+			if (state.activeRequestId !== null && state.activeRequestId !== payload.requestId) return state;
+			const currentOwner = state.responseOwners[payload.responseMessageId];
+			const currentTerminal = currentOwner === void 0 ? void 0 : terminalGenerationReason(state, currentOwner.generationId, currentOwner.requestId);
+			if (currentTerminal === "completed" || currentTerminal === "interrupted") return state;
+			if (currentOwner?.requestId === payload.requestId && currentOwner.attempt >= payload.attempt) return state;
+			const activeGeneration = state.activeGeneration;
+			const baseState = activeGeneration !== null && activeGeneration.requestId === payload.requestId && activeGeneration.responseMessageId === payload.responseMessageId && activeGeneration.attempt < payload.attempt && state.activeProjection?.generationId === activeGeneration.generationId ? restoreGenerationBase(state, activeGeneration.generationId, activeGeneration.responseMessageId, "superseded") : state;
+			const baseMessage = baseState.messages.find((message) => message.id === payload.responseMessageId);
+			return {
+				...baseState,
+				status: "generating",
+				activeGeneration: payload,
+				activeResponseMessageId: null,
+				responseOwners: {
+					...baseState.responseOwners,
+					[payload.responseMessageId]: {
+						generationId: payload.generationId,
+						requestId: payload.requestId,
+						attempt: payload.attempt
+					}
+				},
+				activeProjection: {
+					generationId: payload.generationId,
+					responseMessageId: payload.responseMessageId,
+					promptThroughIndex: payload.promptThroughIndex ?? event.index - 1,
+					...baseMessage === void 0 ? {} : { baseMessage },
+					baseCompaction: baseState.compaction,
+					batches: progressBatches(),
+					baseTools: baseState.tools,
+					toolEvents: [],
+					approvalEvents: []
+				},
+				error: null
+			};
+		}
+		case "ai.generation.progress": {
+			const payload = event.payload;
+			if (state.pausedGenerationIds?.[payload.generationId]) return state;
+			if (terminalGenerationReason(state, payload.generationId, payload.requestId) !== void 0) return state;
+			const activeProjection = state.activeProjection;
+			if (state.activeGeneration?.generationId !== payload.generationId || state.activeGeneration.requestId !== payload.requestId || activeProjection?.generationId !== payload.generationId) return state;
+			const progress = advanceProjection({
+				projection: activeProjection,
+				base: state.messages.find((message) => message.id === activeProjection.responseMessageId),
+				chunks: payload.chunks,
+				index: event.index
+			});
+			return {
+				...state,
+				messages: upsertResponse({
+					messages: state.messages,
+					message: progress.message,
+					inputId: state.activeGeneration.messageId
+				}),
+				activeProjection: {
+					...activeProjection,
+					batches: progress.batches,
+					cursor: progress.cursor
+				},
+				status: "generating"
+			};
+		}
+		case "ai.generation.completed": {
+			const payload = event.payload;
+			if (terminalGenerationReason(state, payload.generationId, payload.requestId) !== void 0) return state;
+			if (state.activeGeneration?.generationId !== payload.generationId || state.activeGeneration.requestId !== payload.requestId) return state;
+			const usage = payload.usage ? [...state.usage.filter((entry) => entry.generationId !== payload.generationId), {
+				generationId: payload.generationId,
+				usage: payload.usage
+			}] : state.usage;
+			const next = {
+				...state,
+				activeGeneration: null,
+				activeProjection: state.activeProjection?.generationId === payload.generationId ? {
+					...state.activeProjection,
+					completionIndex: event.index
+				} : state.activeProjection,
+				usage
+			};
+			return {
+				...next,
+				status: waitingStatus(next)
+			};
+		}
+		case "ai.generation.failed": {
+			const payload = event.payload;
+			if (terminalGenerationReason(state, payload.generationId, payload.requestId) !== void 0) return state;
+			if ((state.activeGeneration?.generationId !== payload.generationId || state.activeGeneration.requestId !== payload.requestId) && !(payload.stepLimit === true && state.activeRequestReason === "tool" && state.responseOwners[payload.responseMessageId]?.requestId === payload.requestId && state.responseOwners[payload.responseMessageId]?.generationId === payload.generationId && state.activeRequestSourceGenerationId === payload.generationId && state.activeResponseMessageId === payload.responseMessageId)) return state;
+			if (payload.superseded === true) return restoreGenerationBase(state, payload.generationId, payload.responseMessageId, "superseded");
+			const projection = state.activeProjection?.generationId === payload.generationId ? state.activeProjection : null;
+			const shouldProject = projection !== null && (projection.baseMessage !== void 0 || projection.batches.length > 0);
+			return {
+				...state,
+				messages: shouldProject ? upsertMessage(state.messages, interruptUIMessage(projectedMessage(projection), `Generation failed before tool completion: ${payload.error}`)) : state.messages,
+				status: "failed",
+				activeGeneration: null,
+				activeResponseMessageId: null,
+				activeProjection: projection,
+				terminalGenerations: {
+					...state.terminalGenerations,
+					[payload.generationId]: "failed"
+				},
+				terminalRequestIds: {
+					...state.terminalRequestIds,
+					[payload.requestId]: true,
+					...state.activeRequestId === null ? {} : { [state.activeRequestId]: true }
+				},
+				compaction: projection?.generationId === payload.generationId ? projection.baseCompaction ?? null : state.compaction?.generationId === payload.generationId ? null : state.compaction,
+				pendingApprovals: state.pendingApprovals.filter((approval) => approval.generationId !== payload.generationId),
+				pendingInputs: state.pendingInputs.filter((input) => input.generationId !== payload.generationId),
+				tools: stopGenerationTools(state.tools, payload.generationId, payload.responseMessageId, payload.error),
+				error: payload.error
+			};
+		}
+		case "ai.message.interrupted": {
+			const payload = event.payload;
+			const owner = state.responseOwners[payload.messageId];
+			const currentGenerationId = owner?.generationId;
+			const targetRequestId = payload.requestId ?? (owner?.generationId === payload.generationId ? owner?.requestId : void 0);
+			const ownsRequestPhase = payload.requestId !== void 0 && state.activeGeneration === null && state.activeRequestId === payload.requestId && state.activeResponseMessageId === payload.messageId;
+			if (currentGenerationId !== void 0 && !ownsRequestPhase && (payload.generationId !== void 0 ? currentGenerationId !== payload.generationId : owner?.requestId !== payload.requestId)) return state;
+			if (state.activeGeneration === null && state.activeRequestId !== null && state.activeResponseMessageId === payload.messageId && targetRequestId !== state.activeRequestId) return state;
+			const currentTerminal = currentGenerationId === void 0 ? void 0 : terminalGenerationReason(state, currentGenerationId, owner?.requestId);
+			if (currentTerminal === "completed" || currentTerminal === "interrupted" || currentTerminal === "superseded") return state;
+			const active = state.activeGeneration;
+			if (active === null) {
+				if (payload.requestId !== void 0 && state.activeRequestId !== null && state.activeRequestId === payload.requestId && state.activeResponseMessageId === payload.messageId) {
+					const baseState = (currentGenerationId === void 0 ? null : interruptGenerationProjection(state, currentGenerationId, payload.messageId, payload.lastSeenIndex ?? Number.POSITIVE_INFINITY)) ?? state;
+					return {
+						...baseState,
+						status: "idle",
+						activeRequestId: null,
+						activeRequestReason: null,
+						activeRequestSourceGenerationId: null,
+						activeResponseMessageId: null,
+						activeProjection: null,
+						terminalRequestIds: {
+							...baseState.terminalRequestIds,
+							[payload.requestId]: true
+						},
+						...currentGenerationId === void 0 ? {} : { terminalGenerations: {
+							...baseState.terminalGenerations,
+							[currentGenerationId]: "interrupted"
+						} },
+						error: null
+					};
+				}
+				const targetGenerationId = payload.generationId ?? (currentGenerationId !== void 0 && owner?.requestId === payload.requestId ? currentGenerationId : void 0);
+				if (targetGenerationId === void 0) return state;
+				if (currentGenerationId !== targetGenerationId) return state;
+				const matchesGeneration = (generationId) => targetGenerationId === generationId;
+				const hasMessageWork = state.pendingApprovals.some((approval) => approval.messageId === payload.messageId && matchesGeneration(approval.generationId)) || state.pendingInputs.some((input) => input.messageId === payload.messageId && matchesGeneration(input.generationId)) || state.tools.some((activity) => activity.messageId === payload.messageId && activity.status === "running" && matchesGeneration(activity.generationId));
+				const resolvesFailedGeneration = state.status === "failed" && currentGenerationId === targetGenerationId && (state.activeRequestId === null || state.activeRequestId === targetRequestId || state.activeRequestReason === "tool" && state.activeRequestSourceGenerationId === targetGenerationId);
+				if (!hasMessageWork && !resolvesFailedGeneration && !(currentGenerationId === targetGenerationId && currentTerminal === void 0)) return state;
+				const pendingRequestId = state.activeRequestId;
+				const projectedState = interruptGenerationProjection(state, targetGenerationId, payload.messageId, payload.lastSeenIndex ?? Number.POSITIVE_INFINITY);
+				const baseState = projectedState ?? state;
+				const next = {
+					...baseState,
+					activeRequestId: null,
+					activeRequestReason: null,
+					activeRequestSourceGenerationId: null,
+					activeResponseMessageId: null,
+					activeProjection: null,
+					messages: projectedState === null ? state.messages.map((message) => message.id === payload.messageId ? interruptUIMessage(message) : message) : baseState.messages,
+					pendingApprovals: baseState.pendingApprovals.filter((approval) => approval.messageId !== payload.messageId || !matchesGeneration(approval.generationId)),
+					pendingInputs: baseState.pendingInputs.filter((input) => input.messageId !== payload.messageId || !matchesGeneration(input.generationId)),
+					tools: projectedState === null ? stopGenerationTools(state.tools, targetGenerationId, payload.messageId, "Tool execution was interrupted.") : baseState.tools,
+					terminalGenerations: {
+						...baseState.terminalGenerations,
+						[targetGenerationId]: "interrupted"
+					},
+					...pendingRequestId === null ? {} : { terminalRequestIds: {
+						...baseState.terminalRequestIds,
+						[pendingRequestId]: true
+					} },
+					error: resolvesFailedGeneration ? null : state.error
+				};
+				return {
+					...next,
+					status: waitingStatus(next)
+				};
+			}
+			if (payload.messageId !== active.responseMessageId || payload.generationId !== active.generationId && payload.requestId !== active.requestId) return state;
+			const cutoff = payload.lastSeenIndex ?? Number.POSITIVE_INFINITY;
+			const projectedState = interruptGenerationProjection(state, active.generationId, active.responseMessageId, cutoff);
+			const baseState = projectedState ?? restoreGenerationBase(state, active.generationId, active.responseMessageId, "interrupted");
+			const next = {
+				...baseState,
+				activeRequestId: null,
+				activeRequestReason: null,
+				activeRequestSourceGenerationId: null,
+				activeResponseMessageId: null,
+				terminalRequestIds: {
+					...baseState.terminalRequestIds,
+					[active.requestId]: true
+				},
+				tools: projectedState === null ? stopGenerationTools(baseState.tools, active.generationId, active.responseMessageId, "Tool execution was interrupted.") : baseState.tools
+			};
+			return {
+				...next,
+				status: lifecycleStatus(state, next)
+			};
+		}
+		case "ai.tool.called": {
+			const payload = event.payload;
+			const projection = state.activeProjection;
+			if (isStaleGeneration(state, payload.messageId, payload) || terminalGenerationReason(state, payload.generationId, payload.requestId) !== void 0) return state;
+			if (state.tools.some((activity) => activity.generationId === payload.generationId && activity.toolCallId === payload.toolCallId && activity.status === "failed" && state.activeGeneration?.generationId !== payload.generationId)) return state;
+			if (projection?.generationId !== payload.generationId) {
+				const next = {
+					...state,
+					tools: reduceToolActivity(state.tools, {
+						type: "ai.tool.called",
+						payload
+					})
+				};
+				return {
+					...next,
+					status: lifecycleStatus(state, next)
+				};
+			}
+			const activeProjection = {
+				...projection,
+				toolEvents: [...projection.toolEvents, {
+					index: event.index,
+					type: "ai.tool.called",
+					payload
+				}]
+			};
+			const next = {
+				...state,
+				activeProjection,
+				tools: projectedTools(activeProjection)
+			};
+			return {
+				...next,
+				status: lifecycleStatus(state, next)
+			};
+		}
+		case "ai.tool.result": {
+			const payload = event.payload;
+			const projection = state.activeProjection;
+			const terminalReason = terminalGenerationReason(state, payload.generationId, payload.requestId);
+			const completesFailedTool = terminalReason === "failed" && state.status === "failed" && payload.preliminary !== true && projection?.generationId === payload.generationId && projectedTools(projection).some((activity) => activity.generationId === payload.generationId && activity.toolCallId === payload.toolCallId && activity.status === "running");
+			if (isStaleGeneration(state, payload.messageId, payload) || terminalReason !== void 0 && !completesFailedTool) return state;
+			if (state.tools.some((activity) => activity.generationId === payload.generationId && activity.toolCallId === payload.toolCallId && activity.status === "failed" && state.activeGeneration?.generationId !== payload.generationId && !completesFailedTool)) return state;
+			if (projection?.generationId !== payload.generationId) {
+				const next = {
+					...state,
+					messages: projectMessageChunks(state.messages, payload.messageId, [toolResultChunk(payload)]),
+					tools: reduceToolActivity(state.tools, {
+						type: "ai.tool.result",
+						payload
+					})
+				};
+				return {
+					...next,
+					status: lifecycleStatus(state, next)
+				};
+			}
+			const activeProjection = {
+				...projection,
+				cursor: null,
+				toolEvents: [...projection.toolEvents, {
+					index: event.index,
+					type: "ai.tool.result",
+					payload
+				}]
+			};
+			const projected = projectedResponse({
+				state,
+				projection: activeProjection
+			});
+			const tools = projectedTools(activeProjection);
+			const failureError = state.error ?? "Generation failed.";
+			const next = {
+				...state,
+				messages: upsertMessage(state.messages, terminalReason === "failed" ? interruptUIMessage(projected, `Generation failed before tool completion: ${failureError}`) : projected),
+				activeProjection,
+				tools: terminalReason === "failed" ? stopGenerationTools(tools, payload.generationId, payload.messageId, failureError) : tools
+			};
+			return {
+				...next,
+				status: lifecycleStatus(state, next)
+			};
+		}
+		case "ai.approval.requested": {
+			const payload = event.payload;
+			const projection = state.activeProjection;
+			if (isStaleGeneration(state, payload.messageId, payload) || terminalGenerationReason(state, payload.generationId, payload.requestId) !== void 0) return state;
+			if (state.tools.some((activity) => activity.generationId === payload.generationId && activity.toolCallId === payload.toolCallId && activity.status === "failed" && state.activeGeneration?.generationId !== payload.generationId)) return state;
+			const activeProjection = projection?.generationId === payload.generationId ? {
+				...projection,
+				cursor: null,
+				approvalEvents: [...projection.approvalEvents, {
+					index: event.index,
+					type: "ai.approval.requested",
+					payload
+				}]
+			} : projection;
+			const next = {
+				...state,
+				messages: activeProjection === null || activeProjection === projection ? projectMessageChunks(state.messages, payload.messageId, [approvalRequestedChunk(payload)]) : upsertMessage(state.messages, projectedResponse({
+					state,
+					projection: activeProjection
+				})),
+				activeProjection,
+				pendingApprovals: payload.isAutomatic === true ? state.pendingApprovals : [...state.pendingApprovals.filter((approval) => approval.approvalId !== payload.approvalId || approval.messageId !== payload.messageId), payload]
+			};
+			return {
+				...next,
+				status: lifecycleStatus(state, next)
+			};
+		}
+		case "ai.approval.responded": {
+			const payload = event.payload;
+			if (isStaleGeneration(state, payload.messageId, payload) || terminalGenerationReason(state, payload.generationId, payload.requestId) !== void 0) return state;
+			const projection = state.activeProjection;
+			const pendingRequest = state.pendingApprovals.find((candidate) => candidate.approvalId === payload.approvalId && candidate.messageId === payload.messageId && candidate.generationId === payload.generationId);
+			const activeRequest = projection?.approvalEvents.findLast((candidate) => candidate.type === "ai.approval.requested" && candidate.payload.approvalId === payload.approvalId && candidate.payload.messageId === payload.messageId && candidate.payload.generationId === payload.generationId);
+			if (state.status === "failed" && pendingRequest === void 0 && activeRequest === void 0) return state;
+			const activeProjection = projection !== null && activeRequest !== void 0 ? {
+				...projection,
+				cursor: null,
+				approvalEvents: [...projection.approvalEvents, {
+					index: event.index,
+					type: "ai.approval.responded",
+					payload
+				}]
+			} : projection;
+			const next = {
+				...state,
+				messages: activeProjection === null || activeProjection === projection ? answerApproval(state.messages, payload) : upsertMessage(state.messages, projectedResponse({
+					state,
+					projection: activeProjection
+				})),
+				activeProjection: activeProjection === null ? null : {
+					...activeProjection,
+					cursor: null
+				},
+				pendingApprovals: state.pendingApprovals.filter((approval) => approval.approvalId !== payload.approvalId || approval.messageId !== payload.messageId || approval.generationId !== payload.generationId)
+			};
+			return {
+				...next,
+				status: lifecycleStatus(state, next)
+			};
+		}
+		case "ai.input.requested": {
+			const payload = event.payload;
+			if (isStaleGeneration(state, payload.messageId, payload) || terminalGenerationReason(state, payload.generationId, payload.requestId) !== void 0) return state;
+			const next = {
+				...state,
+				pendingInputs: [...state.pendingInputs.filter((input) => input.messageId !== payload.messageId || input.generationId !== payload.generationId || input.inputId !== payload.inputId), payload]
+			};
+			return {
+				...next,
+				status: lifecycleStatus(state, next)
+			};
+		}
+		case "ai.input.responded": {
+			const payload = event.payload;
+			if (isStaleGeneration(state, payload.messageId, payload) || terminalGenerationReason(state, payload.generationId, payload.requestId) !== void 0) return state;
+			const next = {
+				...state,
+				pendingInputs: state.pendingInputs.filter((input) => input.inputId !== payload.inputId || input.messageId !== payload.messageId || input.generationId !== payload.generationId)
+			};
+			return {
+				...next,
+				status: lifecycleStatus(state, next)
+			};
+		}
+		case "ai.compaction.requested": {
+			const payload = event.payload;
+			if (state.activeGeneration?.generationId !== payload.generationId) return state;
+			return {
+				...state,
+				compaction: {
+					status: "running",
+					...payload
+				}
+			};
+		}
+		case "ai.compaction.completed": {
+			const payload = event.payload;
+			if (state.activeGeneration?.generationId !== payload.generationId || state.compaction?.status !== "running" || state.compaction.generationId !== payload.generationId) return state;
+			const compaction = {
+				status: "completed",
+				...payload,
+				throughIndex: payload.throughIndex ?? state.activeProjection.promptThroughIndex
+			};
+			return {
+				...state,
+				compaction,
+				activeProjection: state.activeProjection && {
+					...state.activeProjection,
+					baseCompaction: compaction
+				}
+			};
+		}
+		default: return state;
+	}
+}
+/** Derive AI SDK UI messages directly from an A2 event history. */
+function deriveUIMessages(history) {
+	let state = initialState();
+	for (const event of history) state = reduceAIState(state, event);
+	return state.messages;
+}
+/** Build the standard AI state projection for any contract containing the protocol. */
+function createReducer(options) {
+	const reducer = options.contract.reducer({
+		name: options.name ?? "a2.ai.state.v21",
+		initialState: initialState(),
+		...options.stateSchema === void 0 ? {} : { stateSchema: options.stateSchema }
+	}).fold(options.fold ?? ((state, event) => reduceAIState(state, event)));
+	return storedAIReducer({
+		...reducer,
+		[clientStateProjection]: projectAIClientState
+	});
+}
+const commandInput = (payload) => [{
+	type: "ai.control.requested",
+	payload
+}];
+const messageInput = (message, generate) => [{
+	type: "ai.control.requested",
+	id: message.id,
+	payload: {
+		action: "send",
+		message,
+		...generate === false ? { generate: false } : {}
+	}
+}];
+/** Pure append inputs for the built-in AI protocol. */
+const inputs = {
+	toolResult: (result) => commandInput({
+		action: "tool-result",
+		result
+	}),
+	queue: {
+		remove: (options) => commandInput({
+			action: "remove",
+			...options
+		}),
+		sendNow: (options) => commandInput({
+			action: "send-now",
+			...options
+		}),
+		edit: (options) => commandInput({
+			action: "edit",
+			...options
+		}),
+		move: (options) => commandInput({
+			action: "move",
+			...options
+		})
+	},
+	stop: (options) => commandInput({
+		action: "stop",
+		...options
+	}),
+	steer: (options) => [{
+		type: "ai.control.requested",
+		id: options.message.id,
+		payload: {
+			action: "steer",
+			...options
+		}
+	}],
+	pause: (options) => commandInput({
+		action: "pause",
+		...options
+	}),
+	resume: () => commandInput({ action: "resume" }),
+	message(message, options) {
+		return messageInput(message, options?.generate);
+	},
+	seed(message) {
+		return messageInput(message, false);
+	},
+	approval: (response) => [{
+		...commandInput({
+			action: "approval",
+			response
+		})[0],
+		id: `ai.approval:${encodeURIComponent(response.requestId)}:${encodeURIComponent(response.messageId)}:${encodeURIComponent(response.generationId)}:${encodeURIComponent(response.approvalId)}:response`
+	}],
+	input: (response) => [{
+		...commandInput({
+			action: "input",
+			response
+		})[0],
+		id: `ai.input:${encodeURIComponent(response.requestId)}:${encodeURIComponent(response.messageId)}:${encodeURIComponent(response.generationId)}:${encodeURIComponent(response.inputId)}:response`
+	}],
+	requestInput: (request) => [{
+		...commandInput({
+			action: "request-input",
+			request
+		})[0],
+		id: `ai.input:${encodeURIComponent(request.requestId)}:${encodeURIComponent(request.messageId)}:${encodeURIComponent(request.generationId)}:${encodeURIComponent(request.inputId)}:request`
+	}],
+	retry: (request) => [{
+		...commandInput({
+			action: "retry",
+			request
+		})[0],
+		id: `ai.retry:${request.retryId}`
+	}],
+	interrupt: (request) => [{
+		...commandInput({
+			action: "interrupt",
+			request
+		})[0],
+		id: `ai.interrupt:${request.generationId ?? request.requestId}`
+	}]
+};
+/**
+* Read the durable handler context ambient to the current AI tool
+* execution. A2 runs each local tool's `execute` inside this scope, so
+* plain AI SDK `tool()` definitions reach their `event`, `attempt`,
+* `session`, and `signal` without an A2-specific wrapper. The agent (or
+* contract) argument carries the event types and is verified against
+* the executing server's contract.
+*/
+function handlerContext(agentOrContract) {
+	const contract = "contract" in agentOrContract ? agentOrContract.contract : agentOrContract;
+	const scope = ambientToolScopeStorage()?.getStore();
+	if (scope === void 0) throw new TypeError(`handlerContext('${contract.name}') requires an ambient A2 tool execution: call it inside a local tool's execute, or wrap direct tool tests with runWithHandlerContext`);
+	if (scope.contract !== void 0 && scope.contract.name !== contract.name) throw new TypeError(`handlerContext('${contract.name}') was called during a tool execution for agent '${scope.contract.name}'`);
+	return scope.context;
+}
+/**
+* Define an agent: built-in AI protocol + application events and one state
+* reducer. The result is isomorphic.
+*/
+function agent(options) {
+	const builtIns = createEvents(options.messageSchema === void 0 ? void 0 : { messageSchema: options.messageSchema });
+	const extensions = options.events ?? {};
+	for (const key of Object.keys(extensions)) if (Object.hasOwn(builtIns, key)) throw new TypeError(`agent event '${key}' conflicts with a built-in event`);
+	const agentContract = contract({
+		name: options.name,
+		events: {
+			...builtIns,
+			...extensions
+		}
+	});
+	const reducer = agentContract.reducer({
+		name: options.reducerName ?? "a2.ai.state.v21",
+		initialState: initialState()
+	}).fold((state, event) => reduceAIState(state, event));
+	return {
+		contract: agentContract,
+		reducer: storedAIReducer({
+			...reducer,
+			[clientStateProjection]: projectAIClientState
+		})
+	};
+}
+//#endregion
+export { applyControlChanges as C, initialControlState as S, progressBatches as _, events as a, AI_EVENT_ID_PREFIX as b, reduceAIState as c, advanceProjection as d, projectedMessage as f, flattenProgressBatches as g, upsertResponse as h, deriveUIMessages as i, aiStateReducer as l, upsertMessage as m, createEvents as n, handlerContext as o, reduceToolActivity as p, createReducer as r, inputs as s, agent as t, storedAIReducer as u, interruptUIMessage as v, controlCommit as w, aiEventId as x, pauseUIMessage as y };
+
+//# sourceMappingURL=ai-CrLYwNEx.js.map