@ls-stack/agent-eval 0.37.0 → 0.39.0

package/dist/{runOrchestration-C4o5TcIu.mjs → runOrchestration-BhUFWvq9.mjs}

@@ -1,14 +1,14 @@
 import { createRequire, registerHooks } from "node:module";
 import { createHash, randomUUID } from "node:crypto";
 import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
-import { extname, isAbsolute, join, relative, resolve } from "node:path";
+import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { formatWithOptions, isDeepStrictEqual, stripVTControlCharacters } from "node:util";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { z, z as z$1 } from "zod/v4";
 import { Blob as Blob$1, Buffer as Buffer$1, File as File$1 } from "node:buffer";
-import { gunzipSync, gzipSync } from "node:zlib";
 import { getCompositeKey } from "@ls-stack/utils/getCompositeKey";
 import { existsSync } from "node:fs";
+import { brotliCompressSync, brotliDecompressSync } from "node:zlib";
 import { Result, resultify } from "t-result";
 import { fileURLToPath, pathToFileURL } from "node:url";
 //#region ../sdk/src/defineEval.ts
@@ -867,33 +867,52 @@ function repoFile(path, mimeType) {
 //#endregion
 //#region ../sdk/src/cacheSerialization.ts
 const serializedCacheValueMarker = "__aecs";
-const legacySerializedCacheValueMarker = "__agentEvalsCacheSerialization";
-const jsonSafeCacheValueVersion = "json-safe-v1";
+const jsonSafeCacheValueVersion = "v1";
 const packedNumberArrayMinLength = 128;
-const compressedStringMinBytes = 16 * 1024;
-const compressedJsonMinBytes = 64 * 1024;
-const maxCompressedSizeRatio = .8;
+const maxPackedNumberArraySizeRatio = .8;
+const externalJsonMinChars = 10 * 1024;
+const jsonSafeCacheValueTypes = new Set("ArrayBuffer BigInt Blob Date Error ExternalJson File Float64Array Headers Map Number Object RegExp Set URL URLSearchParams Undefined".split(" "));
 function isRecordLike$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isJsonSafeSerializedCacheValue(value) {
-	return isRecordLike$3(value) && serializationMarkerValue(value) === jsonSafeCacheValueVersion && typeof value.type === "string";
+	return isRecordLike$3(value) && jsonSafeValueType(value) !== void 0;
 }
 function jsonSafeValue(type, value) {
-	return value === void 0 ? {
-		[serializedCacheValueMarker]: jsonSafeCacheValueVersion,
-		type
-	} : {
-		[serializedCacheValueMarker]: jsonSafeCacheValueVersion,
-		type,
+	return value === void 0 ? { [serializedCacheValueMarker]: jsonSafeMarker(type) } : {
+		[serializedCacheValueMarker]: jsonSafeMarker(type),
 		value
 	};
 }
 function hasSerializationMarkerKey(value) {
-	return Object.hasOwn(value, serializedCacheValueMarker) || Object.hasOwn(value, legacySerializedCacheValueMarker);
+	return Object.hasOwn(value, serializedCacheValueMarker);
+}
+function jsonSafeMarker(type) {
+	return `${jsonSafeCacheValueVersion}:${type}`;
+}
+function jsonSafeValueType(value) {
+	const marker = value[serializedCacheValueMarker];
+	if (typeof marker !== "string") return void 0;
+	if (!marker.startsWith(`${jsonSafeCacheValueVersion}:`)) return void 0;
+	const type = marker.slice(3);
+	return isJsonSafeCacheValueType(type) ? type : void 0;
+}
+function isJsonSafeCacheValueType(value) {
+	return jsonSafeCacheValueTypes.has(value);
+}
+function externalJsonRefFromWrapper(value) {
+	const hash = typeof value.hash === "string" ? toExternalJsonHash(value.hash) : void 0;
+	if (hash === void 0 || typeof value.length !== "number" || typeof value.compressedLength !== "number" || typeof value.path !== "string") return;
+	return {
+		compressedLength: value.compressedLength,
+		hash,
+		length: value.length,
+		path: value.path
+	};
 }
-function serializationMarkerValue(value) {
-	return value[serializedCacheValueMarker] ?? value[legacySerializedCacheValueMarker];
+function toExternalJsonHash(value) {
+	if (!value.startsWith("sha256:")) return void 0;
+	return `sha256:${value.slice(7)}`;
 }
 /**
 * Serialize one cached value while keeping plain JSON as plain JSON.
@@ -902,50 +921,57 @@ function serializationMarkerValue(value) {
 * by default; pass `preserveUndefined: true` to round-trip them explicitly.
 */
 async function serializeCacheValue(value, options = void 0) {
-	return serializeJsonSafeValue(value, /* @__PURE__ */ new WeakSet(), 0, normalizeCacheSerializationOptions(options));
-}
-/** Revive one cached value, while preserving legacy JSON-round-tripped data. */
-function deserializeCacheValue(value) {
-	return deserializeJsonSafeValue(value);
+	return (await serializeJsonSafeValue(value, /* @__PURE__ */ new WeakSet(), 0, normalizeCacheSerializationOptions(options))).value;
 }
-/** Clone one value through the same serialization path used for cache data. */
-async function cloneCacheValue(value, options = void 0) {
-	return deserializeCacheValue(await serializeCacheValue(value, options));
-}
-function normalizeCacheSerializationOptions(options) {
+function serializedResult(value, jsonLength = jsonLengthOfSerializedValue(value)) {
 	return {
-		compress: options?.compress !== false,
-		preserveUndefined: options?.preserveUndefined === true
+		value,
+		jsonLength
 	};
 }
+function jsonLengthOfSerializedValue(value) {
+	if (value === void 0) return 0;
+	if (value === null) return 4;
+	if (typeof value === "string") return approximateJsonStringLength(value);
+	return JSON.stringify(value).length;
+}
+function approximateJsonStringLength(value) {
+	return value.length + 2;
+}
+function jsonArrayLength(itemLengths) {
+	return 2 + itemLengths.reduce((total, itemLength) => total + itemLength, 0) + Math.max(itemLengths.length - 1, 0);
+}
+function jsonObjectLength(entries) {
+	return 2 + entries.reduce((total, [key, valueLength]) => total + approximateJsonStringLength(key) + 1 + valueLength, 0) + Math.max(entries.length - 1, 0);
+}
 async function serializeJsonSafeValue(value, refs, depth, config) {
-	if (value === void 0) return config.preserveUndefined ? jsonSafeValue("Undefined") : void 0;
-	if (typeof value === "bigint") return jsonSafeValue("BigInt", value.toString());
-	if (typeof value === "number") return serializeNumber(value);
-	if (typeof value === "string") return serializeString(value, depth, config);
-	if (value instanceof Date) return jsonSafeValue("Date", value.toISOString());
+	if (value === void 0) return config.preserveUndefined ? serializedResult(jsonSafeValue("Undefined")) : serializedResult(void 0);
+	if (typeof value === "bigint") return serializedResult(jsonSafeValue("BigInt", value.toString()));
+	if (typeof value === "number") return serializedResult(serializeNumber(value));
+	if (typeof value === "string") return await externalizeNestedJsonValue(serializedResult(value, approximateJsonStringLength(value)), depth, config);
+	if (value instanceof Date) return serializedResult(jsonSafeValue("Date", value.toISOString()));
 	if (value instanceof Map) return serializeMap(value, refs, depth, config);
 	if (value instanceof Set) return serializeSet(value, refs, depth, config);
-	if (value instanceof RegExp) return jsonSafeValue("RegExp", {
+	if (value instanceof RegExp) return serializedResult(jsonSafeValue("RegExp", {
 		flags: value.flags,
 		source: value.source
-	});
-	if (value instanceof URL) return jsonSafeValue("URL", value.toString());
-	if (value instanceof URLSearchParams) return jsonSafeValue("URLSearchParams", value.toString());
-	if (value instanceof Headers) return jsonSafeValue("Headers", [...value.entries()]);
-	if (value instanceof File) return jsonSafeValue("File", {
+	}));
+	if (value instanceof URL) return serializedResult(jsonSafeValue("URL", value.toString()));
+	if (value instanceof URLSearchParams) return serializedResult(jsonSafeValue("URLSearchParams", value.toString()));
+	if (value instanceof Headers) return serializedResult(jsonSafeValue("Headers", [...value.entries()]));
+	if (value instanceof File) return serializedResult(jsonSafeValue("File", {
 		bytes: await blobToBase64(value),
 		lastModified: value.lastModified,
 		name: value.name,
 		type: value.type
-	});
-	if (value instanceof Blob) return jsonSafeValue("Blob", {
+	}));
+	if (value instanceof Blob) return serializedResult(jsonSafeValue("Blob", {
 		bytes: await blobToBase64(value),
 		type: value.type
-	});
-	if (value instanceof ArrayBuffer) return jsonSafeValue("ArrayBuffer", bytesToBase64(new Uint8Array(value)));
+	}));
+	if (value instanceof ArrayBuffer) return serializedResult(jsonSafeValue("ArrayBuffer", bytesToBase64(new Uint8Array(value))));
 	if (value instanceof Error) return serializeError(value, refs, depth, config);
-	if (!value || typeof value !== "object") return value;
+	if (!value || typeof value !== "object") return serializedResult(value);
 	if (refs.has(value)) throw new Error("Circular cache values are not supported");
 	refs.add(value);
 	if (Array.isArray(value)) {
@@ -953,25 +979,59 @@ async function serializeJsonSafeValue(value, refs, depth, config) {
 			const packed = packNumberArray(value);
 			if (packed !== void 0) {
 				refs.delete(value);
-				return packed;
+				return serializedResult(packed);
 			}
 		}
 		const items = [];
+		const itemLengths = [];
 		for (const item of value) {
 			const serializedItem = await serializeJsonSafeValue(item, refs, depth + 1, config);
-			if (serializedItem !== void 0) items.push(serializedItem);
+			if (serializedItem.value !== void 0) {
+				items.push(serializedItem.value);
+				itemLengths.push(serializedItem.jsonLength);
+			}
 		}
 		refs.delete(value);
-		return compressNestedJsonValue(items, depth, config) ?? items;
+		return await externalizeNestedJsonValue(serializedResult(items, jsonArrayLength(itemLengths)), depth, config);
 	}
 	const entries = [];
+	const entryLengths = [];
 	for (const [key, entryValue] of Object.entries(value)) {
 		const serializedEntryValue = await serializeJsonSafeValue(entryValue, refs, depth + 1, config);
-		if (serializedEntryValue !== void 0) entries.push([key, serializedEntryValue]);
+		if (serializedEntryValue.value !== void 0) {
+			entries.push([key, serializedEntryValue.value]);
+			entryLengths.push([key, serializedEntryValue.jsonLength]);
+		}
 	}
 	refs.delete(value);
-	const serialized = hasSerializationMarkerKey(value) ? jsonSafeValue("Object", entries) : Object.fromEntries(entries);
-	return compressNestedJsonValue(serialized, depth, config) ?? serialized;
+	if (hasSerializationMarkerKey(value)) return await externalizeNestedJsonValue(serializedResult(jsonSafeValue("Object", entries)), depth, config);
+	return await externalizeNestedJsonValue(serializedResult(Object.fromEntries(entries), jsonObjectLength(entryLengths)), depth, config);
+}
+/** Revive one cached value, while preserving legacy JSON-round-tripped data. */
+function deserializeCacheValue(value) {
+	return deserializeJsonSafeValue(value);
+}
+/** Replace external JSON blob refs with their parsed serialized payloads. */
+async function materializeExternalJsonValues(value, store) {
+	if (isJsonSafeSerializedCacheValue(value) && jsonSafeValueType(value) === "ExternalJson") {
+		const ref = externalJsonRefFromWrapper(value);
+		if (ref === void 0) return value;
+		return materializeExternalJsonValues(JSON.parse(await store.read(ref)), store);
+	}
+	if (Array.isArray(value)) return Promise.all(value.map((item) => materializeExternalJsonValues(item, store)));
+	if (!isRecordLike$3(value)) return value;
+	return Object.fromEntries(await Promise.all(Object.entries(value).map(async ([key, entryValue]) => [key, await materializeExternalJsonValues(entryValue, store)])));
+}
+/** Clone one value through the same serialization path used for cache data. */
+async function cloneCacheValue(value, options = void 0) {
+	return deserializeCacheValue(await serializeCacheValue(value, options));
+}
+function normalizeCacheSerializationOptions(options) {
+	return {
+		compress: options?.compress !== false,
+		externalJsonStore: options?.externalJsonStore,
+		preserveUndefined: options?.preserveUndefined === true
+	};
 }
 function serializeNumber(value) {
 	if (Number.isNaN(value)) return jsonSafeValue("Number", "NaN");
@@ -980,11 +1040,6 @@ function serializeNumber(value) {
 	if (Object.is(value, -0)) return jsonSafeValue("Number", "-0");
 	return value;
 }
-function serializeString(value, depth, config) {
-	if (depth === 0) return value;
-	if (!config.compress) return value;
-	return compressNestedStringValue(value) ?? value;
-}
 function isDenseNumberArray(value) {
 	for (let index = 0; index < value.length; index++) if (typeof value[index] !== "number") return false;
 	return true;
@@ -997,48 +1052,32 @@ function encodeFloat64Array(value) {
 }
 function packNumberArray(value) {
 	const serialized = {
-		[serializedCacheValueMarker]: jsonSafeCacheValueVersion,
+		[serializedCacheValueMarker]: jsonSafeMarker("Float64Array"),
 		length: value.length,
-		type: "Float64Array",
 		value: encodeFloat64Array(value)
 	};
-	return compressionIsWorthIt(serialized, Buffer$1.byteLength(JSON.stringify(value))) ? serialized : void 0;
+	return JSON.stringify(serialized).length < JSON.stringify(value).length * maxPackedNumberArraySizeRatio ? serialized : void 0;
 }
 function decodeFloat64Array(value, length) {
 	const bytes = base64ToArrayBuffer(value);
 	const view = new DataView(bytes);
 	return Array.from({ length }, (_, index) => view.getFloat64(index * 8, true));
 }
-function compressNestedStringValue(value) {
-	const rawSize = Buffer$1.byteLength(JSON.stringify(value));
-	if (rawSize < compressedStringMinBytes) return void 0;
-	const compressed = gzipSync(value);
-	const serialized = {
-		[serializedCacheValueMarker]: jsonSafeCacheValueVersion,
-		codec: "gzip",
-		length: Buffer$1.byteLength(value),
-		type: "CompressedString",
-		value: compressed.toString("base64")
-	};
-	return compressionIsWorthIt(serialized, rawSize) ? serialized : void 0;
-}
-function compressNestedJsonValue(value, depth, config) {
-	if (depth === 0) return void 0;
-	if (!config.compress) return void 0;
-	const raw = JSON.stringify(value);
-	const rawSize = Buffer$1.byteLength(raw);
-	if (rawSize < compressedJsonMinBytes) return void 0;
-	const serialized = {
-		[serializedCacheValueMarker]: jsonSafeCacheValueVersion,
-		codec: "gzip",
-		length: rawSize,
-		type: "CompressedJson",
-		value: gzipSync(raw).toString("base64")
+async function externalizeNestedJsonValue(result, depth, config) {
+	if (depth === 0 || !config.compress || config.externalJsonStore === void 0 || result.jsonLength < externalJsonMinChars) return result;
+	const raw = JSON.stringify(result.value);
+	if (raw.length < externalJsonMinChars) return {
+		...result,
+		jsonLength: raw.length
 	};
-	return compressionIsWorthIt(serialized, rawSize) ? serialized : void 0;
-}
-function compressionIsWorthIt(value, rawSize) {
-	return Buffer$1.byteLength(JSON.stringify(value)) < rawSize * maxCompressedSizeRatio;
+	const ref = await config.externalJsonStore.write(raw);
+	return serializedResult({
+		[serializedCacheValueMarker]: jsonSafeMarker("ExternalJson"),
+		compressedLength: ref.compressedLength,
+		hash: ref.hash,
+		length: ref.length,
+		path: ref.path
+	});
 }
 async function serializeMap(value, refs, depth, config) {
 	if (refs.has(value)) throw new Error("Circular cache values are not supported");
@@ -1047,10 +1086,10 @@ async function serializeMap(value, refs, depth, config) {
 	for (const [key, entryValue] of value.entries()) {
 		const serializedKey = await serializeJsonSafeValue(key, refs, depth + 1, config);
 		const serializedEntryValue = await serializeJsonSafeValue(entryValue, refs, depth + 1, config);
-		if (serializedKey !== void 0 && serializedEntryValue !== void 0) entries.push([serializedKey, serializedEntryValue]);
+		if (serializedKey.value !== void 0 && serializedEntryValue.value !== void 0) entries.push([serializedKey.value, serializedEntryValue.value]);
 	}
 	refs.delete(value);
-	return jsonSafeValue("Map", entries);
+	return serializedResult(jsonSafeValue("Map", entries));
 }
 async function serializeSet(value, refs, depth, config) {
 	if (refs.has(value)) throw new Error("Circular cache values are not supported");
@@ -1058,10 +1097,10 @@ async function serializeSet(value, refs, depth, config) {
 	const items = [];
 	for (const item of value.values()) {
 		const serializedItem = await serializeJsonSafeValue(item, refs, depth + 1, config);
-		if (serializedItem !== void 0) items.push(serializedItem);
+		if (serializedItem.value !== void 0) items.push(serializedItem.value);
 	}
 	refs.delete(value);
-	return jsonSafeValue("Set", items);
+	return serializedResult(jsonSafeValue("Set", items));
 }
 async function serializeError(value, refs, depth, config) {
 	if (refs.has(value)) throw new Error("Circular cache values are not supported");
@@ -1070,17 +1109,17 @@ async function serializeError(value, refs, depth, config) {
 	for (const [key, entryValue] of Object.entries(value)) {
 		if (key === "cause") continue;
 		const serializedEntryValue = await serializeJsonSafeValue(entryValue, refs, depth + 1, config);
-		if (serializedEntryValue !== void 0) props.push([key, serializedEntryValue]);
+		if (serializedEntryValue.value !== void 0) props.push([key, serializedEntryValue.value]);
 	}
 	const serialized = jsonSafeValue("Error", {
-		cause: "cause" in value ? await serializeJsonSafeValue(value.cause, refs, depth + 1, config) : void 0,
+		cause: "cause" in value ? (await serializeJsonSafeValue(value.cause, refs, depth + 1, config)).value : void 0,
 		message: value.message,
 		name: value.name,
 		props,
 		stack: value.stack
 	});
 	refs.delete(value);
-	return serialized;
+	return serializedResult(serialized);
 }
 async function blobToBase64(value) {
 	return bytesToBase64(new Uint8Array(await value.arrayBuffer()));
@@ -1101,14 +1140,13 @@ function deserializeJsonSafeValue(value) {
 	return Object.fromEntries(Object.entries(value).map(([key, entryValue]) => [key, deserializeJsonSafeValue(entryValue)]));
 }
 function deserializeJsonSafeWrapper(value) {
-	switch (value.type) {
+	switch (jsonSafeValueType(value)) {
 		case "ArrayBuffer": return deserializeArrayBuffer(value.value);
 		case "BigInt": return typeof value.value === "string" ? BigInt(value.value) : value.value;
 		case "Blob": return deserializeBlob(value.value);
-		case "CompressedJson": return deserializeCompressedJson(value.value);
-		case "CompressedString": return deserializeCompressedString(value.value);
 		case "Date": return typeof value.value === "string" ? new Date(value.value) : value.value;
 		case "Error": return deserializeError(value.value);
+		case "ExternalJson": return value;
 		case "File": return deserializeFile(value.value);
 		case "Float64Array": return deserializeFloat64Array(value.value, value.length);
 		case "Headers": return new Headers(deserializeStringPairArray(value.value));
@@ -1120,6 +1158,7 @@ function deserializeJsonSafeWrapper(value) {
 		case "URL": return typeof value.value === "string" ? new URL(value.value) : value.value;
 		case "URLSearchParams": return typeof value.value === "string" ? new URLSearchParams(value.value) : value.value;
 		case "Undefined": return;
+		default: return value;
 	}
 }
 function deserializeNumber(value) {
@@ -1129,14 +1168,6 @@ function deserializeNumber(value) {
 	if (value === "-0") return -0;
 	return value;
 }
-function deserializeCompressedString(value) {
-	if (typeof value !== "string") return value;
-	return gunzipSync(Buffer$1.from(value, "base64")).toString("utf8");
-}
-function deserializeCompressedJson(value) {
-	if (typeof value !== "string") return value;
-	return deserializeJsonSafeValue(JSON.parse(gunzipSync(Buffer$1.from(value, "base64")).toString("utf8")));
-}
 function deserializeFloat64Array(value, length) {
 	if (typeof value !== "string" || typeof length !== "number") return value;
 	return decodeFloat64Array(value, length);
@@ -1766,7 +1797,7 @@ function createTraceCache(generateSpanId) {
 				operationType: "value",
 				operationName: info.name,
 				storedAt: new Date(getRealDateNowMs()).toISOString(),
-				recording: await serializeCacheRecording(recording)
+				recording: await serializeCacheRecording(recording, { externalJsonStore: cacheCtx.adapter.externalJsonStore })
 			}, {
 				rawKey: info.key,
 				operationType: "value",
@@ -2209,7 +2240,7 @@ async function traceSpanInternal(info, fn) {
 					spanName: info.name,
 					spanKind: info.kind,
 					storedAt: new Date(getRealDateNowMs()).toISOString(),
-					recording: await serializeCacheRecording(recording)
+					recording: await serializeCacheRecording(recording, { externalJsonStore: ctx.adapter.externalJsonStore })
 				};
 				await ctx.adapter.write(entry, {
 					rawKey: cacheOpts.key,
@@ -4551,8 +4582,9 @@ const updateManualScoreRequestSchema = z.object({ value: z.number().min(0).max(1
 //#region ../runner/src/cacheStore.ts
 const defaultMaxEntriesPerNamespace = 100;
 const cacheSerializationMarker = "__aecs";
-const legacyCacheSerializationMarker = "__agentEvalsCacheSerialization";
-const supportedCacheSerializationVersion = "json-safe-v1";
+const supportedCacheSerializationPrefix = "v1:";
+const externalJsonCacheSerializationMarker = "v1:ExternalJson";
+const externalJsonBlobExtension = ".json.br";
 /**
 * Create a filesystem-backed cache adapter rooted at `<workspaceRoot>/<dir>`.
 *
@@ -4563,20 +4595,28 @@ const supportedCacheSerializationVersion = "json-safe-v1";
 function createFsCacheStore(options) {
 	const cacheDir = resolve(options.workspaceRoot, options.dir ?? ".agent-evals/cache");
 	const debugDir = resolve(options.workspaceRoot, options.debugDir ?? ".agent-evals/cache-debug");
+	const blobDir = resolve(options.workspaceRoot, options.blobDir ?? ".agent-evals/cache-blobs");
+	const externalJsonStore = createExternalJsonBlobStore(blobDir);
 	const defaultMaxEntries = normalizeMaxEntries(options.maxEntriesPerNamespace);
 	return {
+		externalJsonStore,
 		dir() {
 			return cacheDir;
 		},
 		debugDir() {
 			return debugDir;
 		},
+		blobDir() {
+			return blobDir;
+		},
 		async lookup(namespace, keyHash) {
-			return (await readCacheFile(cacheDir, ownerFromNamespace(namespace)))?.entries[keyHash] ?? null;
+			const entry = (await readCacheFile(cacheDir, ownerFromNamespace(namespace)))?.entries[keyHash] ?? null;
+			return entry === null ? null : await materializeExternalJsonCacheEntry(entry, externalJsonStore);
 		},
 		async lookupWithDebug(namespace, keyHash) {
 			const owner = ownerFromNamespace(namespace);
-			const entry = (await readCacheFile(cacheDir, owner))?.entries[keyHash] ?? null;
+			const rawEntry = (await readCacheFile(cacheDir, owner))?.entries[keyHash] ?? null;
+			const entry = rawEntry === null ? null : await materializeExternalJsonCacheEntry(rawEntry, externalJsonStore);
 			if (entry === null) return null;
 			const debugKey = (await readDebugKeyFile(debugDir, owner))?.entries[keyHash];
 			const deserializedEntry = {
@@ -4602,6 +4642,7 @@ function createFsCacheStore(options) {
 					}, entry.namespace, maxEntriesForNamespace(entry.namespace, defaultMaxEntries, options.maxEntriesByNamespace), entry.key)
 				});
 			});
+			await pruneExternalJsonBlobs(cacheDir, blobDir);
 			if (debugKey !== void 0) {
 				if ((await resultify(() => writeDebugKeyEntry({
 					debugDir,
@@ -4653,6 +4694,10 @@ function createFsCacheStore(options) {
 					recursive: true,
 					force: true
 				});
+				await rm(blobDir, {
+					recursive: true,
+					force: true
+				});
 				return;
 			}
 			if (filter.namespace !== void 0) {
@@ -4671,6 +4716,7 @@ function createFsCacheStore(options) {
 					});
 				});
 				await clearDebugEntries(debugDir, filter);
+				await pruneExternalJsonBlobs(cacheDir, blobDir);
 				return;
 			}
 			if (existsSync(cacheDir)) {
@@ -4691,6 +4737,7 @@ function createFsCacheStore(options) {
 				}
 			}
 			await clearDebugEntries(debugDir, filter);
+			await pruneExternalJsonBlobs(cacheDir, blobDir);
 		}
 	};
 }
@@ -4704,9 +4751,10 @@ function createFsCacheStore(options) {
 function createBufferedCacheStore(backingStore) {
 	const pendingEntries = /* @__PURE__ */ new Map();
 	return {
+		externalJsonStore: backingStore.externalJsonStore,
 		async lookup(namespace, keyHash) {
 			const buffered = pendingEntries.get(toPendingKey(namespace, keyHash));
-			if (buffered !== void 0) return buffered.entry;
+			if (buffered !== void 0) return backingStore.externalJsonStore === void 0 ? buffered.entry : await materializeExternalJsonCacheEntry(buffered.entry, backingStore.externalJsonStore);
 			return backingStore.lookup(namespace, keyHash);
 		},
 		write(entry, debugKey) {
@@ -4745,6 +4793,95 @@ function toPendingKey(namespace, keyHash) {
 function sanitizeSegment$1(segment) {
 	return segment.replace(/[^a-zA-Z0-9_.-]/g, "_");
 }
+function createExternalJsonBlobStore(blobDir) {
+	return {
+		async write(rawJson) {
+			const rawBytes = Buffer.from(rawJson, "utf8");
+			const hash = hashExternalJson(rawBytes);
+			const path = externalJsonBlobPath(hash);
+			const compressed = brotliCompressSync(rawBytes);
+			const filePath = resolveStorePath(blobDir, path);
+			if (!existsSync(filePath)) {
+				await mkdir(dirname(filePath), { recursive: true });
+				const tmpPath = `${filePath}.${process.pid.toString()}.tmp`;
+				await writeFile(tmpPath, compressed);
+				await rename(tmpPath, filePath);
+			}
+			return {
+				compressedLength: compressed.byteLength,
+				hash,
+				length: rawBytes.byteLength,
+				path
+			};
+		},
+		async read(ref) {
+			const rawBytes = brotliDecompressSync(await readFile(resolveStorePath(blobDir, ref.path)));
+			const rawJson = rawBytes.toString("utf8");
+			if (rawBytes.byteLength !== ref.length || hashExternalJson(rawBytes) !== ref.hash) throw new Error(`External cache blob failed integrity check: ${ref.hash}`);
+			return rawJson;
+		}
+	};
+}
+function hashExternalJson(rawBytes) {
+	return `sha256:${createHash("sha256").update(rawBytes).digest("hex")}`;
+}
+function externalJsonBlobPath(hash) {
+	const digest = hash.slice(7);
+	return join("sha256", digest.slice(0, 2), `${digest}${externalJsonBlobExtension}`);
+}
+function resolveStorePath(root, relativePath) {
+	const path = resolve(root, relativePath);
+	if (path !== root && !path.startsWith(`${root}${sep}`)) throw new Error(`External cache blob path escapes store: ${relativePath}`);
+	return path;
+}
+async function materializeExternalJsonCacheEntry(entry, store) {
+	return {
+		...entry,
+		recording: cacheRecordingSchema.parse(await materializeExternalJsonValues(entry.recording, store))
+	};
+}
+async function pruneExternalJsonBlobs(cacheDir, blobDir) {
+	if (!existsSync(blobDir)) return;
+	const referenced = await collectReferencedExternalJsonBlobPaths(cacheDir);
+	for (const path of await listExternalJsonBlobPaths(blobDir)) if (!referenced.has(path)) await rm(resolveStorePath(blobDir, path), { force: true });
+}
+async function collectReferencedExternalJsonBlobPaths(cacheDir) {
+	const paths = /* @__PURE__ */ new Set();
+	if (!existsSync(cacheDir)) return paths;
+	const files = await readdir(cacheDir);
+	for (const fileName of files) {
+		if (!fileName.endsWith(".json")) continue;
+		const cacheFile = await readCacheFilePath(join(cacheDir, fileName));
+		if (cacheFile === null) continue;
+		collectExternalJsonBlobPaths(cacheFile, paths);
+	}
+	return paths;
+}
+function collectExternalJsonBlobPaths(value, paths) {
+	if (Array.isArray(value)) {
+		for (const item of value) collectExternalJsonBlobPaths(item, paths);
+		return;
+	}
+	if (!isRecordLike(value)) return;
+	if (value[cacheSerializationMarker] === externalJsonCacheSerializationMarker && typeof value.path === "string") paths.add(value.path);
+	for (const entryValue of Object.values(value)) collectExternalJsonBlobPaths(entryValue, paths);
+}
+async function listExternalJsonBlobPaths(blobDir) {
+	const paths = [];
+	await collectExternalJsonBlobFilePaths(blobDir, blobDir, paths);
+	return paths;
+}
+async function collectExternalJsonBlobFilePaths(root, dir, paths) {
+	const entries = await readdir(dir, { withFileTypes: true });
+	for (const entry of entries) {
+		const path = join(dir, entry.name);
+		if (entry.isDirectory()) {
+			await collectExternalJsonBlobFilePaths(root, path, paths);
+			continue;
+		}
+		if (entry.isFile() && entry.name.endsWith(externalJsonBlobExtension)) paths.push(relative(root, path));
+	}
+}
 async function readCacheFile(cacheDir, owner) {
 	return readCacheFilePath(ownerPath(cacheDir, owner));
 }
@@ -4764,7 +4901,7 @@ async function readCacheFilePath(filePath) {
 function usesSupportedCacheSerialization(value) {
 	if (Array.isArray(value)) return value.every(usesSupportedCacheSerialization);
 	if (!isRecordLike(value)) return true;
-	for (const marker of [cacheSerializationMarker, legacyCacheSerializationMarker]) if (Object.hasOwn(value, marker) && value[marker] !== supportedCacheSerializationVersion) return false;
+	if (Object.hasOwn(value, cacheSerializationMarker) && (typeof value[cacheSerializationMarker] !== "string" || !value[cacheSerializationMarker].startsWith(supportedCacheSerializationPrefix))) return false;
 	return Object.values(value).every(usesSupportedCacheSerialization);
 }
 async function writeOrRemoveCacheFile(cacheDir, cacheFile) {

package/dist/{runner-BTH8m_Er.mjs → runner-B1wfPKNH.mjs}

@@ -1,5 +1,5 @@
-import { n as createRunner } from "./cli-CwGcJYWe.mjs";
-import "./src--13_4uDG.mjs";
+import { n as createRunner } from "./cli-BUX6tr9J.mjs";
+import "./src-BwJ5tod2.mjs";
 //#region ../../apps/server/src/runner.ts
 let runnerInstance = null;
 function getRunnerInstance() {

package/dist/{runner-LqeHPID6.mjs → runner-CoRf7Vef.mjs}

@@ -1,2 +1,2 @@
-import { n as initRunner, t as getRunnerInstance } from "./runner-BTH8m_Er.mjs";
+import { n as initRunner, t as getRunnerInstance } from "./runner-B1wfPKNH.mjs";
 export { getRunnerInstance, initRunner };

package/dist/src-BwJ5tod2.mjs

@@ -0,0 +1,3 @@
+import "./runOrchestration-BhUFWvq9.mjs";
+import "./cli-BUX6tr9J.mjs";
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ls-stack/agent-eval",
-  "version": "0.37.0",
+  "version": "0.39.0",
   "type": "module",
   "bin": {
     "agent-evals": "./dist/bin.mjs"

package/skills/agent-eval/SKILL.md

@@ -491,6 +491,10 @@ Mental model:
   `.agent-evals/cache/<owner>.json`; each namespace is capped at 100 entries by
   default. Configure `cache.maxEntriesPerNamespace` for the default cap and
   `cache.maxEntriesByNamespace` for exact namespace-specific caps.
+- Nested cached JSON values at or above roughly 10K JSON characters are stored
+  as content-addressed Brotli blobs under `.agent-evals/cache-blobs/` and
+  referenced from cache JSON by sha256. Identical large payloads share the same
+  blob.
 - Authored raw cache keys are stored for debugging under
   `.agent-evals/cache-debug/<owner>.json`. This folder may include prompts,
   user inputs, or other sensitive data, should be gitignored, and is not needed
@@ -498,11 +502,11 @@ Mental model:
   can be filtered to hits or new entries added by cache misses/refreshes.
   Misses/refreshes with `cache.store: false` are shown as non-stored activity
   without fetch/delete controls.
-- Cached payloads use advanced serialization/deserialization with the Web API
-  plugin set, so return values and recorded SDK effects preserve richer
-  built-ins such as `Date`, `Map`, `Set`, typed arrays, `URL`, `Headers`,
-  `Blob`, and `File` on hits. Undefined values are omitted by default instead
-  of being written to cache files; direct serializer callers can pass
+- Cached payloads use JSON-safe tagged serialization, so return values and
+  recorded SDK effects preserve richer built-ins such as `Date`, `Map`, `Set`,
+  typed arrays, `URL`, `Headers`, `Blob`, and `File` on hits. Undefined values
+  are omitted by default instead of being written to cache files; direct
+  serializer callers can pass
   `{ preserveUndefined: true }` when explicit undefined wrappers are needed.
   Cache keys still use the deterministic key-hashing rules above.
 - Cache mode per run is controlled by CLI flags (see `agent-evals run --help`).