@absolutejs/absolute 0.19.0-beta.610 → 0.19.0-beta.612

package/dist/types/ai.d.ts

@@ -66,6 +66,7 @@ export type RAGSourceSummary = {
     structure?: RAGChunkStructure;
 };
 export type RAGSectionRetrievalReason = 'best_hit' | 'multi_hit_section' | 'dominant_within_parent' | 'only_section_in_parent' | 'concentrated_evidence';
+export type RAGSectionTraceWeightReason = 'rerank_preserved_lead' | 'final_stage_concentration' | 'final_stage_dominant_within_parent' | 'stage_runner_up_pressure';
 export type RAGSectionRetrievalDiagnostic = {
     key: string;
     label: string;
@@ -88,6 +89,23 @@ export type RAGSectionRetrievalDiagnostic = {
     vectorHits: number;
     lexicalHits: number;
     hybridHits: number;
+    stageCounts: Array<{
+        stage: RAGRetrievalTraceStage;
+        count: number;
+    }>;
+    stageWeights: Array<{
+        stage: RAGRetrievalTraceStage;
+        count: number;
+        stageShare: number;
+        parentStageShare?: number;
+        stageShareGap?: number;
+        parentStageShareGap?: number;
+        strongestSiblingLabel?: string;
+        strongestSiblingCount?: number;
+        reasons: RAGSectionTraceWeightReason[];
+    }>;
+    firstSeenStage?: RAGRetrievalTraceStage;
+    lastSeenStage?: RAGRetrievalTraceStage;
     retrievalMode?: RAGHybridRetrievalMode;
     rerankApplied?: boolean;
     sourceBalanceApplied?: boolean;
@@ -663,6 +681,11 @@ export type RAGRetrievalTraceStep = {
     label: string;
     durationMs?: number;
     count?: number;
+    sectionCounts?: Array<{
+        key: string;
+        label: string;
+        count: number;
+    }>;
     metadata?: Record<string, string | number | boolean | null>;
 };
 export type RAGRetrievalTrace = {

package/dist/vue/ai/index.js

@@ -4702,6 +4702,8 @@ var buildRAGSectionRetrievalDiagnostics = (sources, trace) => {
   }
   const diagnostics = [...sections.values()];
   const strongestBestHit = diagnostics.reduce((highest, section) => Math.max(highest, section.bestScore), 0);
+  const parentLabelByKey = new Map(diagnostics.map((section) => [section.key, section.parentLabel]));
+  const stageSectionCounts = new Map((trace?.steps ?? []).filter((step) => Array.isArray(step.sectionCounts) && step.sectionCounts.length > 0).map((step) => [step.stage, step.sectionCounts ?? []]));
   return diagnostics.map((section) => {
     const siblingPool = diagnostics.filter((entry) => entry.parentLabel === section.parentLabel);
     const siblings = siblingPool.filter((entry) => entry.key !== section.key);
@@ -4718,6 +4720,48 @@ var buildRAGSectionRetrievalDiagnostics = (sources, trace) => {
       totalScore: entry.totalScore
     })).sort((left, right) => right.totalScore - left.totalScore) : [];
     const reasons = [];
+    const stageCounts = trace?.steps.map((step) => ({
+      count: step.sectionCounts?.find((entry) => entry.key === section.key)?.count ?? 0,
+      stage: step.stage
+    })).filter((entry) => entry.count > 0) ?? [];
+    const stageWeights = stageCounts.map((entry) => {
+      const stageEntries = stageSectionCounts.get(entry.stage)?.filter((candidate) => candidate.count > 0) ?? [];
+      const stageTotal = stageEntries.reduce((sum, candidate) => sum + candidate.count, 0);
+      const siblingStageEntries = stageEntries.filter((candidate) => candidate.key !== section.key && parentLabelByKey.get(candidate.key) === section.parentLabel);
+      const parentStageEntries = stageEntries.filter((candidate) => parentLabelByKey.get(candidate.key) === section.parentLabel);
+      const strongestStageSibling = siblingStageEntries.slice().sort((left, right) => right.count - left.count)[0];
+      const parentStageTotal = parentStageEntries.reduce((sum, candidate) => sum + candidate.count, 0);
+      const stageShare = stageTotal > 0 ? entry.count / stageTotal : 0;
+      const parentStageShare = parentStageTotal > 0 ? entry.count / parentStageTotal : undefined;
+      const stageShareGap = stageTotal > 0 && strongestStageSibling ? entry.count / stageTotal - strongestStageSibling.count / stageTotal : undefined;
+      const parentStageShareGap = parentStageTotal > 0 && strongestStageSibling ? entry.count / parentStageTotal - strongestStageSibling.count / parentStageTotal : undefined;
+      const reasons2 = [];
+      if (entry.stage === "rerank" && stageShare > 0.5 && (typeof stageShareGap !== "number" || stageShareGap > 0)) {
+        reasons2.push("rerank_preserved_lead");
+      }
+      if (entry.stage === "finalize" && stageShare >= 0.5) {
+        reasons2.push("final_stage_concentration");
+      }
+      if (entry.stage === "finalize" && typeof parentStageShare === "number" && parentStageShare >= 0.6 && (typeof parentStageShareGap !== "number" || parentStageShareGap > 0)) {
+        reasons2.push("final_stage_dominant_within_parent");
+      }
+      if (strongestStageSibling && (typeof stageShareGap === "number" && stageShareGap <= 0.1 || typeof parentStageShareGap === "number" && parentStageShareGap <= 0.1)) {
+        reasons2.push("stage_runner_up_pressure");
+      }
+      return {
+        count: entry.count,
+        parentStageShare,
+        parentStageShareGap,
+        reasons: reasons2,
+        stage: entry.stage,
+        stageShare,
+        stageShareGap,
+        strongestSiblingCount: strongestStageSibling?.count,
+        strongestSiblingLabel: strongestStageSibling ? diagnostics.find((candidate) => candidate.key === strongestStageSibling.key)?.label ?? strongestStageSibling.key : undefined
+      };
+    });
+    const firstSeenStage = stageCounts[0]?.stage;
+    const lastSeenStage = stageCounts.at(-1)?.stage;
     if (section.bestScore >= strongestBestHit) {
       reasons.push("best_hit");
     }
@@ -4750,11 +4794,15 @@ var buildRAGSectionRetrievalDiagnostics = (sources, trace) => {
       parentShare,
       parentShareGap: typeof parentShare === "number" && strongestSibling && parentTotal > 0 ? parentShare - strongestSibling.totalScore / parentTotal : undefined,
       path: section.path,
+      firstSeenStage,
+      lastSeenStage,
       retrievalMode: trace?.mode,
       reasons,
       rerankApplied: trace?.steps.some((step) => step.stage === "rerank" && step.metadata?.applied === true),
       scoreShare,
       scoreThresholdApplied: trace?.steps.some((step) => step.stage === "score_filter"),
+      stageCounts,
+      stageWeights,
       siblingCount: siblings.length,
       siblingScoreGap: strongestSibling ? section.totalScore - strongestSibling.totalScore : undefined,
       sourceCount: section.sourceSet.size,
@@ -8061,5 +8109,5 @@ export {
   AIStreamKey
 };
 
-//# debugId=1899685E13726C0C64756E2164756E21
+//# debugId=E536AFF01F55D6B764756E2164756E21
 //# sourceMappingURL=index.js.map