@tangle-network/agent-eval 0.119.1 → 0.120.0

package/dist/contract/index.js

@@ -13,12 +13,15 @@ import {
 import {
   analyzeRuns,
   summarizeExecution
-} from "../chunk-XJ7JVCHB.js";
+} from "../chunk-3A246TSA.js";
 import {
   REFERENCE_EQUIVALENCE_INPUT_LIMITS,
   REFERENCE_EQUIVALENCE_JUDGE_VERSION,
   buildEvidenceVector,
+  buildLoopProvenanceRecord,
+  campaignBreakdown,
   campaignMeanComposite,
+  canonicalDigest,
   composeGate,
   createReferenceEquivalenceJudge,
   defaultProductionGate,
@@ -26,24 +29,30 @@ import {
   evolutionaryProposer,
   gepaProposer,
   heldOutGate,
+  loopProvenanceArgsFromResult,
   pairArms,
   paretoPolicy,
   paretoSignificanceGate,
   powerPreflight,
+  renderSurfaceDiff,
   runEval,
   runImprovementLoop,
   runReferenceEquivalenceJudge,
   surfaceContentHash,
-  surfaceHash
-} from "../chunk-PSXJ32SR.js";
+  surfaceHash,
+  verifyLoopProvenanceRecord
+} from "../chunk-32BZXMSO.js";
 import {
-  canonicalJson,
+  assertCampaignSplitIdentity,
+  assertRealAgentReceipts,
+  campaignCoverage,
+  campaignSplitDigest,
   createRunCostLedger,
   fsCampaignStorage,
   inMemoryCampaignStorage,
   resolveRunDir,
   runCampaign
-} from "../chunk-PAHNGS65.js";
+} from "../chunk-XDIRG3TO.js";
 import {
   buildDefaultAnalystRegistry,
   createChatClient
@@ -60,7 +69,9 @@ import "../chunk-DPZAEKA6.js";
 import {
   pairedBootstrap
 } from "../chunk-PJQFMIOX.js";
-import "../chunk-JHOJHHU7.js";
+import {
+  CostLedger
+} from "../chunk-JHOJHHU7.js";
 import "../chunk-VI2UW6B6.js";
 import {
   recordAggregateMeasurements,
@@ -253,29 +264,17 @@ async function runSelfImprove(opts, costLedger, startedAt, runDir, storage) {
     candidateCandidateId: "winner"
   });
   const durationMs = Date.now() - startedAt;
-  const workerRecords = opts.collectWorkerRecords?.() ?? cellsToRunRecords(result.winnerOnHoldout.cells, "winner", runDir, result.winnerSurface);
   const { record: provenance } = await emitLoopProvenance({
-    runId: `${runDir}#${startedAt}`,
-    runDir,
-    timestamp: new Date(startedAt).toISOString(),
-    baselineSurface: opts.baselineSurface,
-    winnerSurface: result.winnerSurface,
-    winnerLabel: result.winnerLabel,
-    winnerRationale: result.winnerRationale,
-    diff: result.promotedDiff,
-    baselineSearchComposite: campaignMeanComposite(result.baselineCampaign),
-    generations: result.generations.map((g) => ({
-      generationIndex: g.record.generationIndex,
-      candidates: g.record.candidates,
-      promoted: g.record.promoted,
-      surfaces: g.surfaces.map((s) => ({ surfaceHash: s.surfaceHash, surface: s.surface }))
-    })),
-    gate: result.gateResult,
-    baselineOnHoldout: result.baselineOnHoldout,
-    winnerOnHoldout: result.winnerOnHoldout,
-    workerRecords,
-    totalCostUsd: totalCost,
-    totalDurationMs: durationMs,
+    ...loopProvenanceArgsFromResult({
+      runId: `${runDir}#${startedAt}`,
+      runDir,
+      timestamp: new Date(startedAt).toISOString(),
+      baselineSurface: opts.baselineSurface,
+      result,
+      costReceipts: costLedger.list(),
+      totalCostUsd: totalCost,
+      totalDurationMs: durationMs
+    }),
     storage,
     hostedClient: opts.hostedTenant ? createHostedClient(opts.hostedTenant) : void 0
   });
@@ -423,7 +422,13 @@ function cellsToRunRecords(cells, candidateId, runId, surface) {
       commitSha: "cell",
       wallMs: cell.durationMs,
       costUsd: cell.costUsd,
-      tokenUsage: { input: 0, output: 0 },
+      tokenUsage: {
+        input: cell.tokenUsage.input,
+        output: cell.tokenUsage.output,
+        ...cell.tokenUsage.reasoning === void 0 ? {} : { reasoning: cell.tokenUsage.reasoning },
+        ...cell.tokenUsage.cached === void 0 ? {} : { cached: cell.tokenUsage.cached },
+        ...cell.tokenUsage.cacheWrite === void 0 ? {} : { cacheWrite: cell.tokenUsage.cacheWrite }
+      },
       outcome: {
         holdoutScore: composite,
         raw: {},
@@ -541,17 +546,35 @@ function requirePositiveInteger(value, field) {
 }
 
 // src/contract/measured-comparison.ts
-import { createHash as createHash2 } from "crypto";
 import {
   agentImprovementMeasuredComparisonSchema
 } from "@tangle-network/agent-interface";
 function measuredComparisonFromSelfImproveResult(options) {
   const { result } = options;
+  verifyLoopProvenanceRecord(result.provenance);
   const power = result.power;
   if (!power) throw new Error("agent improvement comparison requires heldout power analysis");
   if (result.provenance.gate.reasons.length === 0) {
     throw new Error("agent improvement comparison requires measured decision reasons");
   }
+  const receiptLedger = new CostLedger({ receipts: result.receipts });
+  const receiptCost = receiptLedger.summary();
+  const receipts = receiptLedger.list();
+  assertRealAgentReceipts(receipts, { allowMixed: false });
+  const receiptsById = new Map(receipts.map((receipt) => [receipt.callId, receipt]));
+  const receiptIdsByCell = indexReceiptIdsByCell(receipts);
+  assertCompleteMeasuredCampaign(
+    result.raw.baselineOnHoldout,
+    "heldout baseline",
+    receiptsById,
+    receiptIdsByCell
+  );
+  assertCompleteMeasuredCampaign(
+    result.raw.winnerOnHoldout,
+    "heldout candidate",
+    receiptsById,
+    receiptIdsByCell
+  );
   const pairs = pairMeasuredCells(
     result.raw.baselineOnHoldout.cells,
     result.raw.winnerOnHoldout.cells
@@ -569,10 +592,103 @@ function measuredComparisonFromSelfImproveResult(options) {
   assertMeasuredNumber(result.lift, composite.delta, "heldout lift");
   assertMeasuredNumber(result.baseline.compositeMean, composite.baseline, "heldout baseline");
   assertMeasuredNumber(result.winner.compositeMean, composite.candidate, "heldout candidate");
-  assertMeasuredNumber(result.provenance.heldOutLift, composite.delta, "provenance heldout lift");
-  if (result.gateDecision !== result.provenance.gate.decision || power.n !== composite.n || power.confidence !== 0.95) {
-    throw new Error("agent improvement measurement sources do not agree");
+  const baselineContentHash = surfaceContentHash(options.baselineSurface);
+  const candidateContentHash = surfaceContentHash(result.winner.surface);
+  const canonicalDiff = baselineContentHash === candidateContentHash ? "" : renderSurfaceDiff(result.raw.winnerSurface, options.baselineSurface);
+  assertMeasuredIdentity(result.gateDecision, result.raw.gateResult.decision, "raw decision");
+  assertMeasuredIdentity(
+    candidateContentHash,
+    surfaceContentHash(result.raw.winnerSurface),
+    "raw winner surface"
+  );
+  assertMeasuredIdentity(result.diff, canonicalDiff, "surface diff");
+  assertMeasuredIdentity(result.raw.promotedDiff, canonicalDiff, "raw surface diff");
+  if (result.gateDecision === "ship" && (baselineContentHash === candidateContentHash || result.diff.trim().length === 0)) {
+    throw new Error("a shipped improvement requires a changed surface and non-empty diff");
+  }
+  assertMeasuredIdentity(
+    canonicalDigest(power),
+    canonicalDigest(
+      powerPreflight({
+        baselineComposites: pairs.map(([cell]) => measuredComposite(cell)),
+        sharedScorerChannel: true
+      })
+    ),
+    "power analysis"
+  );
+  assertMeasuredNumber(power.n, composite.n, "power sample size");
+  assertMeasuredNumber(power.confidence, 0.95, "power confidence");
+  assertCompleteMeasuredCampaign(
+    result.raw.baselineCampaign,
+    "search baseline",
+    receiptsById,
+    receiptIdsByCell
+  );
+  assertGenerationMeasurements(result.raw.generations, receiptsById, receiptIdsByCell);
+  if (result.raw.neutralizedOnHoldout === void 0 !== (result.raw.neutralizedSurface === void 0)) {
+    throw new Error("neutralized surface and campaign must be supplied together");
+  }
+  if (result.raw.neutralizedOnHoldout) {
+    assertCompleteMeasuredCampaign(
+      result.raw.neutralizedOnHoldout,
+      "heldout neutralized",
+      receiptsById,
+      receiptIdsByCell
+    );
+    pairMeasuredCells(result.raw.baselineOnHoldout.cells, result.raw.neutralizedOnHoldout.cells);
+  }
+  const rebuiltProvenance = buildLoopProvenanceRecord(
+    loopProvenanceArgsFromResult({
+      runId: result.provenance.runId,
+      runDir: result.provenance.runDir,
+      timestamp: result.provenance.timestamp,
+      baselineSurface: options.baselineSurface,
+      result: result.raw,
+      costReceipts: receipts,
+      totalCostUsd: result.totalCostUsd,
+      totalDurationMs: result.durationMs
+    })
+  );
+  assertMeasuredIdentity(
+    result.provenance.recordDigest,
+    rebuiltProvenance.recordDigest,
+    "provenance record"
+  );
+  assertMeasuredIdentity(
+    options.benchmark.splitDigest,
+    rebuiltProvenance.evidence.holdout.splitDigest,
+    "benchmark heldout split"
+  );
+  const generationsExplored = result.raw.generations.length;
+  assertMeasuredNumber(result.generationsExplored, generationsExplored, "generation count");
+  assertMeasuredNumber(result.totalCostUsd, result.cost.totalCostUsd, "cost summary");
+  assertMeasuredIdentity(
+    canonicalDigest(result.cost),
+    canonicalDigest(result.raw.cost),
+    "raw cost summary"
+  );
+  if (!result.cost.accountingComplete) {
+    throw new Error(
+      `cost accounting is incomplete: ${result.cost.incompleteReasons.join("; ") || "unknown reason"}`
+    );
+  }
+  if (!receiptCost.accountingComplete) {
+    throw new Error(
+      `cost accounting is incomplete: ${receiptCost.incompleteReasons.join("; ") || "unknown reason"}`
+    );
   }
+  assertMeasuredIdentity(
+    canonicalDigest(result.cost),
+    canonicalDigest(receiptCost),
+    "cost receipt summary"
+  );
+  assertMeasuredNumber(result.totalCostUsd, receiptCost.totalCostUsd, "cost receipts");
+  assertMeasuredOptional(result.winner.label, result.raw.winnerLabel, "raw winner label");
+  assertMeasuredOptional(
+    result.winner.rationale,
+    result.raw.winnerRationale,
+    "raw winner rationale"
+  );
   return agentImprovementMeasuredComparisonSchema.parse({
     schemaVersion: 1,
     kind: "agent-improvement-measured-comparison",
@@ -598,8 +714,8 @@ function measuredComparisonFromSelfImproveResult(options) {
     } : {},
     decision: {
       outcome: result.gateDecision,
-      reasons: result.provenance.gate.reasons,
-      contributingChecks: result.provenance.gate.contributingGates.map((check) => ({
+      reasons: rebuiltProvenance.gate.reasons,
+      contributingChecks: rebuiltProvenance.gate.contributingGates.map((check) => ({
         name: check.name,
         passed: check.passed
       }))
@@ -615,20 +731,98 @@ function measuredComparisonFromSelfImproveResult(options) {
     },
     provenance: {
       kind: "agent-eval-loop",
-      schema: result.provenance.schema,
-      runId: result.provenance.runId,
-      recordDigest: digest(result.provenance),
-      baselineContentHash: result.provenance.baselineContentHash,
-      candidateContentHash: result.provenance.winnerContentHash
+      schema: rebuiltProvenance.schema,
+      runId: rebuiltProvenance.runId,
+      recordDigest: rebuiltProvenance.recordDigest,
+      baselineContentHash,
+      candidateContentHash
     },
-    diff: result.diff,
+    diff: canonicalDiff,
     evaluation: {
-      generationsExplored: result.generationsExplored,
+      generationsExplored,
       durationMs: result.durationMs,
       totalCostUsd: result.totalCostUsd
     }
   });
 }
+function assertGenerationMeasurements(generations, receiptsById, receiptIdsByCell) {
+  for (const generation of generations) {
+    for (const measured of generation.surfaces) {
+      const candidate = generation.record.candidates.find(
+        (entry) => entry.surfaceHash === measured.surfaceHash
+      );
+      if (!candidate) {
+        throw new Error(
+          `generation ${generation.record.generationIndex} is missing candidate ${measured.surfaceHash}`
+        );
+      }
+      const composite = campaignMeanComposite(measured.campaign);
+      const breakdown = campaignBreakdown(measured.campaign);
+      const coverage = campaignCoverage(
+        measured.campaign.cells,
+        measured.campaign.scenarios,
+        measured.campaign.reps,
+        true
+      );
+      assertScorableMeasuredCells(
+        measured.campaign,
+        coverage.scorableCellIds,
+        receiptsById,
+        receiptIdsByCell
+      );
+      assertMeasuredNumber(
+        candidate.composite,
+        composite,
+        `candidate ${measured.surfaceHash} composite`
+      );
+      if (!candidate.coverage) {
+        throw new Error(`candidate ${measured.surfaceHash} does not report campaign coverage`);
+      }
+      assertMeasuredIdentity(
+        canonicalDigest(candidate.coverage),
+        canonicalDigest({
+          expectedCells: coverage.expectedCellIds.length,
+          scorableCells: coverage.scorableCellIds.length,
+          unscorableCells: coverage.unscorableCells
+        }),
+        `candidate ${measured.surfaceHash} coverage`
+      );
+      assertMeasuredIdentity(
+        String(candidate.eligibleForPromotion),
+        String(coverage.complete),
+        `candidate ${measured.surfaceHash} eligibility`
+      );
+      assertMeasuredIdentity(
+        canonicalDigest(candidate.dimensions),
+        canonicalDigest(breakdown.dimensions),
+        `candidate ${measured.surfaceHash} dimensions`
+      );
+      assertMeasuredIdentity(
+        canonicalDigest(candidate.scenarios),
+        canonicalDigest(breakdown.scenarios),
+        `candidate ${measured.surfaceHash} scenarios`
+      );
+    }
+  }
+}
+function assertCompleteMeasuredCampaign(campaign, name, receiptsById, receiptIdsByCell) {
+  assertCampaignSplitIdentity(campaign.scenarios, campaign.reps, campaign.splitDigest);
+  const coverage = campaignCoverage(campaign.cells, campaign.scenarios, campaign.reps, true);
+  if (!coverage.complete) {
+    throw new Error(
+      `${name} is incomplete (${coverage.scorableCellIds.length}/${coverage.expectedCellIds.length} designed cells scorable)`
+    );
+  }
+  assertScorableMeasuredCells(campaign, coverage.scorableCellIds, receiptsById, receiptIdsByCell);
+}
+function assertScorableMeasuredCells(campaign, scorableCellIds, receiptsById, receiptIdsByCell) {
+  const cellsById = new Map(campaign.cells.map((cell) => [cell.cellId, cell]));
+  for (const cellId of scorableCellIds) {
+    const cell = cellsById.get(cellId);
+    if (!cell) throw new Error(`measured campaign is missing scorable cell ${cellId}`);
+    assertMeasuredCell(cell, receiptsById, receiptIdsByCell, campaign.runDir);
+  }
+}
 function measuredObjectives(pairs) {
   const qualityColumns = /* @__PURE__ */ new Map();
   for (const [baseline, candidate] of pairs) {
@@ -673,19 +867,6 @@ function measuredObjectives(pairs) {
 function measuredCostObjective(pairs) {
   const cells = pairs.flat();
   for (const cell of cells) finiteMeasuredValue(cell.costUsd, "cost:cost");
-  const reported = cells.some(
-    (cell) => cell.costUsd !== 0 || cell.tokenUsage !== void 0 && (cell.tokenUsage.input > 0 || cell.tokenUsage.output > 0)
-  );
-  if (!reported) {
-    return {
-      kind: "cost",
-      name: "cost",
-      availability: "unavailable",
-      reason: "heldout cells did not report model usage or cost",
-      direction: "lower-is-better",
-      unit: "usd"
-    };
-  }
   return measuredObjective(
     {
       kind: "cost",
@@ -705,7 +886,8 @@ function measuredComposite(cell) {
   return measuredMean(values);
 }
 function pairMeasuredCells(baselineCells, candidateCells) {
-  const errors = [...baselineCells, ...candidateCells].filter((cell) => cell.error);
+  const cells = [...baselineCells, ...candidateCells];
+  const errors = cells.filter((cell) => cell.error);
   if (errors.length > 0) {
     throw new Error(
       `measured objectives cannot publish ${errors.length} errored heldout cells: ${errors.map((cell) => measuredCellKey(cell)).join(", ")}`
@@ -729,9 +911,88 @@ function pairMeasuredCells(baselineCells, candidateCells) {
   if (paired.pairs.length === 0 || paired.unpairedBaseline.length > 0 || paired.unpairedTreatment.length > 0) {
     throw new Error("measured objectives require the same non-empty paired heldout cells");
   }
-  return paired.pairs.map(
-    (pair) => [pair.baseline.cell, pair.treatment.cell]
+  return paired.pairs.map((pair) => {
+    const baseline = pair.baseline.cell;
+    const candidate = pair.treatment.cell;
+    if (baseline.seed !== candidate.seed) {
+      throw new Error(`heldout cell ${baseline.cellId} does not share one paired seed`);
+    }
+    return [baseline, candidate];
+  });
+}
+function assertMeasuredCell(cell, receiptsById, receiptIdsByCell, runDir) {
+  if (!cell.scenarioId.trim() || !Number.isSafeInteger(cell.rep) || cell.rep < 0 || !Number.isSafeInteger(cell.seed) || cell.cellId !== measuredCellKey(cell)) {
+    throw new Error(`heldout cell '${cell.cellId}' has an invalid scenario/rep identity`);
+  }
+  nonnegativeMeasuredValue(cell.costUsd, `heldout cell ${cell.cellId} cost`);
+  nonnegativeMeasuredValue(cell.durationMs, `heldout cell ${cell.cellId} latency`);
+  if (!cell.tokenUsage) {
+    throw new Error(`heldout cell ${cell.cellId} does not report token usage`);
+  }
+  nonnegativeMeasuredInteger(cell.tokenUsage.input, `heldout cell ${cell.cellId} input tokens`);
+  nonnegativeMeasuredInteger(cell.tokenUsage.output, `heldout cell ${cell.cellId} output tokens`);
+  if (cell.tokenUsage.cached !== void 0) {
+    nonnegativeMeasuredInteger(cell.tokenUsage.cached, `heldout cell ${cell.cellId} cached tokens`);
+  }
+  if (!Array.isArray(cell.costCallIds)) {
+    throw new Error(`heldout cell ${cell.cellId} does not identify its cost receipts`);
+  }
+  if (new Set(cell.costCallIds).size !== cell.costCallIds.length) {
+    throw new Error(`heldout cell ${cell.cellId} repeats a cost receipt`);
+  }
+  const linkedReceipts = cell.costCallIds.map((callId) => {
+    const receipt = receiptsById.get(callId);
+    if (!receipt)
+      throw new Error(`heldout cell ${cell.cellId} references missing cost receipt ${callId}`);
+    if (receipt.tags?.runDir !== runDir || receipt.tags.cellId !== cell.cellId || receipt.tags.scenarioId !== cell.scenarioId || receipt.tags.rep !== String(cell.rep)) {
+      throw new Error(`heldout cell ${cell.cellId} references a cost receipt from another cell`);
+    }
+    return receipt;
+  });
+  assertMeasuredIdentity(
+    canonicalDigest([...cell.costCallIds].sort()),
+    canonicalDigest(
+      [
+        ...receiptIdsByCell.get(receiptCellKey(runDir, cell.cellId, cell.scenarioId, cell.rep)) ?? []
+      ].sort()
+    ),
+    `heldout cell ${cell.cellId} cost receipt IDs`
   );
+  const agentReceipts = linkedReceipts.filter((receipt) => receipt.channel === "agent");
+  if (agentReceipts.some((receipt) => receipt.error)) {
+    throw new Error(`measured cell ${cell.cellId} links a failed agent receipt`);
+  }
+  assertRealAgentReceipts(agentReceipts, { allowMixed: false });
+  assertMeasuredNumber(
+    cell.costUsd,
+    agentReceipts.reduce((total, receipt) => total + receipt.costUsd, 0),
+    `heldout cell ${cell.cellId} cost receipts`
+  );
+  assertMeasuredNumber(
+    cell.tokenUsage.input,
+    agentReceipts.reduce((total, receipt) => total + receipt.inputTokens, 0),
+    `heldout cell ${cell.cellId} input receipts`
+  );
+  assertMeasuredNumber(
+    cell.tokenUsage.output,
+    agentReceipts.reduce((total, receipt) => total + receipt.outputTokens, 0),
+    `heldout cell ${cell.cellId} output receipts`
+  );
+  assertMeasuredNumber(
+    cell.tokenUsage.cached ?? 0,
+    agentReceipts.reduce((total, receipt) => total + (receipt.cachedTokens ?? 0), 0),
+    `heldout cell ${cell.cellId} cached receipts`
+  );
+  for (const [judge, score] of Object.entries(cell.judgeScores)) {
+    if (score.failed) {
+      throw new Error(`heldout cell ${cell.cellId} contains failed judge '${judge}'`);
+    }
+    finiteMeasuredValue(score.composite, `objective:${judge}`);
+    for (const [dimension, value] of Object.entries(score.dimensions)) {
+      finiteMeasuredValue(value, `dimension:${judge}:${dimension}`);
+    }
+  }
+  measuredComposite(cell);
 }
 function measuredObjective(identity, pairs, value) {
   const key = measuredObjectiveKey(identity);
@@ -788,6 +1049,16 @@ function finiteMeasuredValue(value, name) {
   if (!Number.isFinite(value)) throw new Error(`measured objective '${name}' is not finite`);
   return value;
 }
+function nonnegativeMeasuredValue(value, name) {
+  if (!Number.isFinite(value) || value < 0) throw new Error(`${name} must be non-negative`);
+  return value;
+}
+function nonnegativeMeasuredInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`${name} must be a non-negative safe integer`);
+  }
+  return value;
+}
 function measuredMean(values) {
   if (values.length === 0) throw new Error("measured objective has no paired values");
   return values.reduce((sum, value) => sum + value, 0) / values.length;
@@ -805,10 +1076,26 @@ function assertMeasuredNumber(actual, expected, name) {
     throw new Error(`${name} does not agree across the measured comparison`);
   }
 }
-function digest(value) {
-  const json = JSON.stringify(value);
-  if (json === void 0) throw new Error("agent improvement provenance is not serializable");
-  return `sha256:${createHash2("sha256").update(canonicalJson(JSON.parse(json))).digest("hex")}`;
+function assertMeasuredIdentity(actual, expected, name) {
+  if (actual !== expected) throw new Error(`${name} does not agree across the measured comparison`);
+}
+function assertMeasuredOptional(actual, expected, name) {
+  if (actual !== expected) throw new Error(`${name} does not agree across the measured comparison`);
+}
+function indexReceiptIdsByCell(receipts) {
+  const idsByCell = /* @__PURE__ */ new Map();
+  for (const receipt of receipts) {
+    const tags = receipt.tags;
+    if (!tags?.runDir || !tags.cellId || !tags.scenarioId || tags.rep === void 0) continue;
+    const key = receiptCellKey(tags.runDir, tags.cellId, tags.scenarioId, tags.rep);
+    const ids = idsByCell.get(key) ?? [];
+    ids.push(receipt.callId);
+    idsByCell.set(key, ids);
+  }
+  return idsByCell;
+}
+function receiptCellKey(runDir, cellId, scenarioId, rep) {
+  return JSON.stringify([runDir, cellId, scenarioId, String(rep)]);
 }
 
 // src/contract/eval-reporting-suite.ts
@@ -1326,6 +1613,7 @@ export {
   analyzeRuns,
   buildDefaultAnalystRegistry,
   buildEvidenceVector,
+  campaignSplitDigest,
   composeGate,
   createChatClient,
   createReferenceEquivalenceJudge,