@tangle-network/agent-eval 0.129.0 → 0.130.0

package/dist/mint-yN2M2eh0.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mint-yN2M2eh0.js","names":[],"sources":["../src/rollout/mint.ts"],"sourcesContent":["/**\n * Rollout minting — `tangle.rollout.v1` lines joined from the records the\n * substrate ALREADY keeps. There is no separate rollout store: a rollout\n * is the JOIN of a RunRecord (identity, provenance, cost, outcome) with\n * its trace (spans share `runId`), projected into the canonical line.\n *\n * Composition, not duplication:\n *   - identity/provenance     → `RunRecord` (candidateId, splitTag, agentProfile, hashes)\n *   - step structure          → `buildTrajectory` over the shared TraceStore\n *   - preference-pair export  → `feedbackTrajectoryToOptimizerRow` (feedback-trajectory.ts)\n *   - PRM / reward-model      → `reward-model-export.ts`\n *\n * Anti-Goodhart invariant: a run whose `outcome.realness.gated` is true is\n * never exported with a positive reward OR with any of the numbers that reward\n * was computed from. The gate travels into the training data (`reward` forced\n * to 0, `realness_gated: true`) and the whole outcome is transformed by\n * `gateGamedOutcome` inside `assertMinted` below, which relocates `metrics` and\n * `verdict` to `provenance.gated_evidence`. Mint returns\n * `MintedRolloutLine[]`: the brand the training exporters require, which only\n * this function, `readRolloutLedger`, and an explicit `assertMinted` can mint.\n *\n * A record carrying NEITHER split score is REJECTED (`ValidationError`), never\n * minted at 0 — \"nobody graded this\" is not the same claim as \"graded a total\n * failure\", and a trainer reading 0 learns the second. Lines that already\n * carry `reward: null` (interchange imports, existing ledgers) remain valid on\n * the wire; only the RunRecord→line door refuses.\n *\n * Records without spans become labeled GAP LINES (messages: [],\n * provenance.gap) — present in the output AND surfaced in\n * `missingTraces`; a capture gap is a finding, never a silent omission.\n */\n\nimport { ValidationError } from '../errors'\nimport { type RunRecord, runTaskScore } from '../run-record'\nimport type { LlmSpan, Message, Span, ToolSpan } from '../trace/schema'\nimport type { TraceStore } from '../trace/store'\nimport { buildTrajectory } from '../trajectory'\nimport { rolloutRewardFields, scoreOrigin } from './reward'\nimport {\n  assertMinted,\n  type ChatMessage,\n  type MintedRolloutLine,\n  ROLLOUT_SCHEMA,\n  type RolloutRole,\n  type RolloutSplit,\n  type RolloutStep,\n} from './schema'\n\n/** Redactor applied to every exported string (secrets, PII). Identity by default. */\nexport type RolloutScrubber = (text: string) => string\n\nexport interface MintRolloutOptions {\n  scrub?: RolloutScrubber\n  /** Cap steps per line (longest runs first drop middle steps). Default: no cap. */\n  maxSteps?: number\n  /** Role recorded on every minted line. Default 'agent' (a solo eval run). */\n  role?: RolloutRole\n  /** Task suite label. Default: the record's `experimentId`. */\n  suite?: string\n  /** Injected clock for deterministic output. */\n  now?: () => Date\n}\n\nexport interface MintRolloutResult {\n  rows: MintedRolloutLine[]\n  /** runIds that had a RunRecord but no spans — emitted as gap lines AND listed here. */\n  missingTraces: string[]\n}\n\nconst asText = (v: unknown, scrub: RolloutScrubber): string => {\n  const s = typeof v === 'string' ? v : JSON.stringify(v)\n  return scrub(s ?? '')\n}\n\nfunction projectStep(span: Span, scrub: RolloutScrubber): RolloutStep {\n  const base: RolloutStep = {\n    kind: span.kind,\n    name: scrub(span.name),\n    status: span.status,\n    durationMs: span.endedAt !== undefined ? span.endedAt - span.startedAt : undefined,\n  }\n  if (span.kind === 'llm') {\n    const llm = span as LlmSpan\n    const last = llm.messages[llm.messages.length - 1]\n    if (last) base.input = scrub(last.content)\n    if (llm.output !== undefined) base.output = scrub(llm.output)\n  } else if (span.kind === 'tool') {\n    const tool = span as ToolSpan\n    base.input = asText(tool.args, scrub)\n    if (tool.result !== undefined) base.output = asText(tool.result, scrub)\n  }\n  return base\n}\n\n/** The final llm span's history + output is the completed conversation. */\nfunction finalConversation(spans: Span[], scrub: RolloutScrubber): ChatMessage[] {\n  const llms = spans.filter((s): s is LlmSpan => s.kind === 'llm')\n  const last = llms[llms.length - 1]\n  if (!last) return []\n  const messages: ChatMessage[] = last.messages.map((m: Message) => ({\n    role: m.role,\n    content: scrub(m.content),\n  }))\n  if (last.output !== undefined && last.output !== '') {\n    messages.push({ role: 'assistant', content: scrub(last.output) })\n  }\n  return messages\n}\n\n// The reward derivations live in the leaf module `./reward` so gate and\n// reporting code can import them without dragging in the trace store; they are\n// re-exported here because the derivations shipped from this path.\nexport {\n  isRealnessGated,\n  observedScore,\n  observedSplitScore,\n  type ScoreOrigin,\n  type ScorePreference,\n  scoreOrigin,\n  trainingReward,\n  trainingScore,\n} from './reward'\n\nconst REWARD_SOURCE: Record<ReturnType<typeof scoreOrigin>, string> = {\n  holdout: 'run-record/holdout-score',\n  search: 'run-record/search-score',\n  unscored: 'run-record/unscored',\n}\n\n/**\n * The mint door refuses an execution-only record: a missing training label is\n * not a zero reward, and not a mintable line either. Lines that already carry\n * `reward: null` — interchange imports, existing ledgers — stay valid on the\n * wire and keep their labeled gap; this guard is only about the\n * RunRecord→line door, where the producer can still be told to go score the\n * run instead of shipping an unlabeled row.\n */\nfunction requireTaskScore(record: RunRecord): void {\n  if (runTaskScore(record) === undefined) {\n    throw new ValidationError(`Cannot mint rollout for run ${record.runId}: task score is missing`)\n  }\n}\n\nconst SPLIT_FROM_TAG: Record<RunRecord['splitTag'], RolloutSplit> = {\n  search: 'search',\n  dev: 'dev',\n  holdout: 'holdout',\n}\n\nfunction mintLine(\n  record: RunRecord,\n  steps: RolloutStep[],\n  messages: ChatMessage[],\n  options: MintRolloutOptions,\n  capturedAt: string,\n  gap?: string,\n): MintedRolloutLine {\n  // A missing task score is refused before anything is built: an\n  // execution-only record has no training label, and a missing label is\n  // neither a zero reward nor a mintable row.\n  requireTaskScore(record)\n  // `reward` and `realness_gated` come out of one call, so neither door into\n  // the waist can write one and forget the other.\n  const rewardFields = rolloutRewardFields(record)\n  const uncaptured = record.costProvenance.kind === 'uncaptured'\n  const terminalOutcome = record.terminalOutcome\n  const isCompleted = terminalOutcome === 'succeeded' || terminalOutcome === 'failed'\n  const isTruncated = terminalOutcome === 'cancelled' || terminalOutcome === 'incomplete'\n  const terminalError =\n    terminalOutcome === 'failed' ||\n    terminalOutcome === 'cancelled' ||\n    terminalOutcome === 'incomplete'\n      ? (record.terminalFailureReason ?? `run ended ${terminalOutcome}`)\n      : null\n  // `assertMinted` rather than a cast: mint is the producer the whole gate\n  // rests on, so it proves the line it just built is valid instead of asserting\n  // it by fiat. The brand is unforgeable precisely because nobody casts to it.\n  return assertMinted(\n    {\n      schema: ROLLOUT_SCHEMA,\n      rollout_id: record.runId,\n      parent_rollout_id: null,\n      run_id: record.runId,\n      experiment_id: record.experimentId,\n      candidate_id: record.candidateId,\n      generation: null,\n      candidate_index: null,\n      role: options.role ?? 'agent',\n      task: {\n        suite: options.suite ?? record.experimentId,\n        instance_id: record.scenarioId,\n        split: SPLIT_FROM_TAG[record.splitTag],\n        seed: record.seed,\n        rep: 0,\n      },\n      policy: {\n        harness: null,\n        harness_version: null,\n        model: record.model,\n        provider: null,\n        profile_commit: record.commitSha,\n        prompt_hash: record.promptHash,\n        config_hash: record.configHash,\n        agent_profile_cell_id: record.agentProfile?.cellId ?? null,\n        sampling: null,\n      },\n      messages,\n      tool_defs: [],\n      ...(steps.length > 0 ? { steps } : {}),\n      outcome: {\n        ...rewardFields,\n        reward_source: REWARD_SOURCE[scoreOrigin(record)],\n        verdict: null,\n        // A verbatim bulk copy, deliberately UNFILTERED here. `outcome.raw`\n        // holds the per-layer verifier scores (`layer.*`) that the reward was\n        // derived from, so on a gated run this dict is the reward signal in\n        // component form — but filtering it at this call site is the pattern\n        // that has now leaked twice, because the next producer to write a\n        // reward-bearing field forgets. The gate is applied to the whole\n        // outcome once, in `assertMinted` below (`gateGamedOutcome`), which\n        // moves the block to `provenance.gated_evidence` when the run is gated\n        // and leaves it here untouched when it is not.\n        metrics: { ...record.outcome.raw },\n        is_completed: isCompleted,\n        is_truncated: isTruncated,\n        error: terminalError,\n      },\n      cost: {\n        usd: uncaptured ? null : record.costUsd,\n        tokens_in: record.tokenUsage.input,\n        tokens_out: record.tokenUsage.output,\n        tokens_reasoning: record.tokenUsage.reasoning ?? null,\n        cache_read: record.tokenUsage.cached ?? null,\n        cache_write: record.tokenUsage.cacheWrite ?? null,\n        wall_s: Math.round(record.wallMs / 1000),\n      },\n      artifacts: { patch_path: null, run_dir: null, transcript_ref: null },\n      provenance: {\n        captured_at: capturedAt,\n        capture: 'mint',\n        ...(gap !== undefined ? { gap } : {}),\n      },\n    },\n    `minted rollout line for run ${record.runId}`,\n  )\n}\n\n/**\n * Join RunRecords with their traces into canonical rollout lines. Records\n * without spans are emitted as labeled gap lines and reported in\n * `missingTraces`. Execution-only records without a task score are rejected\n * because a missing training label is not a zero reward.\n */\nexport async function mintRolloutRows(\n  records: RunRecord[],\n  store: TraceStore,\n  options: MintRolloutOptions = {},\n): Promise<MintRolloutResult> {\n  const scrub = options.scrub ?? ((t) => t)\n  const capturedAt = (options.now?.() ?? new Date()).toISOString()\n  const rows: MintedRolloutLine[] = []\n  const missingTraces: string[] = []\n  for (const record of records) {\n    const trajectory = await buildTrajectory(store, record.runId)\n    if (trajectory.steps.length === 0) {\n      missingTraces.push(record.runId)\n      rows.push(\n        mintLine(record, [], [], options, capturedAt, 'no trace spans recorded for this runId'),\n      )\n      continue\n    }\n    let steps = trajectory.steps.map((s) => projectStep(s.span, scrub))\n    if (options.maxSteps !== undefined && steps.length > options.maxSteps) {\n      // Keep the head and tail — the middle of a long run is the least\n      // informative for outcome attribution.\n      const head = Math.ceil(options.maxSteps / 2)\n      const tail = options.maxSteps - head\n      steps = [...steps.slice(0, head), ...steps.slice(steps.length - tail)]\n    }\n    const conversation = finalConversation(\n      trajectory.steps.map((s) => s.span),\n      scrub,\n    )\n    const gap =\n      conversation.length === 0 ? 'trace has no llm spans — no conversation to inline' : undefined\n    rows.push(mintLine(record, steps, conversation, options, capturedAt, gap))\n  }\n  return { rows, missingTraces }\n}\n"],"mappings":"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"}

package/dist/multi-layer-verifier-BHY1gWAc.d.ts

@@ -0,0 +1,138 @@
+import { t as DefaultVerdict } from "./verdict-Dps8_okt.js";
+//#region src/multi-layer-verifier.d.ts
+type LayerStatus = 'pass' | 'fail' | 'skipped' | 'error' | 'timeout';
+type Severity = 'critical' | 'major' | 'minor' | 'info';
+interface Finding {
+  severity: Severity;
+  message: string;
+  evidence?: string;
+  /** Optional layer name the finding belongs to (set by the verifier if omitted). */
+  layer?: string;
+  /**
+   * Free-form structured payload — used by `multiToolchainLayer` to attach
+   * `{ adapter: 'pnpm' }`, by judges to attach evidence pointers, etc.
+   * Renderers MAY interrogate; agent-eval primitives never assume shape.
+   */
+  detail?: Record<string, unknown>;
+}
+interface LayerResult {
+  layer: string;
+  status: LayerStatus;
+  /** Origin of an `error` or `timeout`. Defaults to `execution`. */
+  errorSource?: 'execution' | 'judge';
+  /** 0..1 score, optional — layers that don't produce a numeric score omit. */
+  score?: number;
+  durationMs: number;
+  findings: Finding[];
+  /** Short human-readable summary (one line). */
+  reason?: string;
+  /**
+   * Numeric layer-level diagnostics: error counts, warning counts,
+   * cyclomatic complexity, total adapter wall-time, etc. Keyed by
+   * diagnostic name; null = "diagnostic not applicable / not measured."
+   * Renderers that know the keys can display them; ones that don't,
+   * ignore. Free-form on purpose — consumers type the value shape in
+   * their own namespace.
+   */
+  diagnostics?: Record<string, number | null>;
+  /** Any rich per-layer detail — rendered as-is by consumers that know the layer. */
+  detail?: Record<string, unknown>;
+}
+interface VerifyContext<Env = unknown> {
+  /** Per-run opaque context the caller provides. Layers destructure what they need. */
+  env: Env;
+  /** Previously-computed results from layers that already ran. */
+  prior: Record<string, LayerResult>;
+  /** Signal — if aborted, layers MUST bail within reasonable wall. */
+  signal: AbortSignal;
+}
+interface Layer<Env = unknown> {
+  name: string;
+  /** Origin assigned when this layer errors or times out. Defaults to `execution`. */
+  errorSource?: 'execution' | 'judge';
+  /** Stages that must have `status: 'pass'` before this layer runs. */
+  dependsOn?: string[];
+  /**
+   * Weight in the composite `blendedScore`. Default 1.0. Layers with weight 0
+   * contribute findings but not score.
+   */
+  weight?: number;
+  /**
+   * If true, a `fail` status contributes to `blendedScore` (as 0) instead of
+   * being dropped — use for layers whose failure is a real signal. Default:
+   * fail drops from numerator + denominator, matching VB's existing semantics.
+   */
+  failContributesToScore?: boolean;
+  /** Optional per-layer wall-cap in ms. Honored by the verifier (AbortSignal). */
+  capMs?: number;
+  run: (ctx: VerifyContext<Env>) => Promise<LayerResult> | LayerResult;
+}
+interface VerifyOptions<Env = unknown> {
+  env: Env;
+  /**
+   * Overall wall cap. Default: sum of layer capMs, or Infinity if any layer
+   * omits a cap. The verifier short-circuits remaining layers on overall cap.
+   */
+  overallCapMs?: number;
+  /** Called with each layer result as it completes. */
+  onLayer?: (result: LayerResult) => void;
+}
+/** Extends the substrate verdict spine: `valid` = `allPass`; `score` is the
+ * complete task score or 0 when the configured scoring panel was incomplete. */
+interface VerificationReport extends DefaultVerdict {
+  layers: LayerResult[];
+  passCount: number;
+  failCount: number;
+  skippedCount: number;
+  errorCount: number;
+  /** True iff the configured scoring panel completed and every layer passed. */
+  allPass: boolean;
+  /**
+   * Diagnostic weighted mean across contributing layers. This may represent a
+   * partial panel. It is 0 when no layer contributed.
+   */
+  blendedScore: number;
+  /**
+   * Complete task-quality measurement.
+   * Present when at least one layer produced a valid score, every other layer
+   * completed successfully or contributed an explicit scored failure, and no
+   * result is missing because of a failure, skip, error, or timeout.
+   * Use this field, not `blendedScore`, when creating task labels.
+   */
+  taskScore?: number;
+  durationMs: number;
+  startedAt: string;
+  finishedAt: string;
+}
+/**
+ * Grade a semantic-concept-style judge result into a single layer status.
+ *
+ * Pass when overall score >= threshold AND no critical-severity concept gap.
+ * Fail otherwise. Use inside a `Layer.run` when wrapping a concept judge.
+ *
+ * Generalized from VerticalBench H3 fix: `failingConcepts.length === 0` was
+ * too strict — a single concept at 6/10 failed the entire layer despite
+ * overall score being >= 0.7. Now we trust the judge's own `severity` field:
+ * `critical` findings veto; `major`/`minor` reduce the score but don't veto.
+ */
+declare function gradeSemanticStatus(input: {
+  score: number;
+  findings: Array<{
+    severity: Severity;
+    present?: boolean;
+    score?: number;
+  }>;
+  available: boolean;
+  threshold?: number;
+}): LayerStatus;
+/**
+ * Ordered DAG of verification layers with dependency-based skipping, per-layer findings, soft-fail semantics, and a blended composite score across all passed layers.
+ */
+declare class MultiLayerVerifier<Env = unknown> {
+  private readonly layers;
+  constructor(layers: Layer<Env>[]);
+  run(opts: VerifyOptions<Env>): Promise<VerificationReport>;
+}
+//#endregion
+export { MultiLayerVerifier as a, VerifyContext as c, LayerStatus as i, VerifyOptions as l, Layer as n, Severity as o, LayerResult as r, VerificationReport as s, Finding as t, gradeSemanticStatus as u };
+//# sourceMappingURL=multi-layer-verifier-BHY1gWAc.d.ts.map

package/dist/multi-layer-verifier-BHY1gWAc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi-layer-verifier-BHY1gWAc.d.ts","names":[],"sources":["../src/multi-layer-verifier.ts"],"mappings":";;KA4BY;KAEA;UAEK;EACf,UAAU;EACV;EACA;;EAEA;;;;;;EAMA,SAAS;;UAGM;EACf;EACA,QAAQ;;EAER;;EAEA;EACA;EACA,UAAU;;EAEV;;;;;;;;;EASA,cAAc;;EAEd,SAAS;;UAGM,cAAc;;EAE7B,KAAK;;EAEL,OAAO,eAAe;;EAEtB,QAAQ;;UAGO,MAAM;EACrB;;EAEA;;EAEA;;;;;EAKA;;;;;;EAMA;;EAEA;EACA,MAAM,KAAK,cAAc,SAAS,QAAQ,eAAe;;UAG1C,cAAc;EAC7B,KAAK;;;;;EAKL;;EAEA,WAAW,QAAQ;;;;UAKJ,2BAA2B;EAC1C,QAAQ;EACR;EACA;EACA;EACA;;EAEA;;;;;EAKA;;;;;;;;EAQA;EACA;EACA;EACA;;;;;;;;;;;;;iBAgBc,oBAAoB;EAClC;EACA,UAAU;IAAQ,UAAU;IAAU;IAAmB;;EACzD;EACA;IACE;;;;cAcS,mBAAmB;mBACD;EAA7B,YAA6B,QAAQ,MAAM;EAiBrC,IAAI,MAAM,cAAc,OAAO,QAAQ"}