@tangle-network/agent-eval 0.14.0 → 0.14.2

package/dist/index.d.ts

@@ -6568,6 +6568,13 @@ interface LineageNode {
     /** Filled when scoring lands. */
     meanScore?: number;
     promotedToFrontier?: boolean;
+    /**
+     * The variant payload (e.g. evolved persona text, code mutation diff).
+     * Persisted so a winning variant can be reproduced after a run completes
+     * without re-running the optimizer. Optional — pass `omitPayload: true` to
+     * `upsertVariant` for cases where the payload is too large to log.
+     */
+    payload?: unknown;
 }
 /**
  * `kindOf` decides whether a variant is a seed (no parent), code mutation,
@@ -6600,7 +6607,9 @@ declare class LineageRecorder<P = unknown> {
     private readonly kindOf;
     constructor(path: string, kindOf?: LineageKindResolver<P>);
     upsert(node: LineageNode): Promise<void>;
-    upsertVariant(variant: PromptVariant<P>): Promise<void>;
+    upsertVariant(variant: PromptVariant<P>, opts?: {
+        omitPayload?: boolean;
+    }): Promise<void>;
     snapshot(): LineageNode[];
     /**
      * Write the current consolidated state to `<path>.snapshot` so external

package/dist/index.js

@@ -10252,13 +10252,14 @@ function aggregateTrials(population, scenarioIds, trials) {
     const scenarios = scenarioIds.map((sid) => {
       const scenarioTrials = variantTrials.filter((t) => t.scenarioId === sid);
       const okTrials = scenarioTrials.filter((t) => t.ok);
-      const metrics = aggregateMetrics(okTrials.map((t) => t.metrics ?? {}));
+      const gradedTrials = scenarioTrials.filter((t) => !t.error);
+      const metrics = aggregateMetrics(gradedTrials.map((t) => t.metrics ?? {}));
       return {
         variantId: variant.id,
         scenarioId: sid,
-        meanScore: mean5(okTrials.map((t) => t.score)),
-        meanCost: mean5(okTrials.map((t) => t.cost ?? 0)),
-        meanDurationMs: mean5(okTrials.map((t) => t.durationMs ?? 0)),
+        meanScore: mean5(gradedTrials.map((t) => t.score)),
+        meanCost: mean5(gradedTrials.map((t) => t.cost ?? 0)),
+        meanDurationMs: mean5(gradedTrials.map((t) => t.durationMs ?? 0)),
         okRate: scenarioTrials.length === 0 ? 0 : okTrials.length / scenarioTrials.length,
         trials: scenarioTrials.length,
         metrics
@@ -10493,13 +10494,14 @@ var LineageRecorder = class {
 `);
     });
   }
-  async upsertVariant(variant) {
+  async upsertVariant(variant, opts = {}) {
     await this.upsert({
       id: variant.id,
       parentId: variant.parentId ?? null,
       generation: variant.generation,
       kind: this.kindOf(variant),
-      ...variant.rationale ? { rationale: variant.rationale } : {}
+      ...variant.rationale ? { rationale: variant.rationale } : {},
+      ...opts.omitPayload || variant.payload === void 0 ? {} : { payload: variant.payload }
     });
   }
   snapshot() {
@@ -11212,17 +11214,34 @@ function quote(s) {
 function parseReflectionResponse(raw, maxProposals) {
   let text = raw.trim();
   if (text.startsWith("```")) text = text.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "");
-  const start = text.indexOf("{");
-  const end = text.lastIndexOf("}");
-  if (start < 0 || end <= start) return [];
-  let parsed;
-  try {
-    parsed = JSON.parse(text.slice(start, end + 1));
-  } catch {
-    return [];
+  let parsed = null;
+  const objectStart = text.indexOf("{");
+  const objectEnd = text.lastIndexOf("}");
+  const arrayStart = text.indexOf("[");
+  const arrayEnd = text.lastIndexOf("]");
+  const tryObjectFirst = objectStart >= 0 && (arrayStart < 0 || objectStart < arrayStart);
+  const candidates = [];
+  if (tryObjectFirst) {
+    if (objectStart >= 0 && objectEnd > objectStart) candidates.push(text.slice(objectStart, objectEnd + 1));
+    if (arrayStart >= 0 && arrayEnd > arrayStart) candidates.push(text.slice(arrayStart, arrayEnd + 1));
+  } else {
+    if (arrayStart >= 0 && arrayEnd > arrayStart) candidates.push(text.slice(arrayStart, arrayEnd + 1));
+    if (objectStart >= 0 && objectEnd > objectStart) candidates.push(text.slice(objectStart, objectEnd + 1));
+  }
+  for (const slice of candidates) {
+    try {
+      parsed = JSON.parse(slice);
+      break;
+    } catch {
+    }
+  }
+  if (parsed == null) return [];
+  let proposalsRaw;
+  if (Array.isArray(parsed)) {
+    proposalsRaw = parsed;
+  } else if (parsed && typeof parsed === "object") {
+    proposalsRaw = parsed.proposals;
   }
-  if (!parsed || typeof parsed !== "object") return [];
-  const proposalsRaw = parsed.proposals;
   if (!Array.isArray(proposalsRaw)) return [];
   const out = [];
   for (const p of proposalsRaw) {