experimental-a2 0.15.0 → 0.16.1

package/dist/ai-server.js

@@ -1,12 +1,29 @@
 import { n as validateSync } from "./validate-XKT4FSNn.js";
 import { t as A2Error } from "./errors-DCk6ch5n.js";
 import { f as consumeSchedulerSendFailure, p as installAmbientToolScopeStorage } from "./internal-Dq2qYxou.js";
-import { i as setServerFetchHooks, t as createServer } from "./server-CjJSGcF7.js";
-import { n as applyControlChanges, r as controlCommit, t as initialControlState } from "./ai-control-CcD4hh3y.js";
+import { i as setServerFetchHooks, t as createServer } from "./server-BD5ckxZb.js";
+import { C as interruptUIMessage, S as progressBatches, _ as projectedMessage, a as events, b as upsertResponse, d as AI_EVENT_ID_PREFIX, f as aiEventId, g as advanceProjection, h as controlCommit, l as aiStateReducer, m as applyControlChanges, p as initialControlState, u as storedAIReducer, v as reduceToolActivity, w as pauseUIMessage, x as flattenProgressBatches, y as upsertMessage } from "./ai-DgOBltJ_.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash } from "node:crypto";
-import { asSchema, convertToModelMessages, stepCountIs, streamText, toUIMessageStream } from "ai";
+import { asSchema, convertToModelMessages, isToolUIPart, stepCountIs, streamText, toUIMessageStream } from "ai";
+import { Buffer } from "node:buffer";
 //#region src/ai-coordinator.ts
+const completeCall = (candidate) => {
+	const { requestId, generationId, messageId, toolCallId, toolName, providerExecuted, supportsDeferredResults } = candidate.call;
+	return {
+		terminal: true,
+		call: {
+			requestId,
+			generationId,
+			messageId,
+			toolCallId,
+			toolName,
+			...providerExecuted === void 0 ? {} : { providerExecuted },
+			...supportsDeferredResults === void 0 ? {} : { supportsDeferredResults }
+		},
+		...candidate.work === void 0 ? {} : { work: candidate.work }
+	};
+};
 const updateResponse = (state, update) => state.response === void 0 ? state : {
 	...state,
 	response: update(state.response)
@@ -37,7 +54,7 @@ const foldCoordinator = (state, event) => {
 		case "ai.generation.requested": {
 			const request = event.payload;
 			if (request.reason === "message") {
-				const responseMessageId = request.responseMessageId ?? `${request.messageId}:assistant`;
+				const responseMessageId = request.responseMessageId;
 				const requested = state.queued.findIndex((item) => item.messageId === request.messageId);
 				return {
 					...state,
@@ -48,28 +65,26 @@ const foldCoordinator = (state, event) => {
 						status: "requested",
 						stepCount: 0,
 						activeRequestId: event.id,
+						requestReason: request.reason,
+						...request.sourceGenerationId === void 0 ? {} : { sourceGenerationId: request.sourceGenerationId },
 						calls: [],
 						inputs: []
 					}
 				};
 			}
 			if (state.response === void 0 || request.responseMessageId !== state.response.responseMessageId) return state;
-			if (request.reason === "tool" && (!continuationReady(state) || event.id !== `ai.generate:tools:${state.response.generation?.generationId}`) || request.reason === "retry" && state.response.status !== "failed" || request.reason === "input" && state.response.inputResponse === void 0) return state;
+			if (request.reason === "tool" && (!continuationReady(state) || request.sourceGenerationId !== state.response.generation?.generationId) || request.sourceGenerationId !== void 0 && request.sourceGenerationId !== (state.response.generation ?? state.response.source?.generation)?.generationId || request.reason === "retry" && state.response.status !== "failed" || request.reason === "input" && state.response.inputResponse === void 0) return state;
 			return updateResponse(state, (response) => {
 				const generation = response.generation ?? response.source?.generation;
-				const promptThroughIndex = response.promptThroughIndex ?? response.source?.promptThroughIndex;
 				return {
 					rootMessageId: response.rootMessageId,
 					responseMessageId: response.responseMessageId,
 					status: "requested",
 					stepCount: response.stepCount,
 					activeRequestId: event.id,
-					...generation === void 0 || promptThroughIndex === void 0 ? {} : { source: {
-						generation,
-						promptThroughIndex,
-						failed: response.failure?.generationId === generation.generationId,
-						canCompact: response.calls.every((call) => call.terminal)
-					} },
+					requestReason: request.reason,
+					...request.sourceGenerationId === void 0 ? {} : { sourceGenerationId: request.sourceGenerationId },
+					...generation === void 0 ? {} : { source: { generation } },
 					calls: [],
 					inputs: []
 				};
@@ -84,16 +99,17 @@ const foldCoordinator = (state, event) => {
 				status: "generating",
 				stepCount: response.stepCount,
 				generation,
-				...generation.promptThroughIndex === void 0 ? {} : { promptThroughIndex: generation.promptThroughIndex },
 				...response.source === void 0 ? {} : { source: response.source },
 				activeRequestId: generation.requestId,
+				requestReason: response.requestReason,
+				...response.sourceGenerationId === void 0 ? {} : { sourceGenerationId: response.sourceGenerationId },
 				calls: [],
 				inputs: []
 			}));
 		}
 		case "ai.generation.completed": {
 			const completion = event.payload;
-			if (state.response?.generation?.generationId !== completion.generationId) return state;
+			if (state.response?.generation?.requestId !== completion.requestId || state.response.generation.generationId !== completion.generationId) return state;
 			const { calibration: _, ...uncalibrated } = updateResponse(state, (response) => ({
 				...response,
 				status: "waiting",
@@ -114,8 +130,8 @@ const foldCoordinator = (state, event) => {
 		case "ai.generation.failed": {
 			const failure = event.payload;
 			const response = state.response;
-			const ownsActiveGeneration = response?.generation?.generationId === failure.generationId;
-			const ownsActiveStepLimit = failure.stepLimit === true && response?.activeRequestId === `ai.generate:tools:${failure.generationId}` && response.responseMessageId === failure.responseMessageId;
+			const ownsActiveGeneration = response?.generation?.generationId === failure.generationId && response.generation.requestId === failure.requestId;
+			const ownsActiveStepLimit = failure.stepLimit === true && response?.requestReason === "tool" && response.sourceGenerationId === failure.generationId && response.source?.generation.requestId === failure.requestId && response.responseMessageId === failure.responseMessageId;
 			if (!ownsActiveGeneration && !ownsActiveStepLimit) return state;
 			return updateResponse(state, (current) => ({
 				...current,
@@ -138,7 +154,7 @@ const foldCoordinator = (state, event) => {
 		}
 		case "ai.tool.called": {
 			const call = event.payload;
-			if (state.response?.generation?.generationId !== call.generationId) return state;
+			if (state.response?.generation?.requestId !== call.requestId || state.response.generation.generationId !== call.generationId) return state;
 			return updateResponse(state, (response) => ({
 				...response,
 				calls: [...response.calls.filter((candidate) => candidate.call.toolCallId !== call.toolCallId), {
@@ -149,7 +165,7 @@ const foldCoordinator = (state, event) => {
 		}
 		case "ai.approval.requested": {
 			const approval = event.payload;
-			if (state.response?.generation?.generationId !== approval.generationId) return state;
+			if (state.response?.generation?.requestId !== approval.requestId || state.response.generation.generationId !== approval.generationId) return state;
 			return updateResponse(state, (response) => ({
 				...response,
 				calls: response.calls.map((candidate) => candidate.call.toolCallId === approval.toolCallId ? {
@@ -160,7 +176,7 @@ const foldCoordinator = (state, event) => {
 		}
 		case "ai.approval.responded": {
 			const approval = event.payload;
-			if (state.response?.responseMessageId !== approval.messageId || state.response.generation?.generationId !== approval.generationId) return state;
+			if (state.response?.responseMessageId !== approval.messageId || state.response.generation?.requestId !== approval.requestId || state.response.generation.generationId !== approval.generationId) return state;
 			return updateResponse(state, (response) => ({
 				...response,
 				calls: response.calls.map((candidate) => candidate.approval?.approvalId === approval.approvalId ? {
@@ -171,18 +187,15 @@ const foldCoordinator = (state, event) => {
 		}
 		case "ai.tool.result": {
 			const result = event.payload;
-			if (result.preliminary === true || state.response?.generation?.generationId !== result.generationId) return state;
+			if (result.preliminary === true || state.response?.generation?.requestId !== result.requestId || state.response.generation.generationId !== result.generationId) return state;
 			return updateResponse(state, (response) => ({
 				...response,
-				calls: response.calls.map((candidate) => candidate.call.toolCallId === result.toolCallId ? {
-					...candidate,
-					terminal: true
-				} : candidate)
+				calls: response.calls.map((candidate) => candidate.call.toolCallId === result.toolCallId ? completeCall(candidate) : candidate)
 			}));
 		}
 		case "ai.input.requested": {
 			const input = event.payload;
-			if (state.response?.responseMessageId !== input.messageId || state.response.generation?.generationId !== input.generationId) return state;
+			if (state.response?.responseMessageId !== input.messageId || state.response.generation?.requestId !== input.requestId || state.response.generation.generationId !== input.generationId) return state;
 			return updateResponse(state, (response) => ({
 				...response,
 				inputs: [...response.inputs.filter((candidate) => candidate.messageId !== input.messageId || candidate.generationId !== input.generationId || candidate.inputId !== input.inputId), input]
@@ -191,7 +204,7 @@ const foldCoordinator = (state, event) => {
 		case "ai.input.responded": {
 			const input = event.payload;
 			const requested = state.response?.inputs.find((candidate) => candidate.messageId === input.messageId && candidate.generationId === input.generationId && candidate.inputId === input.inputId && candidate.name === input.name);
-			if (state.response?.responseMessageId !== input.messageId || state.response.generation?.generationId !== input.generationId || requested === void 0) return state;
+			if (state.response?.responseMessageId !== input.messageId || state.response.generation?.requestId !== input.requestId || state.response.generation.generationId !== input.generationId || requested === void 0) return state;
 			return updateResponse(state, (response) => ({
 				...response,
 				inputs: response.inputs.filter((candidate) => candidate.inputId !== input.inputId),
@@ -206,7 +219,7 @@ const foldCoordinator = (state, event) => {
 	}
 };
 const aiCoordinatorReducer = (contract) => contract.reducer({
-	name: "a2.ai.coordinator.v5",
+	name: "a2.ai.coordinator.v6",
 	initialState: {
 		closed: false,
 		queued: []
@@ -226,12 +239,35 @@ const callReadyForModel = (call) => call.terminal || call.call.providerExecuted
 const approvalBlocksExecution = (call) => call.approval !== void 0 && call.response?.approved !== true;
 const createControlRuntime = (options) => {
 	const reducer = options.agent.contract.reducer({
-		name: "a2.ai.control.v1",
+		name: "a2.ai.control.v5",
 		initialState: initialControlState()
-	}).fold((state, event) => event.type === "ai.control.committed" ? applyControlChanges({
-		state,
-		changes: event.payload.changes
-	}) : state);
+	}).fold((state, event) => {
+		if (event.type === "ai.control.requested") {
+			const command = event.payload;
+			if (command.action === "stop") return {
+				...state,
+				pendingStops: {
+					...state.pendingStops,
+					[event.id]: command.turnId
+				}
+			};
+		}
+		if (event.type === "ai.control.decided") {
+			const receipt = event.payload;
+			if (Object.hasOwn(state.pendingStops, receipt.commandId)) {
+				const pendingStops = { ...state.pendingStops };
+				delete pendingStops[receipt.commandId];
+				return {
+					...state,
+					pendingStops
+				};
+			}
+		}
+		return event.type === "ai.control.committed" ? applyControlChanges({
+			state,
+			changes: event.payload.changes
+		}) : state;
+	});
 	const coordinator = aiCoordinatorReducer(options.agent.contract);
 	const handler = async (ctx) => {
 		const snapshot = await ctx.session.state(reducer, { through: "latest" });
@@ -240,11 +276,11 @@ const createControlRuntime = (options) => {
 		const state = structuredClone(snapshot.state);
 		const facts = [];
 		const jobs = [];
-		const emit = ({ type, payload, id = `${ctx.event.id}:fact:${facts.length}` }) => {
+		const emit = async ({ type, payload, id }) => {
 			const fact = {
 				type,
 				payload,
-				id
+				id: id ?? await aiEventId("a2.ai.fact", ctx.event.id, String(facts.length))
 			};
 			facts.push(fact);
 			state.coordinator = foldCoordinator(state.coordinator, {
@@ -253,11 +289,11 @@ const createControlRuntime = (options) => {
 			});
 		};
 		let reason;
-		const end = ({ lastSeenIndex, reason: interruptionReason }) => {
+		const end = async ({ lastSeenIndex, reason: interruptionReason }) => {
 			const response = state.coordinator.response;
 			if (response === void 0) return;
 			const owner = response.generation === void 0 ? { requestId: response.activeRequestId } : { generationId: response.generation.generationId };
-			emit({
+			await emit({
 				type: "ai.message.interrupted",
 				payload: {
 					messageId: response.responseMessageId,
@@ -268,22 +304,13 @@ const createControlRuntime = (options) => {
 			});
 			state.active = null;
 		};
-		const knownInput = (id) => state.inbox.items.some((candidate) => candidate.id === id) || Object.hasOwn(state.reservedIds, id);
-		const missingInputReason = (id) => state.reservedIds[id] === "removed" || !knownInput(id) ? "not-found" : "already-active";
-		const inputTaken = ({ message, generate = true }) => knownInput(message.id) || generate && message.role === "user" && knownInput(`${message.id}:assistant`);
 		const insert = ({ message, generate = true, first = false, afterStepOf }) => {
 			const candidate = {
 				id: message.id,
-				revision: 0,
 				message,
 				generate: generate && message.role === "user",
 				...afterStepOf === void 0 ? {} : { afterStepOf }
 			};
-			state.reservedIds = {
-				...state.reservedIds,
-				[candidate.id]: true,
-				...candidate.generate ? { [`${candidate.id}:assistant`]: true } : {}
-			};
 			if (first) state.inbox.items.unshift(candidate);
 			else state.inbox.items.push(candidate);
 		};
@@ -340,42 +367,28 @@ const createControlRuntime = (options) => {
 			if (state.coordinator.closed) reason = "closed";
 			else switch (command.action) {
 				case "send":
-					if (inputTaken({
-						message: command.message,
-						generate: command.generate !== false
-					})) reason = "duplicate-input";
-					else insert({
+					insert({
 						message: command.message,
 						generate: command.generate !== false
 					});
 					break;
 				case "edit": {
 					const item = state.inbox.items.find((candidate) => candidate.id === command.message.id);
-					if (item === void 0) reason = missingInputReason(command.message.id);
-					else if (item.revision !== command.expectedRevision) reason = "revision-conflict";
-					else if (item.message.role !== command.message.role) reason = "revision-conflict";
-					else {
-						item.message = command.message;
-						item.revision += 1;
-					}
+					if (item === void 0) reason = "not-pending";
+					else if (item.message.role !== command.message.role) reason = "role-mismatch";
+					else item.message = command.message;
 					break;
 				}
 				case "remove": {
 					const position = state.inbox.items.findIndex((item) => item.id === command.inputId);
-					if (position < 0) reason = missingInputReason(command.inputId);
-					else {
-						state.inbox.items.splice(position, 1);
-						state.reservedIds = {
-							...state.reservedIds,
-							[command.inputId]: "removed"
-						};
-					}
+					if (position < 0) reason = "not-pending";
+					else state.inbox.items.splice(position, 1);
 					break;
 				}
 				case "move": {
 					const index = state.inbox.items.findIndex((candidate) => candidate.id === command.inputId);
-					if (index < 0) reason = missingInputReason(command.inputId);
-					else if (command.beforeId !== null && !state.inbox.items.some((candidate) => candidate.id === command.beforeId)) reason = "not-found";
+					if (index < 0) reason = "not-pending";
+					else if (command.beforeId !== null && !state.inbox.items.some((candidate) => candidate.id === command.beforeId)) reason = "not-pending";
 					else {
 						const destination = command.beforeId === null ? state.inbox.items.length : state.inbox.items.findIndex((item) => item.id === command.beforeId);
 						moveInput({
@@ -388,18 +401,11 @@ const createControlRuntime = (options) => {
 				case "send-now": {
 					const position = state.inbox.items.findIndex((item) => item.id === command.inputId);
 					const selected = state.inbox.items[position];
-					if (!selected) reason = missingInputReason(command.inputId);
+					if (!selected) reason = "not-pending";
 					else if ((state.active?.turnId ?? null) !== command.turnId) reason = "stale-turn";
 					else if (selected.message.role !== "user") reason = "not-user-input";
-					else if (!selected.generate && knownInput(`${selected.id}:assistant`)) reason = "duplicate-input";
 					else {
-						if (!selected.generate) {
-							state.reservedIds = {
-								...state.reservedIds,
-								[`${selected.id}:assistant`]: true
-							};
-							selected.generate = true;
-						}
+						selected.generate = true;
 						if (state.active) selected.afterStepOf = state.active.turnId;
 						else delete selected.afterStepOf;
 						moveInput({
@@ -411,14 +417,13 @@ const createControlRuntime = (options) => {
 				}
 				case "stop":
 					if (state.active?.turnId !== command.turnId) reason = "stale-turn";
-					else end({
+					else await end({
 						lastSeenIndex: command.lastSeenIndex,
 						reason: void 0
 					});
 					break;
 				case "steer":
-					if (inputTaken({ message: command.message })) reason = "duplicate-input";
-					else insert({
+					insert({
 						message: command.message,
 						generate: true,
 						first: true,
@@ -428,7 +433,7 @@ const createControlRuntime = (options) => {
 				case "interrupt": {
 					const response = state.coordinator.response;
 					if (!response || response.responseMessageId !== command.request.messageId || command.request.generationId !== response.generation?.generationId && command.request.requestId !== response.activeRequestId) reason = "stale-turn";
-					else end({
+					else await end({
 						lastSeenIndex: command.request.lastSeenIndex,
 						reason: command.request.reason
 					});
@@ -441,7 +446,7 @@ const createControlRuntime = (options) => {
 						active.suspended = true;
 						active.version += 1;
 						const generation = state.coordinator.response?.generation;
-						if (generation) emit({
+						if (generation) await emit({
 							type: "ai.generation.paused",
 							payload: {
 								generationId: generation.generationId,
@@ -455,18 +460,18 @@ const createControlRuntime = (options) => {
 					state.inbox.paused = false;
 					break;
 				case "tool-result":
-					if (!state.coordinator.response?.calls.find((candidate) => candidate.call.generationId === command.result.generationId && candidate.call.messageId === command.result.messageId && candidate.call.toolCallId === command.result.toolCallId && candidate.call.providerExecuted === true && !candidate.terminal)) reason = "not-found";
-					else emit({
+					if (!state.coordinator.response?.calls.find((candidate) => candidate.call.requestId === command.result.requestId && candidate.call.generationId === command.result.generationId && candidate.call.messageId === command.result.messageId && candidate.call.toolCallId === command.result.toolCallId && candidate.call.providerExecuted === true && !candidate.terminal)) reason = "not-found";
+					else await emit({
 						type: "ai.tool.result",
 						payload: command.result
 					});
 					break;
 				case "approval": {
 					const response = state.coordinator.response;
-					const call = response?.calls.find((candidate) => candidate.approval?.approvalId === command.response.approvalId && candidate.approval.generationId === command.response.generationId && candidate.approval.messageId === command.response.messageId);
+					const call = response?.calls.find((candidate) => candidate.approval?.requestId === command.response.requestId && candidate.approval.approvalId === command.response.approvalId && candidate.approval.generationId === command.response.generationId && candidate.approval.messageId === command.response.messageId);
 					if (response?.failure) reason = "stale-turn";
 					else if (!call || call.response || call.terminal) reason = "not-found";
-					else emit({
+					else await emit({
 						type: "ai.approval.responded",
 						payload: command.response
 					});
@@ -476,8 +481,8 @@ const createControlRuntime = (options) => {
 				case "input": {
 					const payload = command.action === "input" ? command.response : command.request;
 					const response = state.coordinator.response;
-					if (response?.failure !== void 0 || response?.generation?.generationId !== payload.generationId || response.responseMessageId !== payload.messageId || command.action === "input" && !response.inputs.some((input) => input.inputId === payload.inputId && input.name === payload.name)) reason = "not-found";
-					else emit({
+					if (response?.failure !== void 0 || response?.generation?.requestId !== payload.requestId || response.generation.generationId !== payload.generationId || response.responseMessageId !== payload.messageId || command.action === "input" && !response.inputs.some((input) => input.inputId === payload.inputId && input.name === payload.name)) reason = "not-found";
+					else await emit({
 						type: command.action === "input" ? "ai.input.responded" : "ai.input.requested",
 						payload
 					});
@@ -487,7 +492,7 @@ const createControlRuntime = (options) => {
 					const response = state.coordinator.response;
 					if (!state.active || response?.status !== "failed" || response.rootMessageId !== command.request.messageId || response.responseMessageId !== command.request.responseMessageId) reason = "stale-turn";
 					else if (!state.inbox.paused && !state.active.suspended) {
-						emit({
+						await emit({
 							type: "ai.retry.requested",
 							payload: command.request
 						});
@@ -497,7 +502,7 @@ const createControlRuntime = (options) => {
 								responseMessageId: response.responseMessageId,
 								reason: "retry"
 							},
-							id: `ai.generate:retry:${command.request.retryId}`
+							id: await aiEventId("a2.ai.request.retry", options.agent.contract.name, ctx.event.sessionId, command.request.retryId)
 						});
 					} else reason = "stale-turn";
 					break;
@@ -505,6 +510,10 @@ const createControlRuntime = (options) => {
 			}
 		} else {
 			const report = ctx.event.payload;
+			if (report.kind === "tool" && report.settled && state.coordinator.unsettledTools) {
+				delete state.coordinator.unsettledTools[report.workId];
+				if (Object.keys(state.coordinator.unsettledTools).length === 0) delete state.coordinator.unsettledTools;
+			}
 			const active = state.active;
 			const call = state.coordinator.response?.calls.find((candidate) => candidate.work?.id === report.workId);
 			const work = report.kind === "model" ? active?.model : call?.work;
@@ -515,7 +524,7 @@ const createControlRuntime = (options) => {
 				for (const event of report.events) {
 					if (work.facts?.includes(event.id)) continue;
 					if (authorized || report.kind === "tool" && event.type === "ai.tool.result") {
-						emit({
+						await emit({
 							type: event.type,
 							payload: event.payload,
 							id: event.id
@@ -523,7 +532,10 @@ const createControlRuntime = (options) => {
 						work.facts = [...work.facts ?? [], event.id];
 					}
 				}
-				if (report.settled) work.settled = true;
+				if (report.settled) {
+					work.settled = true;
+					delete work.facts;
+				}
 				if (!authorized) reason = "stale-work";
 			}
 		}
@@ -544,7 +556,7 @@ const createControlRuntime = (options) => {
 			if (!active.suspended && response.failure === void 0) for (const call of response.calls) {
 				if (call.terminal || call.work !== void 0 && (!call.work.settled || call.work.version === active.version) || call.call.providerExecuted === true || call.approval && !call.response) continue;
 				if (call.response?.approved === false) {
-					emit({
+					await emit({
 						type: "ai.tool.result",
 						payload: {
 							...call.call,
@@ -554,12 +566,16 @@ const createControlRuntime = (options) => {
 					});
 					continue;
 				}
-				const id = `${ctx.event.id}:tool:${call.call.toolCallId}`;
+				const id = await aiEventId("a2.ai.tool.execution", ctx.event.id, call.call.generationId, call.call.toolCallId);
 				call.work = {
 					id,
 					version: active.version,
 					settled: false
 				};
+				state.coordinator.unsettledTools = {
+					...state.coordinator.unsettledTools,
+					[id]: true
+				};
 				jobs.push({
 					type: "ai.tool.execution.requested",
 					id,
@@ -579,7 +595,7 @@ const createControlRuntime = (options) => {
 			const handoffReady = handoff && workSettled && !externalPending && (active.suspended || response.failure !== void 0 || response.calls.every((call) => callReadyForModel(call) || approvalBlocksExecution(call)));
 			const readyForModel = !active.suspended && response.failure === void 0 && modelDone && callsDone && response.inputs.length === 0;
 			const naturalCompletion = readyForModel && response.completion !== void 0 && response.completion.finishReason !== "tool-calls";
-			if (handoffReady && !naturalCompletion) end({
+			if (handoffReady && !naturalCompletion) await end({
 				lastSeenIndex: void 0,
 				reason: "steered after step"
 			});
@@ -588,17 +604,19 @@ const createControlRuntime = (options) => {
 				const input = response.inputResponse;
 				if (!handoff && (resume || continuationReady(state.coordinator) || response.completion && input)) {
 					const nextReason = resume ? "resume" : input ? "input" : "tool";
-					const id = nextReason === "tool" ? `ai.generate:tools:${response.generation.generationId}` : `${ctx.event.id}:generate:${nextReason}`;
+					const sourceGenerationId = (response.generation ?? response.source?.generation)?.generationId;
+					const id = nextReason === "tool" ? await aiEventId("a2.ai.request.tool", response.generation.generationId) : await aiEventId("a2.ai.request", ctx.event.id, nextReason);
 					requestModel({
 						request: {
 							messageId: response.responseMessageId,
 							responseMessageId: response.responseMessageId,
-							reason: nextReason
+							reason: nextReason,
+							...sourceGenerationId === void 0 ? {} : { sourceGenerationId }
 						},
 						id
 					});
 				} else if (naturalCompletion) {
-					emit({
+					await emit({
 						type: "ai.message.completed",
 						payload: { messageId: response.responseMessageId }
 					});
@@ -610,13 +628,13 @@ const createControlRuntime = (options) => {
 		if (state.active === null && !state.inbox.paused && !state.coordinator.closed) while (state.inbox.items.length > 0) {
 			const item = state.inbox.items.shift();
 			delete item.afterStepOf;
-			emit({
+			await emit({
 				type: "ai.message.created",
 				payload: {
 					message: item.message,
 					generate: item.generate
 				},
-				id: `ai.admitted:${item.id}`
+				id: await aiEventId("a2.ai.admitted", options.agent.contract.name, ctx.event.sessionId, item.id)
 			});
 			if (!item.generate) continue;
 			state.active = {
@@ -627,12 +645,14 @@ const createControlRuntime = (options) => {
 				suspended: false,
 				model: null
 			};
+			const requestId = await aiEventId("a2.ai.request.message", options.agent.contract.name, ctx.event.sessionId, item.id);
 			requestModel({
 				request: {
 					messageId: item.id,
+					responseMessageId: requestId,
 					reason: "message"
 				},
-				id: `ai.generate:message:${item.id}`
+				id: requestId
 			});
 			break;
 		}
@@ -646,6 +666,7 @@ const createControlRuntime = (options) => {
 			...facts,
 			{
 				type: "ai.control.committed",
+				id: await aiEventId("a2.ai.control.committed", ctx.event.id),
 				payload: controlCommit({
 					before,
 					after: state,
@@ -655,11 +676,12 @@ const createControlRuntime = (options) => {
 			...jobs,
 			{
 				type: "ai.control.decided",
+				id: await aiEventId("a2.ai.control.decided", ctx.event.id),
 				payload: receipt
 			}
 		];
 	};
-	const report = ({ ctx, events, settled, name }) => {
+	const report = async ({ ctx, events, settled, name }) => {
 		const payload = ctx.event.payload;
 		const { turnId, version } = "turnId" in payload ? payload : payload.control;
 		for (const event of events) {
@@ -669,7 +691,7 @@ const createControlRuntime = (options) => {
 		}
 		return {
 			type: "ai.work.reported",
-			id: `${ctx.event.id}:report:${ctx.attempt}:${name}`,
+			id: await aiEventId("a2.ai.report", ctx.event.id, String(ctx.attempt), name),
 			payload: {
 				workId: ctx.event.id,
 				attempt: ctx.attempt,
@@ -677,11 +699,11 @@ const createControlRuntime = (options) => {
 				version,
 				kind: ctx.event.type === "ai.generation.requested" ? "model" : "tool",
 				settled,
-				events: events.filter((event) => event.type !== "ai.message.completed" && event.type !== "ai.message.interrupted").map((event, index) => ({
+				events: await Promise.all(events.filter((event) => event.type !== "ai.message.completed" && event.type !== "ai.message.interrupted").map(async (event, index) => ({
 					type: event.type,
 					payload: event.payload,
-					id: event.id ?? `${ctx.event.id}:fact:${ctx.attempt}:${name}:${index}`
-				}))
+					id: event.id ?? await aiEventId("a2.ai.work.fact", ctx.event.id, String(ctx.attempt), name, String(index))
+				})))
 			}
 		};
 	};
@@ -689,7 +711,7 @@ const createControlRuntime = (options) => {
 		const progress = events.filter((event) => event.type === "ai.generation.progress");
 		const lifecycle = events.filter((event) => event.type !== "ai.generation.progress");
 		if (lifecycle.length === 0) return ctx.session.append(name, ...progress);
-		const input = report({
+		const input = await report({
 			ctx,
 			events: lifecycle,
 			settled: false,
@@ -744,6 +766,532 @@ const createControlRuntime = (options) => {
 	};
 };
 //#endregion
+//#region src/ai-context-schema.ts
+const record = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const index = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+const id = (value) => typeof value === "string" && value.length > 0;
+const nullableId = (value) => value === null || id(value);
+const matches = (schema, value) => validateSync(schema, value, "AI context checkpoint").issues === void 0;
+const isMessage = (value) => matches(events["ai.message.created"], { message: value });
+const indexes = (value, messages) => record(value) && Object.values(value).every(index) && messages.every((message) => Object.hasOwn(value, message.id));
+const compaction = (value) => value === null || record(value) && Object.keys(value).every((key) => [
+	"status",
+	"generationId",
+	"throughMessageId",
+	"throughIndex",
+	"summary"
+].includes(key)) && ["running", "completed"].includes(String(value["status"])) && id(value["generationId"]) && id(value["throughMessageId"]) && index(value["throughIndex"]) && (value["summary"] === void 0 || typeof value["summary"] === "string");
+const progress = (value) => {
+	if (!record(value) || !index(value["length"]) || !Array.isArray(value["tail"]) || !Array.isArray(value["blocks"])) return false;
+	const pending = [...value["blocks"].toReversed().filter((block) => block !== null), value["tail"]].toReversed();
+	const seen = /* @__PURE__ */ new Set();
+	let count = 0;
+	let last = -1;
+	while (pending.length > 0) {
+		const block = pending.pop();
+		if (typeof block !== "object" || block === null || seen.has(block)) return false;
+		seen.add(block);
+		if (Array.isArray(block)) for (const batch of block) {
+			if (!record(batch) || !index(batch["index"]) || batch["index"] <= last || !Array.isArray(batch["chunks"]) || !batch["chunks"].every((chunk) => record(chunk) && typeof chunk["type"] === "string")) return false;
+			count += 1;
+			last = batch["index"];
+		}
+		else if (record(block) && Object.keys(block).length === 2 && Object.hasOwn(block, "left") && Object.hasOwn(block, "right")) pending.push(block["right"], block["left"]);
+		else return false;
+	}
+	return count === value["length"];
+};
+const indexedEvents = (value, types) => Array.isArray(value) && value.every((event) => record(event) && index(event["index"]) && types.includes(event["type"]) && matches(events[event["type"]], event["payload"]));
+const projection = (value, messages) => {
+	if (!record(value) || Object.keys(value).some((key) => ![
+		"generationId",
+		"responseMessageId",
+		"promptThroughIndex",
+		"completionIndex",
+		"baseMessage",
+		"baseCompaction",
+		"batches",
+		"toolEvents",
+		"approvalEvents",
+		"cursor"
+	].includes(key)) || !id(value["generationId"]) || !id(value["responseMessageId"]) || !index(value["promptThroughIndex"]) || value["completionIndex"] !== void 0 && !index(value["completionIndex"]) || value["baseMessage"] !== void 0 && !isMessage(value["baseMessage"]) || value["baseCompaction"] !== void 0 && !compaction(value["baseCompaction"]) || !progress(value["batches"]) || !indexedEvents(value["toolEvents"], ["ai.tool.called", "ai.tool.result"]) || !indexedEvents(value["approvalEvents"], ["ai.approval.requested", "ai.approval.responded"])) return false;
+	const cursor = value["cursor"];
+	if (cursor === void 0 || cursor === null) return true;
+	if (!record(cursor) || !index(cursor["throughIndex"]) || !record(cursor["stream"])) return false;
+	const stream = cursor["stream"];
+	const current = messages.find((message) => message.id === value["responseMessageId"]);
+	if (!current || !["text", "reasoning"].every((key) => record(stream[key]) && Object.values(stream[key]).every((part) => index(part) && part < current.parts.length)) || !record(stream["tools"])) return false;
+	return Object.values(stream["tools"]).every((tool) => record(tool) && typeof tool["text"] === "string" && typeof tool["toolName"] === "string" && typeof tool["dynamic"] === "boolean");
+};
+const authority = (value) => value === null || record(value) && Object.keys(value).every((key) => [
+	"requestId",
+	"responseMessageId",
+	"sourceGenerationId",
+	"requestReason",
+	"phase"
+].includes(key)) && [
+	"requestId",
+	"responseMessageId",
+	"sourceGenerationId"
+].every((key) => nullableId(value[key])) && (value["requestReason"] === null || [
+	"message",
+	"tool",
+	"input",
+	"resume",
+	"retry"
+].includes(String(value["requestReason"]))) && (value["phase"] === null || [
+	"starting",
+	"generating",
+	"tools",
+	"waiting",
+	"failed",
+	"pausing",
+	"paused"
+].includes(String(value["phase"])));
+const contextSchema = () => ({ "~standard": {
+	version: 1,
+	vendor: "a2-context",
+	validate(value) {
+		const invalid = { issues: [{ message: "invalid AI model context" }] };
+		const keys = [
+			"messages",
+			"compaction",
+			"modelMetadata",
+			"closed",
+			"authority",
+			"generation",
+			"activeProjection",
+			"messageIndexes"
+		];
+		try {
+			if (!record(value) || keys.some((key) => !Object.hasOwn(value, key)) || Object.keys(value).some((key) => !keys.includes(key))) return invalid;
+			const messages = value["messages"];
+			const metadata = value["modelMetadata"];
+			const generation = value["generation"];
+			const current = value["activeProjection"];
+			if (!Array.isArray(messages) || !messages.every(isMessage) || !compaction(value["compaction"]) || typeof value["closed"] !== "boolean" || !authority(value["authority"]) || !record(metadata) || !Object.entries(metadata).every(([modelId, entry]) => record(entry) && (entry["status"] === "pending" || entry["status"] === "unavailable" || entry["status"] === "resolved" && matches(events["ai.model.metadata.resolved"], {
+				modelId,
+				limits: entry["limits"]
+			}))) || !indexes(value["messageIndexes"], messages)) return invalid;
+			if (generation !== null && (!record(generation) || !matches(events["ai.generation.started"], generation["owner"]) || ![
+				"streaming",
+				"completed",
+				"paused",
+				"failed",
+				"superseded"
+			].includes(String(generation["phase"])) || generation["responseIndex"] !== void 0 && !index(generation["responseIndex"]) || generation["phase"] === "failed" && typeof generation["error"] !== "string")) return invalid;
+			const owner = record(generation) && record(generation["owner"]) ? generation["owner"] : void 0;
+			if (current !== null && (!projection(current, messages) || !record(current) || current["generationId"] !== owner?.["generationId"] || current["responseMessageId"] !== owner?.["responseMessageId"])) return invalid;
+			if (generation !== null && generation["phase"] !== "superseded" && current === null) return invalid;
+			if (value["closed"] && (generation !== null || current !== null)) return invalid;
+			return { value };
+		} catch {
+			return invalid;
+		}
+	}
+} });
+//#endregion
+//#region src/ai-context.ts
+const replaceResponse = ({ state, message, index }) => {
+	let messages = upsertResponse({
+		messages: state.messages,
+		message,
+		inputId: state.generation.owner.messageId
+	});
+	if (state.generation?.responseIndex !== void 0 && !state.messages.some((item) => item.id === message.id)) {
+		messages = messages.filter((item) => item.id !== message.id);
+		messages.splice(state.generation.responseIndex, 0, message);
+	}
+	return {
+		...state,
+		messages,
+		messageIndexes: Object.hasOwn(state.messageIndexes, message.id) ? state.messageIndexes : {
+			...state.messageIndexes,
+			[message.id]: index
+		}
+	};
+};
+const calledTools = (projection) => /* @__PURE__ */ new Set([...projection.baseMessage?.parts.flatMap((part) => "toolCallId" in part ? [part.toolCallId] : []) ?? [], ...projection.toolEvents.filter((event) => event.type === "ai.tool.called").map((event) => event.payload.toolCallId)]);
+const renderProjection = ({ state, index }) => {
+	const projection = state.activeProjection;
+	let message = projectedMessage(projection);
+	if (projection.baseMessage === void 0 && projection.batches.length === 0 && message.parts.length === 0) return state;
+	if (state.generation?.phase === "paused") message = pauseUIMessage({
+		message,
+		toolCallIds: calledTools(projection)
+	});
+	if (state.generation?.phase === "failed") message = interruptUIMessage(message, `Generation failed before tool completion: ${state.generation.error}`);
+	return replaceResponse({
+		state: {
+			...state,
+			activeProjection: {
+				...projection,
+				cursor: null
+			}
+		},
+		message,
+		index
+	});
+};
+const generationBase = (state) => {
+	const projection = state.activeProjection;
+	if (!projection) return state;
+	return {
+		...state,
+		messages: projection.baseMessage === void 0 ? state.messages.filter((message) => message.id !== projection.responseMessageId) : upsertMessage(state.messages, projection.baseMessage),
+		compaction: projection.baseCompaction ?? null
+	};
+};
+const contextForAttempt = (state) => ({
+	...state.activeProjection?.completionIndex === void 0 ? generationBase(state) : state,
+	generation: state.generation && {
+		...state.generation,
+		phase: "superseded"
+	},
+	activeProjection: null
+});
+const endGeneration = (state) => ({
+	...state,
+	authority: null,
+	generation: null,
+	activeProjection: null
+});
+const ownsGeneration = (state, owner) => state.generation?.owner.generationId === owner.generationId && state.generation.owner.requestId === owner.requestId && state.generation.phase !== "superseded";
+const createContextReducer = ({ agent }) => {
+	const reducer = agent.contract.reducer({
+		name: "a2.ai.context.v3",
+		initialState: {
+			messages: [],
+			compaction: null,
+			modelMetadata: {},
+			closed: false,
+			authority: null,
+			generation: null,
+			activeProjection: null,
+			messageIndexes: {}
+		},
+		stateSchema: contextSchema()
+	}).fold((state, event) => reduceContext(state, event));
+	return storedAIReducer(reducer);
+};
+const reduceContext = (state, event) => {
+	if (state.closed) return state;
+	switch (event.type) {
+		case "ai.control.committed": {
+			const { view } = event.payload;
+			const { requestId, requestReason, sourceGenerationId, responseMessageId, phase } = view;
+			const next = {
+				...state,
+				authority: {
+					requestId,
+					requestReason,
+					sourceGenerationId,
+					responseMessageId,
+					phase
+				},
+				closed: view.closed
+			};
+			return view.closed ? endGeneration(next) : next;
+		}
+		case "ai.session.closed": return endGeneration({
+			...state,
+			closed: true,
+			compaction: state.compaction?.status === "running" ? state.activeProjection?.baseCompaction ?? null : state.compaction
+		});
+		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,
+				messageIndexes: {
+					...state.messageIndexes,
+					[message.id]: event.index
+				}
+			};
+		}
+		case "ai.generation.requested": {
+			const request = event.payload;
+			if (state.authority?.requestId !== event.id || request.responseMessageId !== state.authority.responseMessageId || request.reason !== state.authority.requestReason || (request.sourceGenerationId ?? null) !== state.authority.sourceGenerationId || request.reason !== "retry") return state;
+			return contextForAttempt(state);
+		}
+		case "ai.generation.started": {
+			const owner = event.payload;
+			if (state.authority?.requestId !== owner.requestId || state.authority.responseMessageId !== owner.responseMessageId || state.authority.phase === "paused" || state.authority.phase === "pausing") return state;
+			const previous = state.generation;
+			if (previous?.owner.requestId === owner.requestId && (previous.owner.attempt >= owner.attempt || previous.phase === "failed" || previous.phase === "completed" || state.activeProjection?.completionIndex !== void 0)) return state;
+			const base = previous?.owner.requestId === owner.requestId ? generationBase(state) : state;
+			const baseMessage = base.messages.find((message) => message.id === owner.responseMessageId);
+			return {
+				...base,
+				generation: {
+					owner,
+					phase: "streaming",
+					...previous?.owner.responseMessageId === owner.responseMessageId && previous.responseIndex !== void 0 ? { responseIndex: previous.responseIndex } : {}
+				},
+				activeProjection: {
+					generationId: owner.generationId,
+					responseMessageId: owner.responseMessageId,
+					promptThroughIndex: owner.promptThroughIndex ?? event.index - 1,
+					...baseMessage === void 0 ? {} : { baseMessage },
+					baseCompaction: base.compaction,
+					batches: progressBatches(),
+					toolEvents: [],
+					approvalEvents: []
+				}
+			};
+		}
+		case "ai.generation.progress": {
+			const payload = event.payload;
+			if (!ownsGeneration(state, payload) || state.generation.owner.responseMessageId !== payload.responseMessageId || state.generation.phase !== "streaming" || !state.activeProjection) return state;
+			const projection = state.activeProjection;
+			const progress = advanceProjection({
+				projection,
+				base: state.messages.find((message) => message.id === projection.responseMessageId),
+				chunks: payload.chunks,
+				index: event.index
+			});
+			return replaceResponse({
+				state: {
+					...state,
+					activeProjection: {
+						...projection,
+						batches: progress.batches,
+						cursor: progress.cursor
+					}
+				},
+				message: progress.message,
+				index: event.index
+			});
+		}
+		case "ai.generation.completed": {
+			const payload = event.payload;
+			if (!ownsGeneration(state, payload) || state.generation.phase !== "streaming") return state;
+			return {
+				...state,
+				generation: {
+					...state.generation,
+					phase: "completed"
+				},
+				activeProjection: {
+					...state.activeProjection,
+					completionIndex: event.index,
+					cursor: null
+				}
+			};
+		}
+		case "ai.generation.failed": {
+			const payload = event.payload;
+			if (!ownsGeneration(state, payload)) return state;
+			if (state.generation.phase !== "streaming" && !(payload.stepLimit && state.authority?.requestReason === "tool" && state.authority.sourceGenerationId === payload.generationId)) return state;
+			if (payload.superseded) return {
+				...generationBase(state),
+				generation: {
+					...state.generation,
+					phase: "superseded"
+				},
+				activeProjection: null
+			};
+			return renderProjection({
+				state: {
+					...state,
+					compaction: state.activeProjection?.baseCompaction ?? null,
+					generation: {
+						...state.generation,
+						phase: "failed",
+						error: payload.error
+					}
+				},
+				index: event.index
+			});
+		}
+		case "ai.message.interrupted": {
+			const payload = event.payload;
+			const owner = state.generation?.owner;
+			const ownsRequest = payload.requestId !== void 0 && payload.requestId === state.authority?.requestId && payload.messageId === state.authority.responseMessageId;
+			const ownsOwner = owner?.responseMessageId === payload.messageId && (payload.generationId === owner.generationId || payload.requestId === owner.requestId);
+			if (!ownsRequest && !ownsOwner) return state;
+			if (ownsOwner && state.authority?.requestId !== owner.requestId && !ownsRequest) return state;
+			const projection = state.activeProjection;
+			if (!projection) return endGeneration(state);
+			const cutoff = payload.lastSeenIndex ?? Number.POSITIVE_INFINITY;
+			const retained = {
+				...projection,
+				batches: progressBatches(flattenProgressBatches(projection.batches).filter((batch) => batch.index <= cutoff)),
+				toolEvents: projection.toolEvents.filter((item) => item.index <= cutoff),
+				approvalEvents: projection.approvalEvents.filter((item) => item.index <= cutoff)
+			};
+			let next = generationBase(state);
+			if (retained.baseMessage !== void 0 || retained.batches.length > 0) next = replaceResponse({
+				state: next,
+				message: interruptUIMessage(projectedMessage(retained)),
+				index: event.index
+			});
+			return endGeneration(next);
+		}
+		case "ai.message.completed": {
+			const { messageId } = event.payload;
+			return state.generation?.owner.responseMessageId === messageId && state.generation.phase !== "failed" && state.generation.phase !== "superseded" ? endGeneration(state) : state;
+		}
+		case "ai.generation.paused": {
+			const { generationId } = event.payload;
+			if (state.generation?.owner.generationId !== generationId || state.generation.phase === "failed" || state.generation.phase === "superseded" || !state.activeProjection) return state;
+			const toolCallIds = calledTools(state.activeProjection);
+			return renderProjection({
+				state: {
+					...state,
+					generation: {
+						...state.generation,
+						phase: "paused"
+					},
+					compaction: state.compaction?.status === "running" ? state.activeProjection.baseCompaction ?? null : state.compaction,
+					activeProjection: {
+						...state.activeProjection,
+						cursor: null,
+						batches: progressBatches(flattenProgressBatches(state.activeProjection.batches).map((batch) => ({
+							index: batch.index,
+							chunks: batch.chunks.filter((chunk) => !("toolCallId" in chunk) || toolCallIds.has(chunk.toolCallId))
+						})))
+					}
+				},
+				index: event.index
+			});
+		}
+		case "ai.tool.called":
+		case "ai.tool.result": {
+			const payload = event.payload;
+			if (!ownsGeneration(state, payload) || !state.activeProjection || state.generation.owner.responseMessageId !== payload.messageId) return state;
+			if (state.generation.phase === "failed") {
+				const result = payload;
+				const running = state.activeProjection.toolEvents.reduce((tools, item) => reduceToolActivity(tools, item), []).some((tool) => tool.toolCallId === payload.toolCallId && tool.status === "running");
+				if (event.type !== "ai.tool.result" || result.preliminary || !running) return state;
+			}
+			const toolEvent = event.type === "ai.tool.called" ? {
+				index: event.index,
+				type: "ai.tool.called",
+				payload
+			} : {
+				index: event.index,
+				type: "ai.tool.result",
+				payload
+			};
+			const next = {
+				...state,
+				activeProjection: {
+					...state.activeProjection,
+					toolEvents: [...state.activeProjection.toolEvents, toolEvent]
+				}
+			};
+			if (event.type === "ai.tool.called") return next;
+			next.activeProjection.cursor = null;
+			return renderProjection({
+				state: next,
+				index: event.index
+			});
+		}
+		case "ai.approval.requested":
+		case "ai.approval.responded": {
+			const payload = event.payload;
+			if (!ownsGeneration(state, payload) || !state.activeProjection || state.generation.phase === "failed" || state.generation.owner.responseMessageId !== payload.messageId) return state;
+			const approvalEvent = event.type === "ai.approval.requested" ? {
+				index: event.index,
+				type: "ai.approval.requested",
+				payload
+			} : {
+				index: event.index,
+				type: "ai.approval.responded",
+				payload
+			};
+			return renderProjection({
+				state: {
+					...state,
+					activeProjection: {
+						...state.activeProjection,
+						cursor: null,
+						approvalEvents: [...state.activeProjection.approvalEvents, approvalEvent]
+					}
+				},
+				index: event.index
+			});
+		}
+		case "ai.compaction.requested": {
+			const payload = event.payload;
+			if (state.generation?.owner.generationId !== payload.generationId || state.generation.phase !== "streaming") return state;
+			return {
+				...state,
+				compaction: {
+					status: "running",
+					generationId: payload.generationId,
+					throughMessageId: payload.throughMessageId,
+					throughIndex: payload.throughIndex ?? state.activeProjection.promptThroughIndex
+				}
+			};
+		}
+		case "ai.compaction.completed": {
+			const payload = event.payload;
+			const projection = state.activeProjection;
+			if (state.generation?.owner.generationId !== payload.generationId || state.generation.phase !== "streaming" || state.compaction?.status !== "running" || state.compaction.generationId !== payload.generationId || !projection) return state;
+			const throughIndex = payload.throughIndex ?? projection.promptThroughIndex;
+			const replacements = new Set(payload.messages.map((message) => message.id));
+			const retained = new Set(payload.retainedMessageIds ?? []);
+			const messages = [...payload.messages, ...state.messages.filter((message) => !replacements.has(message.id) && (retained.has(message.id) || (state.messageIndexes[message.id] ?? 0) > throughIndex))];
+			const activeProjection = {
+				...projection,
+				cursor: null
+			};
+			delete activeProjection.baseMessage;
+			const baseMessage = messages.find((message) => message.id === projection.responseMessageId);
+			if (baseMessage !== void 0) activeProjection.baseMessage = baseMessage;
+			const compaction = {
+				status: "completed",
+				generationId: payload.generationId,
+				throughMessageId: payload.throughMessageId,
+				throughIndex,
+				...payload.summary === void 0 ? {} : { summary: payload.summary }
+			};
+			activeProjection.baseCompaction = compaction;
+			return {
+				...state,
+				messages,
+				compaction,
+				generation: {
+					...state.generation,
+					responseIndex: payload.messages.length
+				},
+				activeProjection,
+				messageIndexes: Object.fromEntries(messages.map((message) => [message.id, replacements.has(message.id) ? throughIndex : state.messageIndexes[message.id]]))
+			};
+		}
+		case "ai.model.metadata.requested": {
+			const { modelId } = event.payload;
+			return Object.hasOwn(state.modelMetadata, modelId) ? state : {
+				...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
+					}
+				}
+			};
+		}
+		default: return state;
+	}
+};
+//#endregion
 //#region src/ai-sdk-step.ts
 const CONTROLLED_SETTINGS = [
 	"_internal",
@@ -885,6 +1433,40 @@ const readModelLimits = async (options) => {
 	}
 };
 //#endregion
+//#region src/ai-input-tokens.ts
+const withoutProviderOptions = (value) => {
+	const result = { ...value };
+	Reflect.deleteProperty(result, "providerOptions");
+	return result;
+};
+const estimatedMessage = (message) => ({
+	...withoutProviderOptions(message),
+	content: typeof message.content === "string" ? message.content : message.content.map((part) => part.type === "tool-result" ? {
+		...withoutProviderOptions(part),
+		output: {
+			...withoutProviderOptions(part.output),
+			...part.output.type === "content" ? { value: part.output.value.map(withoutProviderOptions) } : {}
+		}
+	} : withoutProviderOptions(part))
+});
+const estimateInputTokens = async (options) => {
+	const tools = await Promise.all(Object.entries(options.tools).map(async ([name, tool]) => ({
+		name,
+		description: tool.description,
+		inputSchema: await asSchema(tool.inputSchema).jsonSchema
+	})));
+	const instructions = options.instructions;
+	return Math.ceil(Buffer.byteLength(JSON.stringify({
+		messages: options.messages.map(estimatedMessage),
+		instructions: instructions === void 0 || typeof instructions === "string" ? instructions : Array.isArray(instructions) ? instructions.map(estimatedMessage) : estimatedMessage(instructions),
+		tools
+	}), "utf8") / 4);
+};
+const measuredInputTokens = (options) => {
+	const previous = options.calibration;
+	return previous !== void 0 && previous.model === options.model && options.estimate >= previous.estimate ? Math.ceil(previous.inputTokens + options.estimate - previous.estimate) : options.estimate;
+};
+//#endregion
 //#region src/ai-server.ts
 /**
 * experimental-a2/ai/server — the server-only implementation of an experimental-a2/ai definition.
@@ -1066,7 +1648,7 @@ async function* consumeGeneration(options) {
 }
 const foldAIEvents = (options) => {
 	let state = options.state;
-	for (const event of options.events) state = options.agent.reducer.fold(state, event);
+	for (const event of options.events) state = options.reducer.fold(state, event);
 	return state;
 };
 const summarize = async (options) => {
@@ -1107,7 +1689,7 @@ const summarize = async (options) => {
 				role: "user",
 				content: instruction
 			}],
-			responseMessageId: `${options.context.generationId}:summary`
+			responseMessageId: await aiEventId("a2.ai.summary", options.context.generationId)
 		},
 		messageMetadata: void 0
 	});
@@ -1133,52 +1715,11 @@ const summarize = async (options) => {
 };
 const activeCompaction = (state) => {
 	const compaction = state.compaction;
-	return compaction?.status === "completed" && compaction.messages !== void 0 && state.messages.some((message) => message.id === compaction.throughMessageId) ? compaction : null;
+	return compaction?.status === "completed" ? compaction : null;
 };
-const contextMessages = async (options) => {
-	const { agent, session, snapshot } = options;
-	const appended = options.appended ?? [];
-	const state = foldAIEvents({
-		agent,
-		events: appended,
-		state: snapshot.state
-	});
-	const compaction = activeCompaction(state);
-	const queued = new Set(options.coordinator.queued.map((item) => item.messageId));
-	const visible = (messages) => messages.filter((message) => !queued.has(message.id));
-	if (compaction === null) return visible(state.messages);
-	const retained = new Set(compaction.retainedMessageIds ?? []);
-	const throughIndex = compaction.throughIndex;
-	if (throughIndex !== void 0) {
-		const [prefix, priorCoordinator, tail] = await Promise.all([
-			throughIndex === snapshot.index ? Promise.resolve(snapshot) : session.state(agent.reducer, { through: throughIndex }),
-			session.state(aiCoordinatorReducer(agent.contract), { through: throughIndex }),
-			throughIndex >= snapshot.index ? Promise.resolve([]) : session.history({
-				gte: throughIndex + 1,
-				lte: snapshot.index
-			})
-		]);
-		for (const item of priorCoordinator.state.queued) retained.add(item.messageId);
-		const events = options.excluded === void 0 ? tail : withoutGenerationLifecycle(tail, options.excluded);
-		const context = foldAIEvents({
-			agent,
-			events: [...events, ...appended],
-			state: {
-				...prefix.state,
-				messages: [...compaction.messages, ...prefix.state.messages.filter((message) => retained.has(message.id))],
-				activeProjection: null
-			}
-		});
-		const positions = /* @__PURE__ */ new Map();
-		for (const message of [...compaction.messages, ...state.messages]) if (!positions.has(message.id)) positions.set(message.id, positions.size);
-		return visible(context.messages.toSorted((left, right) => (positions.get(left.id) ?? positions.size) - (positions.get(right.id) ?? positions.size)));
-	}
-	const boundary = state.messages.findIndex((message) => message.id === compaction.throughMessageId);
-	return visible([
-		...compaction.messages,
-		...state.messages.slice(0, boundary + 1).filter((message) => retained.has(message.id)),
-		...state.messages.slice(boundary + 1)
-	]);
+const contextMessages = ({ state, coordinator }) => {
+	const queued = new Set(coordinator.queued.map((item) => item.messageId));
+	return state.messages.filter((message) => !queued.has(message.id));
 };
 const modelContext = async (options) => {
 	const messages = await convertToModelMessages(options.messages, { tools: options.tools });
@@ -1188,25 +1729,9 @@ const modelContext = async (options) => {
 		content: summary
 	}, ...messages];
 };
-const estimateInputTokens = async (options) => {
-	const tools = await Promise.all(Object.entries(options.tools).map(async ([name, tool]) => ({
-		name,
-		description: tool.description,
-		inputSchema: await asSchema(tool.inputSchema).jsonSchema
-	})));
-	return Math.ceil(new TextEncoder().encode(JSON.stringify({
-		messages: options.messages,
-		instructions: options.instructions,
-		tools
-	})).byteLength / 4);
-};
-const measuredInputTokens = (options) => {
-	const previous = options.calibration;
-	return previous !== void 0 && previous.model === options.model && options.estimate >= previous.estimate ? Math.max(options.estimate, Math.ceil(previous.inputTokens + options.estimate - previous.estimate)) : options.estimate;
-};
-const toolCalledEvent = (payload) => ({
+const toolCalledEvent = async (payload) => ({
 	type: "ai.tool.called",
-	id: `${payload.generationId}:tool:${payload.toolCallId}:called`,
+	id: await aiEventId("a2.ai.tool.called", payload.generationId, payload.toolCallId),
 	payload
 });
 const approvalClassification = (tools, generation, toolName) => {
@@ -1220,7 +1745,7 @@ const approvalClassification = (tools, generation, toolName) => {
 	if (typeof tool?.needsApproval === "function") return "unknown";
 	return tool?.needsApproval === true ? "approval" : "automatic";
 };
-const lifecycleEvents = (options) => {
+const lifecycleEvents = async (options) => {
 	const result = [];
 	const pending = [...options.pending];
 	const take = (toolCallId) => {
@@ -1228,12 +1753,12 @@ const lifecycleEvents = (options) => {
 		if (index === -1) return void 0;
 		return pending.splice(index, 1)[0];
 	};
-	const flush = (toolCallId) => {
+	const flush = async (toolCallId) => {
 		const pendingCall = take(toolCallId);
-		if (pendingCall) result.push(toolCalledEvent(pendingCall.call));
+		if (pendingCall) result.push(await toolCalledEvent(pendingCall.call));
 	};
 	for (const [chunkIndex, chunk] of options.chunks.entries()) {
-		const resultId = `${options.generationId}:tool-result:${options.sequence}:${chunkIndex}`;
+		const resultId = () => aiEventId("a2.ai.tool.stream-result", options.generationId, String(options.sequence), String(chunkIndex));
 		if (chunk.type === "tool-input-available") {
 			const payload = {
 				requestId: options.requestId,
@@ -1251,7 +1776,7 @@ const lifecycleEvents = (options) => {
 			};
 			take(payload.toolCallId);
 			const classification = approvalClassification(options.tools, options.generation, chunk.toolName);
-			if (classification === "automatic") result.push(toolCalledEvent(payload));
+			if (classification === "automatic") result.push(await toolCalledEvent(payload));
 			else pending.push({
 				call: payload,
 				classification
@@ -1280,13 +1805,13 @@ const lifecycleEvents = (options) => {
 				input: chunk.input
 			};
 			take(chunk.toolCallId);
-			result.push(toolCalledEvent(called), {
+			result.push(await toolCalledEvent(called), {
 				type: "ai.tool.result",
-				id: resultId,
+				id: await resultId(),
 				payload
 			});
 		} else if (chunk.type === "tool-output-available") {
-			flush(chunk.toolCallId);
+			await flush(chunk.toolCallId);
 			const payload = {
 				requestId: options.requestId,
 				messageId: options.messageId,
@@ -1302,11 +1827,11 @@ const lifecycleEvents = (options) => {
 			};
 			result.push({
 				type: "ai.tool.result",
-				id: resultId,
+				id: await resultId(),
 				payload
 			});
 		} else if (chunk.type === "tool-output-error") {
-			flush(chunk.toolCallId);
+			await flush(chunk.toolCallId);
 			const payload = {
 				requestId: options.requestId,
 				messageId: options.messageId,
@@ -1321,11 +1846,11 @@ const lifecycleEvents = (options) => {
 			};
 			result.push({
 				type: "ai.tool.result",
-				id: resultId,
+				id: await resultId(),
 				payload
 			});
 		} else if (chunk.type === "tool-output-denied") {
-			flush(chunk.toolCallId);
+			await flush(chunk.toolCallId);
 			const payload = {
 				requestId: options.requestId,
 				messageId: options.messageId,
@@ -1336,12 +1861,13 @@ const lifecycleEvents = (options) => {
 			};
 			result.push({
 				type: "ai.tool.result",
-				id: resultId,
+				id: await resultId(),
 				payload
 			});
 		} else if (chunk.type === "tool-approval-request") {
-			flush(chunk.toolCallId);
+			await flush(chunk.toolCallId);
 			const payload = {
+				requestId: options.requestId,
 				messageId: options.messageId,
 				generationId: options.generationId,
 				approvalId: chunk.approvalId,
@@ -1351,13 +1877,14 @@ const lifecycleEvents = (options) => {
 			};
 			result.push({
 				type: "ai.approval.requested",
-				id: `${options.generationId}:approval:${chunk.approvalId}`,
+				id: await aiEventId("a2.ai.approval.requested", options.generationId, chunk.approvalId),
 				payload
 			});
 		} else if (chunk.type === "tool-approval-response") result.push({
 			type: "ai.approval.responded",
-			id: `${options.generationId}:approval:${chunk.approvalId}:automatic-response`,
+			id: await aiEventId("a2.ai.approval.automatic-response", options.generationId, chunk.approvalId),
 			payload: {
+				requestId: options.requestId,
 				messageId: options.messageId,
 				generationId: options.generationId,
 				approvalId: chunk.approvalId,
@@ -1371,24 +1898,6 @@ const lifecycleEvents = (options) => {
 		pending
 	};
 };
-function withoutGenerationLifecycle(history, generationIds) {
-	if (generationIds.size === 0) return history;
-	const approvalKeys = /* @__PURE__ */ new Set();
-	const inputKeys = /* @__PURE__ */ new Set();
-	for (const event of history) {
-		const payload = event.payload;
-		if (typeof payload.generationId !== "string" || !generationIds.has(payload.generationId) || typeof payload.messageId !== "string") continue;
-		if (event.type === "ai.approval.requested" && typeof payload.approvalId === "string") approvalKeys.add(`${payload.messageId}\u001f${payload.approvalId}`);
-		if (event.type === "ai.input.requested" && typeof payload.inputId === "string") inputKeys.add(`${payload.messageId}\u001f${payload.inputId}`);
-	}
-	return history.filter((event) => {
-		const payload = event.payload;
-		if (typeof payload.generationId === "string" && generationIds.has(payload.generationId)) return false;
-		if (event.type === "ai.approval.responded" && typeof payload.messageId === "string" && typeof payload.approvalId === "string") return !approvalKeys.has(`${payload.messageId}\u001f${payload.approvalId}`);
-		if (event.type === "ai.input.responded" && typeof payload.messageId === "string" && typeof payload.inputId === "string") return !inputKeys.has(`${payload.messageId}\u001f${payload.inputId}`);
-		return true;
-	});
-}
 const validateCompaction = (options) => {
 	let compaction = options.compaction;
 	if (compaction !== false && (typeof compaction !== "object" || compaction === null)) throw new TypeError("compaction must resolve to false or a policy object");
@@ -1428,10 +1937,18 @@ function createHandlers(options) {
 	const maxSteps = options.maxSteps ?? Number.POSITIVE_INFINITY;
 	const control = createControlRuntime({ agent: options.agent });
 	const coordinator = control.coordinator;
+	const contextReducer = createContextReducer({ agent: options.agent });
+	const readContext = async (session, through) => {
+		const snapshot = await session.state(contextReducer, { through });
+		return {
+			state: contextReducer.view(snapshot.state),
+			index: snapshot.index
+		};
+	};
 	const promptCache = /* @__PURE__ */ new Map();
-	const resultEvent = (call, suffix, result) => ({
+	const resultEvent = async (call, suffix, result) => ({
 		type: "ai.tool.result",
-		id: `${call.generationId}:tool:${call.toolCallId}:${suffix}`,
+		id: await aiEventId("a2.ai.tool.result", call.generationId, call.toolCallId, suffix),
 		payload: {
 			requestId: call.requestId,
 			messageId: call.messageId,
@@ -1457,28 +1974,11 @@ function createHandlers(options) {
 		const computation = (async () => {
 			const frontier = owner.promptThroughIndex;
 			if (frontier === void 0) throw new TypeError("AI work requires a prompt checkpoint");
-			const [snapshot, atPrompt, tail] = await Promise.all([
-				ctx.session.state(options.agent.reducer, { through: frontier }),
-				ctx.session.state(coordinator, { through: frontier }),
-				ctx.session.history({
-					gte: frontier + 1,
-					lte: ctx.event.index
-				})
-			]);
-			const appended = tail.filter((event) => (event.type === "ai.generation.started" || event.type === "ai.compaction.requested" || event.type === "ai.compaction.completed") && event.payload.generationId === call.generationId);
-			const state = foldAIEvents({
-				agent: options.agent,
-				events: appended,
-				state: snapshot.state
-			});
+			const snapshot = await readContext(ctx.session, ctx.event.index);
+			if (snapshot.state.generation?.owner.generationId !== owner.generationId || snapshot.state.generation.owner.requestId !== owner.requestId || snapshot.state.activeProjection?.generationId !== owner.generationId) throw new TypeError("Tool prompt checkpoint does not own its generation");
+			const state = generationBase(snapshot.state);
 			return modelContext({
-				messages: await contextMessages({
-					agent: options.agent,
-					session: ctx.session,
-					snapshot,
-					coordinator: atPrompt.state,
-					appended
-				}),
+				messages: state.messages.filter((message) => state.messageIndexes[message.id] <= frontier),
 				state,
 				tools
 			});
@@ -1489,7 +1989,7 @@ function createHandlers(options) {
 		});
 		return computation;
 	};
-	const toolExecutionFailure = (ctx, call, error) => {
+	const toolExecutionFailure = async (ctx, call, error) => {
 		const schedulerFailure = consumeSchedulerSendFailure(error);
 		if (checkAbort(ctx.signal)) return;
 		if (schedulerFailure === "retryable") throw error;
@@ -1534,7 +2034,7 @@ function createHandlers(options) {
 				await control.append({
 					ctx,
 					name: `tool:${call.toolCallId}:preliminary:${sequence}`,
-					events: [resultEvent(call, `${ctx.event.id}:execution:${ctx.attempt}:${sequence}:preliminary`, {
+					events: [await resultEvent(call, `${ctx.event.id}:execution:${ctx.attempt}:${sequence}:preliminary`, {
 						output: result.value,
 						preliminary: true
 					})]
@@ -1565,7 +2065,7 @@ function createHandlers(options) {
 			const state = (await ctx.session.state(control.reducer, { through: "latest" })).state;
 			const request = ctx.event.payload;
 			const call = state.coordinator.response?.calls.find((candidate) => candidate.work?.id === ctx.event.id);
-			if (state.active?.turnId !== request.turnId || state.active.suspended || state.active.version !== request.version || state.coordinator.response?.failure !== void 0 || !call || call.terminal || call.work?.settled) return control.settled({
+			if (state.active?.turnId !== request.turnId || Object.values(state.pendingStops).includes(request.turnId) || state.active.suspended || state.active.version !== request.version || state.coordinator.response?.failure !== void 0 || !call || call.terminal || call.work?.settled) return control.settled({
 				ctx,
 				events: void 0
 			});
@@ -1592,46 +2092,29 @@ function createHandlers(options) {
 		if (checkAbort(ctx.signal)) return;
 		const requestId = ctx.event.id;
 		const request = ctx.event.payload;
-		const snapshot = await ctx.session.state(options.agent.reducer, { through: "latest" });
-		if (snapshot.state.active?.phase === "paused" || snapshot.state.active?.phase === "pausing") return;
-		const coordinatorState = (await ctx.session.state(coordinator, { through: snapshot.index })).state;
+		const snapshot = await readContext(ctx.session, "latest");
+		if (snapshot.state.closed || snapshot.state.authority?.requestId !== requestId || snapshot.state.authority?.phase === "paused" || snapshot.state.authority?.phase === "pausing") return;
+		const controlState = (await ctx.session.state(control.reducer, { through: snapshot.index })).state;
+		if (request.control !== void 0 && Object.values(controlState.pendingStops).includes(request.control.turnId)) return;
+		const coordinatorState = controlState.coordinator;
 		if (coordinatorState.closed || coordinatorState.response?.activeRequestId !== requestId) return;
 		const response = coordinatorState.response;
 		const current = response.generation?.requestId === requestId ? response.generation : void 0;
 		if (current !== void 0 && (response.completion !== void 0 || response.failure !== void 0 && response.failure.superseded !== true)) return;
 		if (current !== void 0 && current.attempt >= ctx.attempt) return;
 		const attempt = ctx.attempt;
-		const generationId = `${requestId}:generation:${attempt}`;
-		const responseMessageId = request.responseMessageId ?? (request.reason === "message" ? `${request.messageId}:assistant` : request.messageId);
+		const generationId = await aiEventId("a2.ai.generation", requestId, String(attempt));
+		const responseMessageId = request.responseMessageId;
 		const responseStepCount = response.stepCount;
-		if (request.reason === "tool" && (requestId !== `ai.generate:tools:${response.source?.generation.generationId}` || response.responseMessageId !== request.messageId || response.responseMessageId !== request.responseMessageId)) return;
+		if (request.reason === "tool" && (request.sourceGenerationId !== response.source?.generation.generationId || response.responseMessageId !== request.messageId || response.responseMessageId !== request.responseMessageId)) return;
 		const previous = current;
-		const replaced = previous === void 0 ? [] : [{
-			generation: previous,
-			frontier: response.promptThroughIndex
-		}];
-		if (request.reason === "retry" && response.source?.failed) replaced.push({
-			generation: response.source.generation,
-			frontier: response.source.promptThroughIndex
-		});
-		const replacedGenerationIds = new Set(replaced.map(({ generation: owner }) => owner.generationId));
-		let state = snapshot.state;
-		if (replaced.length > 0) {
-			const through = Math.min(...replaced.map(({ frontier }) => frontier));
-			const baseline = await ctx.session.state(options.agent.reducer, { through });
-			const tail = await ctx.session.history({
-				gte: through + 1,
-				lte: snapshot.index
-			});
-			state = foldAIEvents({
-				agent: options.agent,
-				events: withoutGenerationLifecycle(tail, replacedGenerationIds),
-				state: baseline.state
-			});
-		}
+		const state = previous === void 0 ? snapshot.state : contextForAttempt(snapshot.state);
 		const resolverContext = {
 			event: ctx.event,
-			state,
+			messages: contextMessages({
+				state,
+				coordinator: coordinatorState
+			}),
 			session: { state: (reducer, readOptions) => ctx.session.state(reducer, {
 				...readOptions,
 				through: readOptions?.through ?? snapshot.index
@@ -1657,7 +2140,7 @@ function createHandlers(options) {
 				if (source === void 0) return;
 				return {
 					type: "ai.generation.failed",
-					id: `${requestId}:step-limit`,
+					id: await aiEventId("a2.ai.step-limit", requestId),
 					payload: {
 						requestId: source.requestId,
 						messageId: source.messageId,
@@ -1684,7 +2167,7 @@ function createHandlers(options) {
 			const startEvents = [];
 			if (discoversMetadata && !Object.hasOwn(state.modelMetadata, catalogModelId)) startEvents.push({
 				type: "ai.model.metadata.requested",
-				id: `ai.model.metadata:${encodeURIComponent(options.agent.contract.name)}:${encodeURIComponent(ctx.event.sessionId)}:${encodeURIComponent(catalogModelId)}`,
+				id: await aiEventId("a2.ai.model.metadata", options.agent.contract.name, ctx.event.sessionId, catalogModelId),
 				payload: { modelId: catalogModelId }
 			});
 			if (previous) {
@@ -1699,7 +2182,7 @@ function createHandlers(options) {
 				};
 				startEvents.push({
 					type: "ai.generation.failed",
-					id: `${payload.generationId}:superseded`,
+					id: await aiEventId("a2.ai.superseded", payload.generationId),
 					payload: superseded
 				});
 			}
@@ -1716,15 +2199,9 @@ function createHandlers(options) {
 			generationStarted = true;
 			if (checkAbort(ctx.signal)) return;
 			const promptCoordinatorState = coordinatorState;
-			const messages = await contextMessages({
-				agent: options.agent,
-				session: ctx.session,
-				snapshot: {
-					state,
-					index: snapshot.index
-				},
-				coordinator: promptCoordinatorState,
-				excluded: replacedGenerationIds
+			const messages = contextMessages({
+				state,
+				coordinator: promptCoordinatorState
 			});
 			let generationMessages = messages;
 			let modelMessages = await modelContext({
@@ -1739,7 +2216,6 @@ function createHandlers(options) {
 				responseMessageId,
 				messages,
 				modelMessages,
-				state,
 				session: resolverContext.session,
 				signal: ctx.signal,
 				model: resolvedModel,
@@ -1753,8 +2229,9 @@ function createHandlers(options) {
 			const limits = metadata?.status === "resolved" && !usesFallbackModels ? metadata.limits : void 0;
 			let inputTokenEstimate;
 			let compacted = false;
-			const canCompact = response.source?.canCompact ?? true;
-			if (policy && canCompact) {
+			let compactionEstimate;
+			const hasPendingTools = messages.some((message) => message.parts.some((part) => isToolUIPart(part) && !(part.state === "output-error" || part.state === "output-denied" || part.state === "output-available" && part.preliminary !== true)));
+			if (policy && !hasPendingTools) {
 				const compactionContext = {
 					...resolverContext,
 					messages,
@@ -1776,8 +2253,18 @@ function createHandlers(options) {
 					const threshold = policy.thresholdTokens ?? (limits === void 0 ? void 0 : Math.floor(Math.min(limits.contextWindow * .75, limits.contextWindow - (generation.maxOutputTokens ?? 0))));
 					if (limits !== void 0 && threshold !== void 0 && threshold <= 0) throw new Error(`output allowance exhausts the ${limits.contextWindow}-token context window`);
 					shouldCompact = threshold !== void 0 && inputTokens >= threshold;
+					if (threshold !== void 0 && shouldCompact) compactionEstimate = {
+						inputTokenEstimate,
+						inputTokens,
+						thresholdTokens: threshold
+					};
 				} else shouldCompact = false;
 				if (checkAbort(ctx.signal)) return;
+				if (shouldCompact) {
+					const latest = (await ctx.session.state(coordinator, { through: "latest" })).state;
+					shouldCompact = Object.keys(latest.unsettledTools ?? {}).length === 0;
+				}
+				if (checkAbort(ctx.signal)) return;
 				if (shouldCompact) {
 					const throughMessageId = state.messages.findLast((message) => !promptCoordinatorState.queued.some((queued) => queued.messageId === message.id))?.id ?? request.messageId;
 					const throughIndex = snapshot.index;
@@ -1786,11 +2273,12 @@ function createHandlers(options) {
 						name: "compaction-requested",
 						events: [{
 							type: "ai.compaction.requested",
-							id: `${generationId}:compaction:requested`,
+							id: await aiEventId("a2.ai.compaction.requested", generationId),
 							payload: {
 								generationId,
 								throughMessageId,
-								throughIndex
+								throughIndex,
+								...compactionEstimate
 							}
 						}]
 					}));
@@ -1815,7 +2303,7 @@ function createHandlers(options) {
 						name: "compaction-completed",
 						events: [{
 							type: "ai.compaction.completed",
-							id: `${generationId}:compaction:completed`,
+							id: await aiEventId("a2.ai.compaction.completed", generationId),
 							payload: completed
 						}]
 					}));
@@ -1825,16 +2313,13 @@ function createHandlers(options) {
 				}
 			}
 			const currentState = foldAIEvents({
-				agent: options.agent,
+				reducer: contextReducer[aiStateReducer],
 				events: generationEvents,
-				state: snapshot.state
+				state
 			});
-			if (request.reason === "retry" || previous !== void 0) generationMessages = await contextMessages({
-				agent: options.agent,
-				session: ctx.session,
-				snapshot,
-				coordinator: promptCoordinatorState,
-				appended: generationEvents
+			if (request.reason === "retry" || previous !== void 0) generationMessages = contextMessages({
+				state: currentState,
+				coordinator: promptCoordinatorState
 			});
 			if (policy && "shouldCompact" in policy || generationMessages !== messages || activeCompaction(currentState)?.summary !== activeCompaction(state)?.summary) modelMessages = await modelContext({
 				messages: generationMessages,
@@ -1856,7 +2341,6 @@ function createHandlers(options) {
 				responseMessageId,
 				messages: generationMessages,
 				modelMessages,
-				state: currentState,
 				session: resolverContext.session,
 				signal: ctx.signal,
 				model: resolvedModel,
@@ -1889,7 +2373,7 @@ function createHandlers(options) {
 					sequence,
 					chunks: update.chunks
 				};
-				const lifecycle = lifecycleEvents({
+				const lifecycle = await lifecycleEvents({
 					requestId,
 					messageId: responseMessageId,
 					generationId,
@@ -1906,7 +2390,7 @@ function createHandlers(options) {
 					name: `generation-progress:${sequence}`,
 					events: [{
 						type: "ai.generation.progress",
-						id: `${generationId}:progress:${sequence}`,
+						id: await aiEventId("a2.ai.progress", generationId, String(sequence)),
 						payload: progress
 					}, ...lifecycle.events]
 				});
@@ -1924,19 +2408,19 @@ function createHandlers(options) {
 			};
 			const completionEvent = {
 				type: "ai.generation.completed",
-				id: `${generationId}:completed`,
+				id: await aiEventId("a2.ai.completed", generationId),
 				payload: completed
 			};
 			const unresolved = options.generate ? pendingToolCalls.filter((pending) => pending.classification !== "automatic") : [];
 			if (unresolved.length > 0) throw new Error(`generation ended with unresolved tool authorization for '${unresolved[0].call.toolName}'`);
-			const pendingEvents = pendingToolCalls.filter((pending) => pending.classification === "automatic" || options.generate === void 0 && pending.classification === "unknown").map((pending) => toolCalledEvent(pending.call));
+			const pendingEvents = await Promise.all(pendingToolCalls.filter((pending) => pending.classification === "automatic" || options.generate === void 0 && pending.classification === "unknown").map((pending) => toolCalledEvent(pending.call)));
 			if (finish.finishReason === "tool-calls") return [...pendingEvents, completionEvent];
 			return [
 				...pendingEvents,
 				completionEvent,
 				{
 					type: "ai.message.completed",
-					id: `${generationId}:message:completed`,
+					id: await aiEventId("a2.ai.message.completed", generationId),
 					payload: { messageId: responseMessageId }
 				}
 			];
@@ -1957,7 +2441,7 @@ function createHandlers(options) {
 			};
 			return {
 				type: "ai.generation.failed",
-				id: `${generationId}:failed`,
+				id: await aiEventId("a2.ai.failed", generationId),
 				payload: failed
 			};
 		}
@@ -1975,7 +2459,7 @@ function createHandlers(options) {
 			ctx.signal.throwIfAborted();
 			return {
 				type: "ai.model.metadata.resolved",
-				id: `${ctx.event.id}:resolved`,
+				id: await aiEventId("a2.ai.model.metadata.resolved", ctx.event.id),
 				payload: {
 					modelId: ctx.event.payload.modelId,
 					limits
@@ -1983,7 +2467,13 @@ function createHandlers(options) {
 			};
 		} },
 		"ai.control.requested": {
-			lane: "a2.ai.control",
+			lane: ({ event }) => {
+				const command = event.payload;
+				if (event.id === "") throw new A2Error("INVALID_PAYLOAD", "AI command IDs must be nonempty");
+				if (event.id?.startsWith("a2.ai:")) throw new A2Error("INVALID_PAYLOAD", `AI command IDs cannot use the reserved '${AI_EVENT_ID_PREFIX}' prefix`);
+				if ((command.action === "send" || command.action === "steer") && event.id !== command.message.id) throw new A2Error("INVALID_PAYLOAD", "AI input event ID must equal message.id");
+				return "a2.ai.control";
+			},
 			handler: control.handler
 		},
 		"ai.work.reported": {
@@ -2010,6 +2500,7 @@ function createHandlers(options) {
 		"ai.generation.requested": {
 			lane: "a2.ai.model",
 			abortOn: {
+				"ai.control.requested": (event, trigger) => event.payload.action === "stop" && event.payload.turnId === trigger.payload.control?.turnId,
 				"ai.control.committed": (event, trigger) => {
 					const active = event.payload.view;
 					return active?.turnId !== trigger.payload.control?.turnId || active?.version !== trigger.payload.control?.version;
@@ -2036,6 +2527,7 @@ function createHandlers(options) {
 		},
 		"ai.tool.execution.requested": {
 			abortOn: {
+				"ai.control.requested": (event, trigger) => event.payload.action === "stop" && event.payload.turnId === trigger.payload.turnId,
 				"ai.generation.failed": (event, trigger) => event.payload.generationId === trigger.payload.call.generationId,
 				"ai.control.committed": (event, trigger) => {
 					const active = event.payload.view;