@absolutejs/absolute 0.19.0-beta.533 → 0.19.0-beta.534

package/dist/react/ai/index.js

@@ -2131,6 +2131,166 @@ var buildGroundingCaseSnapshots = ({
   });
 };
 var getStatusRank = (status) => status === "pass" ? 2 : status === "partial" ? 1 : 0;
+var formatSignedDelta = (value, decimals = 0, suffix = "") => `${value >= 0 ? "+" : ""}${value.toFixed(decimals)}${suffix}`;
+var formatEvaluationSummary = (response) => `${response.summary.passedCases}/${response.totalCases} pass \xB7 f1 ${response.summary.averageF1.toFixed(3)} \xB7 latency ${response.summary.averageLatencyMs.toFixed(1)}ms`;
+var formatHistoryCaseLabels = (cases) => cases.length > 0 ? cases.map((entry) => entry.label ?? entry.caseId).join(", ") : "none";
+var formatTraceModes = (modes) => modes.length > 0 ? modes.join(" / ") : "n/a";
+var formatTraceStageSummary = (stageCounts) => {
+  const topStages = Object.entries(stageCounts).sort((left, right) => right[1] - left[1]).slice(0, 3);
+  return topStages.length > 0 ? topStages.map(([stage, count]) => `${stage} ${count}`).join(" \xB7 ") : "n/a";
+};
+var formatTraceRatio = (count, total) => `${count}/${total}`;
+var formatTraceCountDelta = (value) => `${value >= 0 ? "+" : ""}${value}`;
+var buildRAGComparisonTraceSummaryRows = (entry) => {
+  const trace = entry.traceSummary;
+  if (!trace) {
+    return [{ label: "Trace", value: "Unavailable" }];
+  }
+  return [
+    { label: "Modes", value: formatTraceModes(trace.modes) },
+    { label: "Avg final", value: trace.averageFinalCount.toFixed(1) },
+    { label: "Avg vector", value: trace.averageVectorCount.toFixed(1) },
+    { label: "Avg lexical", value: trace.averageLexicalCount.toFixed(1) },
+    {
+      label: "Transforms",
+      value: formatTraceRatio(trace.transformedCases, trace.totalCases)
+    },
+    {
+      label: "Variants",
+      value: formatTraceRatio(trace.variantCases, trace.totalCases)
+    },
+    {
+      label: "TopK",
+      value: `${trace.averageCandidateTopK.toFixed(1)} / ${trace.averageLexicalTopK.toFixed(1)}`
+    },
+    {
+      label: "Stages",
+      value: formatTraceStageSummary(trace.stageCounts)
+    }
+  ];
+};
+var buildRAGComparisonTraceDiffRows = (entry, leader) => {
+  const trace = entry.traceSummary;
+  if (!trace) {
+    return [{ label: "Trace", value: "Unavailable for comparison" }];
+  }
+  const leaderTrace = leader?.traceSummary;
+  if (!leaderTrace) {
+    return [{ label: "Baseline", value: "Leader trace unavailable" }];
+  }
+  if (entry === leader) {
+    return [{ label: "Baseline", value: "Leader strategy" }];
+  }
+  const stageDelta = Object.keys({
+    ...leaderTrace.stageCounts,
+    ...trace.stageCounts
+  }).map((stage) => {
+    const typedStage = stage;
+    const delta = (trace.stageCounts[typedStage] ?? 0) - (leaderTrace.stageCounts[typedStage] ?? 0);
+    return delta === 0 ? null : `${typedStage} ${formatTraceCountDelta(delta)}`;
+  }).filter((value) => Boolean(value)).slice(0, 3).join(" \xB7 ");
+  const rows = [
+    { label: "Baseline", value: leader.label }
+  ];
+  if (formatTraceModes(trace.modes) !== formatTraceModes(leaderTrace.modes)) {
+    rows.push({
+      label: "Modes vs leader",
+      value: `${formatTraceModes(trace.modes)} vs ${formatTraceModes(leaderTrace.modes)}`
+    });
+  }
+  rows.push({
+    label: "Final delta",
+    value: formatSignedDelta(trace.averageFinalCount - leaderTrace.averageFinalCount, 1)
+  }, {
+    label: "Vector delta",
+    value: formatSignedDelta(trace.averageVectorCount - leaderTrace.averageVectorCount, 1)
+  }, {
+    label: "Lexical delta",
+    value: formatSignedDelta(trace.averageLexicalCount - leaderTrace.averageLexicalCount, 1)
+  }, {
+    label: "Transform delta",
+    value: formatTraceCountDelta(trace.transformedCases - leaderTrace.transformedCases)
+  });
+  if (stageDelta) {
+    rows.push({ label: "Stage delta", value: stageDelta });
+  }
+  return rows;
+};
+var buildRAGEvaluationHistoryRows = (history) => {
+  if (!history?.latestRun) {
+    return [
+      { label: "History", value: "No persisted benchmark runs yet." }
+    ];
+  }
+  const rows = [
+    { label: "Runs recorded", value: String(history.runs.length) },
+    {
+      label: "Latest",
+      value: `${history.latestRun.label} \xB7 ${formatEvaluationSummary(history.latestRun.response)}`
+    }
+  ];
+  if (history.latestRun.traceSummary) {
+    rows.push({
+      label: "Latest trace",
+      value: `${formatTraceModes(history.latestRun.traceSummary.modes)} \xB7 final ${history.latestRun.traceSummary.averageFinalCount.toFixed(1)} \xB7 vector ${history.latestRun.traceSummary.averageVectorCount.toFixed(1)} \xB7 lexical ${history.latestRun.traceSummary.averageLexicalCount.toFixed(1)}`
+    });
+  }
+  if (history.previousRun) {
+    rows.push({
+      label: "Previous",
+      value: `${history.previousRun.label} \xB7 ${formatEvaluationSummary(history.previousRun.response)}`
+    });
+  }
+  if (!history.diff) {
+    rows.push({
+      label: "History diff",
+      value: "Run the benchmark again to diff regressions over time."
+    });
+    return rows;
+  }
+  rows.push({
+    label: "Passing delta",
+    value: formatSignedDelta(history.diff.summaryDelta.passingRate, 1, "%")
+  }, {
+    label: "Average F1 delta",
+    value: formatSignedDelta(history.diff.summaryDelta.averageF1, 3)
+  }, {
+    label: "Latency delta",
+    value: formatSignedDelta(history.diff.summaryDelta.averageLatencyMs, 1, "ms")
+  }, {
+    label: "Improved",
+    value: formatHistoryCaseLabels(history.diff.improvedCases)
+  }, {
+    label: "Regressed",
+    value: formatHistoryCaseLabels(history.diff.regressedCases)
+  });
+  if (history.diff.traceSummaryDelta) {
+    rows.push({
+      label: "Trace mode shift",
+      value: history.diff.traceSummaryDelta.modesChanged ? "changed" : "stable"
+    }, {
+      label: "Trace final delta",
+      value: formatSignedDelta(history.diff.traceSummaryDelta.averageFinalCount, 1)
+    }, {
+      label: "Trace vector delta",
+      value: formatSignedDelta(history.diff.traceSummaryDelta.averageVectorCount, 1)
+    }, {
+      label: "Trace lexical delta",
+      value: formatSignedDelta(history.diff.traceSummaryDelta.averageLexicalCount, 1)
+    }, {
+      label: "Trace transform delta",
+      value: formatTraceCountDelta(history.diff.traceSummaryDelta.transformedCases)
+    }, {
+      label: "Trace variant delta",
+      value: formatTraceCountDelta(history.diff.traceSummaryDelta.variantCases)
+    });
+    const stageDelta = Object.entries(history.diff.traceSummaryDelta.stageCounts ?? {}).map(([stage, count]) => `${stage} ${formatTraceCountDelta(count)}`).join(", ");
+    if (stageDelta) {
+      rows.push({ label: "Trace stage delta", value: stageDelta });
+    }
+  }
+  return rows;
+};
 var buildRAGEvaluationRunDiff = ({
   current,
   previous
@@ -3661,5 +3821,5 @@ export {
   AIStreamProvider
 };
 
-//# debugId=C9B1E6E0FB917C8664756E2164756E21
+//# debugId=7AF88C780C340EF364756E2164756E21
 //# sourceMappingURL=index.js.map