experimental-a2 0.11.0 → 0.13.0

package/dist/ai-server.js

@@ -1,8 +1,8 @@
 import { t as A2Error } from "./errors-DCk6ch5n.js";
 import { f as consumeSchedulerSendFailure, p as installAmbientToolScopeStorage } from "./internal-Dq2qYxou.js";
-import { r as setServerFetchHooks, t as createServer } from "./server-Dkz2a84E.js";
+import { i as setServerFetchHooks, t as createServer } from "./server-BeNADlCI.js";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { convertToModelMessages, stepCountIs, streamText, toUIMessageStream } from "ai";
+import { asSchema, convertToModelMessages, stepCountIs, streamText, toUIMessageStream } from "ai";
 //#region src/ai-sdk-step.ts
 const CONTROLLED_SETTINGS = [
 	"_internal",
@@ -45,7 +45,7 @@ const errorMessage$1 = (error) => error instanceof Error ? error.message : Strin
 async function generateAISDKStep(input) {
 	const settings = safeSettings(input.settings);
 	const tools = modelToolSet(input.tools);
-	const messages = await convertToModelMessages(input.messages, { tools });
+	const messages = input.modelMessages ?? await convertToModelMessages(input.messages, { tools });
 	const streamOptions = {
 		...settings,
 		model: input.model,
@@ -85,6 +85,66 @@ async function generateAISDKStep(input) {
 	};
 }
 //#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,
@@ -286,7 +346,23 @@ function validateAgentIngress(context) {
 	});
 	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 +401,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 +423,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 +446,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 +461,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 {
@@ -412,20 +496,131 @@ const replay = (definition, history) => {
 	for (const event of history) state = definition.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 = (options) => {
+	const { agent, state, history } = options;
+	const compaction = activeCompaction(state);
+	if (compaction === null) return state.messages;
 	const retained = new Set(compaction.retainedMessageIds ?? []);
-	return boundary === -1 ? state.messages : [
+	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);
+	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 boundary = state.messages.findIndex((message) => message.id === compaction.throughMessageId);
+	return [
 		...compaction.messages,
 		...state.messages.slice(0, boundary + 1).filter((message) => retained.has(message.id)),
 		...state.messages.slice(boundary + 1)
 	];
 };
-const activeContextMessages = (state, coordinator) => {
-	const queued = new Set(coordinator.queued.map((item) => item.messageId));
-	return contextMessages(state).filter((message) => !queued.has(message.id));
+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 });
+	const summary = activeCompaction(options.state)?.summary;
+	return summary === void 0 ? messages : [{
+		role: "user",
+		content: summary
+	}, ...messages];
+};
+const estimateInputTokens = async (options) => {
+	const tools = await Promise.all(Object.entries(options.tools).map(async ([name, tool]) => ({
+		name,
+		description: tool.description,
+		inputSchema: await asSchema(tool.inputSchema).jsonSchema
+	})));
+	return Math.ceil(new TextEncoder().encode(JSON.stringify({
+		messages: options.messages,
+		instructions: options.instructions,
+		tools
+	})).byteLength / 4);
+};
+const measuredInputTokens = (options) => {
+	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:");
@@ -639,6 +834,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 resolve synchronously");
+	}
+	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,6 +861,13 @@ 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;
@@ -729,15 +949,20 @@ function createHandlers(options) {
 		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 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);
+			return modelContext({
+				messages: activeContextMessages({
+					agent: options.agent,
+					state,
+					history: promptHistory,
+					coordinator: coordinatorStateAt(promptHistory)
+				}),
+				state,
+				tools
+			});
 		})();
 		promptCache.set(key, computation);
 		computation.catch(() => {
@@ -747,7 +972,7 @@ 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) });
 	};
@@ -771,33 +996,31 @@ function createHandlers(options) {
 		if (iterator === void 0) return resultEvent(call, "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) {
+		let done = false;
+		try {
+			for (;;) {
+				let result;
 				try {
-					await iterator.return?.();
-				} catch {}
-				return;
-			}
-			last = result.value;
-			try {
-				await ctx.session.append(`tool:${call.toolCallId}:preliminary:${sequence}`, resultEvent(call, `execution:${sequence}:preliminary`, {
+					result = await iterator.next();
+				} catch (error) {
+					return toolExecutionFailure(ctx, call, error);
+				}
+				if (checkAbort(ctx.signal)) return;
+				if (result.done) {
+					done = true;
+					break;
+				}
+				last = result.value;
+				await ctx.session.append(`tool:${call.toolCallId}:preliminary:${sequence}`, resultEvent(call, `execution:${ctx.attempt}:${sequence}:preliminary`, {
 					output: result.value,
 					preliminary: true
 				}));
-			} catch (error) {
-				try {
-					await iterator.return?.();
-				} catch {}
-				throw error;
+				sequence += 1;
 			}
-			sequence += 1;
+		} finally {
+			if (!done) try {
+				await iterator.return?.();
+			} catch {}
 		}
 		return resultEvent(call, `execution:${sequence}:final`, sequence === 0 ? {} : { output: last });
 	};
@@ -805,7 +1028,7 @@ function createHandlers(options) {
 		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 (checkAbort(ctx.signal)) return;
 		const scope = {
 			contract: options.agent.contract,
 			context: ctx
@@ -863,120 +1086,211 @@ function createHandlers(options) {
 		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 state = replay(options.agent, promptHistory);
 		const resolverContext = {
 			event: ctx.event,
 			state,
 			history,
 			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: 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;
+				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: history.at(-1)?.index ?? ctx.event.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.payload;
+				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 generationHistory = [...history, ...await ctx.session.append("generation-start", ...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)
 			};
-			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 messages = activeContextMessages({
+				agent: options.agent,
+				state,
+				history: promptHistory,
+				coordinator: promptCoordinatorState
+			});
+			let modelMessages = await modelContext({
+				messages,
+				state,
+				tools
+			});
+			const baseContext = {
+				request: ctx.event,
+				requestId,
+				generationId,
+				responseMessageId,
+				messages,
+				modelMessages,
+				state,
+				history,
+				signal: ctx.signal,
+				model: resolvedModel,
+				tools,
+				...resolvedInstructions === void 0 ? {} : { instructions: resolvedInstructions },
+				generation
+			};
+			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 = sourceCoordinatorState.response?.calls.every((call) => call.terminal) ?? 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),
+						history
+					});
+					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 = 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 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) }
+					};
+					generationHistory.push(...await ctx.session.append("compaction-completed", {
+						type: "ai.compaction.completed",
+						id: `${generationId}:compaction:completed`,
+						payload: completed
+					}));
+					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 = replay(options.agent, generationHistory);
+			const currentCoordinatorState = coordinatorStateAt(generationHistory);
+			const generationMessages = activeContextMessages({
+				agent: options.agent,
+				state: currentState,
+				history: generationHistory,
+				coordinator: currentCoordinatorState
+			});
+			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,
 				signal: ctx.signal,
@@ -1031,6 +1345,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,8 +1368,11 @@ function createHandlers(options) {
 				}
 			];
 		} catch (error) {
-			if (error instanceof A2Error) throw error;
-			if (ctx.signal.aborted) {
+			if (error instanceof A2Error) {
+				checkAbort(ctx.signal);
+				throw error;
+			}
+			if (checkAbort(ctx.signal)) {
 				const interrupted = {
 					messageId: responseMessageId,
 					generationId,
@@ -1066,6 +1384,7 @@ function createHandlers(options) {
 					payload: interrupted
 				};
 			}
+			if (!generationStarted) throw error;
 			const failed = {
 				requestId,
 				messageId: request.messageId,
@@ -1111,6 +1430,21 @@ function createHandlers(options) {
 		return scheduleNext(ctx);
 	};
 	return {
+		"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.message.created": {
 			lane: "a2.ai.turn",
 			handler: handleMessageCreated