experimental-a2 0.12.0 → 0.14.0

package/dist/ai-server.js

@@ -1,90 +1,10 @@
+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-BeNADlCI.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 { AsyncLocalStorage } from "node:async_hooks";
-import { convertToModelMessages, stepCountIs, streamText, toUIMessageStream } from "ai";
-//#region src/ai-sdk-step.ts
-const CONTROLLED_SETTINGS = [
-	"_internal",
-	"abortSignal",
-	"instructions",
-	"messages",
-	"model",
-	"onToolExecutionEnd",
-	"onToolExecutionStart",
-	"experimental_onToolCallFinish",
-	"experimental_onToolCallStart",
-	"experimental_sandbox",
-	"experimental_toolCallers",
-	"experimental_toolApprovalSecret",
-	"prompt",
-	"prepareStep",
-	"stopWhen",
-	"system",
-	"tools"
-];
-const safeSettings = (settings) => {
-	const result = { ...settings };
-	for (const key of CONTROLLED_SETTINGS) Reflect.deleteProperty(result, key);
-	if (typeof result.timeout === "object" && result.timeout !== null) {
-		const timeout = { ...result.timeout };
-		Reflect.deleteProperty(timeout, "toolMs");
-		Reflect.deleteProperty(timeout, "tools");
-		result.timeout = timeout;
-	}
-	return result;
-};
-const modelToolSet = (tools) => Object.fromEntries(Object.entries(tools).map(([name, tool]) => {
-	if (tool.type === "provider" && tool.isProviderExecuted === true) return [name, tool];
-	const definition = { ...tool };
-	Reflect.deleteProperty(definition, "execute");
-	return [name, definition];
-}));
-const errorMessage$1 = (error) => error instanceof Error ? error.message : String(error);
-/** Run exactly one AI SDK model step while leaving local tool execution to A2. */
-async function generateAISDKStep(input) {
-	const settings = safeSettings(input.settings);
-	const tools = modelToolSet(input.tools);
-	const messages = await convertToModelMessages(input.messages, { tools });
-	const streamOptions = {
-		...settings,
-		model: input.model,
-		tools,
-		messages,
-		abortSignal: input.abortSignal,
-		...input.instructions === void 0 ? {} : { instructions: input.instructions },
-		stopWhen: stepCountIs(1),
-		onError: settings.onError ?? (() => {})
-	};
-	const result = streamText(streamOptions);
-	let completion;
-	let fatalError;
-	const observed = result.stream.pipeThrough(new TransformStream({ transform(part, controller) {
-		if (part.type === "error" && fatalError === void 0) fatalError = { value: part.error };
-		else if (part.type === "finish") completion = {
-			finishReason: part.finishReason,
-			usage: part.totalUsage
-		};
-		controller.enqueue(part);
-	} }));
-	return {
-		stream: toUIMessageStream({
-			stream: observed,
-			tools,
-			originalMessages: input.messages,
-			generateMessageId: () => input.responseMessageId,
-			onError: errorMessage$1,
-			...input.messageMetadata === void 0 ? {} : { messageMetadata: input.messageMetadata }
-		}),
-		completion() {
-			if (fatalError !== void 0) throw fatalError.value;
-			if (completion === void 0) throw new Error("AI SDK step ended without a finish part");
-			if (completion.finishReason === "error") throw new Error("AI SDK step finished with an error");
-			return completion;
-		}
-	};
-}
-//#endregion
+import { asSchema, convertToModelMessages, stepCountIs, streamText, toUIMessageStream } from "ai";
 //#region src/ai-coordinator.ts
 const updateResponse = (state, update) => state.response === void 0 ? state : {
 	...state,
@@ -96,6 +16,11 @@ const foldCoordinator = (state, event) => {
 			closed: true,
 			queued: []
 		};
+		case "ai.retry.requested":
+		case "ai.compaction.completed": {
+			const { calibration: _, ...rest } = state;
+			return rest;
+		}
 		case "ai.message.created": {
 			const payload = event.payload;
 			const message = payload.message;
@@ -103,24 +28,24 @@ const foldCoordinator = (state, event) => {
 			return {
 				...state,
 				queued: [...state.queued.filter((item) => item.messageId !== message.id), {
-					index: event.index,
 					messageId: message.id,
 					generate: payload.generate !== false
-				}].toSorted((left, right) => left.index - right.index)
+				}]
 			};
 		}
 		case "ai.generation.requested": {
 			const request = event.payload;
 			if (request.reason === "message") {
 				const responseMessageId = request.responseMessageId ?? `${request.messageId}:assistant`;
-				const requested = state.queued.find((item) => item.messageId === request.messageId);
+				const requested = state.queued.findIndex((item) => item.messageId === request.messageId);
 				return {
 					...state,
-					queued: requested === void 0 ? state.queued.filter((item) => item.messageId !== request.messageId) : state.queued.filter((item) => item.index > requested.index),
+					queued: requested < 0 ? state.queued.filter((item) => item.messageId !== request.messageId) : state.queued.slice(requested + 1),
 					response: {
 						rootMessageId: request.messageId,
 						responseMessageId,
 						status: "requested",
+						stepCount: 0,
 						activeRequestId: event.id,
 						calls: [],
 						inputs: []
@@ -129,14 +54,25 @@ const foldCoordinator = (state, event) => {
 			}
 			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;
-			return updateResponse(state, (response) => ({
-				rootMessageId: response.rootMessageId,
-				responseMessageId: response.responseMessageId,
-				status: "requested",
-				activeRequestId: event.id,
-				calls: [],
-				inputs: []
-			}));
+			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)
+					} },
+					calls: [],
+					inputs: []
+				};
+			});
 		}
 		case "ai.generation.started": {
 			const generation = event.payload;
@@ -145,7 +81,10 @@ const foldCoordinator = (state, event) => {
 				rootMessageId: response.rootMessageId,
 				responseMessageId: response.responseMessageId,
 				status: "generating",
+				stepCount: response.stepCount,
 				generation,
+				...generation.promptThroughIndex === void 0 ? {} : { promptThroughIndex: generation.promptThroughIndex },
+				...response.source === void 0 ? {} : { source: response.source },
 				activeRequestId: generation.requestId,
 				calls: [],
 				inputs: []
@@ -154,11 +93,22 @@ const foldCoordinator = (state, event) => {
 		case "ai.generation.completed": {
 			const completion = event.payload;
 			if (state.response?.generation?.generationId !== completion.generationId) return state;
-			return updateResponse(state, (response) => ({
+			const { calibration: _, ...uncalibrated } = updateResponse(state, (response) => ({
 				...response,
 				status: "waiting",
-				completion
+				completion,
+				stepCount: response.stepCount + (response.completion === void 0 ? 1 : 0)
 			}));
+			const inputTokens = completion.usage?.inputTokens;
+			const estimate = completion.inputTokenEstimate;
+			return inputTokens !== void 0 && Number.isFinite(inputTokens) && inputTokens >= 0 && estimate !== void 0 ? {
+				...uncalibrated,
+				calibration: {
+					model: state.response.generation.model,
+					inputTokens,
+					estimate
+				}
+			} : uncalibrated;
 		}
 		case "ai.generation.failed": {
 			const failure = event.payload;
@@ -174,18 +124,16 @@ const foldCoordinator = (state, event) => {
 		}
 		case "ai.message.completed": {
 			const messageId = event.payload.messageId;
-			return state.response?.responseMessageId === messageId ? {
-				closed: state.closed,
-				queued: state.queued
-			} : state;
+			if (state.response?.responseMessageId !== messageId) return state;
+			const { response: _, ...rest } = state;
+			return rest;
 		}
 		case "ai.message.interrupted": {
 			const interruption = event.payload;
 			const response = state.response;
-			return response?.responseMessageId === interruption.messageId && (interruption.generationId === response.generation?.generationId || interruption.requestId === response.activeRequestId) ? {
-				closed: state.closed,
-				queued: state.queued
-			} : state;
+			if (response?.responseMessageId !== interruption.messageId || interruption.generationId !== response.generation?.generationId && interruption.requestId !== response.activeRequestId) return state;
+			const { response: _, ...rest } = state;
+			return rest;
 		}
 		case "ai.tool.called": {
 			const call = event.payload;
@@ -193,7 +141,6 @@ const foldCoordinator = (state, event) => {
 			return updateResponse(state, (response) => ({
 				...response,
 				calls: [...response.calls.filter((candidate) => candidate.call.toolCallId !== call.toolCallId), {
-					index: event.index,
 					call,
 					terminal: false
 				}]
@@ -217,8 +164,7 @@ const foldCoordinator = (state, event) => {
 				...response,
 				calls: response.calls.map((candidate) => candidate.approval?.approvalId === approval.approvalId ? {
 					...candidate,
-					response: approval,
-					responseIndex: event.index
+					response: approval
 				} : candidate)
 			}));
 		}
@@ -249,7 +195,6 @@ const foldCoordinator = (state, event) => {
 				...response,
 				inputs: response.inputs.filter((candidate) => candidate.inputId !== input.inputId),
 				inputResponse: {
-					index: event.index,
 					generationId: input.generationId,
 					inputId: input.inputId,
 					name: requested.name
@@ -260,17 +205,685 @@ const foldCoordinator = (state, event) => {
 	}
 };
 const aiCoordinatorReducer = (contract) => contract.reducer({
-	name: "a2.ai.coordinator.v3",
+	name: "a2.ai.coordinator.v5",
 	initialState: {
 		closed: false,
 		queued: []
 	}
-}).fold((state, event) => foldCoordinator(state, event));
+}).fold((state, event) => event.type === "ai.control.committed" ? applyControlChanges({
+	state,
+	changes: event.payload.changes.filter((change) => change.path[0] === "coordinator").map((change) => Object.assign({}, change, { path: change.path.slice(1) }))
+}) : state);
 const continuationReady = (state) => {
 	const response = state.response;
 	return !state.closed && response?.completion?.finishReason === "tool-calls" && response.generation?.generationId === response.completion.generationId && response.failure === void 0 && response.calls.length > 0 && response.calls.every((call) => call.terminal || call.call.providerExecuted === true && call.call.supportsDeferredResults !== true && call.approval !== void 0 && call.response !== void 0);
 };
 //#endregion
+//#region src/ai-control-server.ts
+var ControlCancelled = class extends Error {};
+const callReadyForModel = (call) => call.terminal || call.call.providerExecuted === true && !call.call.supportsDeferredResults && call.response !== void 0;
+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",
+		initialState: initialControlState()
+	}).fold((state, event) => 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" });
+		const before = structuredClone(snapshot.state);
+		const moves = [];
+		const state = structuredClone(snapshot.state);
+		const facts = [];
+		const jobs = [];
+		const emit = ({ type, payload, id = `${ctx.event.id}:fact:${facts.length}` }) => {
+			const fact = {
+				type,
+				payload,
+				id
+			};
+			facts.push(fact);
+			state.coordinator = foldCoordinator(state.coordinator, {
+				...ctx.event,
+				...fact
+			});
+		};
+		let reason;
+		const end = ({ 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({
+				type: "ai.message.interrupted",
+				payload: {
+					messageId: response.responseMessageId,
+					...owner,
+					...interruptionReason === void 0 ? {} : { reason: interruptionReason },
+					...lastSeenIndex === void 0 ? {} : { lastSeenIndex }
+				}
+			});
+			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);
+		};
+		const moveInput = ({ from, to }) => {
+			if (from === to) return;
+			const [moved] = state.inbox.items.splice(from, 1);
+			state.inbox.items.splice(to, 0, moved);
+			const [previous] = before.inbox.items.splice(from, 1);
+			before.inbox.items.splice(to, 0, previous);
+			moves.push({
+				path: ["inbox", "items"],
+				move: {
+					from,
+					to
+				}
+			});
+		};
+		const requestModel = ({ request, id }) => {
+			const active = state.active;
+			const payload = {
+				...request,
+				control: {
+					turnId: active.turnId,
+					version: active.version
+				}
+			};
+			state.coordinator = foldCoordinator(state.coordinator, {
+				...ctx.event,
+				type: "ai.generation.requested",
+				id,
+				payload
+			});
+			active.model = {
+				id,
+				version: active.version,
+				settled: false
+			};
+			active.phase = "starting";
+			jobs.push({
+				type: "ai.generation.requested",
+				id,
+				payload
+			});
+		};
+		if (ctx.event.type === "ai.session.closed") {
+			state.coordinator = {
+				closed: true,
+				queued: []
+			};
+			state.active = null;
+			state.inbox.items = [];
+		} else if (ctx.event.type === "ai.control.requested") {
+			const command = ctx.event.payload;
+			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({
+						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;
+					}
+					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"
+						};
+					}
+					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";
+					else {
+						const destination = command.beforeId === null ? state.inbox.items.length : state.inbox.items.findIndex((item) => item.id === command.beforeId);
+						moveInput({
+							from: index,
+							to: destination > index ? destination - 1 : destination
+						});
+					}
+					break;
+				}
+				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);
+					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;
+						}
+						if (state.active) selected.afterStepOf = state.active.turnId;
+						else delete selected.afterStepOf;
+						moveInput({
+							from: position,
+							to: 0
+						});
+					}
+					break;
+				}
+				case "stop":
+					if (state.active?.turnId !== command.turnId) reason = "stale-turn";
+					else end({
+						lastSeenIndex: command.lastSeenIndex,
+						reason: void 0
+					});
+					break;
+				case "steer":
+					if (inputTaken({ message: command.message })) reason = "duplicate-input";
+					else insert({
+						message: command.message,
+						generate: true,
+						first: true,
+						afterStepOf: command.turnId
+					});
+					break;
+				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({
+						lastSeenIndex: command.request.lastSeenIndex,
+						reason: command.request.reason
+					});
+					break;
+				}
+				case "pause": {
+					state.inbox.paused = true;
+					const active = state.active;
+					if (command.when === "now" && active !== null && !active.suspended) {
+						active.suspended = true;
+						active.version += 1;
+						const generation = state.coordinator.response?.generation;
+						if (generation) emit({
+							type: "ai.generation.paused",
+							payload: {
+								generationId: generation.generationId,
+								messageId: generation.responseMessageId
+							}
+						});
+					}
+					break;
+				}
+				case "resume":
+					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({
+						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);
+					if (response?.failure) reason = "stale-turn";
+					else if (!call || call.response || call.terminal) reason = "not-found";
+					else emit({
+						type: "ai.approval.responded",
+						payload: command.response
+					});
+					break;
+				}
+				case "request-input":
+				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({
+						type: command.action === "input" ? "ai.input.responded" : "ai.input.requested",
+						payload
+					});
+					break;
+				}
+				case "retry": {
+					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({
+							type: "ai.retry.requested",
+							payload: command.request
+						});
+						requestModel({
+							request: {
+								messageId: response.rootMessageId,
+								responseMessageId: response.responseMessageId,
+								reason: "retry"
+							},
+							id: `ai.generate:retry:${command.request.retryId}`
+						});
+					} else reason = "stale-turn";
+					break;
+				}
+			}
+		} else {
+			const report = ctx.event.payload;
+			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;
+			if (!(active?.turnId === report.turnId && work?.id === report.workId && work.version === report.version && !work.settled && report.attempt >= (work.attempt ?? 0))) reason = "stale-work";
+			else {
+				work.attempt = report.attempt;
+				const authorized = !active.suspended && active.version === report.version;
+				for (const event of report.events) {
+					if (work.facts?.includes(event.id)) continue;
+					if (authorized || report.kind === "tool" && event.type === "ai.tool.result") {
+						emit({
+							type: event.type,
+							payload: event.payload,
+							id: event.id
+						});
+						work.facts = [...work.facts ?? [], event.id];
+					}
+				}
+				if (report.settled) work.settled = true;
+				if (!authorized) reason = "stale-work";
+			}
+		}
+		let active = state.active;
+		let response = state.coordinator.response;
+		if (active && response === void 0) {
+			state.active = null;
+			active = null;
+		}
+		if (active && response) {
+			const handoff = state.inbox.items.some((item) => item.afterStepOf === active.turnId);
+			const outstanding = active.model !== null && !active.model.settled || response.calls.some((candidate) => candidate.work !== void 0 && !candidate.work.settled);
+			if (active.suspended) {
+				active.phase = outstanding ? "pausing" : "paused";
+				if (!state.inbox.paused && !outstanding && !handoff) active.suspended = false;
+			}
+			if (!active.suspended && response.failure) active.phase = "failed";
+			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({
+						type: "ai.tool.result",
+						payload: {
+							...call.call,
+							denied: true,
+							phase: "execution"
+						}
+					});
+					continue;
+				}
+				const id = `${ctx.event.id}:tool:${call.call.toolCallId}`;
+				call.work = {
+					id,
+					version: active.version,
+					settled: false
+				};
+				jobs.push({
+					type: "ai.tool.execution.requested",
+					id,
+					payload: {
+						turnId: active.turnId,
+						version: active.version,
+						call: call.call,
+						generation: response.generation
+					}
+				});
+			}
+			response = state.coordinator.response;
+			const callsDone = response.calls.every(callReadyForModel);
+			const modelDone = active.model === null || active.model.settled;
+			const workSettled = modelDone && response.calls.every((call) => call.work === void 0 || call.work.settled);
+			const externalPending = response.calls.some((call) => call.call.providerExecuted && call.call.supportsDeferredResults && !call.terminal && !approvalBlocksExecution(call));
+			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({
+				lastSeenIndex: void 0,
+				reason: "steered after step"
+			});
+			else if (readyForModel && (!handoff || handoffReady)) {
+				const resume = active.model !== null && active.model.version !== active.version;
+				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}`;
+					requestModel({
+						request: {
+							messageId: response.responseMessageId,
+							responseMessageId: response.responseMessageId,
+							reason: nextReason
+						},
+						id
+					});
+				} else if (naturalCompletion) {
+					emit({
+						type: "ai.message.completed",
+						payload: { messageId: response.responseMessageId }
+					});
+					state.active = null;
+				}
+			}
+			if (!active.suspended && state.active && jobs.every((job) => job.type !== "ai.generation.requested")) state.active.phase = response.failure ? "failed" : !modelDone ? "generating" : !callsDone ? "tools" : "waiting";
+		}
+		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({
+				type: "ai.message.created",
+				payload: {
+					message: item.message,
+					generate: item.generate
+				},
+				id: `ai.admitted:${item.id}`
+			});
+			if (!item.generate) continue;
+			state.active = {
+				turnId: item.id,
+				input: item,
+				phase: "starting",
+				version: 0,
+				suspended: false,
+				model: null
+			};
+			requestModel({
+				request: {
+					messageId: item.id,
+					reason: "message"
+				},
+				id: `ai.generate:message:${item.id}`
+			});
+			break;
+		}
+		const receipt = {
+			commandId: ctx.event.id,
+			...ctx.event.type === "ai.work.reported" ? { work: true } : {},
+			outcome: reason === void 0 ? "applied" : "rejected",
+			...reason === void 0 ? {} : { reason }
+		};
+		return [
+			...facts,
+			{
+				type: "ai.control.committed",
+				payload: controlCommit({
+					before,
+					after: state,
+					moves
+				})
+			},
+			...jobs,
+			{
+				type: "ai.control.decided",
+				payload: receipt
+			}
+		];
+	};
+	const report = ({ ctx, events, settled, name }) => {
+		const payload = ctx.event.payload;
+		const { turnId, version } = "turnId" in payload ? payload : payload.control;
+		for (const event of events) {
+			const schema = options.agent.contract.events[event.type];
+			const result = validateSync(schema, event.payload, `AI worker ${event.type}`);
+			if (result.issues) throw new TypeError(result.issues.map((issue) => issue.message).join("; "));
+		}
+		return {
+			type: "ai.work.reported",
+			id: `${ctx.event.id}:report:${ctx.attempt}:${name}`,
+			payload: {
+				workId: ctx.event.id,
+				attempt: ctx.attempt,
+				turnId,
+				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) => ({
+					type: event.type,
+					payload: event.payload,
+					id: event.id ?? `${ctx.event.id}:fact:${ctx.attempt}:${name}:${index}`
+				}))
+			}
+		};
+	};
+	const append = async ({ ctx, name, events }) => {
+		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({
+			ctx,
+			events: lifecycle,
+			settled: false,
+			name
+		});
+		const persisted = await ctx.session.append(name, ...progress, input);
+		const index = persisted.at(-1).index;
+		const stream = ctx.session.stream({ startAfter: index })[Symbol.asyncIterator]();
+		const canonical = [];
+		const wanted = new Set(lifecycle.map((event) => event.id));
+		let rejectAbort;
+		const aborted = new Promise((_, reject) => {
+			rejectAbort = reject;
+		});
+		const onAbort = () => {
+			rejectAbort(ctx.signal.reason);
+		};
+		ctx.signal.addEventListener("abort", onAbort, { once: true });
+		try {
+			ctx.signal.throwIfAborted();
+			for (;;) {
+				const item = await Promise.race([stream.next(), aborted]);
+				if (item.done) throw new Error("AI control acknowledgement stream ended");
+				if (wanted.has(item.value.id)) canonical.push(item.value);
+				if (item.value.type === "ai.control.decided" && item.value.payload.commandId === input.id) {
+					if (item.value.payload.outcome === "rejected") throw new ControlCancelled("stale AI work");
+					return [...persisted.filter((event) => event.type !== "ai.work.reported"), ...canonical];
+				}
+			}
+		} finally {
+			ctx.signal.removeEventListener("abort", onAbort);
+			await stream.return?.();
+		}
+	};
+	const settled = ({ ctx, events }) => report({
+		ctx,
+		events: events === void 0 ? [] : Array.isArray(events) ? events : [events],
+		settled: true,
+		name: "settled"
+	});
+	const cancelled = ({ error, signal }) => {
+		if (signal.reason instanceof A2Error) throw signal.reason;
+		return error instanceof ControlCancelled || signal.aborted;
+	};
+	return {
+		handler,
+		append,
+		settled,
+		cancelled,
+		reducer,
+		coordinator
+	};
+};
+//#endregion
+//#region src/ai-sdk-step.ts
+const CONTROLLED_SETTINGS = [
+	"_internal",
+	"abortSignal",
+	"instructions",
+	"messages",
+	"model",
+	"onToolExecutionEnd",
+	"onToolExecutionStart",
+	"experimental_onToolCallFinish",
+	"experimental_onToolCallStart",
+	"experimental_sandbox",
+	"experimental_toolCallers",
+	"experimental_toolApprovalSecret",
+	"prompt",
+	"prepareStep",
+	"stopWhen",
+	"system",
+	"tools"
+];
+const safeSettings = (settings) => {
+	const result = { ...settings };
+	for (const key of CONTROLLED_SETTINGS) Reflect.deleteProperty(result, key);
+	if (typeof result.timeout === "object" && result.timeout !== null) {
+		const timeout = { ...result.timeout };
+		Reflect.deleteProperty(timeout, "toolMs");
+		Reflect.deleteProperty(timeout, "tools");
+		result.timeout = timeout;
+	}
+	return result;
+};
+const modelToolSet = (tools) => Object.fromEntries(Object.entries(tools).map(([name, tool]) => {
+	if (tool.type === "provider" && tool.isProviderExecuted === true) return [name, tool];
+	const definition = { ...tool };
+	Reflect.deleteProperty(definition, "execute");
+	return [name, definition];
+}));
+const errorMessage$1 = (error) => error instanceof Error ? error.message : String(error);
+/** Run exactly one AI SDK model step while leaving local tool execution to A2. */
+async function generateAISDKStep(input) {
+	const settings = safeSettings(input.settings);
+	const tools = modelToolSet(input.tools);
+	const messages = input.modelMessages ?? await convertToModelMessages(input.messages, { tools });
+	const streamOptions = {
+		...settings,
+		model: input.model,
+		tools,
+		messages,
+		abortSignal: input.abortSignal,
+		...input.instructions === void 0 ? {} : { instructions: input.instructions },
+		stopWhen: stepCountIs(1),
+		onError: settings.onError ?? (() => {})
+	};
+	const result = streamText(streamOptions);
+	let completion;
+	let fatalError;
+	const observed = result.stream.pipeThrough(new TransformStream({ transform(part, controller) {
+		if (part.type === "error" && fatalError === void 0) fatalError = { value: part.error };
+		else if (part.type === "finish") completion = {
+			finishReason: part.finishReason,
+			usage: part.totalUsage
+		};
+		controller.enqueue(part);
+	} }));
+	return {
+		stream: toUIMessageStream({
+			stream: observed,
+			tools,
+			generateMessageId: () => input.responseMessageId,
+			onError: errorMessage$1,
+			...input.messageMetadata === void 0 ? {} : { messageMetadata: input.messageMetadata }
+		}),
+		completion() {
+			if (fatalError !== void 0) throw fatalError.value;
+			if (completion === void 0) throw new Error("AI SDK step ended without a finish part");
+			if (completion.finishReason === "error") throw new Error("AI SDK step finished with an error");
+			return completion;
+		}
+	};
+}
+//#endregion
+//#region src/ai-model-metadata.ts
+const catalogUrl = "https://ai-gateway.vercel.sh/v1/models";
+const catalogLifetimeMs = 36e5;
+const catalogTimeoutMs = 5e3;
+let catalog;
+const gatewayModelId = (model) => {
+	if (typeof model === "string") return globalThis.AI_SDK_DEFAULT_PROVIDER === void 0 ? model : void 0;
+	return model.provider === "gateway" ? model.modelId : void 0;
+};
+const readCatalog = () => {
+	if (catalog && catalog.expiresAt > Date.now()) return catalog.promise;
+	const entry = {
+		expiresAt: Number.POSITIVE_INFINITY,
+		promise: (async () => {
+			const controller = new AbortController();
+			const timeout = setTimeout(() => controller.abort(/* @__PURE__ */ new Error("model catalog request timed out")), catalogTimeoutMs);
+			timeout.unref?.();
+			try {
+				const response = await fetch(catalogUrl, { signal: controller.signal });
+				if (!response.ok) throw new Error(`model catalog request failed: HTTP ${response.status}`);
+				const body = await response.json();
+				if (typeof body !== "object" || body === null || !("data" in body) || !Array.isArray(body.data)) throw new Error("model catalog response must contain a data array");
+				const models = /* @__PURE__ */ new Map();
+				for (const row of body.data) {
+					if (typeof row !== "object" || row === null || !("type" in row) || !("id" in row) || !("context_window" in row) || !("max_tokens" in row) || row.type !== "language" || typeof row.id !== "string" || typeof row.context_window !== "number" || typeof row.max_tokens !== "number" || !Number.isSafeInteger(row.context_window) || row.context_window <= 0 || !Number.isSafeInteger(row.max_tokens) || row.max_tokens <= 0) continue;
+					models.set(row.id, {
+						contextWindow: row.context_window,
+						maxOutputTokens: row.max_tokens
+					});
+				}
+				return models;
+			} finally {
+				clearTimeout(timeout);
+			}
+		})()
+	};
+	catalog = entry;
+	entry.promise = entry.promise.then((models) => {
+		entry.expiresAt = Date.now() + catalogLifetimeMs;
+		return models;
+	}, (error) => {
+		if (catalog === entry) catalog = void 0;
+		throw error;
+	});
+	return entry.promise;
+};
+const readModelLimits = async (options) => {
+	options.signal.throwIfAborted();
+	let onAbort;
+	const aborted = new Promise((_resolve, reject) => {
+		onAbort = () => reject(options.signal.reason);
+		options.signal.addEventListener("abort", onAbort, { once: true });
+	});
+	try {
+		return (await Promise.race([readCatalog(), aborted])).get(options.modelId) ?? null;
+	} finally {
+		options.signal.removeEventListener("abort", onAbort);
+	}
+};
+//#endregion
 //#region src/ai-server.ts
 /**
 * experimental-a2/ai/server — the server-only implementation of an experimental-a2/ai definition.
@@ -280,13 +893,31 @@ const continuationReady = (state) => {
 */
 function validateAgentIngress(context) {
 	const rejected = context.events.find((event) => {
-		if (event.type !== "ai.message.created") return !(event.type === "ai.approval.responded" || event.type === "ai.input.responded" || event.type === "ai.message.interrupted" || event.type === "ai.retry.requested");
-		const payload = event.payload;
-		return typeof payload !== "object" || payload === null || !("message" in payload) || typeof payload.message !== "object" || payload.message === null || !("role" in payload.message) || payload.message.role !== "user";
+		if (event.type !== "ai.control.requested") return true;
+		const command = event.payload;
+		if (command["action"] === "request-input" || command["action"] === "tool-result") return true;
+		if (command["action"] === "send" || command["action"] === "edit" || command["action"] === "steer") return command["message"]?.role !== "user";
+		return false;
 	});
 	if (rejected !== void 0) throw new A2Error("INVALID_PAYLOAD", `event '${rejected.type}' is server-only for an AI agent`);
 }
-const resolve = async (value, context) => typeof value === "function" ? await value(context) : value;
+const checkAbort = (signal) => {
+	if (!signal.aborted) return false;
+	const reason = signal.reason;
+	if (reason instanceof A2Error && (reason.code === "CLAIM_EXPIRED" || reason.code === "SUPERSEDED_ATTEMPT")) throw reason;
+	return true;
+};
+const resolve = async (value, context) => {
+	let result;
+	try {
+		result = typeof value === "function" ? await value(context) : value;
+	} catch (error) {
+		checkAbort(context.signal);
+		throw error;
+	}
+	checkAbort(context.signal);
+	return result;
+};
 const modelName = (model) => {
 	if (typeof model === "string") return model;
 	if ("modelId" in model && typeof model.modelId === "string") return model.modelId;
@@ -325,6 +956,7 @@ async function generateWithAISDK(context, messageMetadata) {
 		model: context.model,
 		tools: context.tools,
 		messages: context.messages,
+		modelMessages: context.modelMessages,
 		responseMessageId: context.responseMessageId,
 		abortSignal: context.signal,
 		...context.instructions === void 0 ? {} : { instructions: context.instructions },
@@ -346,8 +978,8 @@ async function* consumeGeneration(options) {
 	const maxChunks = options.progress?.maxChunks ?? 16;
 	const maxDelayMs = options.progress?.maxDelayMs ?? 30;
 	let lastFlush = Date.now();
-	const chunks = options.source.stream[Symbol.asyncIterator]();
-	let pendingChunk = chunks.next();
+	const reader = options.source.stream.getReader();
+	let pendingChunk = reader.read();
 	try {
 		for (;;) {
 			let result;
@@ -369,7 +1001,7 @@ async function* consumeGeneration(options) {
 			pending.push(chunk);
 			if (chunk.type === "finish") streamedFinishReason = chunk.finishReason;
 			if (chunk.type === "error") streamedError = chunk.errorText;
-			pendingChunk = chunks.next();
+			pendingChunk = reader.read();
 			if (pending.length >= maxChunks || isBoundaryChunk(pending.at(-1))) {
 				yield {
 					type: "progress",
@@ -384,6 +1016,13 @@ async function* consumeGeneration(options) {
 			chunks: pending.splice(0)
 		};
 		throw error;
+	} finally {
+		pendingChunk.catch(() => {});
+		try {
+			await reader.cancel();
+		} catch {} finally {
+			reader.releaseLock();
+		}
 	}
 	let completion;
 	try {
@@ -407,29 +1046,141 @@ async function* consumeGeneration(options) {
 		...completion?.usage === void 0 ? {} : { usage: completion.usage }
 	};
 }
-const replay = (definition, history) => {
-	let state = definition.reducer.initialState;
-	for (const event of history) state = definition.reducer.fold(state, event);
+const foldAIEvents = (options) => {
+	let state = options.state;
+	for (const event of options.events) state = options.agent.reducer.fold(state, event);
 	return state;
 };
-const contextMessages = (state) => {
+const summarize = async (options) => {
+	const instruction = [
+		"Summarize this conversation so you can continue the task after the earlier context is replaced by your summary.",
+		"Preserve the objective, constraints, decisions, exact identifiers, completed actions and their results, unresolved questions, and next steps. Distinguish observations from assumptions.",
+		"Respond only with the summary as text. Do not call any tools or continue working on the task.",
+		options.instructions
+	].filter(Boolean).join("\n");
+	const generation = { ...options.context.generation };
+	for (const key of Object.keys(generation)) if (key.startsWith("on") || key.startsWith("experimental_on") || [
+		"repairToolCall",
+		"experimental_repairToolCall",
+		"experimental_refineToolInput",
+		"experimental_transform",
+		"toolApproval"
+	].includes(key)) Reflect.deleteProperty(generation, key);
+	const tools = Object.fromEntries(Object.entries(options.context.tools).map(([name, tool]) => {
+		const definition = {
+			...tool,
+			needsApproval: false
+		};
+		for (const key of [
+			"execute",
+			"onInputStart",
+			"onInputDelta",
+			"onInputAvailable"
+		]) Reflect.deleteProperty(definition, key);
+		return [name, definition];
+	}));
+	const source = await generateWithAISDK({
+		...options.context,
+		generation,
+		tools,
+		modelMessages: [...options.context.modelMessages, {
+			role: "user",
+			content: instruction
+		}],
+		responseMessageId: `${options.context.generationId}:summary`
+	}, void 0);
+	let summary = "";
+	let calledTool = false;
+	let finish;
+	for await (const update of consumeGeneration({ source })) {
+		options.context.signal.throwIfAborted();
+		if (update.type === "finish") {
+			finish = update;
+			continue;
+		}
+		for (const chunk of update.chunks) {
+			if (chunk.type === "text-delta") summary += chunk.delta;
+			if (chunk.type.startsWith("tool-")) calledTool = true;
+		}
+	}
+	if (calledTool || summary.trim().length === 0 || finish?.finishReason !== "stop") throw new Error("compaction must produce a complete text summary without calling tools");
+	return {
+		summary,
+		...finish.usage === void 0 ? {} : { usage: finish.usage }
+	};
+};
+const activeCompaction = (state) => {
 	const compaction = state.compaction;
-	if (compaction?.status !== "completed" || !compaction.messages) return state.messages;
-	const boundary = state.messages.findIndex((message) => message.id === compaction.throughMessageId);
+	return compaction?.status === "completed" && compaction.messages !== void 0 && state.messages.some((message) => message.id === compaction.throughMessageId) ? 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 ?? []);
-	return boundary === -1 ? state.messages : [
+	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 modelContext = async (options) => {
+	const messages = await convertToModelMessages(options.messages, { tools: options.tools });
+	const summary = activeCompaction(options.state)?.summary;
+	return summary === void 0 ? messages : [{
+		role: "user",
+		content: summary
+	}, ...messages];
 };
-const activeContextMessages = (state, coordinator) => {
-	const queued = new Set(coordinator.queued.map((item) => item.messageId));
-	return contextMessages(state).filter((message) => !queued.has(message.id));
+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 generationRequestId = (generationId) => {
-	const markerIndex = generationId.lastIndexOf(":generation:");
-	return markerIndex === -1 ? void 0 : generationId.slice(0, markerIndex);
+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) => ({
 	type: "ai.tool.called",
@@ -598,29 +1349,6 @@ const lifecycleEvents = (options) => {
 		pending
 	};
 };
-function queuedMessagesAt(history) {
-	const queued = [];
-	for (const event of history) {
-		if (event.type === "ai.message.created") {
-			const payload = event.payload;
-			if (payload.message.role !== "user") continue;
-			const duplicate = queued.findIndex((item) => item.messageId === payload.message.id);
-			if (duplicate !== -1) queued.splice(duplicate, 1);
-			queued.push({
-				index: event.index,
-				messageId: payload.message.id,
-				generate: payload.generate !== false
-			});
-			continue;
-		}
-		if (event.type !== "ai.generation.requested") continue;
-		const request = event.payload;
-		if (request.reason !== "message") continue;
-		const requested = queued.findIndex((item) => item.messageId === request.messageId);
-		if (requested !== -1) queued.splice(0, requested + 1);
-	}
-	return queued;
-}
 function withoutGenerationLifecycle(history, generationIds) {
 	if (generationIds.size === 0) return history;
 	const approvalKeys = /* @__PURE__ */ new Set();
@@ -639,6 +1367,24 @@ function withoutGenerationLifecycle(history, generationIds) {
 		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");
+	if (compaction !== false && "then" in compaction) {
+		Promise.resolve(compaction).catch(() => {});
+		throw new TypeError("compaction options must be a policy or a resolver");
+	}
+	if (compaction !== false && !("shouldCompact" in compaction)) {
+		if (compaction.thresholdTokens !== void 0 && (!Number.isSafeInteger(compaction.thresholdTokens) || compaction.thresholdTokens < 1)) throw new TypeError("compaction.thresholdTokens must be a positive safe integer");
+		const choice = options.generation?.toolChoice;
+		const unsupported = options.generation?.output !== void 0 ? "structured output" : choice !== void 0 && choice !== "auto" && choice !== "none" ? "forced tool choice" : Object.values(options.tools ?? {}).some((tool) => tool.type === "provider" && tool.isProviderExecuted === true) ? "provider-executed tools" : void 0;
+		if (unsupported !== void 0) {
+			if (options.explicit) throw new TypeError(`automatic compaction does not support ${unsupported}; use a custom policy or compaction: false`);
+			compaction = false;
+		}
+	}
+	return compaction;
+};
 /**
 * Build the ordinary A2 handler table for the built-in agent protocol.
 * Application handlers can be spread beside this table.
@@ -648,61 +1394,19 @@ function createHandlers(options) {
 	if (options.progress?.maxChunks !== void 0 && (!Number.isInteger(options.progress.maxChunks) || options.progress.maxChunks < 1)) throw new TypeError("progress.maxChunks must be a positive integer");
 	if (options.progress?.maxDelayMs !== void 0 && (!Number.isFinite(options.progress.maxDelayMs) || options.progress.maxDelayMs < 0)) throw new TypeError("progress.maxDelayMs must be a non-negative number");
 	if (options.maxSteps !== void 0 && options.maxSteps !== Number.POSITIVE_INFINITY && (!Number.isInteger(options.maxSteps) || options.maxSteps < 1)) throw new TypeError("maxSteps must be a positive integer or Infinity");
+	const configuredCompaction = options.compaction ?? (options.generate === void 0 ? {} : false);
+	const staticCompaction = typeof configuredCompaction === "function" ? void 0 : validateCompaction({
+		compaction: configuredCompaction,
+		explicit: options.compaction !== void 0,
+		generation: options.generation,
+		tools: options.tools
+	});
 	const tools = options.tools ?? {};
 	const generation = options.generation ?? {};
 	const maxSteps = options.maxSteps ?? Number.POSITIVE_INFINITY;
-	const coordinator = aiCoordinatorReducer(options.agent.contract);
+	const control = createControlRuntime({ agent: options.agent });
+	const coordinator = control.coordinator;
 	const promptCache = /* @__PURE__ */ new Map();
-	const coordinatorStateAt = (history, frontier = Number.POSITIVE_INFINITY) => {
-		let state = coordinator.initialState;
-		for (const event of history) {
-			if (event.index >= frontier) break;
-			state = coordinator.fold(state, event);
-		}
-		return state;
-	};
-	const requestForNextMessage = (state) => {
-		if (state.closed || state.response !== void 0) return void 0;
-		const next = state.queued.find((item) => item.generate !== false);
-		if (next === void 0) return void 0;
-		return {
-			type: "ai.generation.requested",
-			id: `ai.generate:message:${next.messageId}`,
-			payload: {
-				messageId: next.messageId,
-				reason: "message"
-			}
-		};
-	};
-	const scheduleNext = async (ctx) => requestForNextMessage((await ctx.session.state(coordinator, { through: "latest" })).state);
-	const continueIfReady = async (ctx, generationId) => {
-		const state = (await ctx.session.state(coordinator, { through: "latest" })).state;
-		const response = state.response;
-		if (response?.generation?.generationId !== generationId) return;
-		const input = response.inputResponse;
-		if (response.completion?.generationId === generationId && response.failure === void 0 && input !== void 0 && response.inputs.length === 0 && response.calls.every((call) => call.terminal || call.call.providerExecuted === true && call.call.supportsDeferredResults !== true && call.approval !== void 0 && call.response !== void 0)) {
-			await ctx.session.append("continue-after-input", {
-				type: "ai.generation.requested",
-				id: `ai.generate:input:${encodeURIComponent(response.responseMessageId)}:${encodeURIComponent(input.generationId)}:${encodeURIComponent(input.inputId)}`,
-				payload: {
-					messageId: response.responseMessageId,
-					responseMessageId: response.responseMessageId,
-					reason: "input"
-				}
-			});
-			return;
-		}
-		if (!continuationReady(state)) return;
-		await ctx.session.append("continue-after-tools", {
-			type: "ai.generation.requested",
-			id: `ai.generate:tools:${generationId}`,
-			payload: {
-				messageId: response.responseMessageId,
-				responseMessageId: response.responseMessageId,
-				reason: "tool"
-			}
-		});
-	};
 	const resultEvent = (call, suffix, result) => ({
 		type: "ai.tool.result",
 		id: `${call.generationId}:tool:${call.toolCallId}:${suffix}`,
@@ -723,21 +1427,39 @@ function createHandlers(options) {
 			...call.toolMetadata === void 0 ? {} : { toolMetadata: call.toolMetadata }
 		}
 	});
-	const promptMessages = (sessionId, call, readHistory) => {
-		const key = promptCacheKey(sessionId, call.generationId);
+	const promptMessages = (input) => {
+		const { ctx, call, generation: owner } = input;
+		const key = promptCacheKey(ctx.event.sessionId, call.generationId);
 		const cached = promptCache.get(key);
 		if (cached) return cached;
 		const computation = (async () => {
-			const history = await readHistory();
-			const coordinatorState = coordinatorStateAt(history);
-			const compaction = history.find((event) => event.type === "ai.compaction.completed" && event.payload.generationId === call.generationId);
-			if (compaction !== void 0) {
-				const messages = compaction.payload.messages.filter((message) => !coordinatorState.queued.some((queued) => queued.messageId === message.id));
-				return convertToModelMessages(messages, { tools });
-			}
-			const frontier = history.find((event) => event.type === "ai.generation.started" && event.payload.generationId === call.generationId)?.index ?? Number.POSITIVE_INFINITY;
-			const state = replay(options.agent, history.filter((event) => event.index < frontier));
-			return convertToModelMessages(activeContextMessages(state, coordinatorState), { tools });
+			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
+			});
+			return modelContext({
+				messages: await contextMessages({
+					agent: options.agent,
+					session: ctx.session,
+					snapshot,
+					coordinator: atPrompt.state,
+					appended
+				}),
+				state,
+				tools
+			});
 		})();
 		promptCache.set(key, computation);
 		computation.catch(() => {
@@ -747,9 +1469,9 @@ function createHandlers(options) {
 	};
 	const toolExecutionFailure = (ctx, call, error) => {
 		const schedulerFailure = consumeSchedulerSendFailure(error);
-		if (ctx.signal.aborted) return;
+		if (checkAbort(ctx.signal)) return;
 		if (schedulerFailure === "retryable") throw error;
-		return resultEvent(call, "execution:error", { error: errorMessage(error) });
+		return resultEvent(call, `${ctx.event.id}:execution:error`, { error: errorMessage(error) });
 	};
 	const runToolExecution = async (ctx, call, execute, messages) => {
 		let output;
@@ -768,217 +1490,351 @@ function createHandlers(options) {
 		} catch (error) {
 			return toolExecutionFailure(ctx, call, error);
 		}
-		if (iterator === void 0) return resultEvent(call, "execution:0", { output });
+		if (iterator === void 0) return resultEvent(call, `${ctx.event.id}:execution:0`, { output });
 		let last;
 		let sequence = 0;
-		for (;;) {
-			let result;
-			try {
-				result = await iterator.next();
-			} catch (error) {
-				return toolExecutionFailure(ctx, call, error);
-			}
-			if (result.done) break;
-			if (ctx.signal.aborted) {
-				try {
-					await iterator.return?.();
-				} catch {}
-				return;
-			}
-			last = result.value;
-			try {
-				await ctx.session.append(`tool:${call.toolCallId}:preliminary:${sequence}`, resultEvent(call, `execution:${sequence}:preliminary`, {
-					output: result.value,
-					preliminary: true
-				}));
-			} catch (error) {
+		let done = false;
+		try {
+			for (;;) {
+				let result;
 				try {
-					await iterator.return?.();
-				} catch {}
-				throw error;
+					result = await iterator.next();
+				} catch (error) {
+					return toolExecutionFailure(ctx, call, error);
+				}
+				if (result.done) {
+					if (ctx.signal.reason instanceof A2Error) throw ctx.signal.reason;
+					done = true;
+					break;
+				}
+				if (checkAbort(ctx.signal)) return;
+				last = result.value;
+				await control.append({
+					ctx,
+					name: `tool:${call.toolCallId}:preliminary:${sequence}`,
+					events: [resultEvent(call, `${ctx.event.id}:execution:${ctx.attempt}:${sequence}:preliminary`, {
+						output: result.value,
+						preliminary: true
+					})]
+				});
+				sequence += 1;
 			}
-			sequence += 1;
+		} finally {
+			if (!done) try {
+				await iterator.return?.();
+			} catch {}
 		}
-		return resultEvent(call, `execution:${sequence}:final`, sequence === 0 ? {} : { output: last });
+		return resultEvent(call, `${ctx.event.id}:execution:${sequence}:final`, sequence === 0 ? {} : { output: last });
 	};
-	const executeTool = async (ctx, call) => {
+	const executeTool = async (input) => {
+		const { ctx, call } = input;
 		const execute = tools[call.toolName]?.execute;
-		if (execute === void 0) return resultEvent(call, "execution:error", { error: `Tool '${call.toolName}' has no server executor` });
-		const messages = await promptMessages(ctx.event.sessionId, call, ctx.session.history);
-		if (ctx.signal.aborted) return;
+		if (execute === void 0) return resultEvent(call, `${ctx.event.id}:execution:error`, { error: `Tool '${call.toolName}' has no server executor` });
+		const messages = await promptMessages(input);
+		if (checkAbort(ctx.signal)) return;
 		const scope = {
 			contract: options.agent.contract,
 			context: ctx
 		};
 		return toolScopeStorage.run(scope, () => runToolExecution(ctx, call, execute, messages));
 	};
-	const handleToolCall = async (ctx) => {
-		const response = (await ctx.session.state(coordinator, { through: "latest" })).state.response;
-		const current = response?.calls.find((candidate) => candidate.index === ctx.event.index);
-		if (current === void 0 || response?.generation?.generationId !== ctx.event.payload.generationId || response.failure !== void 0 || current.terminal || current.approval !== void 0) return;
-		if (current.call.providerExecuted === true) {
-			await continueIfReady(ctx, current.call.generationId);
-			return;
-		}
-		return executeTool(ctx, current.call);
-	};
-	const handleApproval = async (ctx) => {
-		const response = (await ctx.session.state(coordinator, { through: "latest" })).state.response;
-		const current = response?.calls.find((candidate) => candidate.approval?.approvalId === ctx.event.payload.approvalId && candidate.approval.messageId === ctx.event.payload.messageId && candidate.approval.generationId === ctx.event.payload.generationId && candidate.responseIndex === ctx.event.index);
-		if (current === void 0 || response?.generation?.generationId !== current.call.generationId || response.failure !== void 0 || current.terminal) return;
-		if (current.call.providerExecuted === true) {
-			await continueIfReady(ctx, current.call.generationId);
-			return;
+	const handleToolExecution = async (ctx) => {
+		try {
+			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({
+				ctx,
+				events: void 0
+			});
+			return control.settled({
+				ctx,
+				events: await executeTool({
+					ctx,
+					call: request.call,
+					generation: request.generation
+				})
+			});
+		} catch (error) {
+			if (control.cancelled({
+				error,
+				signal: ctx.signal
+			})) return control.settled({
+				ctx,
+				events: void 0
+			});
+			throw error;
 		}
-		if (!ctx.event.payload.approved) return resultEvent(current.call, "execution:denied", { denied: true });
-		return executeTool(ctx, current.call);
 	};
 	const generationHandler = async (ctx) => {
-		const history = await ctx.session.history();
+		if (checkAbort(ctx.signal)) return;
 		const requestId = ctx.event.id;
 		const request = ctx.event.payload;
-		const coordinatorState = (await ctx.session.state(coordinator, { through: "latest" })).state;
+		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;
 		if (coordinatorState.closed || coordinatorState.response?.activeRequestId !== requestId) return;
-		if (history.some((event) => {
-			if (event.type === "ai.generation.completed") return event.payload.requestId === requestId;
-			if (event.type !== "ai.generation.failed") return false;
-			const payload = event.payload;
-			return payload.requestId === requestId && payload.superseded !== true;
-		})) return;
-		const previousStarts = history.filter((event) => event.type === "ai.generation.started" && event.payload.requestId === requestId);
-		if (previousStarts.map((event) => event.payload.attempt).some((priorAttempt) => priorAttempt >= ctx.attempt)) 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 responseStepCount = history.filter((event) => event.type === "ai.generation.completed" && event.payload.responseMessageId === responseMessageId).length;
-		const sourceCoordinatorState = coordinatorStateAt(history, ctx.event.index);
-		if (request.reason === "tool") {
-			if (!requestId.startsWith("ai.generate:tools:")) return;
-			const sourceGenerationId = requestId.slice(18);
-			if (!continuationReady(sourceCoordinatorState) || sourceCoordinatorState.response?.generation?.generationId !== sourceGenerationId || sourceCoordinatorState.response.responseMessageId !== request.messageId || sourceCoordinatorState.response.responseMessageId !== request.responseMessageId) return;
+		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;
+		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 previous = previousStarts.filter((event) => event.payload.attempt < attempt).toSorted((left, right) => right.payload.attempt - left.payload.attempt)[0];
-		const incompleteId = previous ? previous.payload.generationId : void 0;
-		const replacedGenerationIds = /* @__PURE__ */ new Set();
-		if (incompleteId !== void 0) replacedGenerationIds.add(incompleteId);
-		if (request.reason === "retry" && sourceCoordinatorState.response?.failure?.generationId !== void 0) replacedGenerationIds.add(sourceCoordinatorState.response.failure.generationId);
-		const promptHistory = withoutGenerationLifecycle(history, replacedGenerationIds);
-		let state = replay(options.agent, promptHistory);
 		const resolverContext = {
 			event: ctx.event,
 			state,
-			history,
+			session: { state: (reducer, readOptions) => ctx.session.state(reducer, {
+				...readOptions,
+				through: readOptions?.through ?? snapshot.index
+			}) },
 			signal: ctx.signal
 		};
-		const resolvedModel = await resolve(options.model, resolverContext);
-		if (resolvedModel === void 0) throw new TypeError("the model resolver returned undefined");
-		if (ctx.signal.aborted) return;
-		if (request.reason === "tool" && responseStepCount >= maxSteps) {
-			const source = sourceCoordinatorState.response?.generation;
-			if (source === void 0) return;
-			return {
-				type: "ai.generation.failed",
-				id: `${requestId}:step-limit`,
-				payload: {
-					requestId: source.requestId,
-					messageId: source.messageId,
-					generationId: source.generationId,
-					responseMessageId,
-					error: `agent exceeded the ${maxSteps}-step limit`,
-					stepLimit: true
-				}
-			};
-		}
-		const started = {
-			requestId,
-			messageId: request.messageId,
-			generationId,
-			responseMessageId,
-			attempt,
-			model: modelName(resolvedModel)
-		};
-		const startEvents = [];
-		if (previous) {
-			const payload = previous.payload;
-			const superseded = {
+		let generationStarted = false;
+		try {
+			const resolvedModel = await resolve(options.model, resolverContext);
+			if (resolvedModel === void 0) throw new TypeError("the model resolver returned undefined");
+			if (checkAbort(ctx.signal)) return;
+			const resolvedInstructions = options.instructions === void 0 ? void 0 : await resolve(options.instructions, resolverContext);
+			if (checkAbort(ctx.signal)) return;
+			const compaction = typeof configuredCompaction === "function" ? validateCompaction({
+				compaction: await resolve(configuredCompaction, resolverContext),
+				explicit: true,
+				generation: options.generation,
+				tools: options.tools
+			}) : staticCompaction;
+			if (checkAbort(ctx.signal)) return;
+			if (request.reason === "tool" && responseStepCount >= maxSteps) {
+				const source = response.source?.generation;
+				if (source === void 0) return;
+				return {
+					type: "ai.generation.failed",
+					id: `${requestId}:step-limit`,
+					payload: {
+						requestId: source.requestId,
+						messageId: source.messageId,
+						generationId: source.generationId,
+						responseMessageId,
+						error: `agent exceeded the ${maxSteps}-step limit`,
+						stepLimit: true
+					}
+				};
+			}
+			const started = {
 				requestId,
-				messageId: payload.messageId,
-				generationId: payload.generationId,
-				responseMessageId: payload.responseMessageId,
-				error: "generation attempt was superseded after an incomplete run",
-				superseded: true
+				messageId: request.messageId,
+				generationId,
+				responseMessageId,
+				attempt,
+				model: modelName(resolvedModel),
+				promptThroughIndex: snapshot.index
 			};
+			const catalogModelId = gatewayModelId(resolvedModel);
+			const gatewayOptions = options.generation?.providerOptions?.["gateway"];
+			const usesFallbackModels = Array.isArray(gatewayOptions?.["models"]) && gatewayOptions["models"].length > 0;
+			const discoversMetadata = compaction !== false && !("shouldCompact" in compaction) && compaction.thresholdTokens === void 0 && !usesFallbackModels && catalogModelId !== void 0;
+			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)}`,
+				payload: { modelId: catalogModelId }
+			});
+			if (previous) {
+				const payload = previous;
+				const superseded = {
+					requestId,
+					messageId: payload.messageId,
+					generationId: payload.generationId,
+					responseMessageId: payload.responseMessageId,
+					error: "generation attempt was superseded after an incomplete run",
+					superseded: true
+				};
+				startEvents.push({
+					type: "ai.generation.failed",
+					id: `${payload.generationId}:superseded`,
+					payload: superseded
+				});
+			}
 			startEvents.push({
-				type: "ai.generation.failed",
-				id: `${payload.generationId}:superseded`,
-				payload: superseded
+				type: "ai.generation.started",
+				id: generationId,
+				payload: started
 			});
-		}
-		startEvents.push({
-			type: "ai.generation.started",
-			id: generationId,
-			payload: started
-		});
-		await ctx.session.append("generation-start", ...startEvents);
-		const startedCoordinatorState = (await ctx.session.state(coordinator, { through: "latest" })).state;
-		if (startedCoordinatorState.response?.activeRequestId !== requestId || startedCoordinatorState.response.generation?.generationId !== generationId) return;
-		const promptCoordinatorState = {
-			...coordinatorStateAt(history),
-			queued: queuedMessagesAt(history)
-		};
-		let messages = activeContextMessages(state, promptCoordinatorState);
-		if (options.compaction) {
-			const compactionContext = {
-				...resolverContext,
-				messages
+			const generationEvents = await control.append({
+				ctx,
+				name: "generation-start",
+				events: startEvents
+			});
+			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
+			});
+			let generationMessages = messages;
+			let modelMessages = await modelContext({
+				messages,
+				state,
+				tools
+			});
+			const baseContext = {
+				request: ctx.event,
+				requestId,
+				generationId,
+				responseMessageId,
+				messages,
+				modelMessages,
+				state,
+				session: resolverContext.session,
+				signal: ctx.signal,
+				model: resolvedModel,
+				tools,
+				...resolvedInstructions === void 0 ? {} : { instructions: resolvedInstructions },
+				generation
 			};
-			if (await options.compaction.shouldCompact(compactionContext)) {
-				const throughMessageId = messages.at(-1)?.id ?? request.messageId;
-				await ctx.session.append("compaction-requested", {
-					type: "ai.compaction.requested",
-					id: `${generationId}:compaction:requested`,
-					payload: {
-						generationId,
-						throughMessageId
-					}
-				});
-				messages = await options.compaction.compact(compactionContext);
-				const completed = {
-					generationId,
-					throughMessageId,
+			const policy = compaction;
+			const tracksInput = policy !== false && !("shouldCompact" in policy) && (policy.thresholdTokens !== void 0 || discoversMetadata);
+			const metadata = catalogModelId === void 0 ? void 0 : state.modelMetadata[catalogModelId];
+			const limits = metadata?.status === "resolved" && !usesFallbackModels ? metadata.limits : void 0;
+			let inputTokenEstimate;
+			let compacted = false;
+			const canCompact = response.source?.canCompact ?? true;
+			if (policy && canCompact) {
+				const compactionContext = {
+					...resolverContext,
 					messages,
-					...promptCoordinatorState.queued.length === 0 ? {} : { retainedMessageIds: promptCoordinatorState.queued.map((item) => item.messageId) }
-				};
-				await ctx.session.append("compaction-completed", {
-					type: "ai.compaction.completed",
-					id: `${generationId}:compaction:completed`,
-					payload: completed
-				});
-				state = {
-					...state,
-					compaction: {
-						status: "completed",
-						...completed
-					}
+					modelMessages
 				};
+				let shouldCompact;
+				if ("shouldCompact" in policy) shouldCompact = await policy.shouldCompact(compactionContext);
+				else if (tracksInput) {
+					inputTokenEstimate = await estimateInputTokens({
+						messages: modelMessages,
+						instructions: resolvedInstructions,
+						tools
+					});
+					const inputTokens = measuredInputTokens({
+						estimate: inputTokenEstimate,
+						model: modelName(resolvedModel),
+						calibration: coordinatorState.calibration
+					});
+					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;
+				} else shouldCompact = false;
+				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;
+					generationEvents.push(...await control.append({
+						ctx,
+						name: "compaction-requested",
+						events: [{
+							type: "ai.compaction.requested",
+							id: `${generationId}:compaction:requested`,
+							payload: {
+								generationId,
+								throughMessageId,
+								throughIndex
+							}
+						}]
+					}));
+					const result = !("shouldCompact" in policy) ? {
+						messages: [],
+						...await summarize({
+							context: baseContext,
+							instructions: policy.instructions
+						})
+					} : { messages: await policy.compact(compactionContext) };
+					if (checkAbort(ctx.signal)) return;
+					const completed = {
+						generationId,
+						throughMessageId,
+						throughIndex,
+						...result,
+						...promptCoordinatorState.queued.length === 0 ? {} : { retainedMessageIds: promptCoordinatorState.queued.map((item) => item.messageId) }
+					};
+					generationEvents.push(...await control.append({
+						ctx,
+						name: "compaction-completed",
+						events: [{
+							type: "ai.compaction.completed",
+							id: `${generationId}:compaction:completed`,
+							payload: completed
+						}]
+					}));
+					const queued = new Set(promptCoordinatorState.queued.map((item) => item.messageId));
+					generationMessages = result.messages.filter((message) => !queued.has(message.id));
+					compacted = true;
+				}
 			}
-		}
-		const currentState = (await ctx.session.state(options.agent.reducer, { through: "latest" })).state;
-		const currentCoordinatorState = (await ctx.session.state(coordinator, { through: "latest" })).state;
-		const generationMessages = activeContextMessages(currentState, currentCoordinatorState);
-		promptCache.set(promptCacheKey(ctx.event.sessionId, generationId), convertToModelMessages(generationMessages, { tools }));
-		let pendingToolCalls = [];
-		try {
-			const resolvedInstructions = options.instructions === void 0 ? void 0 : await resolve(options.instructions, resolverContext);
-			if (ctx.signal.aborted) return;
+			const currentState = foldAIEvents({
+				agent: options.agent,
+				events: generationEvents,
+				state: snapshot.state
+			});
+			if (request.reason === "retry" || previous !== void 0) generationMessages = await contextMessages({
+				agent: options.agent,
+				session: ctx.session,
+				snapshot,
+				coordinator: promptCoordinatorState,
+				appended: generationEvents
+			});
+			if (policy && "shouldCompact" in policy || generationMessages !== messages || activeCompaction(currentState)?.summary !== activeCompaction(state)?.summary) modelMessages = await modelContext({
+				messages: generationMessages,
+				state: currentState,
+				tools
+			});
+			promptCache.set(promptCacheKey(ctx.event.sessionId, generationId), Promise.resolve(modelMessages));
+			if (tracksInput && (inputTokenEstimate === void 0 || compacted)) inputTokenEstimate = await estimateInputTokens({
+				messages: modelMessages,
+				instructions: resolvedInstructions,
+				tools
+			});
+			let pendingToolCalls = [];
+			if (checkAbort(ctx.signal)) return;
 			const generateContext = {
 				request: ctx.event,
 				requestId,
 				generationId,
 				responseMessageId,
 				messages: generationMessages,
+				modelMessages,
 				state: currentState,
-				history,
+				session: resolverContext.session,
 				signal: ctx.signal,
 				model: resolvedModel,
 				tools,
@@ -1018,11 +1874,15 @@ function createHandlers(options) {
 					custom
 				});
 				pendingToolCalls = lifecycle.pending;
-				await ctx.session.append(`generation-progress:${sequence}`, {
-					type: "ai.generation.progress",
-					id: `${generationId}:progress:${sequence}`,
-					payload: progress
-				}, ...lifecycle.events);
+				await control.append({
+					ctx,
+					name: `generation-progress:${sequence}`,
+					events: [{
+						type: "ai.generation.progress",
+						id: `${generationId}:progress:${sequence}`,
+						payload: progress
+					}, ...lifecycle.events]
+				});
 				sequence += 1;
 			}
 			if (!finish) throw new Error("agent generation finished without output");
@@ -1031,6 +1891,7 @@ function createHandlers(options) {
 				messageId: request.messageId,
 				generationId,
 				responseMessageId,
+				...inputTokenEstimate === void 0 ? {} : { inputTokenEstimate },
 				...finish.finishReason === void 0 ? {} : { finishReason: finish.finishReason },
 				...finish.usage === void 0 ? {} : { usage: finish.usage }
 			};
@@ -1053,19 +1914,13 @@ function createHandlers(options) {
 				}
 			];
 		} catch (error) {
-			if (error instanceof A2Error) throw error;
-			if (ctx.signal.aborted) {
-				const interrupted = {
-					messageId: responseMessageId,
-					generationId,
-					reason: "aborted"
-				};
-				return {
-					type: "ai.message.interrupted",
-					id: `${generationId}:interrupted`,
-					payload: interrupted
-				};
+			if (error instanceof ControlCancelled) throw error;
+			if (error instanceof A2Error) {
+				checkAbort(ctx.signal);
+				throw error;
 			}
+			if (checkAbort(ctx.signal)) return;
+			if (!generationStarted) throw error;
 			const failed = {
 				requestId,
 				messageId: request.messageId,
@@ -1080,97 +1935,89 @@ function createHandlers(options) {
 			};
 		}
 	};
-	const handleMessageCreated = async (ctx) => {
-		if (ctx.event.payload.message.role !== "user" || ctx.event.payload.generate === false) return;
-		return scheduleNext(ctx);
-	};
-	const handleRetry = async (ctx) => {
-		const response = (await ctx.session.state(coordinator, { through: "latest" })).state.response;
-		if (response?.status !== "failed" || response.rootMessageId !== ctx.event.payload.messageId || response.responseMessageId !== ctx.event.payload.responseMessageId) return;
-		return {
-			type: "ai.generation.requested",
-			id: `ai.generate:retry:${ctx.event.payload.retryId}`,
-			payload: {
-				messageId: response.rootMessageId,
-				responseMessageId: response.responseMessageId,
-				reason: "retry"
-			}
-		};
-	};
-	const handleInputResponse = async (ctx) => {
-		const response = (await ctx.session.state(coordinator, { through: "latest" })).state.response;
-		if (response?.responseMessageId !== ctx.event.payload.messageId || response.inputResponse?.index !== ctx.event.index || response.inputResponse.generationId !== ctx.event.payload.generationId || response.inputResponse.inputId !== ctx.event.payload.inputId) return;
-		await continueIfReady(ctx, ctx.event.payload.generationId);
-	};
 	const clearPromptCache = (sessionId) => {
 		const prefix = `${sessionId}\u001f`;
 		for (const key of promptCache.keys()) if (key.startsWith(prefix)) promptCache.delete(key);
 	};
-	const handleResponseEnded = async (ctx) => {
-		clearPromptCache(ctx.event.sessionId);
-		return scheduleNext(ctx);
-	};
 	return {
-		"ai.message.created": {
-			lane: "a2.ai.turn",
-			handler: handleMessageCreated
-		},
-		"ai.retry.requested": {
-			lane: "a2.ai.turn",
-			handler: handleRetry
-		},
-		"ai.input.responded": {
-			lane: "a2.ai.turn",
-			handler: handleInputResponse
-		},
-		"ai.message.completed": {
-			lane: "a2.ai.turn",
-			handler: handleResponseEnded
+		"ai.model.metadata.requested": { handler: async (ctx) => {
+			const limits = await readModelLimits({
+				modelId: ctx.event.payload.modelId,
+				signal: ctx.signal
+			});
+			ctx.signal.throwIfAborted();
+			return {
+				type: "ai.model.metadata.resolved",
+				id: `${ctx.event.id}:resolved`,
+				payload: {
+					modelId: ctx.event.payload.modelId,
+					limits
+				}
+			};
+		} },
+		"ai.control.requested": {
+			lane: "a2.ai.control",
+			handler: control.handler
 		},
-		"ai.message.interrupted": {
-			lane: "a2.ai.turn",
-			handler: handleResponseEnded
+		"ai.work.reported": {
+			lane: "a2.ai.control",
+			handler: control.handler
 		},
-		"ai.session.closed": { handler: (ctx) => {
+		"ai.message.completed": { handler: async (ctx) => {
 			clearPromptCache(ctx.event.sessionId);
-			return Promise.resolve();
 		} },
+		"ai.message.interrupted": { handler: async (ctx) => {
+			clearPromptCache(ctx.event.sessionId);
+		} },
+		"ai.session.closed": {
+			lane: "a2.ai.control",
+			handler: async (ctx) => {
+				clearPromptCache(ctx.event.sessionId);
+				return control.handler(ctx);
+			}
+		},
 		"ai.generation.failed": { handler: (ctx) => {
 			promptCache.delete(promptCacheKey(ctx.event.sessionId, ctx.event.payload.generationId));
 			return Promise.resolve();
 		} },
 		"ai.generation.requested": {
-			lane: "a2.ai.turn",
+			lane: "a2.ai.model",
 			abortOn: {
-				"ai.message.interrupted": (event, trigger, context) => {
-					const responseMessageId = trigger.payload.responseMessageId ?? (trigger.payload.reason === "message" ? `${trigger.payload.messageId}:assistant` : trigger.payload.messageId);
-					return event.payload.messageId === responseMessageId && (event.payload.requestId === trigger.id || event.payload.generationId === `${trigger.id}:generation:${context.attempt}`);
+				"ai.control.committed": (event, trigger) => {
+					const active = event.payload.view;
+					return active?.turnId !== trigger.payload.control?.turnId || active?.version !== trigger.payload.control?.version;
 				},
 				"ai.session.closed": true
 			},
-			handler: generationHandler
-		},
-		"ai.generation.completed": { handler: async (ctx) => continueIfReady(ctx, ctx.event.payload.generationId) },
-		"ai.tool.called": {
-			abortOn: {
-				"ai.generation.failed": (event, trigger) => event.payload.generationId === trigger.payload.generationId,
-				"ai.message.interrupted": (event, trigger) => event.payload.messageId === trigger.payload.messageId && (event.payload.requestId === trigger.payload.requestId || event.payload.generationId === trigger.payload.generationId),
-				"ai.session.closed": true
-			},
-			handler: handleToolCall
+			handler: async (ctx) => {
+				try {
+					return control.settled({
+						ctx,
+						events: await generationHandler(ctx)
+					});
+				} catch (error) {
+					if (control.cancelled({
+						error,
+						signal: ctx.signal
+					})) return control.settled({
+						ctx,
+						events: void 0
+					});
+					throw error;
+				}
+			}
 		},
-		"ai.approval.responded": {
+		"ai.tool.execution.requested": {
 			abortOn: {
-				"ai.generation.failed": (event, trigger) => event.payload.responseMessageId === trigger.payload.messageId && event.payload.generationId === trigger.payload.generationId,
-				"ai.message.interrupted": (event, trigger) => event.payload.messageId === trigger.payload.messageId && (event.payload.requestId === generationRequestId(trigger.payload.generationId) || event.payload.generationId === trigger.payload.generationId),
+				"ai.generation.failed": (event, trigger) => event.payload.generationId === trigger.payload.call.generationId,
+				"ai.control.committed": (event, trigger) => {
+					const active = event.payload.view;
+					return active?.turnId !== trigger.payload.turnId || active?.version !== trigger.payload.version;
+				},
 				"ai.session.closed": true
 			},
-			handler: handleApproval
-		},
-		"ai.tool.result": { handler: async (ctx) => {
-			if (ctx.event.payload.preliminary === true) return;
-			await continueIfReady(ctx, ctx.event.payload.generationId);
-		} }
+			handler: handleToolExecution
+		}
 	};
 }
 /** Assemble an A2 server with the built-in agent handlers and app extensions. */