@tangle-network/agent-eval 0.182.0 → 0.184.0

package/dist/rl.js

@@ -1,18 +1,18 @@
 import { s as ValidationError } from "./errors-Dngq5h35.js";
-import { i as compareCodeUnits } from "./canonical-DPyQ_rpt.js";
+import { i as compareCodeUnits } from "./canonical-BsZVgBhW.js";
 import { a as medianInPlace } from "./internal-BMFSR8Ns.js";
 import { t as mulberry32 } from "./random-Dn5fPWkt.js";
 import { l as wilcoxonSignedRank } from "./paired-arms-JSDcs2zx.js";
 import { r as pairedBootstrap } from "./paired-tests-C8iCsioC.js";
-import { a as campaignCellToRunRecord, s as decidePairedPromotion } from "./run-record-DPa2PeHx.js";
+import { a as campaignCellToRunRecord, s as decidePairedPromotion } from "./run-record-BhMVsHR1.js";
 import { r as observedSplitScore, s as trainingScore } from "./reward-nw2xZGZG.js";
-import { s as runTaskScore } from "./run-record-DualPTn2.js";
+import { s as runTaskScore } from "./run-record-tg_5H2IK.js";
 import { i as filterDeterministicallyRewarded, n as extractVerifiableReward, r as extractVerifiableRewardsFromRecords, t as detectRewardHacking } from "./reward-hacking-D0XwhVWE.js";
 import { n as InMemoryTraceStore } from "./store-DNe_Uv1Q.js";
-import { t as runEvalCampaign } from "./eval-campaign-CCEkwzoH.js";
+import { t as runEvalCampaign } from "./eval-campaign-XFHEpN86.js";
 import { s as assertRewardGate } from "./schema-C1aaAxTf.js";
-import { t as isSplitEligible } from "./exporters-Df7TgHFv.js";
-import { t as mintRolloutRows } from "./mint-ySIIkKlV.js";
+import { n as isTrainingLineEligible, s as toSftRows$1, t as isSplitEligible } from "./exporters-DEcXbvgO.js";
+import { t as mintRolloutRows } from "./mint-B4zgSAJW.js";
 import { t as evaluateInterimReleaseConfidence } from "./sequential-CzK5DarL.js";
 import { n as assertUniqueObservationIds, s as validateOutcomeMetricSpecifications, t as rubricPredictiveValidity } from "./rubric-predictive-validity-CCK-1B7w.js";
 import { n as thompsonCurriculum, r as varianceBasedCurriculum, t as observationsFromRunRecords } from "./active-curriculum-OjIWgrUJ.js";
@@ -664,10 +664,12 @@ function admitUngatedByInvocation(items, idsOf, context, requirement, inspect) {
 * agent-eval's contract; without first-party exporters consumers reverse-
 * engineer the mapping every release. The exporters codify it.
 *
-* The exporters take callbacks for any field that isn't on the canonical
-* artifact (specifically: prompt + completion text, since the package
-* stores only their hashes by design — full text is the consumer's
-* trace store / raw event log).
+* The text-only formats (DPO, GRPO, PRM) take callbacks for prompt and
+* completion text, which the canonical artifact does not carry as flat fields —
+* the consumer resolves them from its trace store / raw event log. SFT is the
+* one format whose row IS the captured conversation, so it projects the line's
+* inline `messages` through `rollout/exporters.toSftRows` and uses the text
+* lookups only to recover a gap line (a line minted without a transcript).
 *
 * Every exporter that produces a training row accepts canonical minted rollout
 * lines. Convert run records once with `mintRolloutRows`; downstream transforms
@@ -749,7 +751,7 @@ async function toGrpoRows(lines, lookups) {
 async function grpoRowsFromLines(lines, lookups) {
 	const grouped = /* @__PURE__ */ new Map();
 	for (const line of lines) {
-		if (!isSelectedSplit(line, lookups)) continue;
+		if (!isSplitEligible(line, lookups)) continue;
 		const arr = grouped.get(line.task.instance_id) ?? [];
 		arr.push(line);
 		grouped.set(line.task.instance_id, arr);
@@ -796,62 +798,67 @@ function toGrpoJsonl(rows) {
 * pass `include` to filter further (e.g., keep only `reward >= 0.8` for
 * rejection-sampling SFT).
 *
-* Realness-gated lines are dropped outright, not zeroed. SFT is imitation
-* learning: unlike GRPO, where a 0 reward teaches "this trajectory was bad",
-* every row here is a target to copy, so a gamed trajectory must not be in the
-* file at all. Mirrors the waist filter in `rollout/exporters.toSftRows`.
-*
-* The exporter is fail-closed on the split, same rule as
-* `rollout/exporters.toSftRows` (`isSplitEligible`): `search` ships by
-* default, held-out lines need `allowHeldOutTrainingData: true`, `dev` and
-* `canary` never pass the default rule. A non-training bundle that wants an
-* explicit slice (e.g. a holdout-only eval bundle) names it with
-* `splitFilter: ['holdout']` — explicit selection replaces the default rule.
+* Eligibility and the transcript projection belong to
+* `rollout/exporters.toSftRows`: same fail-closed policy (realness-gated lines
+* are dropped, not zeroed; `search` ships by default, held-out needs
+* `allowHeldOutTrainingData`, `splitFilter` names an explicit slice) and the
+* same copied-context drop. This adapter adds only the legacy text lookups: a
+* line whose transcript was captured is exported as captured, tool turns
+* included, and a gap line (empty `messages`, `provenance.gap` set) is
+* recovered from `promptOf` / `completionOf` / `systemOf`. `meta.transcriptSource`
+* says which path a row took. A captured transcript whose every turn is copied
+* context yields no row rather than a lookup-built substitute.
 */
 async function toSftRows(lines, lookups) {
-	return sftRowsFromLines(lines, lookups);
-}
-async function sftRowsFromLines(lines, lookups) {
+	for (const line of lines) assertRewardGate(line, "SFT export");
 	const include = lookups.include ?? (() => true);
-	const minimumQualityExclusive = lookups.minimumQualityExclusive ?? 0;
-	if (!Number.isFinite(minimumQualityExclusive)) throw new Error("minimumQualityExclusive must be finite");
 	const rows = [];
 	for (const line of lines) {
-		assertRewardGate(line, "SFT export");
-		if (isLineRealnessGated(line)) continue;
-		if (!isSelectedSplit(line, lookups)) continue;
-		const score = trainableLineReward(line);
-		if (score === null || score <= minimumQualityExclusive) continue;
-		if (!line.outcome.is_completed || line.outcome.is_truncated || line.outcome.error !== null) continue;
-		if (!include(line)) continue;
-		const system = lookups.systemOf?.(line);
-		const [prompt, completion] = await Promise.all([Promise.resolve(lookups.promptOf(line.run_id)), Promise.resolve(lookups.completionOf(line.run_id))]);
-		const messages = [];
-		if (system) messages.push({
-			role: "system",
-			content: system
-		});
-		messages.push({
-			role: "user",
-			content: prompt
-		});
-		messages.push({
-			role: "assistant",
-			content: completion
-		});
+		if (!isTrainingLineEligible(line, lookups) || !include(line)) continue;
+		const captured = line.messages.length > 0;
+		const messages = captured ? line.messages : await recoveredTranscript(line, lookups);
+		const [row] = toSftRows$1([{
+			...line,
+			messages
+		}], lookups);
+		if (row === void 0) continue;
 		rows.push({
-			messages,
+			messages: row.messages,
 			meta: {
 				runId: line.run_id,
+				rolloutId: line.rollout_id,
 				candidateId: line.candidate_id ?? null,
 				scenarioId: line.task.instance_id,
-				score,
-				model: line.policy.model
+				score: row.metadata.reward,
+				model: line.policy.model,
+				transcriptSource: captured ? "captured" : "lookups",
+				captureGap: line.provenance.gap ?? null,
+				realness_gated: row.metadata.realness_gated,
+				realness_screened: row.metadata.realness_screened
 			}
 		});
 	}
 	return rows;
 }
+/** A gap line's transcript from the text lookups. Blank or non-string text is refused. */
+async function recoveredTranscript(line, lookups) {
+	const system = lookups.systemOf?.(line);
+	const [prompt, completion] = await Promise.all([Promise.resolve(lookups.promptOf(line.run_id)), Promise.resolve(lookups.completionOf(line.run_id))]);
+	if (typeof prompt !== "string" || prompt.trim() === "" || typeof completion !== "string" || completion.trim() === "" || system != null && typeof system !== "string") throw new Error(`SFT export: rollout ${line.rollout_id} has invalid text lookups`);
+	const messages = [];
+	if (system) messages.push({
+		role: "system",
+		content: system
+	});
+	messages.push({
+		role: "user",
+		content: prompt
+	}, {
+		role: "assistant",
+		content: completion
+	});
+	return messages;
+}
 function toSftJsonl(rows) {
 	return rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length > 0 ? "\n" : "");
 }
@@ -961,10 +968,6 @@ function stepRewardsToJsonl(stepRewards, context) {
 	}));
 	return rows.map((r) => JSON.stringify(r)).join("\n") + (rows.length > 0 ? "\n" : "");
 }
-function isSelectedSplit(line, options) {
-	if (options.splitFilter !== void 0) return options.splitFilter.includes(line.task.split);
-	return isSplitEligible(line, options);
-}
 //#endregion
 //#region src/rl/dataset.ts
 const DATASET_FORMAT_SET = /* @__PURE__ */ new Set([
@@ -1052,9 +1055,10 @@ function computeStatsFromLines(lines) {
 /**
 * Package graded rollout lines into a publishable RL dataset bundle: the
 * trainer-format JSONL files + a manifest + a datasheet. DPO requires
-* pre-extracted preference triples (pass `preferences`); GRPO/SFT derive from
-* the lines directly via the supplied lookups. Throws on an empty corpus —
-* an empty dataset must never be published.
+* pre-extracted preference triples (pass `preferences`); GRPO derives from the
+* lines via the supplied text lookups; SFT ships each line's captured
+* transcript and uses the lookups only to recover gap lines. Throws on an
+* empty corpus — an empty dataset must never be published.
 */
 async function buildRlDataset(lines, lookups, config, preferences) {
 	if (lines.length === 0) throw new Error("buildRlDataset: no rollout lines — refusing to package an empty dataset");
@@ -2058,12 +2062,25 @@ async function runRLCampaign(opts) {
 		validateOutcomeMetricSpecifications(outcomeMetrics);
 	}
 	const splitTag = opts.splitTag ?? "search";
+	const stores = /* @__PURE__ */ new Map();
 	const campaign = await runEvalCampaign({
 		...opts,
-		splitTag
+		splitTag,
+		storeFactory: (params) => {
+			const store = opts.storeFactory(params);
+			stores.set(params.runId, store);
+			return store;
+		}
 	});
 	const rewardSignals = extractVerifiableRewardsFromRecords(campaign.runs, opts.verifiableReward ?? {});
-	const { rows: rolloutLines } = await mintRolloutRows(campaign.runs.filter((run) => runTaskScore(run) !== void 0), new InMemoryTraceStore());
+	const scoredRuns = campaign.runs.filter((run) => runTaskScore(run) !== void 0);
+	const rolloutLines = [];
+	for (const run of scoredRuns) {
+		const store = stores.get(run.runId);
+		if (!store) throw new Error(`runRLCampaign: evaluation trace store missing for ${run.runId}`);
+		const { rows } = await mintRolloutRows([run], store, opts.rollout);
+		rolloutLines.push(...rows);
+	}
 	const preferences = extractPreferences(rolloutLines, {
 		...opts.preferences,
 		strategy: opts.preferences?.strategy ?? "paired-by-scenario-and-seed",
@@ -2112,6 +2129,7 @@ async function runRLCampaign(opts) {
 	});
 	return {
 		campaign,
+		rolloutLines,
 		rewardSignals,
 		preferences,
 		interimConfidence,