@tangle-network/agent-eval 0.144.0 → 0.144.3

package/dist/{single-run-lock-t1si1ob7.js → single-run-lock-D5iN0Xzb.js}

@@ -1,16 +1,46 @@
 import { c as ValidationError } from "./errors-D-LKuDhb.js";
 import { c as costForTokenPricing, i as CostLedger } from "./cost-ledger-DMFxsLKr.js";
-import { a as appendLedgerLine, d as tryAcquireAtomicFileLock, o as tryWithLedgerFileLock, u as probeAtomicFileLock } from "./ledger-core-Dxz0Rkwa.js";
+import { a as appendLedgerLine, d as tryAcquireAtomicFileLock, o as tryWithLedgerFileLock, u as probeAtomicFileLock } from "./ledger-core-DXZIqu17.js";
 import { createRequire } from "node:module";
 import { appendFileSync, existsSync, readFileSync } from "node:fs";
 import { isAbsolute, join, resolve } from "node:path";
 import { createHash, randomBytes } from "node:crypto";
+import { constants as constants$1 } from "node:buffer";
 import { createServer } from "node:http";
 import { spawn } from "node:child_process";
 import { lstat, mkdtemp, open, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 //#region src/campaign/external-optimizer-contracts.ts
 const MAX_TIMER_DELAY_MS$1 = 2147483647;
+const MAXIMUM_JSON_BYTES = Math.min(constants$1.MAX_LENGTH - 1, constants$1.MAX_STRING_LENGTH);
+const DEFAULT_EXTERNAL_OPTIMIZER_PROCESS_LIMITS = Object.freeze({
+	maxInputBytes: 64 * 1024 * 1024,
+	maxResultBytes: 4 * 1024 * 1024,
+	maxOutputChars: 64e3
+});
+const DEFAULT_EXTERNAL_OPTIMIZER_CALLBACK_LIMITS = Object.freeze({
+	maxRequestBytes: 1e6,
+	maxResponseBytes: 4e6
+});
+function resolveExternalOptimizerProcessLimits(value, label = "external optimizer process limits") {
+	const resolved = {
+		...DEFAULT_EXTERNAL_OPTIMIZER_PROCESS_LIMITS,
+		...value
+	};
+	assertBoundedPositiveInteger(resolved.maxInputBytes, `${label}.maxInputBytes`, MAXIMUM_JSON_BYTES);
+	assertBoundedPositiveInteger(resolved.maxResultBytes, `${label}.maxResultBytes`, MAXIMUM_JSON_BYTES);
+	assertBoundedPositiveInteger(resolved.maxOutputChars, `${label}.maxOutputChars`, constants$1.MAX_STRING_LENGTH);
+	return resolved;
+}
+function resolveExternalOptimizerCallbackLimits(value, label = "external optimizer callback limits") {
+	const resolved = {
+		...DEFAULT_EXTERNAL_OPTIMIZER_CALLBACK_LIMITS,
+		...value
+	};
+	assertBoundedPositiveInteger(resolved.maxRequestBytes, `${label}.maxRequestBytes`, MAXIMUM_JSON_BYTES);
+	assertBoundedPositiveInteger(resolved.maxResponseBytes, `${label}.maxResponseBytes`, MAXIMUM_JSON_BYTES);
+	return resolved;
+}
 function isCandidateText(value, maxChars) {
 	return typeof value === "string" && value.trim().length > 0 && value.length <= maxChars;
 }
@@ -59,12 +89,9 @@ function removeCredentialEnvironment(environment) {
 }
 function assertExternalOptimizerModelBudget(value, label) {
 	if (!value || typeof value !== "object") throw new Error(`${label} is required`);
-	for (const [field, entry] of [
-		["maxRequests", value.maxRequests],
-		["maxRequestBytes", value.maxRequestBytes],
-		["maxResponseBytes", value.maxResponseBytes],
-		["maxOutputTokensPerRequest", value.maxOutputTokensPerRequest]
-	]) if (!Number.isSafeInteger(entry) || entry <= 0) throw new Error(`${label}.${field} must be a positive safe integer`);
+	for (const [field, entry] of [["maxRequests", value.maxRequests], ["maxOutputTokensPerRequest", value.maxOutputTokensPerRequest]]) if (!Number.isSafeInteger(entry) || entry <= 0) throw new Error(`${label}.${field} must be a positive safe integer`);
+	assertBoundedPositiveInteger(value.maxRequestBytes, `${label}.maxRequestBytes`, MAXIMUM_JSON_BYTES);
+	assertBoundedPositiveInteger(value.maxResponseBytes, `${label}.maxResponseBytes`, MAXIMUM_JSON_BYTES);
 	if (value.maxReasoningTokensPerRequest !== void 0 && (!Number.isSafeInteger(value.maxReasoningTokensPerRequest) || value.maxReasoningTokensPerRequest < 0)) throw new Error(`${label}.maxReasoningTokensPerRequest must be a non-negative safe integer`);
 	if (value.maxCostUsd !== void 0 && (!Number.isFinite(value.maxCostUsd) || value.maxCostUsd <= 0)) throw new Error(`${label}.maxCostUsd must be positive and finite when supplied`);
 	if (value.requestTimeoutMs !== void 0 && (!Number.isSafeInteger(value.requestTimeoutMs) || value.requestTimeoutMs <= 0 || value.requestTimeoutMs > MAX_TIMER_DELAY_MS$1)) throw new Error(`${label}.requestTimeoutMs must be between 1 and ${MAX_TIMER_DELAY_MS$1}`);
@@ -77,6 +104,9 @@ function assertExternalOptimizerModelBudget(value, label) {
 function safePathComponent(value) {
 	return value.replace(/[^a-zA-Z0-9._-]/g, "_");
 }
+function assertBoundedPositiveInteger(value, label, maximum) {
+	if (!Number.isSafeInteger(value) || value <= 0 || value > maximum) throw new Error(`${label} must be an integer between 1 and ${maximum}`);
+}
 function isCredentialKey(key) {
 	return key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/-/g, "_").toLowerCase().split("_").some((segment) => [
 		"auth",
@@ -294,6 +324,7 @@ async function startExternalOptimizerModelProxy(args) {
 	let modelCallInvocations = 0;
 	let executionRecordCount = 0;
 	let executionSequence = 0;
+	const failures = [];
 	let totalRequestCount = args.initialUsage?.requests ?? 0;
 	let committedForBudget = args.initialUsage?.costUsd ?? 0;
 	let reservedForBudget = 0;
@@ -303,7 +334,7 @@ async function startExternalOptimizerModelProxy(args) {
 	const activeHandlers = /* @__PURE__ */ new Set();
 	const server = createServer((request, response) => {
 		if (!accepting) {
-			sendJsonIfOpen(response, 503, { error: "external optimizer model proxy is closing" });
+			sendJsonIfOpen$1(response, 503, { error: "external optimizer model proxy is closing" });
 			return;
 		}
 		const controller = new AbortController();
@@ -355,6 +386,9 @@ async function startExternalOptimizerModelProxy(args) {
 			},
 			recordModelCallInvocation: () => {
 				modelCallInvocations += 1;
+			},
+			recordFailure: (error) => {
+				failures.push(error);
 			}
 		}).finally(() => {
 			controller.signal.removeEventListener("abort", abortRequest);
@@ -370,6 +404,7 @@ async function startExternalOptimizerModelProxy(args) {
 		return closePromise;
 	};
 	const onAbort = () => {
+		for (const controller of activeControllers) controller.abort(args.signal?.reason);
 		close().catch(() => void 0);
 	};
 	args.signal?.addEventListener("abort", onAbort, { once: true });
@@ -383,6 +418,7 @@ async function startExternalOptimizerModelProxy(args) {
 		requestAttempts: () => requestCount,
 		successfulCompletions: () => successfulCompletionCount,
 		assertExecutionComplete,
+		failures: () => [...failures],
 		close
 	};
 	async function closeModelProxy() {
@@ -390,8 +426,7 @@ async function startExternalOptimizerModelProxy(args) {
 		accepting = false;
 		const closingServer = closeServer(server);
 		server.closeIdleConnections?.();
-		for (const controller of activeControllers) controller.abort();
-		const [serverResult] = await Promise.allSettled([closingServer, waitForActiveHandlers(activeHandlers)]);
+		const [serverResult] = await Promise.allSettled([closingServer, waitForActiveHandlers$1(activeHandlers)]);
 		if (activeControllers.size !== 0 || activeHandlers.size !== 0) throw new Error("external optimizer model proxy closed with active request work");
 		let executionError;
 		try {
@@ -409,26 +444,28 @@ async function handleModelProxyRequest(args) {
 	try {
 		const path = request.url ? new URL(request.url, "http://127.0.0.1").pathname : "";
 		if (request.method !== "POST" || !MODEL_PROXY_PATHS.has(path)) {
-			sendJsonIfOpen(response, 404, { error: "not found" });
+			sendJsonIfOpen$1(response, 404, { error: "not found" });
 			return;
 		}
+		const modelPath = path;
 		if (request.headers.authorization !== `Bearer ${args.token}`) {
-			sendJsonIfOpen(response, 401, { error: "unauthorized" });
+			sendJsonIfOpen$1(response, 401, { error: "unauthorized" });
 			return;
 		}
 		const body = await readBody(request, args.args.budget.maxRequestBytes);
-		const parsed = parseModelProxyRequest(body, args.args.model, args.args.budget);
+		const parsed = parseModelProxyRequest(body, modelPath, args.args.model, args.args.budget);
 		const maximumUsage = conservativeMaximumUsage(body.byteLength, parsed.maxOutputTokens + (args.args.budget.maxReasoningTokensPerRequest ?? 0), args.args.budget.pricing);
 		const maximumCostUsd = args.args.budget.pricing ? costForTokenPricing(args.args.budget.pricing, maximumUsage) : void 0;
 		const reservation = args.nextReservation(maximumCostUsd);
 		if (!reservation.accepted) {
-			sendJsonIfOpen(response, 429, { error: reservation.reason });
+			sendJsonIfOpen$1(response, 429, { error: reservation.reason });
 			return;
 		}
 		const timeout = setTimeout(() => controller.abort(), args.args.budget.requestTimeoutMs ?? 3e5);
 		let chargedForBudget = maximumCostUsd;
 		try {
 			const paid = await args.args.costLedger.runPaidCall({
+				...args.args.callId ? { callId: args.args.callId } : {},
 				channel: args.args.channel ?? "optimizer",
 				phase: args.args.phase,
 				actor: args.args.actor,
@@ -438,18 +475,20 @@ async function handleModelProxyRequest(args) {
 					customTokenPricing: args.args.budget.pricing,
 					...maximumUsage
 				} } : {},
-				execute: async () => forwardModelProxyRequest({
+				signal: controller.signal,
+				execute: async (paidCallSignal, paidCallId) => forwardModelProxyRequest({
 					call: args.args.call,
+					callId: paidCallId,
 					callRef: args.args.callRef,
 					recordExecutionReceipt: args.recordExecutionReceipt,
 					recordModelCallInvocation: args.recordModelCallInvocation,
-					path,
-					requestBody: parsed.body,
+					path: modelPath,
+					request: parsed.request,
 					model: args.args.model,
 					maxOutputTokens: parsed.maxOutputTokens,
 					...args.args.budget.maxReasoningTokensPerRequest === void 0 ? {} : { maxReasoningTokens: args.args.budget.maxReasoningTokensPerRequest },
 					maxResponseBytes: args.args.budget.maxResponseBytes,
-					signal: controller.signal
+					signal: paidCallSignal
 				}),
 				receipt: (result) => result.receipt,
 				receiptFromError: () => ({
@@ -461,17 +500,18 @@ async function handleModelProxyRequest(args) {
 				})
 			});
 			if (!paid.succeeded) {
+				args.recordFailure(paid.error);
 				chargedForBudget = paid.receipt ? paid.receipt.usageUnknown || paid.receipt.costUnknown ? maximumCostUsd : paid.receipt.costUsd : void 0;
-				sendJsonIfOpen(response, isAbortError(paid.error) ? 504 : paid.error instanceof ProviderResponseTooLargeError || paid.error instanceof MissingModelExecutionError || paid.error instanceof ModelExecutionPersistenceError || paid.error instanceof OwnerModelContractError ? 502 : 429, { error: paid.error.message });
+				sendJsonIfOpen$1(response, isAbortError(paid.error) ? 504 : paid.error instanceof ProviderResponseTooLargeError || paid.error instanceof MissingModelExecutionError || paid.error instanceof ModelExecutionPersistenceError || paid.error instanceof OwnerModelContractError ? 502 : 429, { error: paid.error.message });
 				return;
 			}
 			if (paid.value.modelCallFailed) {
-				sendJsonIfOpen(response, 502, { error: paid.value.modelCallFailed });
+				sendJsonIfOpen$1(response, 502, { error: paid.value.modelCallFailed });
 				return;
 			}
 			chargedForBudget = paid.value.usageComplete ? paid.receipt.costUsd : maximumCostUsd;
 			if (paid.value.usageRejected) {
-				sendJsonIfOpen(response, 502, { error: paid.value.usageRejected });
+				sendJsonIfOpen$1(response, 502, { error: paid.value.usageRejected });
 				return;
 			}
 			if (paid.value.status >= 200 && paid.value.status < 300) args.recordSuccessfulCompletion();
@@ -486,13 +526,13 @@ async function handleModelProxyRequest(args) {
 			args.settleReservation(maximumCostUsd, chargedForBudget);
 		}
 	} catch (error) {
-		sendJsonIfOpen(response, error instanceof RequestBodyTooLargeError ? 413 : error instanceof Error && isAbortError(error) ? 503 : 400, { error: toErrorMessage(error) });
+		sendJsonIfOpen$1(response, error instanceof RequestBodyTooLargeError ? 413 : error instanceof Error && isAbortError(error) ? 503 : 400, { error: toErrorMessage(error) });
 	}
 }
-async function waitForActiveHandlers(activeHandlers) {
+async function waitForActiveHandlers$1(activeHandlers) {
 	while (activeHandlers.size > 0) await Promise.allSettled([...activeHandlers]);
 }
-function sendJsonIfOpen(response, status, body) {
+function sendJsonIfOpen$1(response, status, body) {
 	if (response.destroyed || response.writableEnded) return;
 	sendJson(response, status, body);
 }
@@ -501,9 +541,9 @@ async function forwardModelProxyRequest(args) {
 	let called;
 	try {
 		called = await args.call({
-			path: args.path,
-			model: args.model,
-			body: freezeJsonSnapshot(args.requestBody, "optimizer model call body"),
+			callId: args.callId,
+			request: freezeJsonSnapshot(args.request, "optimizer model canonical request"),
+			endpointFormat: endpointFormat(args.path),
 			signal: args.signal
 		});
 	} catch (error) {
@@ -517,18 +557,55 @@ async function forwardModelProxyRequest(args) {
 		throw new MissingModelExecutionError(`optimizer model callback returned invalid execution evidence: ${toErrorMessage(error)}`);
 	}
 	if (called.succeeded) {
-		if (!(called.response instanceof Response)) throw new MissingModelExecutionError("optimizer model callback success did not return a Response");
+		let authoritativeReceipt;
+		let canonicalResponse;
+		try {
+			authoritativeReceipt = snapshotModelReceipt(called.receipt, args.model);
+			canonicalResponse = snapshotChatResponse(called.response, args.model);
+			assertResponseUsageMatchesReceipt(canonicalResponse, authoritativeReceipt);
+		} catch (error) {
+			args.recordExecutionReceipt({
+				callId: args.callId,
+				callRef: args.callRef,
+				path: args.path,
+				model: args.model,
+				succeeded: false,
+				error: toErrorMessage(error),
+				execution
+			});
+			throw error;
+		}
 		args.recordExecutionReceipt({
+			callId: args.callId,
 			callRef: args.callRef,
 			path: args.path,
 			model: args.model,
 			succeeded: true,
-			responseStatus: called.response.status,
+			responseStatus: 200,
 			execution
 		});
+		const usageKnown = canonicalResponse.usage.captured !== false;
+		const reasoningTokens = canonicalResponse.usage.reasoningTokens ?? 0;
+		const completionTokens = canonicalResponse.usage.completionTokens - reasoningTokens;
+		const usageRejected = usageKnown && completionTokens > args.maxOutputTokens ? `optimizer model execution reported ${completionTokens} completion tokens, exceeding requested limit ${args.maxOutputTokens}` : usageKnown && args.maxReasoningTokens !== void 0 && reasoningTokens > args.maxReasoningTokens ? `optimizer model execution reported ${reasoningTokens} reasoning tokens, exceeding the declared budget ${args.maxReasoningTokens}` : void 0;
+		return {
+			status: 200,
+			contentType: "application/json",
+			body: encodeCanonicalModelResponse({
+				path: args.path,
+				callId: args.callId,
+				response: canonicalResponse,
+				receipt: authoritativeReceipt,
+				maxBytes: args.maxResponseBytes
+			}),
+			receipt: authoritativeReceipt,
+			usageComplete: authoritativeReceipt.usageUnknown !== true,
+			...usageRejected ? { usageRejected } : {}
+		};
 	} else {
 		if (typeof called.error !== "string" || !called.error.trim()) throw new MissingModelExecutionError("optimizer model callback failure did not return a public error");
 		args.recordExecutionReceipt({
+			callId: args.callId,
 			callRef: args.callRef,
 			path: args.path,
 			model: args.model,
@@ -546,23 +623,6 @@ async function forwardModelProxyRequest(args) {
 			modelCallFailed: called.error
 		};
 	}
-	const response = called.response;
-	const authoritativeReceipt = snapshotModelReceipt(called.receipt, args.model);
-	const body = await readProviderResponseBody(response, args.maxResponseBytes);
-	const usage = parseProviderUsage(body);
-	const successful = response.status >= 200 && response.status < 300;
-	const completionTokens = usage === void 0 ? 0 : usage.outputTokens - (usage.reasoningTokens ?? 0);
-	const reasoningTokens = usage?.reasoningTokens ?? 0;
-	const usageRejected = successful && usage !== void 0 && completionTokens > args.maxOutputTokens ? `optimizer model provider reported ${completionTokens} completion tokens, exceeding requested limit ${args.maxOutputTokens}` : successful && args.maxReasoningTokens !== void 0 && reasoningTokens > args.maxReasoningTokens ? `optimizer model provider reported ${reasoningTokens} reasoning tokens, exceeding the declared budget ${args.maxReasoningTokens}` : void 0;
-	if (usage !== void 0) assertResponseUsageMatchesReceipt(usage, authoritativeReceipt);
-	return {
-		status: response.status,
-		contentType: response.headers.get("content-type") ?? "application/json",
-		body,
-		receipt: authoritativeReceipt,
-		usageComplete: authoritativeReceipt.usageUnknown !== true,
-		...usageRejected ? { usageRejected } : {}
-	};
 }
 function snapshotModelReceipt(value, expectedModel) {
 	let snapshot;
@@ -586,17 +646,20 @@ function deepFreezeJson(value) {
 	}
 	return value;
 }
-function assertResponseUsageMatchesReceipt(usage, receipt) {
-	for (const field of [
-		"inputTokens",
-		"outputTokens",
-		"cachedTokens",
-		"cacheWriteTokens",
-		"reasoningTokens"
-	]) if ((usage[field] ?? 0) !== (receipt[field] ?? 0)) throw new OwnerModelContractError(`optimizer model response usage disagrees with Runtime receipt at ${field}`);
-	if (usage.actualCostUsd !== void 0 && usage.actualCostUsd !== receipt.actualCostUsd) throw new OwnerModelContractError("optimizer model response cost disagrees with Runtime receipt");
-}
-function parseModelProxyRequest(body, expectedModel, budget) {
+function assertResponseUsageMatchesReceipt(response, receipt) {
+	if (response.usage.captured === false || receipt.usageUnknown === true) {
+		if (response.usage.captured !== false || receipt.usageUnknown !== true) throw new OwnerModelContractError("optimizer model response and execution receipt disagree about whether usage was captured");
+	} else {
+		const cachedTokens = response.usage.cachedPromptTokens ?? 0;
+		if (receipt.inputTokens + (receipt.cachedTokens ?? 0) !== response.usage.promptTokens) throw new OwnerModelContractError("optimizer model response promptTokens must equal receipt inputTokens plus cachedTokens");
+		if (cachedTokens !== (receipt.cachedTokens ?? 0)) throw new OwnerModelContractError("optimizer model response cachedPromptTokens disagrees with the execution receipt");
+		if (response.usage.completionTokens !== receipt.outputTokens) throw new OwnerModelContractError("optimizer model response completionTokens disagrees with the execution receipt");
+		if ((response.usage.reasoningTokens ?? 0) !== (receipt.reasoningTokens ?? 0)) throw new OwnerModelContractError("optimizer model response reasoningTokens disagrees with the execution receipt");
+	}
+	const receiptCostUsd = receipt.actualCostUsd ?? receipt.estimatedCostUsd ?? (receipt.customTokenPricing && receipt.usageUnknown !== true ? costForTokenPricing(receipt.customTokenPricing, receipt) : null);
+	if (response.costUsd !== receiptCostUsd) throw new OwnerModelContractError("optimizer model response billed cost disagrees with the execution receipt");
+}
+function parseModelProxyRequest(body, path, expectedModel, budget) {
 	let value;
 	try {
 		value = JSON.parse(Buffer.from(body).toString("utf8"));
@@ -612,148 +675,376 @@ function parseModelProxyRequest(body, expectedModel, budget) {
 		"candidate_count",
 		"num_candidates"
 	]) if (value[field] !== void 0 && value[field] !== 1) throw new Error(`optimizer model request ${field} must be 1 when supplied`);
-	const suppliedMaximums = [
-		value.max_output_tokens,
-		value.max_completion_tokens,
-		value.max_tokens
-	].filter((maximum) => maximum !== void 0);
-	if (suppliedMaximums.length === 0 || suppliedMaximums.some((maximum) => !Number.isSafeInteger(maximum) || maximum <= 0)) throw new Error("optimizer model request requires a positive output-token limit");
-	const maxOutputTokens = Math.max(...suppliedMaximums);
+	if (value.reasoning !== void 0 || value.reasoning_effort !== void 0) throw new Error("optimizer model reasoning settings belong to the execution AgentProfile");
+	const maxOutputTokens = parseOutputMaximum(value, path === "/v1/responses" ? ["max_output_tokens"] : [
+		"max_tokens",
+		"max_completion_tokens",
+		"max_output_tokens"
+	]);
 	if (maxOutputTokens > budget.maxOutputTokensPerRequest) throw new Error("optimizer model request exceeds maxOutputTokensPerRequest");
 	return {
 		maxOutputTokens,
-		body: value
+		request: freezeJsonSnapshot(path === "/v1/chat/completions" ? parseChatCompletionsRequest(value, expectedModel, maxOutputTokens) : parseResponsesRequest(value, expectedModel, maxOutputTokens), "optimizer model canonical request")
 	};
 }
-function parseProviderUsage(body) {
-	let value;
-	try {
-		value = JSON.parse(Buffer.from(body).toString("utf8"));
-	} catch {
-		return;
-	}
-	if (!isRecord(value) || !isRecord(value.usage)) return void 0;
-	const usage = value.usage;
-	const totalInputTokens = usage.input_tokens ?? usage.prompt_tokens;
-	const outputTokens = usage.output_tokens ?? usage.completion_tokens;
-	if (!Number.isSafeInteger(totalInputTokens) || totalInputTokens < 0 || !Number.isSafeInteger(outputTokens) || outputTokens < 0) return;
-	const inputDetails = isRecord(usage.input_tokens_details) ? usage.input_tokens_details : isRecord(usage.prompt_tokens_details) ? usage.prompt_tokens_details : {};
-	const outputDetails = isRecord(usage.output_tokens_details) ? usage.output_tokens_details : isRecord(usage.completion_tokens_details) ? usage.completion_tokens_details : {};
-	const nestedCachedTokens = optionalTokenCount(inputDetails, ["cached_tokens", "cache_read_tokens"]);
-	const separateCachedTokens = optionalTokenCount(usage, ["cache_read_input_tokens"]);
-	const nestedCacheWriteTokens = optionalTokenCount(inputDetails, ["cache_write_tokens", "cache_creation_tokens"]);
-	const separateCacheWriteTokens = optionalTokenCount(usage, ["cache_creation_input_tokens"]);
-	const nestedReasoningTokens = optionalTokenCount(outputDetails, ["reasoning_tokens"]);
-	const separateReasoningTokens = optionalTokenCount(usage, ["reasoning_tokens"]);
-	const actualCostUsd = typeof usage.cost === "number" && Number.isFinite(usage.cost) && usage.cost >= 0 ? usage.cost : void 0;
-	if (nestedCachedTokens === INVALID_TOKEN_COUNT || separateCachedTokens === INVALID_TOKEN_COUNT || nestedCacheWriteTokens === INVALID_TOKEN_COUNT || separateCacheWriteTokens === INVALID_TOKEN_COUNT || nestedReasoningTokens === INVALID_TOKEN_COUNT || separateReasoningTokens === INVALID_TOKEN_COUNT) return;
-	const cached = selectProviderTokenClass(nestedCachedTokens, separateCachedTokens);
-	const cacheWrite = selectProviderTokenClass(nestedCacheWriteTokens, separateCacheWriteTokens);
-	const reasoning = selectProviderTokenClass(nestedReasoningTokens, separateReasoningTokens);
-	if (cached === void 0 || cacheWrite === void 0 || reasoning === void 0) return void 0;
-	const classifiedInputTokens = (cached.includedInTotal ? cached.count : 0) + (cacheWrite.includedInTotal ? cacheWrite.count : 0);
-	if (classifiedInputTokens > totalInputTokens || reasoning.count > outputTokens) return;
+function parseChatCompletionsRequest(body, model, maxTokens) {
+	assertAllowedKeys(body, [
+		"model",
+		"messages",
+		"max_tokens",
+		"max_completion_tokens",
+		"max_output_tokens",
+		"temperature",
+		"thinking",
+		"response_format",
+		"stream",
+		"n",
+		"best_of",
+		"candidate_count",
+		"num_candidates"
+	]);
 	return {
-		inputTokens: totalInputTokens - classifiedInputTokens,
-		outputTokens,
-		...cached.supplied ? { cachedTokens: cached.count } : {},
-		...cacheWrite.supplied ? { cacheWriteTokens: cacheWrite.count } : {},
-		...reasoning.supplied ? { reasoningTokens: reasoning.count } : {},
-		...actualCostUsd === void 0 ? {} : { actualCostUsd }
+		model,
+		messages: parseChatMessages(body.messages),
+		maxTokens,
+		...parseTemperature(body.temperature),
+		...parseThinking(body.thinking),
+		...parseChatResponseFormat(body.response_format)
 	};
 }
-/**
-* OpenAI reports a cache class inside the input total; Anthropic reports it
-* beside the input total. When both equivalent forms are present they must
-* agree, and the nested normalized form wins.
-*/
-function selectProviderTokenClass(nested, separate) {
-	if (nested !== void 0 && separate !== void 0 && nested > 0 && separate > 0) {
-		if (nested !== separate) return void 0;
-		return {
-			count: nested,
-			supplied: true,
-			includedInTotal: true
-		};
-	}
-	if (nested !== void 0 && nested > 0) return {
-		count: nested,
-		supplied: true,
-		includedInTotal: true
+function parseResponsesRequest(body, model, maxTokens) {
+	assertAllowedKeys(body, [
+		"model",
+		"input",
+		"instructions",
+		"max_output_tokens",
+		"temperature",
+		"thinking",
+		"text",
+		"stream",
+		"n",
+		"best_of",
+		"candidate_count",
+		"num_candidates"
+	]);
+	const instructions = body.instructions;
+	if (instructions !== void 0 && typeof instructions !== "string") throw new Error("optimizer Responses instructions must be a string");
+	return {
+		model,
+		messages: [...instructions === void 0 ? [] : [{
+			role: "system",
+			content: instructions
+		}], ...parseResponsesInput(body.input)],
+		maxTokens,
+		...parseTemperature(body.temperature),
+		...parseThinking(body.thinking),
+		...parseResponsesTextFormat(body.text)
 	};
-	if (separate !== void 0 && separate > 0) return {
-		count: separate,
-		supplied: true,
-		includedInTotal: false
+}
+function parseOutputMaximum(body, fields) {
+	const supplied = fields.flatMap((field) => body[field] === void 0 ? [] : [{
+		field,
+		value: body[field]
+	}]);
+	if (supplied.length === 0 || supplied.some(({ value }) => !Number.isSafeInteger(value) || value <= 0)) throw new Error("optimizer model request requires a positive output-token limit");
+	if (new Set(supplied.map(({ value }) => value)).size !== 1) throw new Error("optimizer model request supplied conflicting output-token limits");
+	return supplied[0].value;
+}
+function parseTemperature(value) {
+	if (value === void 0) return {};
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new Error("optimizer model request temperature must be finite");
+	return { temperature: value };
+}
+function parseThinking(value) {
+	if (value === void 0) return {};
+	if (!isRecord(value)) throw new Error("optimizer model request thinking must be an object");
+	assertAllowedKeys(value, ["type"], "optimizer model request thinking");
+	if (value.type !== "enabled" && value.type !== "disabled") throw new Error("optimizer model request thinking.type must be enabled or disabled");
+	return { thinking: value.type };
+}
+function parseChatMessages(value) {
+	if (!Array.isArray(value)) throw new Error("optimizer chat request messages must be an array");
+	return value.map((message, index) => parseMessage(message, `optimizer chat message ${index}`));
+}
+function parseResponsesInput(value) {
+	if (typeof value === "string") return [{
+		role: "user",
+		content: value
+	}];
+	if (!Array.isArray(value) || value.length === 0) throw new Error("optimizer Responses request requires non-empty input");
+	return value.map((message, index) => {
+		if (!isRecord(message)) throw new Error(`optimizer Responses input ${index} must be a message object`);
+		assertAllowedKeys(message, [
+			"type",
+			"role",
+			"content"
+		], `optimizer Responses input ${index}`);
+		if (message.type !== void 0 && message.type !== "message") throw new Error(`optimizer Responses input ${index} type must be message`);
+		return parseMessage(message, `optimizer Responses input ${index}`, true);
+	});
+}
+function parseMessage(value, label, responsesContent = false) {
+	if (!isRecord(value)) throw new Error(`${label} must be an object`);
+	assertAllowedKeys(value, responsesContent ? [
+		"type",
+		"role",
+		"content"
+	] : ["role", "content"], label);
+	if (value.role !== "system" && value.role !== "user" && value.role !== "assistant") throw new Error(`${label} role must be system, user, or assistant`);
+	return {
+		role: value.role,
+		content: parseMessageContent(value.content, label, responsesContent)
 	};
+}
+function parseMessageContent(value, label, responsesContent) {
+	if (typeof value === "string") return value;
+	if (!Array.isArray(value) || value.length === 0) throw new Error(`${label} content must be text or a non-empty content array`);
+	return value.map((part, partIndex) => {
+		if (!isRecord(part)) throw new Error(`${label} content ${partIndex} must be an object`);
+		const partLabel = `${label} content ${partIndex}`;
+		if (part.type === "text" || responsesContent && part.type === "input_text") {
+			assertAllowedKeys(part, ["type", "text"], partLabel);
+			if (typeof part.text !== "string") throw new Error(`${partLabel} text must be a string`);
+			return {
+				type: "text",
+				text: part.text
+			};
+		}
+		if (responsesContent && part.type === "output_text") {
+			assertAllowedKeys(part, ["type", "text"], partLabel);
+			if (typeof part.text !== "string") throw new Error(`${partLabel} text must be a string`);
+			return {
+				type: "text",
+				text: part.text
+			};
+		}
+		if (part.type === "image_url") {
+			assertAllowedKeys(part, ["type", "image_url"], partLabel);
+			if (!isRecord(part.image_url) || typeof part.image_url.url !== "string") throw new Error(`${partLabel} image_url must contain a URL string`);
+			assertAllowedKeys(part.image_url, ["url", "detail"], `${partLabel} image_url`);
+			const detail = parseImageDetail(part.image_url.detail, partLabel);
+			return {
+				type: "image_url",
+				image_url: {
+					url: part.image_url.url,
+					...detail
+				}
+			};
+		}
+		if (responsesContent && part.type === "input_image") {
+			assertAllowedKeys(part, [
+				"type",
+				"image_url",
+				"detail"
+			], partLabel);
+			if (typeof part.image_url !== "string") throw new Error(`${partLabel} image_url must be a URL string`);
+			const detail = parseImageDetail(part.detail, partLabel);
+			return {
+				type: "image_url",
+				image_url: {
+					url: part.image_url,
+					...detail
+				}
+			};
+		}
+		throw new Error(`${partLabel} uses an unsupported content type`);
+	});
+}
+function parseImageDetail(value, label) {
+	if (value === void 0) return {};
+	if (value !== "auto" && value !== "low" && value !== "high") throw new Error(`${label} image detail must be auto, low, or high`);
+	return { detail: value };
+}
+function parseChatResponseFormat(value) {
+	if (value === void 0) return {};
+	if (!isRecord(value) || typeof value.type !== "string") throw new Error("optimizer chat response_format must be an object with a type");
+	if (value.type === "text") {
+		assertAllowedKeys(value, ["type"], "optimizer chat response_format");
+		return {};
+	}
+	if (value.type === "json_object") {
+		assertAllowedKeys(value, ["type"], "optimizer chat response_format");
+		return { jsonMode: true };
+	}
+	if (value.type !== "json_schema") throw new Error("optimizer chat response_format type is unsupported");
+	assertAllowedKeys(value, ["type", "json_schema"], "optimizer chat response_format");
+	return { jsonSchema: parseJsonSchema(value.json_schema, "optimizer chat response_format") };
+}
+function parseResponsesTextFormat(value) {
+	if (value === void 0) return {};
+	if (!isRecord(value)) throw new Error("optimizer Responses text must be an object");
+	assertAllowedKeys(value, ["format"], "optimizer Responses text");
+	if (value.format === void 0) return {};
+	if (!isRecord(value.format) || typeof value.format.type !== "string") throw new Error("optimizer Responses text.format must be an object with a type");
+	const format = value.format;
+	if (format.type === "text") {
+		assertAllowedKeys(format, ["type"], "optimizer Responses text.format");
+		return {};
+	}
+	if (format.type === "json_object") {
+		assertAllowedKeys(format, ["type"], "optimizer Responses text.format");
+		return { jsonMode: true };
+	}
+	if (format.type !== "json_schema") throw new Error("optimizer Responses text.format type is unsupported");
+	return { jsonSchema: parseJsonSchema(format, "optimizer Responses text.format", true) };
+}
+function parseJsonSchema(value, label, flat = false) {
+	if (!isRecord(value)) throw new Error(`${label} JSON schema must be an object`);
+	assertAllowedKeys(value, [
+		"name",
+		"schema",
+		"strict",
+		...flat ? ["type"] : []
+	], label);
+	if (typeof value.name !== "string" || !value.name.trim()) throw new Error(`${label} JSON schema name must be non-empty`);
+	if (!isRecord(value.schema)) throw new Error(`${label} JSON schema body must be an object`);
+	if (value.strict !== void 0 && value.strict !== true) throw new Error(`${label} JSON schema strict must be true when supplied`);
 	return {
-		count: 0,
-		supplied: nested !== void 0 || separate !== void 0,
-		includedInTotal: nested !== void 0
+		name: value.name,
+		schema: freezeJsonSnapshot(value.schema, `${label} schema`)
 	};
 }
-const INVALID_TOKEN_COUNT = Symbol("invalid-token-count");
-function optionalTokenCount(details, fields) {
-	let found;
-	for (const field of fields) {
-		const value = details[field];
-		if (value === void 0 || value === null) continue;
-		if (!Number.isSafeInteger(value) || value < 0) return INVALID_TOKEN_COUNT;
-		if (found !== void 0 && found !== value) return INVALID_TOKEN_COUNT;
-		found = value;
+function assertAllowedKeys(value, allowed, label = "optimizer model request") {
+	const allowedSet = new Set(allowed);
+	const unknown = Object.keys(value).filter((key) => !allowedSet.has(key));
+	if (unknown.length > 0) throw new Error(`${label} contains unsupported fields: ${unknown.join(", ")}`);
+}
+function snapshotChatResponse(value, expectedModel) {
+	if (!isRecord(value)) throw new OwnerModelContractError("optimizer model callback response must be an object");
+	if (typeof value.content !== "string") throw new OwnerModelContractError("optimizer model callback response content must be a string");
+	if (value.model !== expectedModel) throw new OwnerModelContractError(`optimizer model callback response used '${String(value.model)}' instead of '${expectedModel}'`);
+	if (!isNonnegativeFiniteNumber(value.durationMs)) throw new OwnerModelContractError("optimizer model callback response durationMs must be finite and non-negative");
+	if (value.costUsd !== null && !isNonnegativeFiniteNumber(value.costUsd)) throw new OwnerModelContractError("optimizer model callback response costUsd must be null or finite and non-negative");
+	if (value.finishReason !== void 0 && value.finishReason !== null && typeof value.finishReason !== "string") throw new OwnerModelContractError("optimizer model callback response finishReason must be a string or null");
+	if (value.contentEmpty !== void 0 && (typeof value.contentEmpty !== "boolean" || value.contentEmpty !== (value.content.trim().length === 0))) throw new OwnerModelContractError("optimizer model callback response contentEmpty must match content");
+	if (!isRecord(value.raw)) throw new OwnerModelContractError("optimizer model callback response raw must be an object");
+	if (!isRecord(value.usage)) throw new OwnerModelContractError("optimizer model callback response usage must be an object");
+	const usage = value.usage;
+	for (const field of [
+		"promptTokens",
+		"completionTokens",
+		"totalTokens"
+	]) if (!isNonnegativeSafeInteger(usage[field])) throw new OwnerModelContractError(`optimizer model callback response usage.${field} must be a non-negative safe integer`);
+	const promptTokens = usage.promptTokens;
+	const completionTokens = usage.completionTokens;
+	const totalTokens = usage.totalTokens;
+	if (totalTokens !== promptTokens + completionTokens) throw new OwnerModelContractError("optimizer model callback response totalTokens must equal promptTokens plus completionTokens");
+	if (usage.captured !== void 0 && typeof usage.captured !== "boolean") throw new OwnerModelContractError("optimizer model callback response usage.captured must be a boolean");
+	if (usage.cachedPromptTokens !== void 0 && (!isNonnegativeSafeInteger(usage.cachedPromptTokens) || usage.cachedPromptTokens > promptTokens)) throw new OwnerModelContractError("optimizer model callback response cachedPromptTokens must be a subset of promptTokens");
+	if (usage.reasoningTokens !== void 0 && (!isNonnegativeSafeInteger(usage.reasoningTokens) || usage.reasoningTokens > completionTokens)) throw new OwnerModelContractError("optimizer model callback response reasoningTokens must be a subset of completionTokens");
+	let raw;
+	try {
+		raw = freezeJsonSnapshot(value.raw, "optimizer model callback canonical response.raw");
+	} catch (error) {
+		throw new OwnerModelContractError(`optimizer model callback returned invalid raw response evidence: ${toErrorMessage(error)}`);
 	}
-	return found;
+	return deepFreezeJson({
+		content: value.content,
+		usage: {
+			promptTokens,
+			completionTokens,
+			totalTokens,
+			...usage.captured === void 0 ? {} : { captured: usage.captured },
+			...usage.reasoningTokens === void 0 ? {} : { reasoningTokens: usage.reasoningTokens },
+			...usage.cachedPromptTokens === void 0 ? {} : { cachedPromptTokens: usage.cachedPromptTokens }
+		},
+		costUsd: value.costUsd,
+		model: value.model,
+		durationMs: value.durationMs,
+		...value.finishReason === void 0 ? {} : { finishReason: value.finishReason },
+		...value.contentEmpty === void 0 ? {} : { contentEmpty: value.contentEmpty },
+		raw
+	});
+}
+function encodeCanonicalModelResponse(args) {
+	const usage = encodeProtocolUsage(args.path, args.response, args.receipt);
+	const finishReason = args.response.finishReason === void 0 ? "stop" : args.response.finishReason;
+	const body = args.path === "/v1/chat/completions" ? {
+		id: `chatcmpl-${args.callId}`,
+		object: "chat.completion",
+		created: 0,
+		model: args.response.model,
+		choices: [{
+			index: 0,
+			message: {
+				role: "assistant",
+				content: args.response.content
+			},
+			finish_reason: finishReason
+		}],
+		...usage ? { usage } : {}
+	} : {
+		id: `resp-${args.callId}`,
+		object: "response",
+		created_at: 0,
+		model: args.response.model,
+		status: finishReason === "length" ? "incomplete" : "completed",
+		error: null,
+		incomplete_details: finishReason === "length" ? { reason: "max_output_tokens" } : null,
+		output: [{
+			id: `msg-${args.callId}`,
+			type: "message",
+			status: finishReason === "length" ? "incomplete" : "completed",
+			role: "assistant",
+			content: [{
+				type: "output_text",
+				text: args.response.content,
+				annotations: []
+			}]
+		}],
+		output_text: args.response.content,
+		...usage ? { usage } : {}
+	};
+	const encoded = new TextEncoder().encode(JSON.stringify(body));
+	if (encoded.byteLength > args.maxBytes) throw new ProviderResponseTooLargeError();
+	return encoded;
+}
+function endpointFormat(path) {
+	return path === "/v1/responses" ? "responses" : "chat-completions";
+}
+function encodeProtocolUsage(path, response, receipt) {
+	if (response.usage.captured === false) return void 0;
+	const inputDetails = {
+		...receipt.cachedTokens === void 0 ? {} : { cached_tokens: receipt.cachedTokens },
+		...receipt.cacheWriteTokens === void 0 ? {} : path === "/v1/chat/completions" ? { cache_creation_tokens: receipt.cacheWriteTokens } : { cache_write_tokens: receipt.cacheWriteTokens }
+	};
+	const outputDetails = { ...receipt.reasoningTokens === void 0 ? {} : { reasoning_tokens: receipt.reasoningTokens } };
+	return path === "/v1/chat/completions" ? {
+		prompt_tokens: response.usage.promptTokens,
+		completion_tokens: response.usage.completionTokens,
+		total_tokens: response.usage.totalTokens,
+		...Object.keys(inputDetails).length > 0 ? { prompt_tokens_details: inputDetails } : {},
+		...Object.keys(outputDetails).length > 0 ? { completion_tokens_details: outputDetails } : {},
+		...receipt.actualCostUsd === void 0 ? {} : { cost: receipt.actualCostUsd }
+	} : {
+		input_tokens: response.usage.promptTokens,
+		output_tokens: response.usage.completionTokens,
+		total_tokens: response.usage.totalTokens,
+		...Object.keys(inputDetails).length > 0 ? { input_tokens_details: inputDetails } : {},
+		...Object.keys(outputDetails).length > 0 ? { output_tokens_details: outputDetails } : {},
+		...receipt.actualCostUsd === void 0 ? {} : { cost: receipt.actualCostUsd }
+	};
+}
+function isNonnegativeFiniteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function isNonnegativeSafeInteger(value) {
+	return Number.isSafeInteger(value) && value >= 0;
 }
 function conservativeMaximumUsage(inputTokenUpperBound, outputTokenUpperBound, pricing) {
 	if (pricing === void 0) return {
 		inputTokens: inputTokenUpperBound,
 		outputTokens: outputTokenUpperBound
 	};
-	const inputRates = [
-		pricing.inputUsdPerMillion,
-		pricing.cachedInputUsdPerMillion ?? pricing.inputUsdPerMillion,
-		pricing.cacheWriteUsdPerMillion ?? pricing.inputUsdPerMillion
-	];
+	const inputRates = [pricing.inputUsdPerMillion, pricing.cachedInputUsdPerMillion ?? pricing.inputUsdPerMillion];
 	const mostExpensiveInputClass = inputRates.indexOf(Math.max(...inputRates));
 	return {
 		inputTokens: mostExpensiveInputClass === 0 ? inputTokenUpperBound : 0,
 		...mostExpensiveInputClass === 1 ? { cachedTokens: inputTokenUpperBound } : {},
-		...mostExpensiveInputClass === 2 ? { cacheWriteTokens: inputTokenUpperBound } : {},
+		cacheWriteTokens: inputTokenUpperBound,
 		outputTokens: outputTokenUpperBound
 	};
 }
-async function readProviderResponseBody(response, maxBytes) {
-	const declaredLength = response.headers.get("content-length");
-	if (declaredLength !== null) {
-		const parsedLength = Number(declaredLength);
-		if (Number.isFinite(parsedLength) && parsedLength > maxBytes) throw new ProviderResponseTooLargeError();
-	}
-	if (!response.body) return /* @__PURE__ */ new Uint8Array();
-	const reader = response.body.getReader();
-	const chunks = [];
-	let totalBytes = 0;
-	try {
-		while (true) {
-			const next = await reader.read();
-			if (next.done) break;
-			totalBytes += next.value.byteLength;
-			if (totalBytes > maxBytes) {
-				await reader.cancel();
-				throw new ProviderResponseTooLargeError();
-			}
-			chunks.push(next.value);
-		}
-	} finally {
-		reader.releaseLock();
-	}
-	const body = new Uint8Array(totalBytes);
-	let offset = 0;
-	for (const chunk of chunks) {
-		body.set(chunk, offset);
-		offset += chunk.byteLength;
-	}
-	return body;
-}
 function assertModelProxyConfig(args) {
 	for (const [label, value] of [
 		["model", args.model],
@@ -763,6 +1054,10 @@ function assertModelProxyConfig(args) {
 	if (typeof args.call !== "function") throw new Error("external optimizer model proxy: call must be a function");
 	if (typeof args.callRef !== "string" || !args.callRef.trim() || args.callRef.trim() !== args.callRef) throw new Error("external optimizer model proxy: callRef must be trimmed and non-empty");
 	if (typeof args.recordExecution !== "function") throw new Error("external optimizer model proxy: recordExecution must be a function");
+	if (args.callId !== void 0) {
+		if (typeof args.callId !== "string" || !args.callId.trim() || args.callId !== args.callId.trim()) throw new Error("external optimizer model proxy: callId must be trimmed and non-empty");
+		if (args.budget.maxRequests !== 1) throw new Error("external optimizer model proxy: callId requires budget.maxRequests to be 1");
+	}
 	assertExternalOptimizerModelBudget(args.budget, "external optimizer model proxy: budget");
 	if (args.tags !== void 0) {
 		for (const [key, value] of Object.entries(args.tags)) if (!key.trim() || key.trim() !== key || !value.trim() || value.trim() !== value) throw new Error("external optimizer model proxy: tags must be trimmed and non-empty");
@@ -845,16 +1140,13 @@ function toError(cause) {
 }
 //#endregion
 //#region src/campaign/external-optimizer-subprocess.ts
-const MAX_PROCESS_OUTPUT_CHARS = 64e3;
-const MAX_PROCESS_INPUT_BYTES = 64 * 1024 * 1024;
-const MAX_PROCESS_RESULT_BYTES = 4 * 1024 * 1024;
 const PROCESS_TERMINATION_GRACE_MS = 5e3;
 const PROCESS_TERMINATION_POLL_MS = 25;
 const PROCESS_KILL_WAIT_MS = 1e3;
 const MAX_TIMER_DELAY_MS = 2147483647;
-const PROCESS_OUTPUT_HEAD_CHARS = MAX_PROCESS_OUTPUT_CHARS / 2;
 async function runExternalOptimizerProcess(args) {
 	if (!Number.isSafeInteger(args.timeoutMs) || args.timeoutMs <= 0 || args.timeoutMs > MAX_TIMER_DELAY_MS) throw new Error(`${args.label} timeoutMs must be between 1 and ${MAX_TIMER_DELAY_MS}`);
+	const limits = resolveExternalOptimizerProcessLimits(args.runner?.limits);
 	if (process.platform === "win32") throw new Error(`${args.label} requires POSIX process-group cleanup; run the optimizer through WSL or Linux`);
 	throwIfAborted(args.signal, args.label);
 	const dir = await mkdtemp(join(tmpdir(), args.tempPrefix));
@@ -867,11 +1159,12 @@ async function runExternalOptimizerProcess(args) {
 			if (serializedInput === void 0) throw new Error(`${args.label} input must be JSON-serializable`);
 			const inputJson = `${serializedInput}\n`;
 			const inputBytes = Buffer.byteLength(inputJson);
-			if (inputBytes > MAX_PROCESS_INPUT_BYTES) throw new Error(`${args.label} input exceeds ${MAX_PROCESS_INPUT_BYTES} bytes (${inputBytes})`);
+			if (inputBytes > limits.maxInputBytes) throw new Error(`${args.label} input exceeds ${limits.maxInputBytes} bytes (${inputBytes})`);
 			await writeFile(inputPath, inputJson);
 			const command = resolveRunnerCommand(args.runner?.command ?? "python");
 			const commandArgs = [
 				...args.runner?.args ?? ["-m", args.module],
+				...args.additionalArgs ?? [],
 				"--input",
 				inputPath,
 				"--output",
@@ -884,10 +1177,11 @@ async function runExternalOptimizerProcess(args) {
 				cwd: dir,
 				env: args.runner?.env,
 				timeoutMs: args.timeoutMs,
+				maxOutputChars: limits.maxOutputChars,
 				signal: args.signal
 			});
 			throwIfAborted(args.signal, args.label);
-			const raw = JSON.parse(await readBoundedTextFile(outputPath, MAX_PROCESS_RESULT_BYTES, `${args.label} output`));
+			const raw = JSON.parse(await readBoundedTextFile(outputPath, limits.maxResultBytes, `${args.label} output`));
 			throwIfAborted(args.signal, args.label);
 			if (!isRecord(raw)) throw new Error(`${args.label} output must be a JSON object`);
 			return raw;
@@ -964,10 +1258,10 @@ function runProcess(args) {
 		args.signal?.addEventListener("abort", onAbort, { once: true });
 		if (args.signal?.aborted) onAbort();
 		child.stdout.on("data", (chunk) => {
-			appendProcessOutput(stdout, chunk);
+			appendProcessOutput(stdout, chunk, args.maxOutputChars);
 		});
 		child.stderr.on("data", (chunk) => {
-			appendProcessOutput(stderr, chunk);
+			appendProcessOutput(stderr, chunk, args.maxOutputChars);
 		});
 		child.on("error", (error) => {
 			finish(/* @__PURE__ */ new Error(`${args.label} could not start: ${error.message}`));
@@ -1059,21 +1353,23 @@ function createProcessOutputCapture() {
 		totalChars: 0
 	};
 }
-function appendProcessOutput(capture, chunk) {
+function appendProcessOutput(capture, chunk, maxOutputChars) {
 	const text = chunk.toString();
 	capture.totalChars += text.length;
+	const headChars = Math.floor(maxOutputChars / 2);
+	const tailChars = maxOutputChars - headChars;
 	if (capture.full !== void 0) {
 		const combined = `${capture.full}${text}`;
-		if (combined.length <= MAX_PROCESS_OUTPUT_CHARS) {
+		if (combined.length <= maxOutputChars) {
 			capture.full = combined;
 			return;
 		}
-		capture.head = combined.slice(0, PROCESS_OUTPUT_HEAD_CHARS);
-		capture.tail = combined.slice(-32e3);
+		capture.head = combined.slice(0, headChars);
+		capture.tail = combined.slice(-tailChars);
 		capture.full = void 0;
 		return;
 	}
-	capture.tail = `${capture.tail}${text}`.slice(-32e3);
+	capture.tail = `${capture.tail}${text}`.slice(-tailChars);
 }
 function summarizeProcessOutput(capture, max = 4e3) {
 	const compact = (capture.full ?? `${capture.head}\n...[${capture.totalChars - capture.head.length - capture.tail.length} chars omitted]...\n${capture.tail}`).trim().replace(/\s+/g, " ");
@@ -1083,6 +1379,242 @@ function summarizeProcessOutput(capture, max = 4e3) {
 	return `${compact.slice(0, headChars)}...[${compact.length - max} chars omitted]...${compact.slice(-tailChars)}`;
 }
 //#endregion
+//#region src/campaign/external-optimizer-callback.ts
+async function startExternalOptimizerCallback(args) {
+	assertCallbackConfig(args);
+	const limits = resolveExternalOptimizerCallbackLimits(args.limits);
+	args.signal?.throwIfAborted();
+	let evaluations = 0;
+	let accepting = true;
+	let closePromise;
+	const activeControllers = /* @__PURE__ */ new Set();
+	const activeHandlers = /* @__PURE__ */ new Set();
+	const proposedCandidateHashes = /* @__PURE__ */ new Set();
+	let observationSequence = 0;
+	const server = createServer((request, response) => {
+		if (!accepting) {
+			sendJsonIfOpen(response, 503, { error: "external optimizer callback is closing" });
+			return;
+		}
+		const controller = new AbortController();
+		const abortRequest = () => {
+			request.destroy();
+			response.destroy();
+		};
+		activeControllers.add(controller);
+		controller.signal.addEventListener("abort", abortRequest, { once: true });
+		let handler;
+		handler = handleCallback(request, response, controller.signal, args, limits, () => {
+			const accepted = args.acceptEvaluation ? args.acceptEvaluation() : evaluations + 1;
+			if (accepted === void 0) return void 0;
+			if (!Number.isSafeInteger(accepted) || accepted <= 0) throw new Error("external optimizer callback: invalid accepted evaluation count");
+			if (accepted > args.maxEvaluations) return void 0;
+			evaluations += 1;
+			return accepted;
+		}, (observation) => {
+			if (!args.observe) return;
+			args.observe({
+				...observation,
+				sequence: ++observationSequence
+			});
+		}, proposedCandidateHashes).finally(() => {
+			controller.signal.removeEventListener("abort", abortRequest);
+			activeControllers.delete(controller);
+			activeHandlers.delete(handler);
+		});
+		activeHandlers.add(handler);
+		handler.catch(() => void 0);
+	});
+	const port = await listenLocal(server);
+	const close = () => {
+		closePromise ??= closeCallbackServer();
+		return closePromise;
+	};
+	const onAbort = () => {
+		close().catch(() => void 0);
+	};
+	args.signal?.addEventListener("abort", onAbort, { once: true });
+	if (args.signal?.aborted) onAbort();
+	return {
+		url: `http://127.0.0.1:${port}/evaluate`,
+		token: args.token,
+		evaluations: () => evaluations,
+		close
+	};
+	async function closeCallbackServer() {
+		args.signal?.removeEventListener("abort", onAbort);
+		accepting = false;
+		const closingServer = closeServer(server);
+		server.closeIdleConnections?.();
+		for (const controller of activeControllers) controller.abort();
+		const [serverResult] = await Promise.allSettled([closingServer, waitForActiveHandlers(activeHandlers)]);
+		if (activeControllers.size !== 0 || activeHandlers.size !== 0) throw new Error("external optimizer callback closed with active request work");
+		if (serverResult?.status === "rejected") throw serverResult.reason;
+	}
+}
+async function handleCallback(request, response, signal, args, limits, nextEvaluation, observe, proposedCandidateHashes) {
+	try {
+		if (request.method !== "POST" || request.url !== "/evaluate") {
+			sendJsonIfOpen(response, 404, { error: "not found" });
+			return;
+		}
+		if (request.headers.authorization !== `Bearer ${args.token}`) {
+			sendJsonIfOpen(response, 401, { error: "unauthorized" });
+			return;
+		}
+		let body;
+		try {
+			body = await readJson(request, limits.maxRequestBytes);
+		} catch {
+			observe({
+				kind: "refusal",
+				reason: "invalid-request"
+			});
+			sendJsonIfOpen(response, 400, { error: "request body must be bounded valid JSON" });
+			return;
+		}
+		if (!isRecord(body) || !isExternalTextCandidate(body.candidate) || typeof body.exampleId !== "string") {
+			observe({
+				kind: "refusal",
+				reason: "invalid-request"
+			});
+			sendJsonIfOpen(response, 400, { error: "candidate and exampleId are required strings" });
+			return;
+		}
+		const candidate = cloneCandidate(body.candidate);
+		const candidateHash = contentHash({
+			kind: "external-text-candidate",
+			candidate
+		});
+		if (!proposedCandidateHashes.has(candidateHash)) {
+			observe({
+				kind: "proposal",
+				candidate,
+				candidateHash
+			});
+			proposedCandidateHashes.add(candidateHash);
+		}
+		const count = nextEvaluation();
+		if (count === void 0) {
+			observe({
+				kind: "refusal",
+				reason: "evaluation-limit",
+				candidate,
+				candidateHash,
+				exampleId: body.exampleId
+			});
+			sendJsonIfOpen(response, 429, { error: "evaluation limit reached" });
+			return;
+		}
+		let result;
+		try {
+			result = await args.evaluate({
+				candidate,
+				exampleId: body.exampleId
+			}, signal);
+		} catch {
+			observe({
+				kind: "refusal",
+				reason: "evaluation-failed",
+				candidate,
+				candidateHash,
+				exampleId: body.exampleId
+			});
+			sendJsonIfOpen(response, 500, { error: "evaluation failed" });
+			return;
+		}
+		let encoded;
+		try {
+			encoded = encodeJsonResponse(result);
+		} catch {
+			observe({
+				kind: "refusal",
+				reason: "evaluation-failed",
+				candidate,
+				candidateHash,
+				exampleId: body.exampleId
+			});
+			sendJsonIfOpen(response, 500, { error: "evaluation response must be valid JSON" });
+			return;
+		}
+		if (Buffer.byteLength(encoded) > limits.maxResponseBytes) {
+			observe({
+				kind: "refusal",
+				reason: "evaluation-failed",
+				candidate,
+				candidateHash,
+				exampleId: body.exampleId
+			});
+			sendJsonIfOpen(response, 413, { error: "evaluation response too large" });
+			return;
+		}
+		observe({
+			kind: "evaluation",
+			candidate,
+			candidateHash,
+			exampleId: body.exampleId,
+			evaluationNumber: count,
+			response: structuredClone(result)
+		});
+		sendEncodedJsonIfOpen(response, 200, encoded);
+	} catch {
+		sendJsonIfOpen(response, 500, { error: "evaluation failed" });
+	}
+}
+async function waitForActiveHandlers(activeHandlers) {
+	while (activeHandlers.size > 0) await Promise.allSettled([...activeHandlers]);
+}
+function sendJsonIfOpen(response, status, body) {
+	if (response.destroyed || response.writableEnded) return;
+	sendJson(response, status, body);
+}
+function readJson(request, maxRequestBytes) {
+	return new Promise((resolvePromise, reject) => {
+		let size = 0;
+		const chunks = [];
+		request.on("data", (chunk) => {
+			size += chunk.length;
+			if (size > maxRequestBytes) {
+				reject(/* @__PURE__ */ new Error("callback body too large"));
+				request.destroy();
+				return;
+			}
+			chunks.push(chunk);
+		});
+		request.on("error", reject);
+		request.on("end", () => {
+			try {
+				resolvePromise(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+			} catch (error) {
+				reject(error);
+			}
+		});
+	});
+}
+function encodeJsonResponse(value) {
+	const encoded = JSON.stringify(value);
+	if (encoded === void 0) throw new Error("evaluation response must be JSON-serializable");
+	return encoded;
+}
+function sendEncodedJsonIfOpen(response, status, encoded) {
+	if (response.destroyed || response.writableEnded) return;
+	response.writeHead(status, {
+		"content-type": "application/json; charset=utf-8",
+		"content-length": String(Buffer.byteLength(encoded))
+	});
+	response.end(encoded);
+}
+function assertCallbackConfig(args) {
+	if (typeof args.token !== "string" || !args.token.trim()) throw new Error("external optimizer callback: token must be non-empty");
+	if (!Number.isSafeInteger(args.maxEvaluations) || args.maxEvaluations <= 0) throw new Error("external optimizer callback: maxEvaluations must be a positive safe integer");
+	if (args.acceptEvaluation !== void 0 && typeof args.acceptEvaluation !== "function") throw new Error("external optimizer callback: acceptEvaluation must be a function");
+	if (typeof args.evaluate !== "function") throw new Error("external optimizer callback: evaluate must be a function");
+	if (args.observe !== void 0 && typeof args.observe !== "function") throw new Error("external optimizer callback: observe must be a function");
+}
+function cloneCandidate(candidate) {
+	return typeof candidate === "string" ? candidate : { ...candidate };
+}
+//#endregion
 //#region src/campaign/search-ledger-errors.ts
 /** Base error for invalid search-ledger input or operations. */
 var SearchLedgerError = class extends ValidationError {};
@@ -1262,6 +1794,6 @@ function acquireSingleRunLock(opts) {
 	return { release };
 }
 //#endregion
-export { assertNoCredentialValues as C, removeCredentialEnvironment as D, isRecord as E, safePathComponent as O, assertJsonValue as S, isExternalTextCandidate as T, canonicalJson as _, SEARCH_LEDGER_FILE_CONTEXT as a, inMemoryVerdictCache as b, SearchLedgerIntegrityError as c, runWithCleanup as d, startExternalOptimizerModelProxy as f, cachedJudge as g, sendJson as h, inMemoryCampaignStorage as i, runExternalOptimizerProcess as l, listenLocal as m, createRunCostLedger as n, SearchLedgerConflictError as o, closeServer as p, fsCampaignStorage as r, SearchLedgerError as s, acquireSingleRunLock as t, closeExternalOptimizerResources as u, contentHash as v, isCandidateText as w, assertExternalOptimizerModelBudget as x, fileVerdictCache as y };
+export { removeCredentialEnvironment as A, DEFAULT_EXTERNAL_OPTIMIZER_PROCESS_LIMITS as C, isCandidateText as D, assertNoCredentialValues as E, resolveExternalOptimizerProcessLimits as M, safePathComponent as N, isExternalTextCandidate as O, DEFAULT_EXTERNAL_OPTIMIZER_CALLBACK_LIMITS as S, assertJsonValue as T, cachedJudge as _, SEARCH_LEDGER_FILE_CONTEXT as a, fileVerdictCache as b, SearchLedgerIntegrityError as c, closeExternalOptimizerResources as d, runWithCleanup as f, sendJson as g, listenLocal as h, inMemoryCampaignStorage as i, resolveExternalOptimizerCallbackLimits as j, isRecord as k, startExternalOptimizerCallback as l, closeServer as m, createRunCostLedger as n, SearchLedgerConflictError as o, startExternalOptimizerModelProxy as p, fsCampaignStorage as r, SearchLedgerError as s, acquireSingleRunLock as t, runExternalOptimizerProcess as u, canonicalJson as v, assertExternalOptimizerModelBudget as w, inMemoryVerdictCache as x, contentHash as y };
 
-//# sourceMappingURL=single-run-lock-t1si1ob7.js.map
+//# sourceMappingURL=single-run-lock-D5iN0Xzb.js.map