experimental-a2 0.13.0 → 0.14.1

package/dist/ai-server.js

@@ -1,150 +1,11 @@
+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 { createHash } from "node:crypto";
 import { asSchema, 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 = 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,
-			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
-//#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-coordinator.ts
 const updateResponse = (state, update) => state.response === void 0 ? state : {
 	...state,
@@ -156,6 +17,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;
@@ -163,24 +29,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: []
@@ -189,14 +55,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;
@@ -205,7 +82,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: []
@@ -214,11 +94,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;
@@ -234,18 +125,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;
@@ -253,7 +142,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
 				}]
@@ -277,8 +165,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)
 			}));
 		}
@@ -301,34 +188,701 @@ const foldCoordinator = (state, event) => {
 				inputs: [...response.inputs.filter((candidate) => candidate.messageId !== input.messageId || candidate.generationId !== input.generationId || candidate.inputId !== input.inputId), input]
 			}));
 		}
-		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;
-			return updateResponse(state, (response) => ({
-				...response,
-				inputs: response.inputs.filter((candidate) => candidate.inputId !== input.inputId),
-				inputResponse: {
-					index: event.index,
-					generationId: input.generationId,
-					inputId: input.inputId,
-					name: requested.name
+		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;
+			return updateResponse(state, (response) => ({
+				...response,
+				inputs: response.inputs.filter((candidate) => candidate.inputId !== input.inputId),
+				inputResponse: {
+					generationId: input.generationId,
+					inputId: input.inputId,
+					name: requested.name
+				}
+			}));
+		}
+		default: return state;
+	}
+};
+const aiCoordinatorReducer = (contract) => contract.reducer({
+	name: "a2.ai.coordinator.v5",
+	initialState: {
+		closed: false,
+		queued: []
+	}
+}).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
+					});
 				}
-			}));
-		}
-		default: return state;
-	}
+				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 aiCoordinatorReducer = (contract) => contract.reducer({
-	name: "a2.ai.coordinator.v3",
-	initialState: {
-		closed: false,
-		queued: []
+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);
 	}
-}).fold((state, event) => foldCoordinator(state, event));
-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-server.ts
@@ -340,9 +894,11 @@ 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`);
 }
@@ -396,7 +952,23 @@ const nextOrTimer = async (next, delayMs) => {
 		if (timer !== void 0) clearTimeout(timer);
 	}
 };
-async function generateWithAISDK(context, messageMetadata) {
+async function generateWithAISDK(options) {
+	const { agentName, context, messageMetadata } = options;
+	const headers = context.generation.headers ?? {};
+	const generation = gatewayModelId(context.model) === void 0 ? context.generation : {
+		...context.generation,
+		headers: Object.keys(headers).some((key) => key.toLowerCase() === "x-session-affinity") ? headers : {
+			...headers,
+			"x-session-affinity": createHash("sha256").update(JSON.stringify([agentName, context.request.sessionId])).digest("hex")
+		},
+		providerOptions: {
+			...context.generation.providerOptions,
+			gateway: {
+				caching: "auto",
+				...context.generation.providerOptions?.["gateway"]
+			}
+		}
+	};
 	const step = await generateAISDKStep({
 		model: context.model,
 		tools: context.tools,
@@ -405,9 +977,10 @@ async function generateWithAISDK(context, messageMetadata) {
 		responseMessageId: context.responseMessageId,
 		abortSignal: context.signal,
 		...context.instructions === void 0 ? {} : { instructions: context.instructions },
-		settings: context.generation,
+		settings: generation,
 		...messageMetadata === void 0 ? {} : { messageMetadata: ({ part }) => messageMetadata({
 			...context,
+			generation,
 			part
 		}) }
 	});
@@ -491,9 +1064,9 @@ 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 summarize = async (options) => {
@@ -525,15 +1098,19 @@ const summarize = async (options) => {
 		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);
+		agentName: options.agentName,
+		context: {
+			...options.context,
+			generation,
+			tools,
+			modelMessages: [...options.context.modelMessages, {
+				role: "user",
+				content: instruction
+			}],
+			responseMessageId: `${options.context.generationId}:summary`
+		},
+		messageMetadata: void 0
+	});
 	let summary = "";
 	let calledTool = false;
 	let finish;
@@ -558,35 +1135,50 @@ 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;
 };
-const contextMessages = (options) => {
-	const { agent, state, history } = options;
+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);
-	if (compaction === null) return state.messages;
+	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 startedIndex = history.find((event) => event.type === "ai.generation.started" && event.payload.generationId === compaction.generationId)?.index;
-	const throughIndex = compaction.throughIndex ?? (startedIndex === void 0 ? void 0 : startedIndex - 1);
+	const throughIndex = compaction.throughIndex;
 	if (throughIndex !== void 0) {
-		const prefix = history.filter((event) => event.index <= throughIndex);
-		for (const queued of queuedMessagesAt(prefix)) retained.add(queued.messageId);
-		let context = replay(agent, prefix);
-		context = {
-			...context,
-			messages: [...compaction.messages, ...context.messages.filter((message) => retained.has(message.id))],
-			activeProjection: null
-		};
-		for (const event of history) if (event.index > throughIndex) context = agent.reducer.fold(context, event);
-		return context.messages;
+		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 [
+	return visible([
 		...compaction.messages,
 		...state.messages.slice(0, boundary + 1).filter((message) => retained.has(message.id)),
 		...state.messages.slice(boundary + 1)
-	];
-};
-const activeContextMessages = (options) => {
-	const queued = new Set(options.coordinator.queued.map((item) => item.messageId));
-	return contextMessages(options).filter((message) => !queued.has(message.id));
+	]);
 };
 const modelContext = async (options) => {
 	const messages = await convertToModelMessages(options.messages, { tools: options.tools });
@@ -609,22 +1201,8 @@ const estimateInputTokens = async (options) => {
 	})).byteLength / 4);
 };
 const measuredInputTokens = (options) => {
-	for (const event of options.history.toReversed()) {
-		if (event.type === "ai.compaction.completed" || event.type === "ai.retry.requested") break;
-		if (event.type !== "ai.generation.completed") continue;
-		const completed = event.payload;
-		const started = options.history.find((candidate) => candidate.type === "ai.generation.started" && candidate.payload.generationId === completed.generationId);
-		const input = completed.usage?.inputTokens;
-		const estimate = completed.inputTokenEstimate;
-		if ((started?.payload)?.model !== options.model) break;
-		if (input === void 0 || estimate === void 0 || !Number.isFinite(input) || input < 0 || options.estimate < estimate) break;
-		return Math.max(options.estimate, Math.ceil(input + options.estimate - estimate));
-	}
-	return options.estimate;
-};
-const generationRequestId = (generationId) => {
-	const markerIndex = generationId.lastIndexOf(":generation:");
-	return markerIndex === -1 ? void 0 : generationId.slice(0, markerIndex);
+	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",
@@ -793,29 +1371,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();
@@ -839,7 +1394,7 @@ const validateCompaction = (options) => {
 	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 resolve synchronously");
+		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");
@@ -871,58 +1426,9 @@ function createHandlers(options) {
 	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}`,
@@ -943,22 +1449,35 @@ 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 started = history.find((event) => event.type === "ai.generation.started" && event.payload.generationId === call.generationId);
-			const frontier = (started?.payload)?.promptThroughIndex ?? (started?.index ?? Number.POSITIVE_INFINITY) - 1;
-			const promptHistory = history.filter((event) => event.index <= frontier || (event.type === "ai.generation.started" || event.type === "ai.compaction.requested" || event.type === "ai.compaction.completed") && event.payload.generationId === call.generationId);
-			const state = replay(options.agent, promptHistory);
+			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: activeContextMessages({
+				messages: await contextMessages({
 					agent: options.agent,
-					state,
-					history: promptHistory,
-					coordinator: coordinatorStateAt(promptHistory)
+					session: ctx.session,
+					snapshot,
+					coordinator: atPrompt.state,
+					appended
 				}),
 				state,
 				tools
@@ -974,7 +1493,7 @@ function createHandlers(options) {
 		const schedulerFailure = consumeSchedulerSendFailure(error);
 		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;
@@ -993,7 +1512,7 @@ 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;
 		let done = false;
@@ -1005,16 +1524,21 @@ function createHandlers(options) {
 				} catch (error) {
 					return toolExecutionFailure(ctx, call, error);
 				}
-				if (checkAbort(ctx.signal)) return;
 				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 ctx.session.append(`tool:${call.toolCallId}:preliminary:${sequence}`, resultEvent(call, `execution:${ctx.attempt}:${sequence}:preliminary`, {
-					output: result.value,
-					preliminary: true
-				}));
+				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;
 			}
 		} finally {
@@ -1022,12 +1546,13 @@ function createHandlers(options) {
 				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 (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,
@@ -1035,62 +1560,82 @@ function createHandlers(options) {
 		};
 		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);
-		const 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
 		};
 		let generationStarted = false;
@@ -1101,14 +1646,14 @@ function createHandlers(options) {
 			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: configuredCompaction(resolverContext),
+				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 = sourceCoordinatorState.response?.generation;
+				const source = response.source?.generation;
 				if (source === void 0) return;
 				return {
 					type: "ai.generation.failed",
@@ -1130,7 +1675,7 @@ function createHandlers(options) {
 				responseMessageId,
 				attempt,
 				model: modelName(resolvedModel),
-				promptThroughIndex: history.at(-1)?.index ?? ctx.event.index
+				promptThroughIndex: snapshot.index
 			};
 			const catalogModelId = gatewayModelId(resolvedModel);
 			const gatewayOptions = options.generation?.providerOptions?.["gateway"];
@@ -1143,7 +1688,7 @@ function createHandlers(options) {
 				payload: { modelId: catalogModelId }
 			});
 			if (previous) {
-				const payload = previous.payload;
+				const payload = previous;
 				const superseded = {
 					requestId,
 					messageId: payload.messageId,
@@ -1163,20 +1708,25 @@ function createHandlers(options) {
 				id: generationId,
 				payload: started
 			});
-			const generationHistory = [...history, ...await ctx.session.append("generation-start", ...startEvents)];
+			const generationEvents = await control.append({
+				ctx,
+				name: "generation-start",
+				events: startEvents
+			});
 			generationStarted = true;
-			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)
-			};
-			const messages = activeContextMessages({
+			if (checkAbort(ctx.signal)) return;
+			const promptCoordinatorState = coordinatorState;
+			const messages = await contextMessages({
 				agent: options.agent,
-				state,
-				history: promptHistory,
-				coordinator: promptCoordinatorState
+				session: ctx.session,
+				snapshot: {
+					state,
+					index: snapshot.index
+				},
+				coordinator: promptCoordinatorState,
+				excluded: replacedGenerationIds
 			});
+			let generationMessages = messages;
 			let modelMessages = await modelContext({
 				messages,
 				state,
@@ -1190,7 +1740,7 @@ function createHandlers(options) {
 				messages,
 				modelMessages,
 				state,
-				history,
+				session: resolverContext.session,
 				signal: ctx.signal,
 				model: resolvedModel,
 				tools,
@@ -1203,7 +1753,7 @@ function createHandlers(options) {
 			const limits = metadata?.status === "resolved" && !usesFallbackModels ? metadata.limits : void 0;
 			let inputTokenEstimate;
 			let compacted = false;
-			const canCompact = sourceCoordinatorState.response?.calls.every((call) => call.terminal) ?? true;
+			const canCompact = response.source?.canCompact ?? true;
 			if (policy && canCompact) {
 				const compactionContext = {
 					...resolverContext,
@@ -1221,7 +1771,7 @@ function createHandlers(options) {
 					const inputTokens = measuredInputTokens({
 						estimate: inputTokenEstimate,
 						model: modelName(resolvedModel),
-						history
+						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`);
@@ -1230,19 +1780,24 @@ function createHandlers(options) {
 				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 = history.at(-1)?.index ?? ctx.event.index;
-					generationHistory.push(...await ctx.session.append("compaction-requested", {
-						type: "ai.compaction.requested",
-						id: `${generationId}:compaction:requested`,
-						payload: {
-							generationId,
-							throughMessageId,
-							throughIndex
-						}
+					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({
+							agentName: options.agent.contract.name,
 							context: baseContext,
 							instructions: policy.instructions
 						})
@@ -1255,23 +1810,33 @@ function createHandlers(options) {
 						...result,
 						...promptCoordinatorState.queued.length === 0 ? {} : { retainedMessageIds: promptCoordinatorState.queued.map((item) => item.messageId) }
 					};
-					generationHistory.push(...await ctx.session.append("compaction-completed", {
-						type: "ai.compaction.completed",
-						id: `${generationId}:compaction:completed`,
-						payload: completed
+					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 = replay(options.agent, generationHistory);
-			const currentCoordinatorState = coordinatorStateAt(generationHistory);
-			const generationMessages = activeContextMessages({
+			const currentState = foldAIEvents({
 				agent: options.agent,
-				state: currentState,
-				history: generationHistory,
-				coordinator: currentCoordinatorState
+				events: generationEvents,
+				state: snapshot.state
 			});
-			modelMessages = await modelContext({
+			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
@@ -1292,7 +1857,7 @@ function createHandlers(options) {
 				messages: generationMessages,
 				modelMessages,
 				state: currentState,
-				history,
+				session: resolverContext.session,
 				signal: ctx.signal,
 				model: resolvedModel,
 				tools,
@@ -1301,7 +1866,11 @@ function createHandlers(options) {
 			};
 			const custom = options.generate !== void 0;
 			const updates = consumeGeneration({
-				source: options.generate === void 0 ? await generateWithAISDK(generateContext, options.messageMetadata) : { stream: await options.generate(generateContext) },
+				source: options.generate === void 0 ? await generateWithAISDK({
+					agentName: options.agent.contract.name,
+					context: generateContext,
+					messageMetadata: options.messageMetadata
+				}) : { stream: await options.generate(generateContext) },
 				...options.progress === void 0 ? {} : { progress: options.progress }
 			});
 			let sequence = 0;
@@ -1332,11 +1901,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");
@@ -1368,22 +1941,12 @@ function createHandlers(options) {
 				}
 			];
 		} catch (error) {
+			if (error instanceof ControlCancelled) throw error;
 			if (error instanceof A2Error) {
 				checkAbort(ctx.signal);
 				throw error;
 			}
-			if (checkAbort(ctx.signal)) {
-				const interrupted = {
-					messageId: responseMessageId,
-					generationId,
-					reason: "aborted"
-				};
-				return {
-					type: "ai.message.interrupted",
-					id: `${generationId}:interrupted`,
-					payload: interrupted
-				};
-			}
+			if (checkAbort(ctx.signal)) return;
 			if (!generationStarted) throw error;
 			const failed = {
 				requestId,
@@ -1399,36 +1962,10 @@ 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.model.metadata.requested": { handler: async (ctx) => {
 			const limits = await readModelLimits({
@@ -1445,66 +1982,69 @@ function createHandlers(options) {
 				}
 			};
 		} },
-		"ai.message.created": {
-			lane: "a2.ai.turn",
-			handler: handleMessageCreated
-		},
-		"ai.retry.requested": {
-			lane: "a2.ai.turn",
-			handler: handleRetry
+		"ai.control.requested": {
+			lane: "a2.ai.control",
+			handler: control.handler
 		},
-		"ai.input.responded": {
-			lane: "a2.ai.turn",
-			handler: handleInputResponse
+		"ai.work.reported": {
+			lane: "a2.ai.control",
+			handler: control.handler
 		},
-		"ai.message.completed": {
-			lane: "a2.ai.turn",
-			handler: handleResponseEnded
-		},
-		"ai.message.interrupted": {
-			lane: "a2.ai.turn",
-			handler: handleResponseEnded
-		},
-		"ai.session.closed": { handler: (ctx) => {
+		"ai.message.completed": { handler: async (ctx) => {
+			clearPromptCache(ctx.event.sessionId);
+		} },
+		"ai.message.interrupted": { handler: async (ctx) => {
 			clearPromptCache(ctx.event.sessionId);
-			return Promise.resolve();
 		} },
+		"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. */