experimental-a2 0.16.0 → 0.17.0

package/dist/{ai-CrLYwNEx.js → ai-UrWfKeuv.js}

@@ -1,251 +1,135 @@
-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 { a as reducer, o as assertSyncSchema, s as validateSync } from "./reducer-BAXc8JyF.js";
+import { t as contract } from "./contract-BYKASlCV.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;
+import { i as withReducerRuntime } from "./reducer-runtime-DQwz_J59.js";
+import { u as ambientToolScopeStorage } from "./internal-CbVvEwad.js";
+//#region src/equal-json.ts
+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)));
 };
-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();
+//#endregion
+//#region src/ai-message-base.ts
+const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const assertFields = (fields) => {
+	if (fields === void 0) return;
+	if (!record(fields)) throw new TypeError("invalid AI message base fields");
+	for (const [key, undo] of Object.entries(fields)) if (!record(undo) || Object.keys(undo).length > 1 || !(Object.keys(undo).length === 0 || "value" in undo || undo["remove"] === true || key === "text" && Number.isSafeInteger(undo["length"]) && undo["length"] >= 0)) throw new TypeError("invalid AI message base field");
+};
+/** Checks decoded recovery data; `restoreMessageBase` trusts this shape. */
+function assertMessageBase(value) {
+	if (!record(value) || !Number.isSafeInteger(value["partCount"]) || value["partCount"] < 0 || value["partCount"] > 4294967294 || Object.keys(value).some((key) => ![
+		"partCount",
+		"fields",
+		"parts"
+	].includes(key)) || value["parts"] !== void 0 && !record(value["parts"])) throw new TypeError("invalid AI message base");
+	assertFields(value["fields"]);
+	const partCount = value["partCount"];
+	for (const [key, undo] of Object.entries(value["parts"] ?? {})) {
+		const index = Number(key);
+		if (!Number.isSafeInteger(index) || String(index) !== key || index < 0 || index >= partCount || !record(undo) || Object.keys(undo).length !== 1 || !("value" in undo && record(undo["value"]) || "fields" in undo)) throw new TypeError("invalid AI message base part");
+		if ("fields" in undo) assertFields(undo["fields"]);
 	}
-	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;
+const restoreFields = (current, fields) => {
+	if (fields === void 0) return current;
+	const restored = { ...current };
+	for (const [key, undo] of Object.entries(fields)) if ("remove" in undo) delete restored[key];
+	else if ("length" in undo) {
+		const text = current[key];
+		if (typeof text !== "string" || undo.length > text.length) return void 0;
+		restored[key] = text.slice(0, undo.length);
+	} else Object.defineProperty(restored, key, {
+		value: undo.value,
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	return restored;
+};
+/** `undefined` when `base` no longer describes `current`, including a removed message. */
+const restoreMessageBase = (options) => {
+	const { current, base } = options;
+	if (base === void 0 || current === void 0) return void 0;
+	const parts = current.parts.slice(0, base.partCount);
+	for (const [key, undo] of Object.entries(base.parts ?? {})) {
+		const index = Number(key);
+		if ("value" in undo) {
+			parts[index] = undo.value;
+			continue;
 		}
-		changes.push({
-			path,
-			value: right
-		});
+		const part = parts[index];
+		const restored = part === void 0 ? void 0 : restoreFields(part, undo.fields);
+		if (!restored) return void 0;
+		parts[index] = restored;
+	}
+	if (parts.length !== base.partCount || Object.keys(parts).length !== parts.length) return void 0;
+	const { parts: _parts, ...fields } = current;
+	const restored = restoreFields(fields, base.fields);
+	return restored && {
+		...restored,
+		parts
 	};
-	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);
+const updateFields = (options) => {
+	const { before, after, undo } = options;
+	const original = restoreFields(before, undo);
+	if (!original) return void 0;
+	return Object.fromEntries([.../* @__PURE__ */ new Set([...Object.keys(original), ...Object.keys(after)])].flatMap((key) => {
+		if (Object.hasOwn(original, key) === Object.hasOwn(after, key) && sameValue(original[key], after[key])) return [];
+		const value = original[key];
+		const next = after[key];
+		return [[key, !Object.hasOwn(original, key) ? { remove: true } : key === "text" && typeof value === "string" && typeof next === "string" && next.startsWith(value) ? { length: value.length } : value === void 0 ? {} : { value }]];
+	}));
+};
+/** `undefined` when `before` no longer matches `base`, so the recovery must be dropped. */
+const updateMessageBase = (options) => {
+	const { base, before, after } = options;
+	if (before === after) return base;
+	const { parts: beforeParts, ...beforeFields } = before;
+	const { parts: afterParts, ...afterFields } = after;
+	const fields = updateFields({
+		before: beforeFields,
+		after: afterFields,
+		...base.fields && { undo: base.fields }
+	});
+	if (!fields) return void 0;
+	const parts = [];
+	for (let index = 0; index < base.partCount; index += 1) {
+		const previous = beforeParts[index];
+		const current = afterParts[index];
+		const undo = base.parts?.[index];
+		const original = undo && "value" in undo ? undo.value : previous;
+		if (!original) return void 0;
+		if (previous === current && undo === void 0) continue;
+		const originalFields = original;
+		const undoFields = undo && "fields" in undo ? undo.fields : void 0;
+		if (!current) {
+			const value = restoreFields(originalFields, undoFields);
+			if (!value) return void 0;
+			parts.push([String(index), { 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
+		const changed = updateFields({
+			before: originalFields,
+			after: current,
+			...undoFields && { undo: undoFields }
 		});
+		if (!changed) return void 0;
+		if (Object.keys(changed).length > 0) parts.push([String(index), { fields: changed }]);
 	}
-	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
-		}
+		partCount: base.partCount,
+		...Object.keys(fields).length > 0 && { fields },
+		...parts.length > 0 && { parts: Object.fromEntries(parts) }
 	};
 };
 //#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.
@@ -527,7 +411,13 @@ const cloneMessage = (messageId, base) => base === void 0 ? {
 } : {
 	...base,
 	id: messageId,
-	parts: base.parts.map((part) => ({ ...part }))
+	parts: [...base.parts]
+};
+const editPart = ({ parts, part }) => {
+	const index = parts.indexOf(part);
+	const next = { ...part };
+	parts[index] = next;
+	return next;
 };
 const currentStepParts = (parts) => {
 	let start = parts.length - 1;
@@ -540,6 +430,10 @@ const findToolPart = (parts, toolCallId) => {
 	if (current) return current;
 	return parts.findLast((part) => isToolPart(part) && part["toolCallId"] === toolCallId);
 };
+const hasToolCall = ({ message, call }) => {
+	const part = findToolPart(message.parts, call.toolCallId);
+	return part !== void 0 && part["state"] !== "input-streaming" && sameValue(part["input"], call.input) && (part["callProviderMetadata"] !== void 0 || call.providerMetadata === void 0) && (part["toolMetadata"] !== void 0 || call.toolMetadata === void 0) && (call.providerExecuted === void 0 || part["providerExecuted"] === call.providerExecuted) && (call.title === void 0 || part["title"] === call.title);
+};
 const findApprovalPart = (parts, approvalId) => parts.find((part) => {
 	const approval = part["approval"];
 	return isToolPart(part) && isRecord$3(approval) && approval["id"] === approvalId;
@@ -556,7 +450,10 @@ const setToolPart = (options) => {
 			toolCallId: options.toolCallId
 		};
 		options.parts.push(part);
-	}
+	} else part = editPart({
+		parts: options.parts,
+		part
+	});
 	part["state"] = options.state;
 	part["input"] = options.input;
 	delete part["output"];
@@ -614,13 +511,22 @@ function projectUIMessageStream(options) {
 				activeText.set(chunk.id, part);
 				parts.push(part);
 			}
+			part = editPart({
+				parts,
+				part
+			});
+			activeText.set(chunk.id, 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) {
+			const current = activeText.get(chunk.id);
+			if (current) {
+				const part = editPart({
+					parts,
+					part: current
+				});
 				part["state"] = "done";
 				setOptional(part, "providerMetadata", chunk.providerMetadata);
 				activeText.delete(chunk.id);
@@ -649,13 +555,22 @@ function projectUIMessageStream(options) {
 				activeReasoning.set(chunk.id, part);
 				parts.push(part);
 			}
-			part["text"] = `${typeof part["text"] === "string" ? part["text"] : ""}${chunk.delta}`;
+			part = editPart({
+				parts,
+				part
+			});
+			activeReasoning.set(chunk.id, 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) {
+			const current = activeReasoning.get(chunk.id);
+			if (current) {
+				const part = editPart({
+					parts,
+					part: current
+				});
 				part["state"] = "done";
 				setOptional(part, "providerMetadata", chunk.providerMetadata);
 				activeReasoning.delete(chunk.id);
@@ -737,6 +652,35 @@ function projectUIMessageStream(options) {
 			});
 			break;
 		}
+		case "a2-tool-called": {
+			const call = chunk.call;
+			const current = findToolPart(parts, call.toolCallId);
+			if (current) {
+				const existing = editPart({
+					parts,
+					part: current
+				});
+				existing["input"] = call.input;
+				if (existing["state"] === "input-streaming") existing["state"] = "input-available";
+				if (existing["callProviderMetadata"] === void 0) setOptional(existing, "callProviderMetadata", call.providerMetadata);
+				if (existing["toolMetadata"] === void 0) setOptional(existing, "toolMetadata", call.toolMetadata);
+				setOptional(existing, "providerExecuted", call.providerExecuted);
+				setOptional(existing, "title", call.title);
+			} else setToolPart({
+				parts,
+				toolCallId: call.toolCallId,
+				toolName: call.toolName,
+				dynamic: call.dynamic === true,
+				state: "input-available",
+				input: call.input,
+				providerExecuted: call.providerExecuted,
+				providerMetadata: call.providerMetadata,
+				toolMetadata: call.toolMetadata,
+				title: call.title
+			});
+			partialTools.delete(call.toolCallId);
+			break;
+		}
 		case "tool-input-available":
 			setToolPart({
 				parts,
@@ -772,8 +716,12 @@ function projectUIMessageStream(options) {
 			break;
 		}
 		case "tool-approval-request": {
-			const part = findToolPart(parts, chunk.toolCallId);
-			if (!part) break;
+			const current = findToolPart(parts, chunk.toolCallId);
+			if (!current) break;
+			const part = editPart({
+				parts,
+				part: current
+			});
 			part["state"] = "approval-requested";
 			part["approval"] = {
 				id: chunk.approvalId,
@@ -783,8 +731,12 @@ function projectUIMessageStream(options) {
 			break;
 		}
 		case "tool-approval-response": {
-			const part = findApprovalPart(parts, chunk.approvalId);
-			if (!part) break;
+			const current = findApprovalPart(parts, chunk.approvalId);
+			if (!current) break;
+			const part = editPart({
+				parts,
+				part: current
+			});
 			const approval = isRecord$3(part["approval"]) ? part["approval"] : {};
 			part["state"] = "approval-responded";
 			part["approval"] = {
@@ -838,7 +790,10 @@ function projectUIMessageStream(options) {
 		}
 		case "tool-output-denied": {
 			const part = findToolPart(parts, chunk.toolCallId);
-			if (part) part["state"] = "output-denied";
+			if (part) editPart({
+				parts,
+				part
+			})["state"] = "output-denied";
 			break;
 		}
 		case "start-step":
@@ -862,7 +817,10 @@ function projectUIMessageStream(options) {
 		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;
+			if (existing) editPart({
+				parts,
+				part: existing
+			})["data"] = chunk.data;
 			else parts.push({
 				type: chunk.type,
 				...chunk.id === void 0 ? {} : { id: chunk.id },
@@ -923,6 +881,7 @@ function interruptUIMessage(message, toolError = "Tool execution was interrupted
 }
 //#endregion
 //#region src/ai-progress-batches.ts
+const progressOwnedBy = ({ payload, owner, startIndex }) => "startIndex" in payload ? payload.startIndex === startIndex : payload.requestId === owner.requestId && payload.generationId === owner.generationId && payload.responseMessageId === owner.responseMessageId;
 const PAGE_SIZE = 64;
 const appendProgressBatch = ({ batches, batch }) => {
 	if (batches.tail.length < PAGE_SIZE) return {
@@ -981,22 +940,22 @@ const flattenProgressBatches = (batches) => {
 //#endregion
 //#region src/ai-message-projection.ts
 const isRecord$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const positionOf = (messages, id) => messages.findLastIndex((message) => message.id === id);
+const findMessage = (messages, id) => messages.findLast((message) => message.id === id);
 const upsertMessage = (messages, message) => {
-	const index = messages.findIndex((candidate) => candidate.id === message.id);
+	const index = positionOf(messages, message.id);
 	if (index === -1) return [...messages, message];
-	const next = [...messages];
-	next[index] = message;
-	return next;
+	return messages[index] === message ? messages : messages.with(index, message);
 };
 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];
+	if (positionOf(messages, message.id) !== -1) return upsertMessage(messages, message);
+	const inputIndex = positionOf(messages, inputId);
+	const position = inputIndex === -1 ? messages.length : inputIndex + 1;
 	return [
-		...messages.slice(0, inputIndex + 1),
+		...messages.slice(0, position),
 		message,
-		...messages.slice(inputIndex + 1)
+		...messages.slice(position)
 	];
 };
 const answerApproval = (messages, response) => messages.map((message) => {
@@ -1034,6 +993,10 @@ const approvalRespondedChunk = (payload) => ({
 	approved: payload.approved,
 	...payload.reason === void 0 ? {} : { reason: payload.reason }
 });
+const toolCalledChunk = (payload) => ({
+	type: "a2-tool-called",
+	call: payload
+});
 const toolResultChunk = (payload) => {
 	if (payload.phase === "input") return {
 		type: "tool-input-error",
@@ -1070,97 +1033,525 @@ const toolResultChunk = (payload) => {
 		...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 projectedMessageStream = ({ projection, current }) => {
+	const base = restoreMessageBase({
+		current,
+		base: projection.base
+	});
+	const projectionEvents = flattenProgressBatches(projection.batches);
+	for (const event of projection.toolEvents) projectionEvents.push({
+		index: event.index,
+		chunks: [event.type === "ai.tool.called" ? toolCalledChunk(event.payload) : 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)]
+	});
+	const ordered = projectionEvents.toSorted((left, right) => left.index - right.index);
+	return {
+		...projectUIMessageStream({
+			messageId: projection.responseMessageId,
+			...base === void 0 ? {} : { base },
+			chunks: ordered.flatMap((event) => event.chunks)
+		}),
+		throughIndex: ordered.at(-1)?.index ?? 0
+	};
+};
+const projectedMessage = (options) => projectedMessageStream(options).message;
+const reduceToolActivity = (tools, event) => {
+	if (event.type === "ai.tool.called") {
+		const payload = event.payload;
+		const activity = {
+			requestId: payload.requestId,
+			messageId: payload.messageId,
+			generationId: payload.generationId,
+			toolCallId: payload.toolCallId,
+			toolName: payload.toolName,
+			...payload.dynamic === void 0 ? {} : { dynamic: payload.dynamic },
+			...payload.providerExecuted === void 0 ? {} : { providerExecuted: payload.providerExecuted },
+			...payload.title === void 0 ? {} : { title: payload.title },
+			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 dynamic = payload.dynamic ?? existing?.dynamic;
+	const providerExecuted = payload.providerExecuted ?? existing?.providerExecuted;
+	const activity = {
+		requestId: payload.requestId,
+		messageId: payload.messageId,
+		generationId: payload.generationId,
+		toolCallId: payload.toolCallId,
+		...toolName === void 0 ? {} : { toolName },
+		...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?.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: {
+			...projection,
+			batches
+		},
+		current: base
+	});
+	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
+		}
+	};
+};
+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;
+	const restored = restoreMessageBase({
+		current: findMessage(state.messages, responseMessageId),
+		base: projection?.base
+	});
+	const base = restored !== void 0 && reason === "superseded" ? withoutRunningCompactionPart(restored, generationId) : restored;
+	return {
+		...state,
+		messages: base === void 0 ? state.messages.filter((message) => message.id !== responseMessageId) : upsertMessage(state.messages, base),
+		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.base !== void 0 || retained.batches.length > 0;
+	const restored = restoreGenerationBase(state, generationId, responseMessageId, "interrupted");
+	return {
+		...restored,
+		messages: shouldProject ? upsertMessage(state.messages, interruptUIMessage(projectedMessage({
+			projection: retained,
+			current: findMessage(state.messages, responseMessageId)
+		}))) : 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 retainMessageBase = (options) => {
+	const { before, after } = options;
+	const projection = after.activeProjection;
+	if (before.messages === after.messages || !projection?.base || projection.base !== before.activeProjection?.base) return after;
+	const previous = findMessage(before.messages, projection.responseMessageId);
+	const current = findMessage(after.messages, projection.responseMessageId);
+	if (previous !== void 0 && previous === current) return after;
+	const base = previous && current && updateMessageBase({
+		base: projection.base,
+		before: previous,
+		after: current
+	});
+	const { base: _stale, ...unrecoverable } = projection;
+	return {
+		...after,
+		activeProjection: base ? {
+			...unrecoverable,
+			base
+		} : unrecoverable
+	};
+};
+const isCompactionPart = (part) => part.type === "data-a2-compaction";
+const compactionPartOf = (message, generationId) => message.parts.findIndex((part) => isCompactionPart(part) && part.id === generationId);
+const withoutRunningCompactionPart = (message, generationId) => {
+	const index = compactionPartOf(message, generationId);
+	const part = message.parts[index];
+	return part !== void 0 && isCompactionPart(part) && part.data.status === "running" ? {
+		...message,
+		parts: message.parts.toSpliced(index, 1)
+	} : message;
+};
+/**
+* Compaction runs before its model step streams, so the part lands between
+* the response's earlier steps and this one. Counting it in the step's base
+* keeps it through Stop cutoffs, failures, and retries of that step.
+*/
+const addCompactionPart = (state, payload) => {
+	const projection = state.activeProjection;
+	if (projection?.generationId !== payload.generationId) return state;
+	const current = findMessage(state.messages, projection.responseMessageId);
+	if (current === void 0 ? projection.base !== void 0 : projection.base?.partCount !== current.parts.length) return state;
+	const inputTokens = payload.inputTokens ?? payload.inputTokenEstimate;
+	const part = {
+		type: "data-a2-compaction",
+		id: payload.generationId,
+		data: {
+			status: "running",
+			...inputTokens === void 0 ? {} : { inputTokens },
+			...payload.thresholdTokens === void 0 ? {} : { thresholdTokens: payload.thresholdTokens }
+		}
+	};
+	const message = current === void 0 ? {
+		id: projection.responseMessageId,
+		role: "assistant",
+		parts: [part]
+	} : {
+		...current,
+		parts: [...current.parts, part]
+	};
+	return {
+		...state,
+		messages: upsertResponse({
+			messages: state.messages,
+			message,
+			inputId: state.activeGeneration?.messageId ?? message.id
+		}),
+		activeProjection: {
+			...projection,
+			cursor: null,
+			base: projection.base === void 0 ? { partCount: 1 } : {
+				...projection.base,
+				partCount: projection.base.partCount + 1
+			}
+		}
+	};
+};
+const settleCompactionPart = (options) => {
+	const { state, generationId, data } = options;
+	const position = state.messages.findLastIndex((message) => compactionPartOf(message, generationId) !== -1);
+	if (position === -1) return state;
+	const message = state.messages[position];
+	const index = compactionPartOf(message, generationId);
+	const part = message.parts[index];
+	return {
+		...state,
+		messages: state.messages.with(position, {
+			...message,
+			parts: message.parts.with(index, {
+				...part,
+				data: {
+					...part.data,
+					...data
+				}
+			})
+		})
+	};
+};
+/** A running compaction whose state reverted without completing was abandoned. */
+const settleAbandonedCompaction = (before, after) => {
+	const running = before.compaction;
+	if (running?.status !== "running" || after.compaction === running || after.compaction?.status === "completed" && after.compaction.generationId === running.generationId) return after;
+	const interrupted = after.status === "closed" || after.pausedGenerationIds?.[running.generationId] === true || after.terminalGenerations?.[running.generationId] === "interrupted";
+	return settleCompactionPart({
+		state: after,
+		generationId: running.generationId,
+		data: { status: interrupted ? "interrupted" : "failed" }
+	});
+};
+//#endregion
+//#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" || command.action === "stop";
+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;
+				break;
+			case "stop": continue;
+		}
+		admit();
+	}
+	items = items.filter((item) => {
+		if (item.afterStepOf === void 0) return true;
+		show(item.message);
+		return false;
+	});
+	const displayed = {
+		...state,
+		messages,
+		inbox: {
+			items,
+			paused
+		},
+		starting: starting && !suspended
+	};
+	const stop = pending.find(({ command }) => command.action === "stop" && command.turnId === state.active?.turnId)?.command;
+	if (stop?.action !== "stop") return displayed;
+	const projection = state.activeProjection;
+	const stopped = projection === null ? displayed : interruptGenerationProjection(displayed, projection.generationId, projection.responseMessageId, stop.lastSeenIndex ?? Number.POSITIVE_INFINITY) ?? displayed;
+	return settleAbandonedCompaction(displayed, {
+		...stopped,
+		active: null,
+		status: paused ? "paused" : "idle",
+		starting: false,
+		activeGeneration: null,
+		activeRequestId: null,
+		activeRequestReason: null,
+		activeRequestSourceGenerationId: null,
+		activeResponseMessageId: null,
+		pendingApprovals: [],
+		pendingInputs: [],
+		error: null
+	});
+}
+//#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
+		});
 	}
-	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];
+	return next;
 };
-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
-	});
+const controlCommit = (options) => {
+	const active = options.after.active;
+	const response = options.after.coordinator.response;
 	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
+		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 = () => ({
+	pendingStops: {},
+	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/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) => {
@@ -1181,15 +1572,6 @@ const payloadFields = /* @__PURE__ */ new Set([
 	"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");
@@ -1288,22 +1670,18 @@ const storeState = (state) => {
 		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 saveProjection = (projection, tools) => {
+		const { baseTools, ...fields } = projection;
 		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);
+	const projection = activeProjection === null ? null : saveProjection(activeProjection, state.tools);
 	return {
-		version: 2,
+		version: 3,
 		fields: pack(fields),
 		projection,
 		values
@@ -1326,99 +1704,114 @@ const loadState = (stored) => {
 	};
 	const fields = stored.fields;
 	const state = unpack(stored.fields);
-	const loadProjection = (saved, messages, tools) => {
+	const loadProjection = (saved, 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");
+			required: ["fields"],
+			optional: ["tools"]
+		}) || !isRecord$1(saved.fields) || "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 (projection.base !== void 0) {
+			assertMessageBase(projection.base);
+			const current = state.messages.find((message) => message.id === projection.responseMessageId);
+			if (current !== void 0 && restoreMessageBase({
+				current,
+				base: projection.base
+			}) === void 0) throw new TypeError("AI message base does not match its 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"]);
+	state.activeProjection = stored.projection === null ? null : loadProjection(stored.projection, 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);
+const withAIStorage = (source) => withReducerRuntime({
+	reducer: source,
+	storage: {
+		encode: (state) => storeState(state),
+		decode(value) {
+			if (!hasKeys(value, { required: [
+				"version",
+				"fields",
+				"projection",
+				"values"
+			] }) || value["version"] !== 3 || !Array.isArray(value["values"]) || !isRecord$1(value["fields"]) || value["projection"] !== null && !isRecord$1(value["projection"])) throw new TypeError("invalid AI stored state");
+			const state = value;
+			if (Object.keys(state.values).length !== state.values.length) throw new TypeError("invalid AI payload table");
+			for (const payload of state.values) if (!hasKeys(payload, {
+				required: [],
+				optional: ["value"]
+			})) throw new TypeError("invalid AI payload table");
+			return loadState(state);
 		}
-	};
+	}
+});
+//#endregion
+//#region src/ai-app-state.ts
+const aiStateKeys = {
+	inbox: true,
+	pendingQueueCommands: true,
+	active: true,
+	starting: true,
+	receipt: true,
+	pausedGenerationIds: true,
+	session: true,
+	messages: true,
+	status: true,
+	activeGeneration: true,
+	activeRequestId: true,
+	activeRequestReason: true,
+	activeRequestSourceGenerationId: true,
+	activeResponseMessageId: true,
+	activeProjection: true,
+	responseOwners: true,
+	terminalRequestIds: true,
+	terminalGenerations: true,
+	pendingApprovals: true,
+	pendingInputs: true,
+	tools: true,
+	compaction: true,
+	modelMetadata: true,
+	usage: true,
+	error: true
+};
+const isAIStateKey = (key) => Object.hasOwn(aiStateKeys, key);
+const keep = (state, ai) => {
+	const kept = {};
+	for (const [key, value] of Object.entries(state)) if (isAIStateKey(key) === ai) kept[key] = value;
+	return kept;
+};
+/** The application part of a merged state: every key `AIState` does not own. */
+const appSlice = (state) => keep(state, false);
+/** A merged state with its application part replaced. */
+const withAppSlice = (state, app) => ({
+	...keep(state, true),
+	...keep(app, false)
+});
+const agentReducers = /* @__PURE__ */ new WeakMap();
+const registerAgentReducer = (reducer, app) => {
+	agentReducers.set(reducer, app ?? null);
+};
+const reducerOf = (contract) => typeof contract.reducer === "object" && contract.reducer !== null ? contract.reducer : void 0;
+const isAgentContract = (contract) => {
+	const reducer = reducerOf(contract);
+	return reducer !== void 0 && agentReducers.has(reducer);
+};
+const appReducerOf = (contract) => {
+	const reducer = reducerOf(contract);
+	return reducer === void 0 ? void 0 : agentReducers.get(reducer) ?? void 0;
 };
 //#endregion
 //#region src/ai.ts
+const reasoningLevels = [
+	"provider-default",
+	"none",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh"
+];
 const issue = (message) => ({ issues: [{ message }] });
 const schema = (label, parse) => ({ "~standard": {
 	version: 1,
@@ -1468,7 +1861,7 @@ const messagePayloadSchema = (messageSchema) => schema("ai.message.created", (va
 	} };
 });
 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");
+	if (!isRecord(value) || !isJSONCompatible(value) || typeof value["startIndex"] !== "number" || !optionalIndexField(value, "startIndex") || !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) => {
@@ -1571,7 +1964,7 @@ function createEvents(options) {
 		"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.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 && (value["model"] === void 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")),
@@ -1613,11 +2006,14 @@ const initialState = () => ({
 	usage: [],
 	error: null
 });
-const projectMessageChunks = (messages, messageId, chunks) => messages.map((message) => message.id === messageId ? projectUIMessage({
-	messageId,
-	base: message,
-	chunks
-}) : message);
+const projectMessageChunks = (messages, messageId, chunks) => {
+	const base = findMessage(messages, messageId);
+	return upsertMessage(messages, projectUIMessage({
+		messageId,
+		...base === void 0 ? {} : { base },
+		chunks
+	}));
+};
 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";
@@ -1628,54 +2024,15 @@ const isStaleGeneration = (state, messageId, owner) => {
 	return current !== void 0 && (current.generationId !== owner.generationId || current.requestId !== owner.requestId);
 };
 const projectedResponse = (options) => {
-	const message = projectedMessage(options.projection);
+	const message = projectedMessage({
+		projection: options.projection,
+		current: findMessage(options.state.messages, options.projection.responseMessageId)
+	});
 	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;
@@ -1683,6 +2040,12 @@ const terminalGenerationReason = (state, generationId, requestId) => {
 };
 /** Pure projection of the built-in AI protocol. Unknown extension events are ignored. */
 function reduceAIState(state, event) {
+	return settleAbandonedCompaction(state, retainMessageBase({
+		before: state,
+		after: reduceAIEvent(state, event)
+	}));
+}
+function reduceAIEvent(state, event) {
 	if (state.status === "closed") return state;
 	switch (event.type) {
 		case "ai.control.requested": {
@@ -1873,11 +2236,14 @@ function reduceAIState(state, event) {
 			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);
+			const baseMessage = findMessage(baseState.messages, payload.responseMessageId);
 			return {
 				...baseState,
 				status: "generating",
-				activeGeneration: payload,
+				activeGeneration: {
+					...payload,
+					startIndex: event.index
+				},
 				activeResponseMessageId: null,
 				responseOwners: {
 					...baseState.responseOwners,
@@ -1891,7 +2257,7 @@ function reduceAIState(state, event) {
 					generationId: payload.generationId,
 					responseMessageId: payload.responseMessageId,
 					promptThroughIndex: payload.promptThroughIndex ?? event.index - 1,
-					...baseMessage === void 0 ? {} : { baseMessage },
+					...baseMessage === void 0 ? {} : { base: { partCount: baseMessage.parts.length } },
 					baseCompaction: baseState.compaction,
 					batches: progressBatches(),
 					baseTools: baseState.tools,
@@ -1903,13 +2269,16 @@ function reduceAIState(state, event) {
 		}
 		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 generation = state.activeGeneration;
 			const activeProjection = state.activeProjection;
-			if (state.activeGeneration?.generationId !== payload.generationId || state.activeGeneration.requestId !== payload.requestId || activeProjection?.generationId !== payload.generationId) return state;
+			if (generation === null || !progressOwnedBy({
+				payload,
+				owner: generation,
+				startIndex: generation.startIndex
+			}) || state.pausedGenerationIds?.[generation.generationId] || terminalGenerationReason(state, generation.generationId, generation.requestId) !== void 0 || activeProjection?.generationId !== generation.generationId) return state;
 			const progress = advanceProjection({
 				projection: activeProjection,
-				base: state.messages.find((message) => message.id === activeProjection.responseMessageId),
+				base: findMessage(state.messages, activeProjection.responseMessageId),
 				chunks: payload.chunks,
 				index: event.index
 			});
@@ -1918,7 +2287,7 @@ function reduceAIState(state, event) {
 				messages: upsertResponse({
 					messages: state.messages,
 					message: progress.message,
-					inputId: state.activeGeneration.messageId
+					inputId: generation.messageId
 				}),
 				activeProjection: {
 					...activeProjection,
@@ -1956,10 +2325,13 @@ function reduceAIState(state, event) {
 			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);
+			const shouldProject = projection !== null && (projection.base !== 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,
+				messages: shouldProject ? upsertMessage(state.messages, interruptUIMessage(projectedMessage({
+					projection,
+					current: findMessage(state.messages, projection.responseMessageId)
+				}), `Generation failed before tool completion: ${payload.error}`)) : state.messages,
 				status: "failed",
 				activeGeneration: null,
 				activeResponseMessageId: null,
@@ -2078,6 +2450,7 @@ function reduceAIState(state, event) {
 			if (projection?.generationId !== payload.generationId) {
 				const next = {
 					...state,
+					messages: projectMessageChunks(state.messages, payload.messageId, [toolCalledChunk(payload)]),
 					tools: reduceToolActivity(state.tools, {
 						type: "ai.tool.called",
 						payload
@@ -2090,15 +2463,49 @@ function reduceAIState(state, event) {
 			}
 			const activeProjection = {
 				...projection,
+				cursor: null,
 				toolEvents: [...projection.toolEvents, {
 					index: event.index,
 					type: "ai.tool.called",
 					payload
 				}]
 			};
+			const base = findMessage(state.messages, payload.messageId);
+			const paused = state.pausedGenerationIds?.[payload.generationId];
+			const cursor = projection.cursor;
+			const projected = base && cursor && !paused && event.index > cursor.throughIndex ? {
+				...hasToolCall({
+					message: base,
+					call: payload
+				}) ? {
+					message: base,
+					cursor: cursor.stream
+				} : projectUIMessageStream({
+					messageId: payload.messageId,
+					base,
+					cursor: cursor.stream,
+					chunks: [toolCalledChunk(payload)]
+				}),
+				throughIndex: event.index
+			} : projectedMessageStream({
+				projection: activeProjection,
+				current: base
+			});
+			activeProjection.cursor = paused ? null : {
+				throughIndex: projected.throughIndex,
+				stream: projected.cursor
+			};
 			const next = {
 				...state,
 				activeProjection,
+				messages: upsertResponse({
+					messages: state.messages,
+					message: paused ? projectedResponse({
+						state,
+						projection: activeProjection
+					}) : projected.message,
+					inputId: state.activeGeneration?.messageId ?? state.active?.input.id ?? payload.messageId
+				}),
 				tools: projectedTools(activeProjection)
 			};
 			return {
@@ -2241,30 +2648,41 @@ function reduceAIState(state, event) {
 		case "ai.compaction.requested": {
 			const payload = event.payload;
 			if (state.activeGeneration?.generationId !== payload.generationId) return state;
-			return {
+			return addCompactionPart({
 				...state,
 				compaction: {
 					status: "running",
 					...payload
 				}
-			};
+			}, 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 { messages: _messages, retainedMessageIds: _retained, ...summary } = payload;
 			const compaction = {
 				status: "completed",
-				...payload,
+				...summary,
 				throughIndex: payload.throughIndex ?? state.activeProjection.promptThroughIndex
 			};
-			return {
-				...state,
-				compaction,
-				activeProjection: state.activeProjection && {
-					...state.activeProjection,
-					baseCompaction: compaction
+			const projection = state.activeProjection;
+			return settleCompactionPart({
+				state: {
+					...state,
+					compaction,
+					activeProjection: projection && {
+						...projection,
+						baseCompaction: compaction,
+						...projection.base === void 0 ? {} : { base: { ...projection.base } }
+					}
+				},
+				generationId: payload.generationId,
+				data: {
+					status: "completed",
+					...summary.summary === void 0 ? {} : { summary: summary.summary },
+					...summary.usage === void 0 ? {} : { usage: summary.usage }
 				}
-			};
+			});
 		}
 		default: return state;
 	}
@@ -2275,18 +2693,6 @@ function deriveUIMessages(history) {
 	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
@@ -2387,45 +2793,64 @@ const inputs = {
 * 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.
+* `session`, and `signal` without an A2-specific wrapper. Pass the
+* agent's contract to type application events; it is verified against
+* the executing agent.
 */
-function handlerContext(agentOrContract) {
-	const contract = "contract" in agentOrContract ? agentOrContract.contract : agentOrContract;
+function handlerContext(contract) {
 	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}'`);
+	if (scope === void 0) throw new TypeError("handlerContext() requires an ambient A2 tool execution: call it inside a local tool's execute, or wrap direct tool tests with runWithHandlerContext");
+	if (contract !== void 0 && 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;
 }
+/** The built-in AI reducer's name, and so its checkpoint identity. */
+const AI_STATE_REDUCER = "a2.ai.state.v26";
 /**
-* Define an agent: built-in AI protocol + application events and one state
-* reducer. The result is isomorphic.
+* The built-in AI protocol plus application events, as a core contract whose
+* reducer folds `AIState`. Isomorphic: share it when a client needs
+* application events or extended state; otherwise `agent({ name })` on the
+* server builds one and clients use the built-in protocol.
 */
-function agent(options) {
+function agentContract(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({
+	const vocabulary = 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
-		})
-	};
+	const app = options.reducer;
+	const aiState = initialState();
+	for (const key of Object.keys(app?.initialState ?? {})) if (isAIStateKey(key)) throw new TypeError(`agent state '${key}' conflicts with AIState`);
+	const reducer$1 = reducer({
+		contract: vocabulary,
+		name: app === void 0 ? AI_STATE_REDUCER : `${app.name}+${AI_STATE_REDUCER}`,
+		initialState: {
+			...aiState,
+			...app?.initialState
+		}
+	}).fold((state, event) => {
+		const next = reduceAIState(state, event);
+		if (app === void 0) return next;
+		const before = appSlice(state);
+		const after = app.fold(before, event);
+		return after === before ? next : withAppSlice(next, after);
+	});
+	const shared = contract({
+		name: options.name,
+		events: vocabulary.events,
+		reducer: withAIStorage(withReducerRuntime({
+			reducer: reducer$1,
+			project: projectAIClientState
+		}))
+	});
+	registerAgentReducer(shared.reducer, app);
+	return shared;
 }
 //#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 };
+export { interruptUIMessage as A, reduceToolActivity as C, flattenProgressBatches as D, upsertResponse as E, assertMessageBase as M, restoreMessageBase as N, progressBatches as O, projectedMessage as S, upsertMessage as T, applyControlChanges as _, events as a, findMessage as b, reasoningLevels as c, appSlice as d, isAgentContract as f, initialControlState as g, aiEventId as h, deriveUIMessages as i, pauseUIMessage as j, progressOwnedBy as k, reduceAIState as l, AI_EVENT_ID_PREFIX as m, agentContract as n, handlerContext as o, withAIStorage as p, createEvents as r, inputs as s, AI_STATE_REDUCER as t, appReducerOf as u, controlCommit as v, retainMessageBase as w, isCompactionPart as x, advanceProjection as y };
 
-//# sourceMappingURL=ai-CrLYwNEx.js.map
+//# sourceMappingURL=ai-UrWfKeuv.js.map