@tangle-network/agent-eval 0.129.0 → 0.130.1

package/dist/run-record-BuoE80Dq.js

@@ -0,0 +1,467 @@
+import { s as ValidationError } from "./errors-8YnH8WlF.js";
+import { r as hashJson } from "./pre-registration-DakwTRXk.js";
+import { n as observedScore } from "./reward-nw2xZGZG.js";
+import { t as FAILURE_CLASSES } from "./schema-CRhEY1SO.js";
+//#region src/agent-profile-cell.ts
+var AgentProfileCellValidationError = class extends ValidationError {
+	path;
+	constructor(message, path = "") {
+		super(path ? `${message} (at ${path})` : message);
+		this.path = path;
+	}
+};
+const SHA256_HEX = /^[0-9a-f]{64}$/;
+const CELL_ID = /^agent-profile-cell:sha256:[0-9a-f]{64}$/;
+async function buildAgentProfileCell(input) {
+	const material = await normalizeAgentProfileCellInput(input);
+	const cellId = `agent-profile-cell:sha256:${await hashJson(material)}`;
+	return {
+		...material,
+		cellId
+	};
+}
+function agentProfileCellHashMaterial(cell) {
+	const { cellId: _cellId, ...material } = cell;
+	return normalizeAgentProfileCell(material);
+}
+/**
+* Verify an `AgentProfileCell`'s `cellId` matches the sha256 of its hash-material fields, confirming the record has not been tampered with.
+*/
+async function verifyAgentProfileCell(cell) {
+	validateAgentProfileCell(cell);
+	return cell.cellId === `agent-profile-cell:sha256:${await hashJson(agentProfileCellHashMaterial(cell))}`;
+}
+function validateAgentProfileCell(input) {
+	if (input === null || typeof input !== "object") throw new AgentProfileCellValidationError("expected object");
+	const obj = input;
+	expectLiteral(obj.schemaVersion, "agent-profile-cell/v1", "schemaVersion");
+	if (typeof obj.cellId !== "string" || !CELL_ID.test(obj.cellId)) throw new AgentProfileCellValidationError("cellId must match agent-profile-cell:sha256:<64 lowercase hex chars>", "cellId");
+	expectString$1(obj.profileId, "profileId");
+	validateSource(obj.sourceProfile, "sourceProfile");
+	if (obj.harness !== void 0) validateHarness(obj.harness, "harness");
+	if (obj.model !== void 0) expectString$1(obj.model, "model");
+	if (obj.promptHash !== void 0) expectString$1(obj.promptHash, "promptHash");
+	if (obj.dimensions !== void 0) validateDimensions(obj.dimensions, "dimensions");
+	return input;
+}
+function requireAgentProfileCell(record) {
+	if (!record.agentProfile) throw new AgentProfileCellValidationError(`run "${record.runId}" is missing agentProfile; profile-cell grouping requires explicit profile identity`, "agentProfile");
+	return validateAgentProfileCell(record.agentProfile);
+}
+function agentProfileCellKey(record) {
+	return requireAgentProfileCell(record).cellId;
+}
+async function assertRunAgentProfileCell(record) {
+	const profile = requireAgentProfileCell(record);
+	if (!await verifyAgentProfileCell(profile)) throw new AgentProfileCellValidationError(`run "${record.runId}" has an agentProfile.cellId that does not match its content`, "agentProfile.cellId");
+	if (profile.model !== void 0 && profile.model !== record.model) throw new AgentProfileCellValidationError(`run "${record.runId}" agentProfile.model "${profile.model}" does not match model "${record.model}"`, "agentProfile.model");
+	if (profile.promptHash !== void 0 && profile.promptHash !== record.promptHash) throw new AgentProfileCellValidationError(`run "${record.runId}" agentProfile.promptHash "${profile.promptHash}" does not match promptHash "${record.promptHash}"`, "agentProfile.promptHash");
+	return profile;
+}
+function groupRunsByAgentProfileCell(records) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		const key = agentProfileCellKey(record);
+		const bucket = groups.get(key);
+		if (bucket) bucket.push(record);
+		else groups.set(key, [record]);
+	}
+	return groups;
+}
+async function normalizeAgentProfileCellInput(input) {
+	return normalizeAgentProfileCell({
+		schemaVersion: "agent-profile-cell/v1",
+		profileId: input.profileId,
+		sourceProfile: await normalizeSourceInput(input.sourceProfile),
+		harness: input.harness,
+		model: input.model,
+		promptHash: input.promptHash,
+		dimensions: input.dimensions
+	});
+}
+function normalizeAgentProfileCell(input) {
+	return compactObject({
+		schemaVersion: "agent-profile-cell/v1",
+		profileId: requireNonEmpty(input.profileId, "profileId"),
+		sourceProfile: normalizeSource(input.sourceProfile),
+		harness: input.harness ? normalizeHarness(input.harness, "harness") : void 0,
+		model: optionalNonEmpty(input.model, "model"),
+		promptHash: optionalNonEmpty(input.promptHash, "promptHash"),
+		dimensions: input.dimensions ? nonEmptyRecord(normalizeDimensions(input.dimensions)) : void 0
+	});
+}
+async function normalizeSourceInput(input) {
+	const kind = requireNonEmpty(input.kind, "sourceProfile.kind");
+	if (input.hash !== void 0 && input.profile !== void 0) throw new AgentProfileCellValidationError("sourceProfile must provide either hash or profile, not both", "sourceProfile");
+	if (input.hash !== void 0) return {
+		kind,
+		hash: requireSha256Hex(input.hash, "sourceProfile.hash")
+	};
+	if (input.profile === void 0) throw new AgentProfileCellValidationError("sourceProfile must provide hash or profile", "sourceProfile");
+	assertJson(input.profile, "sourceProfile.profile");
+	return {
+		kind,
+		hash: await hashJson(input.profile)
+	};
+}
+function normalizeSource(input) {
+	return {
+		kind: requireNonEmpty(input.kind, "sourceProfile.kind"),
+		hash: requireSha256Hex(input.hash, "sourceProfile.hash")
+	};
+}
+function normalizeHarness(input, path) {
+	return compactObject({
+		id: requireNonEmpty(input.id, `${path}.id`),
+		version: optionalNonEmpty(input.version, `${path}.version`),
+		hash: optionalNonEmpty(input.hash, `${path}.hash`)
+	});
+}
+function normalizeDimensions(input) {
+	const out = {};
+	for (const key of Object.keys(input).sort()) {
+		const value = input[key];
+		requireNonEmpty(key, "dimensions.<key>");
+		if (value !== null && typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") throw new AgentProfileCellValidationError("expected primitive dimension value", `dimensions.${key}`);
+		if (typeof value === "number" && !Number.isFinite(value)) throw new AgentProfileCellValidationError("expected finite number", `dimensions.${key}`);
+		out[key] = value;
+	}
+	return out;
+}
+function compactObject(input) {
+	const out = {};
+	for (const [key, value] of Object.entries(input)) if (value !== void 0) out[key] = value;
+	return out;
+}
+function nonEmptyRecord(input) {
+	return Object.keys(input).length > 0 ? input : void 0;
+}
+function validateSource(value, path) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new AgentProfileCellValidationError("expected object", path);
+	const rec = value;
+	expectString$1(rec.kind, `${path}.kind`);
+	requireSha256Hex(rec.hash, `${path}.hash`);
+}
+function validateHarness(value, path) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new AgentProfileCellValidationError("expected object", path);
+	const rec = value;
+	expectString$1(rec.id, `${path}.id`);
+	if (rec.version !== void 0) expectString$1(rec.version, `${path}.version`);
+	if (rec.hash !== void 0) expectString$1(rec.hash, `${path}.hash`);
+}
+function validateDimensions(value, path) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new AgentProfileCellValidationError("expected object", path);
+	normalizeDimensions(value);
+}
+function assertJson(value, path) {
+	if (value === null) return;
+	const type = typeof value;
+	if (type === "string" || type === "boolean") return;
+	if (type === "number") {
+		if (!Number.isFinite(value)) throw new AgentProfileCellValidationError("expected finite number", path);
+		return;
+	}
+	if (Array.isArray(value)) {
+		value.forEach((item, index) => {
+			assertJson(item, `${path}[${index}]`);
+		});
+		return;
+	}
+	if (type === "object") {
+		for (const [key, nested] of Object.entries(value)) {
+			requireNonEmpty(key, `${path}.<key>`);
+			assertJson(nested, `${path}.${key}`);
+		}
+		return;
+	}
+	throw new AgentProfileCellValidationError("expected JSON-compatible value", path);
+}
+function expectLiteral(value, expected, path) {
+	if (value !== expected) throw new AgentProfileCellValidationError(`expected ${expected}`, path);
+}
+function expectString$1(value, path) {
+	if (typeof value !== "string" || value.length === 0) throw new AgentProfileCellValidationError("expected non-empty string", path);
+}
+function requireNonEmpty(value, path) {
+	if (typeof value !== "string" || value.length === 0) throw new AgentProfileCellValidationError("expected non-empty string", path);
+	return value;
+}
+function optionalNonEmpty(value, path) {
+	if (value === void 0) return void 0;
+	return requireNonEmpty(value, path);
+}
+function requireSha256Hex(value, path) {
+	if (typeof value !== "string" || !SHA256_HEX.test(value)) throw new AgentProfileCellValidationError("expected 64 lowercase sha256 hex chars", path);
+	return value;
+}
+/** Canonical `sourceProfile.kind` values. Two products fingerprinting the
+*  same canonical profile MUST use the same kind for their cells to share
+*  `sourceProfile.hash`. Extend rather than create new strings — adding a
+*  new kind is a deliberate cross-product schema change. */
+const AGENT_PROFILE_KINDS = { 
+/** A profile declared via `defineAgentProfile(...)` from
+*  `@tangle-network/agent-interface`. The default kind for router-backed
+*  and sandbox-backed products. */
+AGENT_INTERFACE_PROFILE: "agent-interface-profile" };
+/** Canonicalize an arbitrary value into `AgentProfileJson` by JSON
+*  round-trip. Throws when the value contains anything not representable
+*  as JSON (functions, BigInt, cycles) — non-portable profiles fail loud
+*  rather than silently dropping fields. */
+function toAgentProfileJson(value) {
+	let serialized;
+	try {
+		serialized = JSON.stringify(value);
+	} catch (err) {
+		throw new AgentProfileCellValidationError(`agent profile must be JSON-serializable: ${err instanceof Error ? err.message : String(err)}`, "sourceProfile.profile");
+	}
+	if (serialized === void 0) throw new AgentProfileCellValidationError("agent profile must be JSON-serializable (got undefined after JSON.stringify)", "sourceProfile.profile");
+	return JSON.parse(serialized);
+}
+/** Higher-level helper that hard-codes the canonical
+*  `agent-interface-profile` kind plus the JSON canonicalization. Equivalent
+*  to calling `buildAgentProfileCell` with `profileId = \`${name}@${version}\``
+*  and `sourceProfile = { kind: AGENT_INTERFACE_PROFILE, profile: <round-tripped> }`.
+*
+*  Use this from any product consuming an agent-interface `AgentProfile`; the
+*  manual `buildAgentProfileCell` call is reserved for advanced cases
+*  (custom kinds, pre-computed source hashes, alternate profileId
+*  conventions). */
+async function buildAgentInterfaceProfileCell(profile, input) {
+	if (!profile || typeof profile !== "object") throw new AgentProfileCellValidationError("AgentProfile must be an object", "profile");
+	if (typeof profile.name !== "string" || profile.name.length === 0) throw new AgentProfileCellValidationError("AgentProfile must have a non-empty `name`", "profile.name");
+	if (typeof profile.version !== "string" || profile.version.length === 0) throw new AgentProfileCellValidationError("AgentProfile must have a non-empty `version`", "profile.version");
+	return buildAgentProfileCell({
+		...input,
+		profileId: `${profile.name}@${profile.version}`,
+		sourceProfile: {
+			kind: AGENT_PROFILE_KINDS.AGENT_INTERFACE_PROFILE,
+			profile: toAgentProfileJson(profile)
+		}
+	});
+}
+//#endregion
+//#region src/run-record.ts
+/**
+* Return task quality, preferring held-out evidence when both scores exist.
+*
+* RAW: no realness protection is applied. Built on `observedScore` rather
+* than repeating the split derivation, so only `rollout/reward.ts` reads the
+* raw fields. Anything that becomes training data must use `trainingScore` or
+* `trainingReward` instead.
+*/
+function runTaskScore(record) {
+	const score = observedScore(record);
+	return typeof score === "number" && Number.isFinite(score) ? score : void 0;
+}
+const MANDATORY_TOP_LEVEL = [
+	"runId",
+	"experimentId",
+	"candidateId",
+	"seed",
+	"model",
+	"promptHash",
+	"configHash",
+	"commitSha",
+	"wallMs",
+	"costUsd",
+	"costProvenance",
+	"tokenUsage",
+	"terminalOutcome",
+	"outcome",
+	"splitTag",
+	"scenarioId"
+];
+const SPLIT_TAGS = [
+	"search",
+	"dev",
+	"holdout"
+];
+const TERMINAL_OUTCOMES = [
+	"succeeded",
+	"failed",
+	"cancelled",
+	"incomplete",
+	"unknown"
+];
+var RunRecordValidationError = class extends ValidationError {
+	path;
+	constructor(message, path = "") {
+		super(path ? `${message} (at ${path})` : message);
+		this.path = path;
+	}
+};
+/**
+* Strict validator. Throws `RunRecordValidationError` on the first
+* missing or wrongly-typed field. Returns the input cast to
+* `RunRecord` on success — the validator does not coerce.
+*/
+function validateRunRecord(input) {
+	if (input === null || typeof input !== "object") throw new RunRecordValidationError("expected object");
+	const obj = input;
+	for (const key of MANDATORY_TOP_LEVEL) if (!(key in obj)) throw new RunRecordValidationError(`missing mandatory field "${key}"`);
+	expectString(obj.runId, "runId");
+	expectString(obj.experimentId, "experimentId");
+	expectString(obj.candidateId, "candidateId");
+	expectFiniteNumber(obj.seed, "seed");
+	expectString(obj.model, "model");
+	expectString(obj.promptHash, "promptHash");
+	expectString(obj.configHash, "configHash");
+	expectString(obj.commitSha, "commitSha");
+	expectNonNegativeNumber(obj.wallMs, "wallMs");
+	if (obj.queueMs !== void 0) expectNonNegativeNumber(obj.queueMs, "queueMs");
+	validateCost(obj.costUsd, obj.costProvenance);
+	if (!modelHasSnapshot(obj.model)) throw new RunRecordValidationError(`model "${obj.model}" lacks a snapshot version (use 'name@YYYY-MM-DD' or 'name-YYYYMMDD')`, "model");
+	const tu = obj.tokenUsage;
+	if (tu === null || typeof tu !== "object") throw new RunRecordValidationError("tokenUsage must be an object", "tokenUsage");
+	const tuRec = tu;
+	expectNonNegativeNumber(tuRec.input, "tokenUsage.input");
+	expectNonNegativeNumber(tuRec.output, "tokenUsage.output");
+	if (tuRec.reasoning !== void 0) {
+		expectNonNegativeNumber(tuRec.reasoning, "tokenUsage.reasoning");
+		if (tuRec.reasoning > tuRec.output) throw new RunRecordValidationError("reasoning tokens must be a subset of output tokens", "tokenUsage.reasoning");
+	}
+	if (tuRec.cached !== void 0) expectNonNegativeNumber(tuRec.cached, "tokenUsage.cached");
+	if (tuRec.cacheWrite !== void 0) expectNonNegativeNumber(tuRec.cacheWrite, "tokenUsage.cacheWrite");
+	if (obj.judgeMetadata !== void 0) {
+		const jm = obj.judgeMetadata;
+		if (jm === null || typeof jm !== "object") throw new RunRecordValidationError("judgeMetadata must be an object", "judgeMetadata");
+		const jmRec = jm;
+		expectString(jmRec.model, "judgeMetadata.model");
+		expectString(jmRec.promptVersion, "judgeMetadata.promptVersion");
+		expectFiniteNumber(jmRec.confidence, "judgeMetadata.confidence");
+		if (typeof jmRec.fallback !== "boolean") throw new RunRecordValidationError("judgeMetadata.fallback must be boolean", "judgeMetadata.fallback");
+	}
+	const out = obj.outcome;
+	if (out === null || typeof out !== "object") throw new RunRecordValidationError("outcome must be an object", "outcome");
+	const outRec = out;
+	if (outRec.searchScore !== void 0) expectFiniteNumber(outRec.searchScore, "outcome.searchScore");
+	if (outRec.holdoutScore !== void 0) expectFiniteNumber(outRec.holdoutScore, "outcome.holdoutScore");
+	const raw = outRec.raw;
+	if (raw === null || typeof raw !== "object") throw new RunRecordValidationError("outcome.raw must be an object", "outcome.raw");
+	for (const [k, v] of Object.entries(raw)) expectFiniteNumber(v, `outcome.raw.${k}`);
+	if (outRec.realness !== void 0) {
+		const r = outRec.realness;
+		if (r === null || typeof r !== "object") throw new RunRecordValidationError("outcome.realness must be an object", "outcome.realness");
+		const rr = r;
+		expectFiniteNumber(rr.score, "outcome.realness.score");
+		if (typeof rr.gated !== "boolean") throw new RunRecordValidationError("outcome.realness.gated must be a boolean", "outcome.realness.gated");
+	}
+	if (outRec.judgeScores !== void 0) validateJudgeScores(outRec.judgeScores, "outcome.judgeScores");
+	if (obj.failureClass !== void 0 && (typeof obj.failureClass !== "string" || !FAILURE_CLASSES.includes(obj.failureClass))) throw new RunRecordValidationError(`failureClass must be one of ${FAILURE_CLASSES.join(", ")}`, "failureClass");
+	if (obj.failureMode !== void 0) {
+		expectString(obj.failureMode, "failureMode");
+		if (obj.failureClass === void 0 || obj.failureClass === "success") throw new RunRecordValidationError("failureMode requires a non-success failureClass", "failureMode");
+	}
+	if (typeof obj.terminalOutcome !== "string" || !TERMINAL_OUTCOMES.includes(obj.terminalOutcome)) throw new RunRecordValidationError(`terminalOutcome must be one of ${TERMINAL_OUTCOMES.join(", ")}`, "terminalOutcome");
+	if (obj.terminalFailureReason !== void 0) {
+		expectString(obj.terminalFailureReason, "terminalFailureReason");
+		if (obj.terminalOutcome !== "failed" && obj.terminalOutcome !== "cancelled" && obj.terminalOutcome !== "incomplete") throw new RunRecordValidationError("terminalFailureReason requires terminalOutcome failed, cancelled, or incomplete", "terminalFailureReason");
+	}
+	if (obj.agentProfile !== void 0) try {
+		const profile = validateAgentProfileCell(obj.agentProfile);
+		if (profile.model !== void 0 && profile.model !== obj.model) throw new RunRecordValidationError(`agentProfile.model "${profile.model}" does not match model "${obj.model}"`, "agentProfile.model");
+		if (profile.promptHash !== void 0 && profile.promptHash !== obj.promptHash) throw new RunRecordValidationError(`agentProfile.promptHash "${profile.promptHash}" does not match promptHash "${obj.promptHash}"`, "agentProfile.promptHash");
+	} catch (error) {
+		if (error instanceof RunRecordValidationError) throw error;
+		if (error instanceof Error) throw new RunRecordValidationError(error.message, "agentProfile");
+		throw error;
+	}
+	expectString(obj.scenarioId, "scenarioId");
+	if (typeof obj.splitTag !== "string" || !SPLIT_TAGS.includes(obj.splitTag)) throw new RunRecordValidationError(`splitTag must be one of ${SPLIT_TAGS.join(", ")}, got ${String(obj.splitTag)}`, "splitTag");
+	return input;
+}
+function validateCost(costUsd, provenance) {
+	if (provenance === null || typeof provenance !== "object") throw new RunRecordValidationError("costProvenance must be an object", "costProvenance");
+	const value = provenance;
+	if (value.kind !== "observed" && value.kind !== "estimated" && value.kind !== "uncaptured") throw new RunRecordValidationError("costProvenance.kind must be observed, estimated, or uncaptured", "costProvenance.kind");
+	if (value.kind === "uncaptured") {
+		if (value.usd !== null) throw new RunRecordValidationError("uncaptured costProvenance.usd must be null", "costProvenance.usd");
+		if (costUsd !== null) throw new RunRecordValidationError("uncaptured cost requires costUsd to be null", "costUsd");
+		return;
+	}
+	expectNonNegativeNumber(costUsd, "costUsd");
+	expectNonNegativeNumber(value.usd, "costProvenance.usd");
+	if (value.usd !== costUsd) throw new RunRecordValidationError("costProvenance.usd must equal costUsd", "costProvenance.usd");
+}
+/** Boolean validator — convenience for filtering arrays. */
+function isRunRecord(input) {
+	try {
+		validateRunRecord(input);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Non-throwing validator — returns a discriminated union. */
+function parseRunRecordSafe(input) {
+	try {
+		return {
+			ok: true,
+			value: validateRunRecord(input)
+		};
+	} catch (e) {
+		if (e instanceof RunRecordValidationError) return {
+			ok: false,
+			error: e
+		};
+		throw e;
+	}
+}
+/** Round-trip helper — `JSON.parse(JSON.stringify(record))` then validate. */
+function roundTripRunRecord(record) {
+	const json = JSON.stringify(record);
+	return validateRunRecord(JSON.parse(json));
+}
+function expectString(value, path) {
+	if (typeof value !== "string" || value.length === 0) throw new RunRecordValidationError(`expected non-empty string`, path);
+}
+function expectFiniteNumber(value, path) {
+	if (typeof value !== "number" || !Number.isFinite(value)) throw new RunRecordValidationError(`expected finite number`, path);
+}
+function expectNonNegativeNumber(value, path) {
+	expectFiniteNumber(value, path);
+	if (value < 0) throw new RunRecordValidationError("expected non-negative number", path);
+}
+function validateJudgeScores(value, path) {
+	if (value === null || typeof value !== "object") throw new RunRecordValidationError("judgeScores must be an object", path);
+	const rec = value;
+	const perJudge = rec.perJudge;
+	if (perJudge === null || typeof perJudge !== "object") throw new RunRecordValidationError("perJudge must be an object", `${path}.perJudge`);
+	for (const [judgeId, dims] of Object.entries(perJudge)) {
+		if (dims === null || typeof dims !== "object") throw new RunRecordValidationError("per-judge entry must be an object of dimension scores", `${path}.perJudge.${judgeId}`);
+		for (const [dim, score] of Object.entries(dims)) expectFiniteNumber(score, `${path}.perJudge.${judgeId}.${dim}`);
+	}
+	const perDimMean = rec.perDimMean;
+	if (perDimMean === null || typeof perDimMean !== "object") throw new RunRecordValidationError("perDimMean must be an object", `${path}.perDimMean`);
+	for (const [dim, mean] of Object.entries(perDimMean)) expectFiniteNumber(mean, `${path}.perDimMean.${dim}`);
+	expectFiniteNumber(rec.composite, `${path}.composite`);
+	if (rec.failedJudges !== void 0) {
+		if (!Array.isArray(rec.failedJudges)) throw new RunRecordValidationError("failedJudges must be an array of strings", `${path}.failedJudges`);
+		for (let i = 0; i < rec.failedJudges.length; i++) {
+			const id = rec.failedJudges[i];
+			if (typeof id !== "string" || id.length === 0) throw new RunRecordValidationError("failedJudges entry must be a non-empty string", `${path}.failedJudges[${i}]`);
+		}
+	}
+	if (rec.notes !== void 0 && typeof rec.notes !== "string") throw new RunRecordValidationError("notes must be a string", `${path}.notes`);
+}
+/**
+* Heuristic snapshot check. Accepts:
+*   - `name@YYYY-MM-DD` (Anthropic style: `claude-sonnet-4-6@2025-04-15`)
+*   - `name-YYYYMMDD`   (OpenAI style: `gpt-4o-2024-11-20`)
+*   - `name@<arbitrary-token>` (allow opaque snapshots like `@v3`)
+*   - explicit `:date-...` Vertex-style tags
+*
+* Rejects bare aliases like `claude-sonnet-4` or `gpt-4o` that remap
+* silently as providers ship new snapshots.
+*/
+function modelHasSnapshot(model) {
+	if (model.includes("@")) return true;
+	if (/-\d{8}$/.test(model)) return true;
+	if (/-\d{4}-\d{2}-\d{2}$/.test(model)) return true;
+	if (/:date-/.test(model)) return true;
+	return false;
+}
+//#endregion
+export { toAgentProfileJson as _, roundTripRunRecord as a, AGENT_PROFILE_KINDS as c, agentProfileCellKey as d, assertRunAgentProfileCell as f, requireAgentProfileCell as g, groupRunsByAgentProfileCell as h, parseRunRecordSafe as i, AgentProfileCellValidationError as l, buildAgentProfileCell as m, isRunRecord as n, runTaskScore as o, buildAgentInterfaceProfileCell as p, modelHasSnapshot as r, validateRunRecord as s, RunRecordValidationError as t, agentProfileCellHashMaterial as u, validateAgentProfileCell as v, verifyAgentProfileCell as y };
+
+//# sourceMappingURL=run-record-BuoE80Dq.js.map