@tangle-network/agent-eval 0.143.0 → 0.144.0

package/dist/{single-run-lock-Do-8vBIJ.js → single-run-lock-t1si1ob7.js}

@@ -2,8 +2,9 @@ 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 { createRequire } from "node:module";
+import { appendFileSync, existsSync, readFileSync } from "node:fs";
 import { isAbsolute, join, resolve } from "node:path";
-import { randomBytes } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import { createServer } from "node:http";
 import { spawn } from "node:child_process";
 import { lstat, mkdtemp, open, rm, writeFile } from "node:fs/promises";
@@ -64,12 +65,14 @@ function assertExternalOptimizerModelBudget(value, label) {
 		["maxResponseBytes", value.maxResponseBytes],
 		["maxOutputTokensPerRequest", value.maxOutputTokensPerRequest]
 	]) if (!Number.isSafeInteger(entry) || entry <= 0) throw new Error(`${label}.${field} must be a positive safe integer`);
-	if (!Number.isFinite(value.maxCostUsd) || value.maxCostUsd <= 0) throw new Error(`${label}.maxCostUsd must be positive and finite`);
+	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}`);
-	costForTokenPricing(value.pricing, {
+	if (value.pricing !== void 0) costForTokenPricing(value.pricing, {
 		inputTokens: 1,
 		outputTokens: 1
 	});
+	if (value.maxCostUsd !== void 0 && value.pricing === void 0) throw new Error(`${label}.pricing is required when maxCostUsd is supplied`);
 }
 function safePathComponent(value) {
 	return value.replace(/[^a-zA-Z0-9._-]/g, "_");
@@ -92,6 +95,160 @@ function isRecord(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 //#endregion
+//#region src/verdict-cache.ts
+/**
+* Content-addressed judge-verdict caching.
+*
+* LAW: cache JUDGE VERDICTS only — judging the same artifact with the same
+* judge+rubric is pure. NEVER cache agent rollouts. (A router that cached
+* identical fanout prompts silently destroyed best-of-N diversity; rollout
+* caching reintroduces that failure class. Judging has no diversity to
+* destroy — same artifact + same rubric ⇒ same verdict is the desired
+* property, not a bug.)
+*
+* The cache key is a sha-256 over the canonical JSON of everything that can
+* change a verdict: the artifact content, the scenario id, the judge name,
+* the full dimension list (key + description — the description IS the rubric
+* text shown to the judge), and a caller-supplied `judgeVersion`.
+* `judgeVersion` is REQUIRED: a judge whose prompt/model/ensemble changes
+* without a version bump would otherwise silently serve stale verdicts.
+*
+* Strict canonicalization (`canonicalJson`) throws on undefined / function /
+* symbol / non-finite numbers — an artifact that cannot be unambiguously
+* serialized cannot be content-addressed, and coercing it would let two
+* different artifacts collide on one key.
+*/
+function canonicalizeAt(value, path) {
+	if (value === null) return "null";
+	switch (typeof value) {
+		case "boolean": return value ? "true" : "false";
+		case "number":
+			if (!Number.isFinite(value)) throw new Error(`canonicalJson: non-finite number (${value}) at ${path} — ambiguity is an error, not a coercion`);
+			return JSON.stringify(value);
+		case "string": return JSON.stringify(value);
+		case "undefined":
+		case "function":
+		case "symbol": throw new Error(`canonicalJson: ${typeof value} at ${path} — ambiguity is an error, not a coercion`);
+		case "bigint": throw new Error(`canonicalJson: bigint at ${path} — not representable in JSON`);
+		case "object": break;
+	}
+	const obj = value;
+	if (typeof obj.toJSON === "function") return canonicalizeAt(obj.toJSON(), path);
+	if (Array.isArray(obj)) return `[${obj.map((item, i) => canonicalizeAt(item, `${path}[${i}]`)).join(",")}]`;
+	if (obj instanceof Map || obj instanceof Set) throw new Error(`canonicalJson: ${obj instanceof Map ? "Map" : "Set"} at ${path} — would serialize as '{}'; convert to a plain object/array first`);
+	return `{${Object.keys(obj).sort().map((k) => `${JSON.stringify(k)}:${canonicalizeAt(obj[k], `${path}.${k}`)}`).join(",")}}`;
+}
+/**
+* Stable JSON stringify: object keys sorted recursively, so two semantically
+* equal values produce byte-identical output regardless of key insertion
+* order. Throws on undefined / function / symbol / NaN / ±Infinity / bigint /
+* Map / Set — anything JSON.stringify would coerce or drop silently.
+*
+* Distinct from `pre-registration.ts`'s `canonicalize`/`hashJson`, which are
+* permissive (coercion allowed) and async (web-crypto). Use THIS pair when a
+* hash collision or silent coercion would corrupt a cache key or attestation.
+*/
+function canonicalJson(value) {
+	return canonicalizeAt(value, "$");
+}
+/** Hex sha-256 over `canonicalJson(value)`. The content address used by the
+*  verdict cache and report attestation. */
+function contentHash(value) {
+	return createHash("sha256").update(canonicalJson(value)).digest("hex");
+}
+/** Process-local Map-backed store. */
+function inMemoryVerdictCache() {
+	const entries = /* @__PURE__ */ new Map();
+	return {
+		get: (key) => entries.get(key),
+		set: (key, score) => {
+			entries.set(key, score);
+		}
+	};
+}
+function parseCacheLine(line, path, lineNo) {
+	let parsed;
+	try {
+		parsed = JSON.parse(line);
+	} catch (err) {
+		throw new Error(`fileVerdictCache: corrupt JSONL at ${path}:${lineNo} — ${err instanceof Error ? err.message : String(err)}`);
+	}
+	const rec = parsed;
+	if (typeof rec !== "object" || rec === null || typeof rec.key !== "string" || typeof rec.score !== "object" || rec.score === null || typeof rec.score.composite !== "number" || typeof rec.score.dimensions !== "object") throw new Error(`fileVerdictCache: invalid record shape at ${path}:${lineNo} — expected {key, score:{dimensions, composite, notes}}`);
+	return rec;
+}
+/**
+* JSONL-file-backed store: the full file is loaded into an in-memory index at
+* construction; every `set` appends one line synchronously (durable before
+* the verdict is returned). A corrupt or malformed line throws at load with
+* file:line — a skipped line would silently re-judge (cost) or, worse, mask
+* a half-written file that needs operator attention.
+*/
+function fileVerdictCache(path) {
+	const entries = /* @__PURE__ */ new Map();
+	if (existsSync(path)) {
+		const lines = readFileSync(path, "utf8").split("\n");
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i];
+			if (line === void 0 || line.trim() === "") continue;
+			const rec = parseCacheLine(line, path, i + 1);
+			entries.set(rec.key, rec.score);
+		}
+	}
+	return {
+		get: (key) => entries.get(key),
+		set: (key, score) => {
+			appendFileSync(path, `${JSON.stringify({
+				key,
+				score
+			})}\n`, "utf8");
+			entries.set(key, score);
+		}
+	};
+}
+/**
+* Wrap a `JudgeConfig` so repeat judgments of the same artifact are served
+* from the store instead of re-invoking `score()`. The wrapper is generic
+* over the judge's own type parameters and preserves `appliesTo` — it is a
+* drop-in replacement anywhere a `JudgeConfig` is accepted.
+*
+* A judge that throws is NOT cached: the error propagates and the next
+* attempt re-judges (caching a failure would pin a transient outage forever).
+*/
+function cachedJudge(judge, store, options) {
+	if (typeof options.judgeVersion !== "string" || options.judgeVersion.trim() === "") throw new Error("cachedJudge: judgeVersion is required and must be a non-empty string");
+	const stats = {
+		hits: 0,
+		misses: 0
+	};
+	const wrapped = {
+		name: judge.name,
+		dimensions: judge.dimensions,
+		judgeVersion: options.judgeVersion,
+		async score(input) {
+			const key = contentHash({
+				artifact: canonicalJson(input.artifact),
+				scenarioId: input.scenario.id,
+				judgeName: judge.name,
+				dimensions: judge.dimensions,
+				judgeVersion: options.judgeVersion
+			});
+			const cached = await store.get(key);
+			if (cached !== void 0) {
+				stats.hits += 1;
+				return cached;
+			}
+			const score = await judge.score(input);
+			await store.set(key, score);
+			stats.misses += 1;
+			return score;
+		},
+		stats: () => ({ ...stats })
+	};
+	if (judge.appliesTo) wrapped.appliesTo = judge.appliesTo;
+	return wrapped;
+}
+//#endregion
 //#region src/campaign/external-optimizer-http.ts
 function listenLocal(server) {
 	return new Promise((resolvePromise, reject) => {
@@ -120,36 +277,23 @@ function sendJson(response, status, body) {
 //#region src/campaign/external-optimizer-model-proxy.ts
 const MODEL_PROXY_PATHS = /* @__PURE__ */ new Set(["/v1/chat/completions", "/v1/responses"]);
 /**
-* Backoff before repeating an upstream fetch the provider answered with 429.
-* One admitted request retries at most this many times, each retry consuming
-* one budgeted request slot, before the final 429 is forwarded to the child.
-* Only HTTP 429 is retried: any other status or a transport error keeps
-* failing immediately.
-*/
-const RATE_LIMIT_RETRY_DELAYS_MS = [
-	2e3,
-	8e3,
-	3e4
-];
-/** Uniform 0..25% added to each delay so concurrent workers do not resynchronize. */
-const RATE_LIMIT_RETRY_JITTER_RATIO = .25;
-/**
 * Put an OpenAI-compatible optimizer behind the shared cost ledger.
 *
-* The child process receives only a loopback URL and an ephemeral token.
-* Provider credentials stay in this process. Every request reserves its
-* conservative byte-count input bound plus the provider-enforced output cap
-* before it leaves the machine.
+* The child process receives only a loopback URL and an ephemeral token. The
+* package that owns execution receives a validated immutable request through
+* `call`; Eval receives no provider credential. Every request reserves its
+* conservative byte-count input bound plus the declared output cap before the
+* owner is invoked exactly once.
 */
 async function startExternalOptimizerModelProxy(args) {
 	assertModelProxyConfig(args);
 	args.signal?.throwIfAborted();
 	const token = randomLocalToken();
-	const fetchImpl = args.fetchImpl ?? fetch;
-	const sleepImpl = args.sleepImpl ?? abortableDelay;
 	let requestCount = 0;
 	let successfulCompletionCount = 0;
-	let rateLimitRetryCount = 0;
+	let modelCallInvocations = 0;
+	let executionRecordCount = 0;
+	let executionSequence = 0;
 	let totalRequestCount = args.initialUsage?.requests ?? 0;
 	let committedForBudget = args.initialUsage?.costUsd ?? 0;
 	let reservedForBudget = 0;
@@ -176,36 +320,42 @@ async function startExternalOptimizerModelProxy(args) {
 			controller,
 			token,
 			args,
-			fetchImpl,
 			nextReservation: (maximumCostUsd) => {
 				if (totalRequestCount >= args.budget.maxRequests) return {
 					accepted: false,
 					reason: "optimizer model request limit reached"
 				};
-				if (committedForBudget + reservedForBudget + maximumCostUsd > args.budget.maxCostUsd + Number.EPSILON) return {
+				if (args.budget.maxCostUsd !== void 0 && maximumCostUsd !== void 0 && committedForBudget + reservedForBudget + maximumCostUsd > args.budget.maxCostUsd + Number.EPSILON) return {
 					accepted: false,
 					reason: "optimizer model cost limit reached"
 				};
 				requestCount += 1;
 				totalRequestCount += 1;
-				reservedForBudget += maximumCostUsd;
+				reservedForBudget += maximumCostUsd ?? 0;
 				return { accepted: true };
 			},
 			settleReservation: (maximumCostUsd, chargedCostUsd) => {
-				reservedForBudget = Math.max(0, reservedForBudget - maximumCostUsd);
-				committedForBudget += chargedCostUsd;
+				reservedForBudget = Math.max(0, reservedForBudget - (maximumCostUsd ?? 0));
+				committedForBudget += chargedCostUsd ?? 0;
 			},
 			recordSuccessfulCompletion: () => {
 				successfulCompletionCount += 1;
 			},
-			tryConsumeRateLimitRetry: () => {
-				if (totalRequestCount >= args.budget.maxRequests) return false;
-				requestCount += 1;
-				totalRequestCount += 1;
-				rateLimitRetryCount += 1;
-				return true;
+			recordExecutionReceipt: (observation) => {
+				try {
+					args.recordExecution({
+						...observation,
+						sequence: executionSequence + 1
+					});
+				} catch (error) {
+					throw new ModelExecutionPersistenceError(`optimizer model execution evidence was not persisted: ${toErrorMessage(error)}`);
+				}
+				executionSequence += 1;
+				executionRecordCount += 1;
 			},
-			sleepImpl
+			recordModelCallInvocation: () => {
+				modelCallInvocations += 1;
+			}
 		}).finally(() => {
 			controller.signal.removeEventListener("abort", abortRequest);
 			activeControllers.delete(controller);
@@ -224,12 +374,15 @@ async function startExternalOptimizerModelProxy(args) {
 	};
 	args.signal?.addEventListener("abort", onAbort, { once: true });
 	if (args.signal?.aborted) onAbort();
+	const assertExecutionComplete = () => {
+		if (executionRecordCount !== modelCallInvocations) throw new Error(`external optimizer model callback returned ${executionRecordCount} execution records for ${modelCallInvocations} invoked calls`);
+	};
 	return {
 		baseUrl: `http://127.0.0.1:${port}/v1`,
 		apiKey: token,
 		requestAttempts: () => requestCount,
 		successfulCompletions: () => successfulCompletionCount,
-		rateLimitRetries: () => rateLimitRetryCount,
+		assertExecutionComplete,
 		close
 	};
 	async function closeModelProxy() {
@@ -240,7 +393,15 @@ async function startExternalOptimizerModelProxy(args) {
 		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 model proxy closed with active request work");
+		let executionError;
+		try {
+			assertExecutionComplete();
+		} catch (error) {
+			executionError = error;
+		}
+		if (serverResult?.status === "rejected" && executionError !== void 0) throw new AggregateError([serverResult.reason, executionError], "external optimizer model proxy close and execution evidence both failed");
 		if (serverResult?.status === "rejected") throw serverResult.reason;
+		if (executionError !== void 0) throw executionError;
 	}
 }
 async function handleModelProxyRequest(args) {
@@ -258,7 +419,7 @@ async function handleModelProxyRequest(args) {
 		const body = await readBody(request, args.args.budget.maxRequestBytes);
 		const parsed = parseModelProxyRequest(body, args.args.model, args.args.budget);
 		const maximumUsage = conservativeMaximumUsage(body.byteLength, parsed.maxOutputTokens + (args.args.budget.maxReasoningTokensPerRequest ?? 0), args.args.budget.pricing);
-		const maximumCostUsd = costForTokenPricing(args.args.budget.pricing, maximumUsage);
+		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 });
@@ -273,30 +434,23 @@ async function handleModelProxyRequest(args) {
 				actor: args.args.actor,
 				...args.args.tags ? { tags: args.args.tags } : {},
 				model: args.args.model,
-				maximumCharge: {
+				...args.args.budget.pricing ? { maximumCharge: {
 					customTokenPricing: args.args.budget.pricing,
 					...maximumUsage
-				},
-				execute: async () => {
-					for (let retries = 0;; retries += 1) {
-						const forwarded = await forwardModelProxyRequest({
-							fetchImpl: args.fetchImpl,
-							upstreamBaseUrl: args.args.upstreamBaseUrl,
-							upstreamApiKey: args.args.upstreamApiKey,
-							path,
-							body,
-							model: args.args.model,
-							pricing: args.args.budget.pricing,
-							maxOutputTokens: parsed.maxOutputTokens,
-							...args.args.budget.maxReasoningTokensPerRequest === void 0 ? {} : { maxReasoningTokens: args.args.budget.maxReasoningTokensPerRequest },
-							maxResponseBytes: args.args.budget.maxResponseBytes,
-							signal: controller.signal
-						});
-						if (forwarded.status !== 429 || retries >= RATE_LIMIT_RETRY_DELAYS_MS.length || !args.tryConsumeRateLimitRetry()) return forwarded;
-						const baseDelayMs = RATE_LIMIT_RETRY_DELAYS_MS[retries];
-						await args.sleepImpl(Math.round(baseDelayMs * (1 + Math.random() * RATE_LIMIT_RETRY_JITTER_RATIO)), controller.signal);
-					}
-				},
+				} } : {},
+				execute: async () => forwardModelProxyRequest({
+					call: args.args.call,
+					callRef: args.args.callRef,
+					recordExecutionReceipt: args.recordExecutionReceipt,
+					recordModelCallInvocation: args.recordModelCallInvocation,
+					path,
+					requestBody: parsed.body,
+					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
+				}),
 				receipt: (result) => result.receipt,
 				receiptFromError: () => ({
 					model: args.args.model,
@@ -307,8 +461,12 @@ async function handleModelProxyRequest(args) {
 				})
 			});
 			if (!paid.succeeded) {
-				chargedForBudget = paid.receipt ? paid.receipt.usageUnknown || paid.receipt.costUnknown ? maximumCostUsd : paid.receipt.costUsd : 0;
-				sendJsonIfOpen(response, isAbortError(paid.error) ? 504 : paid.error instanceof ProviderResponseTooLargeError ? 502 : 429, { error: paid.error.message });
+				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 });
+				return;
+			}
+			if (paid.value.modelCallFailed) {
+				sendJsonIfOpen(response, 502, { error: paid.value.modelCallFailed });
 				return;
 			}
 			chargedForBudget = paid.value.usageComplete ? paid.receipt.costUsd : maximumCostUsd;
@@ -339,43 +497,105 @@ function sendJsonIfOpen(response, status, body) {
 	sendJson(response, status, body);
 }
 async function forwardModelProxyRequest(args) {
-	const upstream = modelProxyUpstreamUrl(args.upstreamBaseUrl, args.path);
-	const response = await args.fetchImpl(upstream, {
-		method: "POST",
-		headers: {
-			authorization: `Bearer ${args.upstreamApiKey}`,
-			"content-type": "application/json"
-		},
-		body: args.body.buffer.slice(args.body.byteOffset, args.body.byteOffset + args.body.byteLength),
-		signal: args.signal,
-		redirect: "error"
-	});
+	args.recordModelCallInvocation();
+	let called;
+	try {
+		called = await args.call({
+			path: args.path,
+			model: args.model,
+			body: freezeJsonSnapshot(args.requestBody, "optimizer model call body"),
+			signal: args.signal
+		});
+	} catch (error) {
+		throw new MissingModelExecutionError(`optimizer model callback rejected without execution evidence: ${toErrorMessage(error)}`);
+	}
+	if (!called || typeof called !== "object" || typeof called.succeeded !== "boolean") throw new MissingModelExecutionError("optimizer model callback returned no typed success/failure outcome");
+	let execution;
+	try {
+		execution = freezeJsonSnapshot(called.execution, "optimizer model callback execution evidence");
+	} catch (error) {
+		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");
+		args.recordExecutionReceipt({
+			callRef: args.callRef,
+			path: args.path,
+			model: args.model,
+			succeeded: true,
+			responseStatus: called.response.status,
+			execution
+		});
+	} else {
+		if (typeof called.error !== "string" || !called.error.trim()) throw new MissingModelExecutionError("optimizer model callback failure did not return a public error");
+		args.recordExecutionReceipt({
+			callRef: args.callRef,
+			path: args.path,
+			model: args.model,
+			succeeded: false,
+			error: called.error,
+			execution
+		});
+		const failedReceipt = snapshotModelReceipt(called.receipt, args.model);
+		return {
+			status: 502,
+			contentType: "application/json",
+			body: new TextEncoder().encode(JSON.stringify({ error: called.error })),
+			receipt: failedReceipt,
+			usageComplete: failedReceipt.usageUnknown !== true,
+			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 zeroUsage = successful && usage !== void 0 && usage.inputTokens + usage.outputTokens + (usage.cachedTokens ?? 0) + (usage.cacheWriteTokens ?? 0) === 0;
 	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: usage && !zeroUsage ? {
-			model: args.model,
-			...usage,
-			...usage.actualCostUsd === void 0 ? { customTokenPricing: args.pricing } : {}
-		} : {
-			model: args.model,
-			inputTokens: 0,
-			outputTokens: 0,
-			costUnknown: true,
-			usageUnknown: true
-		},
-		usageComplete: usage !== void 0 && !zeroUsage,
+		receipt: authoritativeReceipt,
+		usageComplete: authoritativeReceipt.usageUnknown !== true,
 		...usageRejected ? { usageRejected } : {}
 	};
 }
+function snapshotModelReceipt(value, expectedModel) {
+	let snapshot;
+	try {
+		assertJsonValue(value, "optimizer model callback receipt");
+		snapshot = JSON.parse(canonicalJson(value));
+	} catch (error) {
+		throw new OwnerModelContractError(`optimizer model callback returned an invalid receipt: ${toErrorMessage(error)}`);
+	}
+	if (snapshot.model !== expectedModel) throw new OwnerModelContractError(`optimizer model callback receipt used '${snapshot.model}' instead of '${expectedModel}'`);
+	return snapshot;
+}
+function freezeJsonSnapshot(value, label) {
+	assertJsonValue(value, label);
+	return deepFreezeJson(JSON.parse(canonicalJson(value)));
+}
+function deepFreezeJson(value) {
+	if (value !== null && typeof value === "object") {
+		for (const child of Object.values(value)) deepFreezeJson(child);
+		Object.freeze(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) {
 	let value;
 	try {
@@ -400,24 +620,10 @@ function parseModelProxyRequest(body, expectedModel, budget) {
 	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 (maxOutputTokens > budget.maxOutputTokensPerRequest) throw new Error("optimizer model request exceeds maxOutputTokensPerRequest");
-	return { maxOutputTokens };
-}
-/**
-* Resolve the upstream URL the way an OpenAI-compatible client does.
-*
-* This proxy exposes `/v1/...` to its child for client compatibility. Whether
-* that prefix belongs upstream depends on the caller's base URL: a base that
-* already names a version segment (`/v1`, `/api/coding/paas/v4`) receives only
-* the endpoint, and a base without one receives the whole versioned path.
-* Forwarding the prefix unconditionally produced `/v4/v1/chat/completions`,
-* which providers answer with 404.
-*/
-function modelProxyUpstreamUrl(baseUrl, requestPath) {
-	const upstream = new URL(baseUrl);
-	const basePath = upstream.pathname.replace(/\/+$/, "");
-	const lastSegment = basePath.split("/").at(-1) ?? "";
-	upstream.pathname = `${basePath}${/^v\d+/.test(lastSegment) ? requestPath.replace(/^\/v1(?=\/)/, "") : requestPath}`;
-	return upstream.toString();
+	return {
+		maxOutputTokens,
+		body: value
+	};
 }
 function parseProviderUsage(body) {
 	let value;
@@ -433,30 +639,59 @@ function parseProviderUsage(body) {
 	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 cachedTokens = optionalTokenCount(inputDetails, [
-		"cached_tokens",
-		"cache_read_tokens",
-		"cache_read_input_tokens"
-	]);
-	const cacheWriteTokens = optionalTokenCount(inputDetails, [
-		"cache_write_tokens",
-		"cache_creation_tokens",
-		"cache_creation_input_tokens"
-	]);
-	const reasoningTokens = optionalTokenCount(outputDetails, ["reasoning_tokens"]);
+	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 (cachedTokens === INVALID_TOKEN_COUNT || cacheWriteTokens === INVALID_TOKEN_COUNT || reasoningTokens === INVALID_TOKEN_COUNT) return;
-	const classifiedInputTokens = (cachedTokens ?? 0) + (cacheWriteTokens ?? 0);
-	if (classifiedInputTokens > totalInputTokens || (reasoningTokens ?? 0) > outputTokens) return;
+	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;
 	return {
 		inputTokens: totalInputTokens - classifiedInputTokens,
 		outputTokens,
-		...cachedTokens === void 0 ? {} : { cachedTokens },
-		...cacheWriteTokens === void 0 ? {} : { cacheWriteTokens },
-		...reasoningTokens === void 0 ? {} : { reasoningTokens },
+		...cached.supplied ? { cachedTokens: cached.count } : {},
+		...cacheWrite.supplied ? { cacheWriteTokens: cacheWrite.count } : {},
+		...reasoning.supplied ? { reasoningTokens: reasoning.count } : {},
 		...actualCostUsd === void 0 ? {} : { actualCostUsd }
 	};
 }
+/**
+* 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
+	};
+	if (separate !== void 0 && separate > 0) return {
+		count: separate,
+		supplied: true,
+		includedInTotal: false
+	};
+	return {
+		count: 0,
+		supplied: nested !== void 0 || separate !== void 0,
+		includedInTotal: nested !== void 0
+	};
+}
 const INVALID_TOKEN_COUNT = Symbol("invalid-token-count");
 function optionalTokenCount(details, fields) {
 	let found;
@@ -470,6 +705,10 @@ function optionalTokenCount(details, fields) {
 	return found;
 }
 function conservativeMaximumUsage(inputTokenUpperBound, outputTokenUpperBound, pricing) {
+	if (pricing === void 0) return {
+		inputTokens: inputTokenUpperBound,
+		outputTokens: outputTokenUpperBound
+	};
 	const inputRates = [
 		pricing.inputUsdPerMillion,
 		pricing.cachedInputUsdPerMillion ?? pricing.inputUsdPerMillion,
@@ -517,26 +756,20 @@ async function readProviderResponseBody(response, maxBytes) {
 }
 function assertModelProxyConfig(args) {
 	for (const [label, value] of [
-		["upstreamBaseUrl", args.upstreamBaseUrl],
-		["upstreamApiKey", args.upstreamApiKey],
 		["model", args.model],
 		["phase", args.phase],
 		["actor", args.actor]
 	]) if (typeof value !== "string" || !value.trim() || value.trim() !== value) throw new Error(`external optimizer model proxy: ${label} must be trimmed and non-empty`);
-	let parsed;
-	try {
-		parsed = new URL(args.upstreamBaseUrl);
-	} catch {
-		throw new Error("external optimizer model proxy: upstreamBaseUrl must be an HTTP(S) URL");
-	}
-	if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || parsed.username || parsed.password || parsed.search || parsed.hash) throw new Error("external optimizer model proxy: upstreamBaseUrl must be an HTTP(S) URL without credentials, query, or fragment");
+	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");
 	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");
 	}
 	if (args.initialUsage !== void 0) {
-		if (!Number.isSafeInteger(args.initialUsage.requests) || args.initialUsage.requests < 0 || !Number.isFinite(args.initialUsage.costUsd) || args.initialUsage.costUsd < 0) throw new Error("external optimizer model proxy: initialUsage must contain non-negative requests and cost");
-		if (args.initialUsage.requests > args.budget.maxRequests || args.initialUsage.costUsd > args.budget.maxCostUsd + Number.EPSILON) throw new Error("external optimizer model proxy: initialUsage exceeds the configured budget");
+		if (!Number.isSafeInteger(args.initialUsage.requests) || args.initialUsage.requests < 0 || args.initialUsage.costUsd !== void 0 && (!Number.isFinite(args.initialUsage.costUsd) || args.initialUsage.costUsd < 0)) throw new Error("external optimizer model proxy: initialUsage must contain non-negative requests and cost");
+		if (args.initialUsage.requests > args.budget.maxRequests || args.budget.maxCostUsd !== void 0 && args.initialUsage.costUsd !== void 0 && args.initialUsage.costUsd > args.budget.maxCostUsd + Number.EPSILON) throw new Error("external optimizer model proxy: initialUsage exceeds the configured budget");
 	}
 }
 var RequestBodyTooLargeError = class extends Error {};
@@ -545,6 +778,9 @@ var ProviderResponseTooLargeError = class extends Error {
 		super("optimizer model response exceeds maxResponseBytes");
 	}
 };
+var MissingModelExecutionError = class extends Error {};
+var ModelExecutionPersistenceError = class extends Error {};
+var OwnerModelContractError = class extends Error {};
 function readBody(request, maximumBytes) {
 	return new Promise((resolvePromise, reject) => {
 		let size = 0;
@@ -573,24 +809,6 @@ function readBody(request, maximumBytes) {
 function randomLocalToken() {
 	return randomBytes(32).toString("hex");
 }
-function abortableDelay(ms, signal) {
-	return new Promise((resolve, reject) => {
-		const abortError = () => signal.reason instanceof Error ? signal.reason : /* @__PURE__ */ new Error("optimizer model retry backoff aborted");
-		if (signal.aborted) {
-			reject(abortError());
-			return;
-		}
-		const onAbort = () => {
-			clearTimeout(timer);
-			reject(abortError());
-		};
-		const timer = setTimeout(() => {
-			signal.removeEventListener("abort", onAbort);
-			resolve();
-		}, ms);
-		signal.addEventListener("abort", onAbort, { once: true });
-	});
-}
 function isAbortError(error) {
 	return error.name === "AbortError" || error.message.toLowerCase().includes("abort");
 }
@@ -1044,6 +1262,6 @@ function acquireSingleRunLock(opts) {
 	return { release };
 }
 //#endregion
-export { safePathComponent as C, removeCredentialEnvironment as S, assertJsonValue as _, SEARCH_LEDGER_FILE_CONTEXT as a, isExternalTextCandidate as b, SearchLedgerIntegrityError as c, runWithCleanup as d, startExternalOptimizerModelProxy as f, assertExternalOptimizerModelBudget 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, assertNoCredentialValues as v, isRecord as x, isCandidateText as y };
+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 };
 
-//# sourceMappingURL=single-run-lock-Do-8vBIJ.js.map
+//# sourceMappingURL=single-run-lock-t1si1ob7.js.map