@absolutejs/rag 0.0.1

package/dist/src/ai/rag/quality.d.ts

@@ -0,0 +1,607 @@
+import type { Database } from 'bun:sqlite';
+import type { RAGAnswerGroundingCaseDifficultyHistory, RAGAnswerGroundingCaseDifficultyHistoryStore, RAGAnswerGroundingCaseDifficultyRun, RAGAnswerGroundingCaseDifficultyRunDiff, RAGAnswerGroundingEvaluationCase, RAGAnswerGroundingEvaluationCaseDifficultyEntry, RAGAnswerGroundingEvaluationCaseResult, RAGAnswerGroundingEvaluationHistory, RAGAnswerGroundingEvaluationLeaderboardEntry, RAGAnswerGroundingEvaluationHistoryStore, RAGAnswerGroundingEvaluationInput, RAGAnswerGroundingEvaluationResponse, RAGAnswerGroundingEvaluationRun, RAGAnswerGroundingEvaluationRunDiff, RAGCollection, RAGEvaluationCase, RAGEvaluationCaseTraceSnapshot, RAGEvaluationCaseResult, RAGEvaluationHistory, RAGEvaluationHistoryStore, RAGEvaluationInput, RAGEvaluationLeaderboardEntry, RAGEvaluationResponse, RAGEvaluationRunDiff, RAGDocumentChunk, RAGEvaluationSuite, RAGEvaluationSuiteGenerationOptions, RAGEvaluationSuiteDatasetSummary, RAGEvaluationSuiteSnapshot, RAGEvaluationSuiteSnapshotDiff, RAGEvaluationSuiteSnapshotHistory, RAGEvaluationSuiteSnapshotHistoryStore, RAGEvaluationSuiteRun, RAGEvaluationEntityQualityView, RAGAnswerGroundingEntityQualityView, RAGRetrievalTraceSummaryRun, RAGRetrievalCandidate, RAGRetrievalComparison, RAGRetrievalBaselineGatePolicy, RAGRetrievalBaselineGatePolicyHistoryRecord, RAGRetrievalBaselineGatePolicyHistoryStore, RAGRetrievalComparisonDecisionSummary, RAGRetrievalReleaseVerdict, RAGRetrievalComparisonHistoryStore, RAGRetrievalBaselineRecord, RAGRetrievalBaselineStore, RAGRetrievalLaneHandoffDecisionRecord, RAGRetrievalLaneHandoffDecisionStore, RAGRetrievalLaneHandoffIncidentHistoryRecord, RAGRetrievalLaneHandoffIncidentHistoryStore, RAGRetrievalLaneHandoffAutoCompletePolicyHistoryRecord, RAGRetrievalLaneHandoffAutoCompletePolicyHistoryStore, RAGRetrievalLaneHandoffIncidentRecord, RAGRetrievalLaneHandoffIncidentStore, RAGRetrievalIncidentRemediationDecisionRecord, RAGRetrievalIncidentRemediationDecisionStore, RAGRetrievalIncidentRemediationExecutionHistoryRecord, RAGRetrievalIncidentRemediationExecutionHistoryStore, RAGRetrievalReleaseDecisionRecord, RAGRetrievalReleaseLanePolicyHistoryRecord, RAGRetrievalReleaseLanePolicyHistoryStore, RAGRetrievalReleaseLaneEscalationPolicyHistoryRecord, RAGRetrievalReleaseLaneEscalationPolicyHistoryStore, RAGRetrievalReleaseDecisionStore, RAGRetrievalReleaseIncidentRecord, RAGRetrievalReleaseIncidentStore, RAGRetrievalComparisonRun, RAGRetrievalComparisonEntry, RAGRetrievalTrace, RAGRetrievalTraceComparisonSummary, RAGRetrievalTraceComparisonSummaryDiff, RAGRetrievalComparisonSummary, RAGRerankerCandidate, RAGRerankerComparison, RAGRerankerComparisonEntry, RAGRerankerComparisonSummary, RAGRerankerProviderLike, RAGRetrievalTraceTrend, RAGSearchTraceDiff, RAGSearchTraceGroupHistory, RAGSearchTraceHistory, RAGChatPluginConfig, RAGSearchTracePruneInput, RAGSearchTracePruneHistoryStore, RAGSearchTracePruneRun, RAGSearchTracePrunePreview, RAGSearchTracePruneResult, RAGSearchTraceRecord, RAGSearchTraceStats, RAGSearchTraceStore, RAGRemediationAction, RAGSource, RAGSQLiteStoreMigrationInspection, RAGSQLiteStoreMigrationResult } from '@absolutejs/ai';
+export declare const buildRAGRetrievalReleaseVerdict: ({ groupKey, decisionSummary }: {
+    groupKey?: string;
+    decisionSummary?: RAGRetrievalComparisonDecisionSummary;
+}) => RAGRetrievalReleaseVerdict | undefined;
+export declare const buildRAGEvaluationLeaderboard: (runs: RAGEvaluationSuiteRun[]) => RAGEvaluationLeaderboardEntry[];
+export declare const buildRAGAnswerGroundingEvaluationLeaderboard: (runs: RAGAnswerGroundingEvaluationRun[]) => RAGAnswerGroundingEvaluationLeaderboardEntry[];
+export declare const buildRAGAnswerGroundingCaseDifficultyLeaderboard: (entries: Array<{
+    label: string;
+    response: RAGAnswerGroundingEvaluationResponse;
+}>) => RAGAnswerGroundingEvaluationCaseDifficultyEntry[];
+export declare const buildRAGAnswerGroundingCaseDifficultyRunDiff: ({ current, previous }: {
+    current: RAGAnswerGroundingCaseDifficultyRun;
+    previous?: RAGAnswerGroundingCaseDifficultyRun;
+}) => RAGAnswerGroundingCaseDifficultyRunDiff;
+export declare const buildRAGEvaluationRunDiff: ({ current, previous }: {
+    current: RAGEvaluationSuiteRun;
+    previous?: RAGEvaluationSuiteRun;
+}) => RAGEvaluationRunDiff;
+export declare const buildRAGAnswerGroundingEvaluationRunDiff: ({ current, previous }: {
+    current: RAGAnswerGroundingEvaluationRun;
+    previous?: RAGAnswerGroundingEvaluationRun;
+}) => RAGAnswerGroundingEvaluationRunDiff;
+export declare const createRAGFileEvaluationHistoryStore: (path: string) => RAGEvaluationHistoryStore;
+export declare const createRAGFileEvaluationSuiteSnapshotHistoryStore: (path: string) => RAGEvaluationSuiteSnapshotHistoryStore;
+export declare const createRAGFileRetrievalComparisonHistoryStore: (path: string) => RAGRetrievalComparisonHistoryStore;
+export declare const createRAGFileRetrievalBaselineStore: (path: string) => RAGRetrievalBaselineStore;
+export declare const createRAGFileRetrievalReleaseDecisionStore: (path: string) => RAGRetrievalReleaseDecisionStore;
+export declare const createRAGFileRetrievalLaneHandoffDecisionStore: (path: string) => RAGRetrievalLaneHandoffDecisionStore;
+export declare const createRAGFileRetrievalReleaseIncidentStore: (path: string) => RAGRetrievalReleaseIncidentStore;
+export declare const createRAGFileRetrievalLaneHandoffIncidentStore: (path: string) => RAGRetrievalLaneHandoffIncidentStore;
+export declare const createRAGFileRetrievalLaneHandoffIncidentHistoryStore: (path: string) => RAGRetrievalLaneHandoffIncidentHistoryStore;
+export declare const createRAGFileRetrievalIncidentRemediationDecisionStore: (path: string) => RAGRetrievalIncidentRemediationDecisionStore;
+export declare const createRAGFileRetrievalIncidentRemediationExecutionHistoryStore: (path: string) => RAGRetrievalIncidentRemediationExecutionHistoryStore;
+export declare const createRAGFileRetrievalLaneHandoffAutoCompletePolicyHistoryStore: (path: string) => RAGRetrievalLaneHandoffAutoCompletePolicyHistoryStore;
+export declare const createRAGFileRetrievalReleaseLanePolicyHistoryStore: (path: string) => RAGRetrievalReleaseLanePolicyHistoryStore;
+export declare const createRAGFileRetrievalBaselineGatePolicyHistoryStore: (path: string) => RAGRetrievalBaselineGatePolicyHistoryStore;
+export declare const createRAGFileRetrievalReleaseLaneEscalationPolicyHistoryStore: (path: string) => RAGRetrievalReleaseLaneEscalationPolicyHistoryStore;
+export declare const createRAGFileSearchTraceStore: (path: string) => RAGSearchTraceStore;
+export declare const createRAGFileSearchTracePruneHistoryStore: (path: string) => RAGSearchTracePruneHistoryStore;
+export type SQLiteRAGSearchTraceStoreOptions = {
+    db?: Database;
+    path?: string;
+    tableName?: string;
+};
+export type SQLiteRAGEvaluationHistoryStoreOptions = {
+    db?: Database;
+    path?: string;
+    tableName?: string;
+};
+export type SQLiteRAGEvaluationSuiteSnapshotHistoryStoreOptions = {
+    db?: Database;
+    path?: string;
+    tableName?: string;
+};
+export type SQLiteRAGAnswerGroundingEvaluationHistoryStoreOptions = {
+    db?: Database;
+    path?: string;
+    tableName?: string;
+};
+export type SQLiteRAGSearchTracePruneHistoryStoreOptions = {
+    db?: Database;
+    path?: string;
+    tableName?: string;
+};
+export type SQLiteRAGRetrievalComparisonHistoryStoreOptions = {
+    db?: Database;
+    path?: string;
+    tableName?: string;
+};
+export type SQLiteRAGRetrievalReleaseDecisionStoreOptions = {
+    db?: Database;
+    path?: string;
+    tableName?: string;
+};
+export type SQLiteRAGRetrievalBaselineStoreOptions = {
+    db?: Database;
+    path?: string;
+    tableName?: string;
+};
+export type SQLiteRAGRetrievalReleaseIncidentStoreOptions = {
+    db?: Database;
+    path?: string;
+    tableName?: string;
+};
+export type SQLiteRAGRetrievalLaneHandoffDecisionStoreOptions = {
+    db?: Database;
+    path?: string;
+    tableName?: string;
+};
+export type SQLiteRAGRetrievalLaneHandoffIncidentStoreOptions = {
+    db?: Database;
+    path?: string;
+    tableName?: string;
+};
+export type SQLiteRAGRetrievalLaneHandoffIncidentHistoryStoreOptions = {
+    db?: Database;
+    path?: string;
+    tableName?: string;
+};
+export type SQLiteRAGRetrievalIncidentRemediationDecisionStoreOptions = {
+    db?: Database;
+    path?: string;
+    tableName?: string;
+};
+export type SQLiteRAGRetrievalIncidentRemediationExecutionHistoryStoreOptions = {
+    db?: Database;
+    path?: string;
+    tableName?: string;
+};
+export type SQLiteRAGRetrievalLaneHandoffAutoCompletePolicyHistoryStoreOptions = {
+    db?: Database;
+    path?: string;
+    tableName?: string;
+};
+export type SQLiteRAGRetrievalReleaseLanePolicyHistoryStoreOptions = {
+    db?: Database;
+    path?: string;
+    tableName?: string;
+};
+export type SQLiteRAGRetrievalBaselineGatePolicyHistoryStoreOptions = {
+    db?: Database;
+    path?: string;
+    tableName?: string;
+};
+export type SQLiteRAGRetrievalReleaseLaneEscalationPolicyHistoryStoreOptions = {
+    db?: Database;
+    path?: string;
+    tableName?: string;
+};
+export type SQLiteRAGGovernanceStoreBundleOptions = {
+    db?: Database;
+    path?: string;
+    tablePrefix?: string;
+};
+export declare const createRAGSQLiteEvaluationHistoryStore: (options: SQLiteRAGEvaluationHistoryStoreOptions) => RAGEvaluationHistoryStore;
+export declare const createRAGSQLiteEvaluationSuiteSnapshotHistoryStore: (options: SQLiteRAGEvaluationSuiteSnapshotHistoryStoreOptions) => RAGEvaluationSuiteSnapshotHistoryStore;
+export declare const createRAGSQLiteAnswerGroundingEvaluationHistoryStore: (options: SQLiteRAGAnswerGroundingEvaluationHistoryStoreOptions) => RAGAnswerGroundingEvaluationHistoryStore;
+type SQLiteStoreMigrationDescriptor = {
+    tableName: string;
+    columns: Array<{
+        name: string;
+        definition: string;
+    }>;
+};
+export type SQLiteRAGStoreMigrationOptions = {
+    db?: Database;
+    path?: string;
+    descriptors?: SQLiteStoreMigrationDescriptor[];
+};
+export declare const inspectRAGSQLiteStoreMigrations: (options?: SQLiteRAGStoreMigrationOptions) => RAGSQLiteStoreMigrationInspection;
+export declare const applyRAGSQLiteStoreMigrations: (options?: SQLiteRAGStoreMigrationOptions) => RAGSQLiteStoreMigrationResult;
+export declare const createRAGSQLiteSearchTraceStore: (options: SQLiteRAGSearchTraceStoreOptions) => RAGSearchTraceStore;
+export declare const createRAGSQLiteSearchTracePruneHistoryStore: (options: SQLiteRAGSearchTracePruneHistoryStoreOptions) => RAGSearchTracePruneHistoryStore;
+export declare const createRAGSQLiteRetrievalComparisonHistoryStore: (options: SQLiteRAGRetrievalComparisonHistoryStoreOptions) => RAGRetrievalComparisonHistoryStore;
+export declare const createRAGSQLiteRetrievalReleaseDecisionStore: (options: SQLiteRAGRetrievalReleaseDecisionStoreOptions) => RAGRetrievalReleaseDecisionStore;
+export declare const createRAGSQLiteRetrievalBaselineStore: (options: SQLiteRAGRetrievalBaselineStoreOptions) => RAGRetrievalBaselineStore;
+export declare const createRAGSQLiteRetrievalReleaseIncidentStore: (options: SQLiteRAGRetrievalReleaseIncidentStoreOptions) => RAGRetrievalReleaseIncidentStore;
+export declare const createRAGSQLiteRetrievalLaneHandoffDecisionStore: (options: SQLiteRAGRetrievalLaneHandoffDecisionStoreOptions) => RAGRetrievalLaneHandoffDecisionStore;
+export declare const createRAGSQLiteRetrievalLaneHandoffIncidentStore: (options: SQLiteRAGRetrievalLaneHandoffIncidentStoreOptions) => RAGRetrievalLaneHandoffIncidentStore;
+export declare const createRAGSQLiteRetrievalLaneHandoffIncidentHistoryStore: (options: SQLiteRAGRetrievalLaneHandoffIncidentHistoryStoreOptions) => RAGRetrievalLaneHandoffIncidentHistoryStore;
+export declare const createRAGSQLiteRetrievalIncidentRemediationDecisionStore: (options: SQLiteRAGRetrievalIncidentRemediationDecisionStoreOptions) => RAGRetrievalIncidentRemediationDecisionStore;
+export declare const createRAGSQLiteRetrievalIncidentRemediationExecutionHistoryStore: (options: SQLiteRAGRetrievalIncidentRemediationExecutionHistoryStoreOptions) => RAGRetrievalIncidentRemediationExecutionHistoryStore;
+export declare const createRAGSQLiteRetrievalLaneHandoffAutoCompletePolicyHistoryStore: (options: SQLiteRAGRetrievalLaneHandoffAutoCompletePolicyHistoryStoreOptions) => RAGRetrievalLaneHandoffAutoCompletePolicyHistoryStore;
+export declare const createRAGSQLiteRetrievalReleaseLanePolicyHistoryStore: (options: SQLiteRAGRetrievalReleaseLanePolicyHistoryStoreOptions) => RAGRetrievalReleaseLanePolicyHistoryStore;
+export declare const createRAGSQLiteRetrievalBaselineGatePolicyHistoryStore: (options: SQLiteRAGRetrievalBaselineGatePolicyHistoryStoreOptions) => RAGRetrievalBaselineGatePolicyHistoryStore;
+export declare const createRAGSQLiteRetrievalReleaseLaneEscalationPolicyHistoryStore: (options: SQLiteRAGRetrievalReleaseLaneEscalationPolicyHistoryStoreOptions) => RAGRetrievalReleaseLaneEscalationPolicyHistoryStore;
+export declare const createRAGFileAnswerGroundingEvaluationHistoryStore: (path: string) => RAGAnswerGroundingEvaluationHistoryStore;
+export declare const createRAGFileAnswerGroundingCaseDifficultyHistoryStore: (path: string) => RAGAnswerGroundingCaseDifficultyHistoryStore;
+export declare const loadRAGEvaluationHistory: ({ store, suite, limit }: {
+    store: RAGEvaluationHistoryStore;
+    suite: RAGEvaluationSuite;
+    limit?: number;
+}) => Promise<RAGEvaluationHistory>;
+export declare const loadRAGEvaluationSuiteSnapshotHistory: ({ store, suite, limit }: {
+    store: RAGEvaluationSuiteSnapshotHistoryStore;
+    suite: Pick<RAGEvaluationSuite, "id" | "label">;
+    limit?: number;
+}) => Promise<RAGEvaluationSuiteSnapshotHistory>;
+export declare const loadRAGSearchTraceHistory: ({ store, query, groupKey, tag, limit }: {
+    store: RAGSearchTraceStore;
+    query?: string;
+    groupKey?: string;
+    tag?: string;
+    limit?: number;
+}) => Promise<RAGSearchTraceHistory>;
+export declare const loadRAGSearchTraceGroupHistory: ({ store, tag, limit }: {
+    store: RAGSearchTraceStore;
+    tag?: string;
+    limit?: number;
+}) => Promise<RAGSearchTraceGroupHistory>;
+export declare const summarizeRAGSearchTraceStore: ({ store, tag }: {
+    store: RAGSearchTraceStore;
+    tag?: string;
+}) => Promise<RAGSearchTraceStats>;
+export declare const previewRAGSearchTraceStorePrune: ({ store, input }: {
+    store: RAGSearchTraceStore;
+    input?: RAGSearchTracePruneInput;
+}) => Promise<RAGSearchTracePrunePreview>;
+export declare const loadRAGAnswerGroundingEvaluationHistory: ({ store, suite, limit }: {
+    store: RAGAnswerGroundingEvaluationHistoryStore;
+    suite: Pick<RAGEvaluationSuite, "id" | "label">;
+    limit?: number;
+}) => Promise<RAGAnswerGroundingEvaluationHistory>;
+export declare const loadRAGAnswerGroundingCaseDifficultyHistory: ({ store, suite, limit }: {
+    store: RAGAnswerGroundingCaseDifficultyHistoryStore;
+    suite: Pick<RAGEvaluationSuite, "id" | "label">;
+    limit?: number;
+}) => Promise<RAGAnswerGroundingCaseDifficultyHistory>;
+export declare const persistRAGEvaluationSuiteRun: ({ store, run }: {
+    store: RAGEvaluationHistoryStore;
+    run: RAGEvaluationSuiteRun;
+}) => Promise<RAGEvaluationSuiteRun>;
+export declare const persistRAGAnswerGroundingEvaluationRun: ({ store, run }: {
+    store: RAGAnswerGroundingEvaluationHistoryStore;
+    run: RAGAnswerGroundingEvaluationRun;
+}) => Promise<RAGAnswerGroundingEvaluationRun>;
+export declare const persistRAGAnswerGroundingCaseDifficultyRun: ({ store, run }: {
+    store: RAGAnswerGroundingCaseDifficultyHistoryStore;
+    run: RAGAnswerGroundingCaseDifficultyRun;
+}) => Promise<RAGAnswerGroundingCaseDifficultyRun>;
+export declare const persistRAGSearchTraceRecord: ({ store, record }: {
+    store: RAGSearchTraceStore;
+    record: RAGSearchTraceRecord;
+}) => Promise<RAGSearchTraceRecord>;
+export declare const pruneRAGSearchTraceStore: ({ store, input }: {
+    store: RAGSearchTraceStore;
+    input?: RAGSearchTracePruneInput;
+}) => Promise<RAGSearchTracePruneResult>;
+export declare const persistRAGSearchTracePruneRun: ({ store, run }: {
+    store: RAGSearchTracePruneHistoryStore;
+    run: RAGSearchTracePruneRun;
+}) => Promise<RAGSearchTracePruneRun>;
+export declare const persistRAGRetrievalComparisonRun: ({ store, run }: {
+    store: RAGRetrievalComparisonHistoryStore;
+    run: RAGRetrievalComparisonRun;
+}) => Promise<RAGRetrievalComparisonRun>;
+export declare const buildRAGRetrievalComparisonDecisionSummary: ({ comparison, baselineRetrievalId, candidateRetrievalId, policy }: {
+    comparison: RAGRetrievalComparison;
+    baselineRetrievalId?: string;
+    candidateRetrievalId?: string;
+    policy?: RAGRetrievalBaselineGatePolicy;
+}) => RAGRetrievalComparisonDecisionSummary | undefined;
+export declare const loadRAGSearchTracePruneHistory: ({ store, limit, trigger }: {
+    store: RAGSearchTracePruneHistoryStore;
+    limit?: number;
+    trigger?: RAGSearchTracePruneRun["trigger"];
+}) => Promise<RAGSearchTracePruneRun[]>;
+export declare const loadRAGRetrievalComparisonHistory: ({ store, limit, suiteId, label, winnerId, corpusGroupKey, groupKey, tag }: {
+    store: RAGRetrievalComparisonHistoryStore;
+    limit?: number;
+    suiteId?: string;
+    label?: string;
+    winnerId?: string;
+    corpusGroupKey?: string;
+    groupKey?: string;
+    tag?: string;
+}) => Promise<RAGRetrievalComparisonRun[]>;
+export declare const loadRAGRetrievalBaselines: ({ store, corpusGroupKey, groupKey, tag, limit, status }: {
+    store: RAGRetrievalBaselineStore;
+    corpusGroupKey?: string;
+    groupKey?: string;
+    tag?: string;
+    limit?: number;
+    status?: RAGRetrievalBaselineRecord["status"];
+}) => Promise<RAGRetrievalBaselineRecord[]>;
+export declare const persistRAGRetrievalBaseline: ({ store, record }: {
+    store: RAGRetrievalBaselineStore;
+    record: RAGRetrievalBaselineRecord;
+}) => Promise<RAGRetrievalBaselineRecord>;
+export declare const loadRAGRetrievalReleaseDecisions: ({ store, corpusGroupKey, groupKey, limit, kind }: {
+    store: RAGRetrievalReleaseDecisionStore;
+    corpusGroupKey?: string;
+    groupKey?: string;
+    limit?: number;
+    kind?: RAGRetrievalReleaseDecisionRecord["kind"];
+}) => Promise<RAGRetrievalReleaseDecisionRecord[]>;
+export declare const loadRAGRetrievalLaneHandoffDecisions: ({ store, corpusGroupKey, groupKey, limit, kind, sourceRolloutLabel, targetRolloutLabel }: {
+    store: RAGRetrievalLaneHandoffDecisionStore;
+    corpusGroupKey?: string;
+    groupKey?: string;
+    limit?: number;
+    kind?: RAGRetrievalLaneHandoffDecisionRecord["kind"];
+    sourceRolloutLabel?: RAGRetrievalLaneHandoffDecisionRecord["sourceRolloutLabel"];
+    targetRolloutLabel?: RAGRetrievalLaneHandoffDecisionRecord["targetRolloutLabel"];
+}) => Promise<RAGRetrievalLaneHandoffDecisionRecord[]>;
+export declare const loadRAGRetrievalReleaseIncidents: ({ store, corpusGroupKey, groupKey, limit, targetRolloutLabel, status, severity }: {
+    store: RAGRetrievalReleaseIncidentStore;
+    corpusGroupKey?: string;
+    groupKey?: string;
+    limit?: number;
+    targetRolloutLabel?: RAGRetrievalReleaseIncidentRecord["targetRolloutLabel"];
+    status?: RAGRetrievalReleaseIncidentRecord["status"];
+    severity?: RAGRetrievalReleaseIncidentRecord["severity"];
+}) => Promise<RAGRetrievalReleaseIncidentRecord[]>;
+export declare const loadRAGRetrievalLaneHandoffIncidents: ({ store, corpusGroupKey, groupKey, limit, targetRolloutLabel, status, severity }: {
+    store: RAGRetrievalLaneHandoffIncidentStore;
+    corpusGroupKey?: string;
+    groupKey?: string;
+    limit?: number;
+    targetRolloutLabel?: RAGRetrievalLaneHandoffIncidentRecord["targetRolloutLabel"];
+    status?: RAGRetrievalLaneHandoffIncidentRecord["status"];
+    severity?: RAGRetrievalLaneHandoffIncidentRecord["severity"];
+}) => Promise<RAGRetrievalLaneHandoffIncidentRecord[]>;
+export declare const loadRAGRetrievalLaneHandoffIncidentHistory: ({ store, corpusGroupKey, action, groupKey, incidentId, limit, targetRolloutLabel }: {
+    store: RAGRetrievalLaneHandoffIncidentHistoryStore;
+    corpusGroupKey?: string;
+    action?: RAGRetrievalLaneHandoffIncidentHistoryRecord["action"];
+    groupKey?: string;
+    incidentId?: string;
+    limit?: number;
+    targetRolloutLabel?: RAGRetrievalLaneHandoffIncidentRecord["targetRolloutLabel"];
+}) => Promise<RAGRetrievalLaneHandoffIncidentHistoryRecord[]>;
+export declare const loadRAGRetrievalIncidentRemediationDecisions: ({ store, groupKey, incidentId, limit, remediationKind, status, targetRolloutLabel }: {
+    store: RAGRetrievalIncidentRemediationDecisionStore;
+    groupKey?: string;
+    incidentId?: string;
+    limit?: number;
+    remediationKind?: RAGRetrievalIncidentRemediationDecisionRecord["remediationKind"];
+    status?: RAGRetrievalIncidentRemediationDecisionRecord["status"];
+    targetRolloutLabel?: RAGRetrievalIncidentRemediationDecisionRecord["targetRolloutLabel"];
+}) => Promise<RAGRetrievalIncidentRemediationDecisionRecord[]>;
+export declare const loadRAGRetrievalIncidentRemediationExecutionHistory: ({ store, actionKind, blockedByGuardrail, code, groupKey, idempotentReplay, incidentId, limit, targetRolloutLabel }: {
+    store: RAGRetrievalIncidentRemediationExecutionHistoryStore;
+    actionKind?: RAGRemediationAction["kind"];
+    blockedByGuardrail?: boolean;
+    code?: RAGRetrievalIncidentRemediationExecutionHistoryRecord["code"];
+    groupKey?: string;
+    idempotentReplay?: boolean;
+    incidentId?: string;
+    limit?: number;
+    targetRolloutLabel?: RAGRetrievalIncidentRemediationExecutionHistoryRecord["targetRolloutLabel"];
+}) => Promise<RAGRetrievalIncidentRemediationExecutionHistoryRecord[]>;
+export declare const loadRAGRetrievalLaneHandoffAutoCompletePolicyHistory: ({ store, corpusGroupKey, groupKey, limit, targetRolloutLabel }: {
+    store: RAGRetrievalLaneHandoffAutoCompletePolicyHistoryStore;
+    corpusGroupKey?: string;
+    groupKey?: string;
+    limit?: number;
+    targetRolloutLabel?: RAGRetrievalLaneHandoffAutoCompletePolicyHistoryRecord["targetRolloutLabel"];
+}) => Promise<RAGRetrievalLaneHandoffAutoCompletePolicyHistoryRecord[]>;
+export declare const loadRAGRetrievalReleaseLanePolicyHistory: ({ store, corpusGroupKey, groupKey, limit, rolloutLabel, scope }: {
+    store: RAGRetrievalReleaseLanePolicyHistoryStore;
+    corpusGroupKey?: string;
+    groupKey?: string;
+    limit?: number;
+    rolloutLabel?: RAGRetrievalReleaseLanePolicyHistoryRecord["rolloutLabel"];
+    scope?: RAGRetrievalReleaseLanePolicyHistoryRecord["scope"];
+}) => Promise<RAGRetrievalReleaseLanePolicyHistoryRecord[]>;
+export declare const loadRAGRetrievalBaselineGatePolicyHistory: ({ store, corpusGroupKey, groupKey, limit, rolloutLabel, scope }: {
+    store: RAGRetrievalBaselineGatePolicyHistoryStore;
+    corpusGroupKey?: string;
+    groupKey?: string;
+    limit?: number;
+    rolloutLabel?: RAGRetrievalBaselineGatePolicyHistoryRecord["rolloutLabel"];
+    scope?: RAGRetrievalBaselineGatePolicyHistoryRecord["scope"];
+}) => Promise<RAGRetrievalBaselineGatePolicyHistoryRecord[]>;
+export declare const loadRAGRetrievalReleaseLaneEscalationPolicyHistory: ({ store, corpusGroupKey, groupKey, limit, targetRolloutLabel }: {
+    store: RAGRetrievalReleaseLaneEscalationPolicyHistoryStore;
+    corpusGroupKey?: string;
+    groupKey?: string;
+    limit?: number;
+    targetRolloutLabel?: RAGRetrievalReleaseLaneEscalationPolicyHistoryRecord["targetRolloutLabel"];
+}) => Promise<RAGRetrievalReleaseLaneEscalationPolicyHistoryRecord[]>;
+export declare const persistRAGRetrievalReleaseDecision: ({ store, record }: {
+    store: RAGRetrievalReleaseDecisionStore;
+    record: RAGRetrievalReleaseDecisionRecord;
+}) => Promise<RAGRetrievalReleaseDecisionRecord>;
+export declare const persistRAGRetrievalLaneHandoffDecision: ({ store, record }: {
+    store: RAGRetrievalLaneHandoffDecisionStore;
+    record: RAGRetrievalLaneHandoffDecisionRecord;
+}) => Promise<RAGRetrievalLaneHandoffDecisionRecord>;
+export declare const persistRAGRetrievalReleaseIncident: ({ store, record }: {
+    store: RAGRetrievalReleaseIncidentStore;
+    record: RAGRetrievalReleaseIncidentRecord;
+}) => Promise<RAGRetrievalReleaseIncidentRecord>;
+export declare const persistRAGRetrievalLaneHandoffIncident: ({ store, record }: {
+    store: RAGRetrievalLaneHandoffIncidentStore;
+    record: RAGRetrievalLaneHandoffIncidentRecord;
+}) => Promise<RAGRetrievalLaneHandoffIncidentRecord>;
+export declare const persistRAGRetrievalIncidentRemediationDecision: ({ store, record }: {
+    store: RAGRetrievalIncidentRemediationDecisionStore;
+    record: RAGRetrievalIncidentRemediationDecisionRecord;
+}) => Promise<RAGRetrievalIncidentRemediationDecisionRecord>;
+export declare const persistRAGRetrievalIncidentRemediationExecutionHistory: ({ store, record }: {
+    store: RAGRetrievalIncidentRemediationExecutionHistoryStore;
+    record: RAGRetrievalIncidentRemediationExecutionHistoryRecord;
+}) => Promise<RAGRetrievalIncidentRemediationExecutionHistoryRecord>;
+export declare const persistRAGRetrievalLaneHandoffIncidentHistory: ({ store, record }: {
+    store: RAGRetrievalLaneHandoffIncidentHistoryStore;
+    record: RAGRetrievalLaneHandoffIncidentHistoryRecord;
+}) => Promise<RAGRetrievalLaneHandoffIncidentHistoryRecord>;
+export declare const persistRAGRetrievalLaneHandoffAutoCompletePolicyHistory: ({ store, record }: {
+    store: RAGRetrievalLaneHandoffAutoCompletePolicyHistoryStore;
+    record: RAGRetrievalLaneHandoffAutoCompletePolicyHistoryRecord;
+}) => Promise<RAGRetrievalLaneHandoffAutoCompletePolicyHistoryRecord>;
+export declare const persistRAGRetrievalReleaseLanePolicyHistory: ({ store, record }: {
+    store: RAGRetrievalReleaseLanePolicyHistoryStore;
+    record: RAGRetrievalReleaseLanePolicyHistoryRecord;
+}) => Promise<RAGRetrievalReleaseLanePolicyHistoryRecord>;
+export declare const persistRAGRetrievalBaselineGatePolicyHistory: ({ store, record }: {
+    store: RAGRetrievalBaselineGatePolicyHistoryStore;
+    record: RAGRetrievalBaselineGatePolicyHistoryRecord;
+}) => Promise<RAGRetrievalBaselineGatePolicyHistoryRecord>;
+export declare const persistRAGRetrievalReleaseLaneEscalationPolicyHistory: ({ store, record }: {
+    store: RAGRetrievalReleaseLaneEscalationPolicyHistoryStore;
+    record: RAGRetrievalReleaseLaneEscalationPolicyHistoryRecord;
+}) => Promise<RAGRetrievalReleaseLaneEscalationPolicyHistoryRecord>;
+export declare const createRAGSQLiteGovernanceStores: (options?: SQLiteRAGGovernanceStoreBundleOptions) => Pick<RAGChatPluginConfig, "searchTraceStore" | "searchTracePruneHistoryStore" | "retrievalComparisonHistoryStore" | "retrievalBaselineStore" | "retrievalReleaseDecisionStore" | "retrievalLaneHandoffDecisionStore" | "retrievalLaneHandoffIncidentStore" | "retrievalLaneHandoffIncidentHistoryStore" | "retrievalLaneHandoffAutoCompletePolicyHistoryStore" | "retrievalReleaseLanePolicyHistoryStore" | "retrievalBaselineGatePolicyHistoryStore" | "retrievalReleaseLaneEscalationPolicyHistoryStore" | "retrievalReleaseIncidentStore" | "retrievalIncidentRemediationDecisionStore" | "retrievalIncidentRemediationExecutionHistoryStore">;
+export declare const buildRAGEvaluationResponse: (cases: RAGEvaluationCaseResult[]) => RAGEvaluationResponse;
+export declare const buildRAGEvaluationEntityQualityView: (response: RAGEvaluationResponse) => RAGEvaluationEntityQualityView;
+export declare const buildRAGAnswerGroundingEntityQualityView: (response: RAGAnswerGroundingEvaluationResponse) => RAGAnswerGroundingEntityQualityView;
+export declare const evaluateRAGAnswerGroundingCase: ({ caseIndex, caseInput }: {
+    caseIndex: number;
+    caseInput: RAGAnswerGroundingEvaluationCase;
+}) => RAGAnswerGroundingEvaluationCaseResult;
+export declare const buildRAGAnswerGroundingEvaluationResponse: (cases: RAGAnswerGroundingEvaluationCaseResult[]) => RAGAnswerGroundingEvaluationResponse;
+export declare const evaluateRAGAnswerGrounding: (input: RAGAnswerGroundingEvaluationInput) => RAGAnswerGroundingEvaluationResponse;
+export declare const compareRAGRerankers: ({ collection, suite, rerankers, defaultTopK }: {
+    collection: RAGCollection;
+    suite: RAGEvaluationSuite;
+    rerankers: RAGRerankerCandidate[];
+    defaultTopK?: number;
+}) => Promise<RAGRerankerComparison>;
+export declare const compareRAGRetrievalStrategies: ({ collection, suite, retrievals, defaultTopK }: {
+    collection: RAGCollection;
+    suite: RAGEvaluationSuite;
+    retrievals: RAGRetrievalCandidate[];
+    defaultTopK?: number;
+}) => Promise<RAGRetrievalComparison>;
+export declare const summarizeRAGRetrievalTraces: (traces: RAGRetrievalTrace[]) => RAGRetrievalTraceComparisonSummary | undefined;
+export declare const compareRAGRetrievalTraceSummaries: (current: RAGRetrievalTraceComparisonSummary, previous: RAGRetrievalTraceComparisonSummary) => RAGRetrievalTraceComparisonSummaryDiff;
+export declare const buildRAGSearchTraceRecord: (input: {
+    trace: RAGRetrievalTrace;
+    results?: Array<{
+        chunkId: string;
+        score: number;
+        source?: string;
+        title?: string;
+        metadata?: Record<string, unknown>;
+    }>;
+    id?: string;
+    label?: string;
+    groupKey?: string;
+    tags?: string[];
+    startedAt?: number;
+    finishedAt?: number;
+    elapsedMs?: number;
+    metadata?: Record<string, unknown>;
+}) => RAGSearchTraceRecord;
+export declare const buildRAGSearchTraceDiff: ({ current, previous }: {
+    current: RAGSearchTraceRecord;
+    previous?: RAGSearchTraceRecord;
+}) => RAGSearchTraceDiff;
+export declare const buildRAGRetrievalTraceHistoryTrend: ({ runs }: {
+    runs: RAGRetrievalTraceSummaryRun[];
+}) => RAGRetrievalTraceTrend;
+export declare const createRAGEvaluationSuite: (suite: RAGEvaluationSuite) => RAGEvaluationSuite;
+export declare const addRAGEvaluationSuiteCase: ({ suite, caseInput, index }: {
+    suite: RAGEvaluationSuite;
+    caseInput: RAGEvaluationCase;
+    index?: number;
+}) => RAGEvaluationSuite;
+export declare const updateRAGEvaluationSuiteCase: ({ suite, caseId, caseInput }: {
+    suite: RAGEvaluationSuite;
+    caseId: string;
+    caseInput: RAGEvaluationCase;
+}) => RAGEvaluationSuite;
+export declare const removeRAGEvaluationSuiteCase: ({ suite, caseId }: {
+    suite: RAGEvaluationSuite;
+    caseId: string;
+}) => RAGEvaluationSuite;
+export declare const reorderRAGEvaluationSuiteCases: ({ suite, caseIds }: {
+    suite: RAGEvaluationSuite;
+    caseIds: string[];
+}) => RAGEvaluationSuite;
+export declare const setRAGEvaluationSuiteCaseGoldenSet: ({ suite, caseId, goldenSet }: {
+    suite: RAGEvaluationSuite;
+    caseId: string;
+    goldenSet: boolean;
+}) => RAGEvaluationSuite;
+export declare const addRAGEvaluationSuiteCaseHardNegative: ({ suite, caseId, kind, value }: {
+    suite: RAGEvaluationSuite;
+    caseId: string;
+    kind: "chunkId" | "source" | "documentId";
+    value: string;
+}) => RAGEvaluationSuite;
+export declare const removeRAGEvaluationSuiteCaseHardNegative: ({ suite, caseId, kind, value }: {
+    suite: RAGEvaluationSuite;
+    caseId: string;
+    kind: "chunkId" | "source" | "documentId";
+    value: string;
+}) => RAGEvaluationSuite;
+export declare const summarizeRAGEvaluationSuiteDataset: ({ suite }: {
+    suite: RAGEvaluationSuite;
+}) => RAGEvaluationSuiteDatasetSummary;
+export declare const generateRAGEvaluationSuiteFromDocuments: ({ suiteId, documents, label, description, maxCases, topK, scoreThreshold, filter, retrieval, includeGoldenSet, hardNegativePerCase, metadata }: RAGEvaluationSuiteGenerationOptions) => RAGEvaluationSuite;
+export declare const createRAGNativeBackendBenchmarkMockEmbedding: (text: string) => Promise<number[]>;
+export declare const createRAGNativeBackendBenchmarkCorpus: (input?: {
+    backend?: "generic" | "sqlite-native" | "postgres";
+    noiseCount?: number;
+}) => RAGDocumentChunk[];
+export declare const createRAGAdaptiveNativePlannerBenchmarkSuite: (input?: {
+    id?: string;
+    label?: string;
+    description?: string;
+    topK?: number;
+    metadata?: Record<string, unknown>;
+}) => RAGEvaluationSuite;
+export declare const createRAGAdaptiveNativePlannerBenchmarkSnapshot: (input?: {
+    suite?: RAGEvaluationSuite;
+    id?: string;
+    version?: number;
+    createdAt?: number;
+    metadata?: Record<string, unknown>;
+}) => RAGEvaluationSuiteSnapshot;
+export declare const createRAGNativeBackendComparisonBenchmarkSuite: (input?: {
+    id?: string;
+    label?: string;
+    description?: string;
+    topK?: number;
+    metadata?: Record<string, unknown>;
+}) => RAGEvaluationSuite;
+export declare const createRAGNativeBackendComparisonBenchmarkSnapshot: (input?: {
+    suite?: RAGEvaluationSuite;
+    id?: string;
+    version?: number;
+    createdAt?: number;
+    metadata?: Record<string, unknown>;
+}) => RAGEvaluationSuiteSnapshot;
+export declare const createRAGPresentationCueBenchmarkSuite: (input?: {
+    id?: string;
+    label?: string;
+    description?: string;
+    topK?: number;
+    metadata?: Record<string, unknown>;
+}) => RAGEvaluationSuite;
+export declare const createRAGPresentationCueBenchmarkSnapshot: (input?: {
+    suite?: RAGEvaluationSuite;
+    id?: string;
+    version?: number;
+    createdAt?: number;
+    metadata?: Record<string, unknown>;
+}) => RAGEvaluationSuiteSnapshot;
+export declare const createRAGSpreadsheetCueBenchmarkSuite: (input?: {
+    id?: string;
+    label?: string;
+    description?: string;
+    topK?: number;
+    metadata?: Record<string, unknown>;
+}) => RAGEvaluationSuite;
+export declare const createRAGSpreadsheetCueBenchmarkSnapshot: (input?: {
+    suite?: RAGEvaluationSuite;
+    id?: string;
+    version?: number;
+    createdAt?: number;
+    metadata?: Record<string, unknown>;
+}) => RAGEvaluationSuiteSnapshot;
+export declare const createRAGEvaluationSuiteSnapshot: ({ suite, id, version, createdAt, metadata }: {
+    suite: RAGEvaluationSuite;
+    id?: string;
+    version?: number;
+    createdAt?: number;
+    metadata?: Record<string, unknown>;
+}) => RAGEvaluationSuiteSnapshot;
+export declare const buildRAGEvaluationSuiteSnapshotDiff: ({ current, previous }: {
+    current: RAGEvaluationSuiteSnapshot;
+    previous?: RAGEvaluationSuiteSnapshot;
+}) => RAGEvaluationSuiteSnapshotDiff;
+export declare const evaluateRAGCollection: ({ collection, input, defaultTopK, rerank }: {
+    collection: RAGCollection;
+    input: RAGEvaluationInput;
+    defaultTopK?: number;
+    rerank?: RAGRerankerProviderLike;
+}) => Promise<RAGEvaluationResponse>;
+export declare const executeDryRunRAGEvaluation: (input: RAGEvaluationInput, defaultTopK?: number) => RAGEvaluationCaseResult[];
+export declare const runRAGEvaluationSuite: ({ suite, evaluate, overrides, artifacts }: {
+    suite: RAGEvaluationSuite;
+    evaluate: (input: RAGEvaluationInput) => Promise<RAGEvaluationResponse>;
+    overrides?: Partial<RAGEvaluationInput>;
+    artifacts?: Pick<RAGEvaluationSuiteRun, "traceSummary" | "caseTraceSnapshots">;
+}) => Promise<{
+    caseTraceSnapshots: RAGEvaluationCaseTraceSnapshot[] | undefined;
+    elapsedMs: number;
+    finishedAt: number;
+    id: `${string}-${string}-${string}-${string}-${string}`;
+    label: string;
+    metadata: Record<string, unknown> | undefined;
+    response: RAGEvaluationResponse;
+    startedAt: number;
+    suiteId: string;
+    traceSummary: RAGRetrievalTraceComparisonSummary | undefined;
+}>;
+export declare const summarizeRAGEvaluationCase: ({ caseIndex, caseInput, query, mode, retrievedIds, expectedIds, elapsedMs, retrievedSources, trace }: {
+    caseIndex: number;
+    caseInput: RAGEvaluationCase;
+    mode: "chunkId" | "source" | "documentId";
+    query: string;
+    retrievedIds: string[];
+    expectedIds: string[];
+    elapsedMs: number;
+    retrievedSources?: RAGSource[];
+    trace?: RAGSearchTraceRecord | RAGRetrievalTrace;
+}) => RAGEvaluationCaseResult;
+export declare const summarizeRAGRerankerComparison: (entries: RAGRerankerComparisonEntry[]) => RAGRerankerComparisonSummary;
+export declare const summarizeRAGRetrievalComparison: (entries: RAGRetrievalComparisonEntry[]) => RAGRetrievalComparisonSummary;
+export {};

package/dist/src/ai/rag/queryTransforms.d.ts

@@ -0,0 +1,17 @@
+import type { RAGQueryTransformInput, RAGQueryTransformProvider, RAGQueryTransformProviderLike, RAGQueryTransformResult, RAGQueryTransformer } from '@absolutejs/ai';
+export type CreateRAGQueryTransformOptions = {
+    transform: RAGQueryTransformer;
+    defaultModel?: string;
+    providerName?: string;
+};
+export type HeuristicRAGQueryTransformOptions = {
+    defaultModel?: string;
+    providerName?: string;
+};
+export declare const createHeuristicRAGQueryTransform: (options?: HeuristicRAGQueryTransformOptions) => RAGQueryTransformProvider;
+export declare const createRAGQueryTransform: (options: CreateRAGQueryTransformOptions) => RAGQueryTransformProvider;
+export declare const resolveRAGQueryTransform: (queryTransform: RAGQueryTransformProviderLike | undefined) => RAGQueryTransformProvider | null;
+export declare const applyRAGQueryTransform: ({ input, queryTransform }: {
+    input: RAGQueryTransformInput;
+    queryTransform?: RAGQueryTransformProviderLike;
+}) => Promise<RAGQueryTransformResult>;

package/dist/src/ai/rag/reranking.d.ts

@@ -0,0 +1,17 @@
+import type { RAGQueryResult, RAGReranker, RAGRerankerInput, RAGRerankerProvider, RAGRerankerProviderLike } from '@absolutejs/ai';
+export type CreateRAGRerankerOptions = {
+    rerank: RAGReranker;
+    defaultModel?: string;
+    providerName?: string;
+};
+export type HeuristicRAGRerankerOptions = {
+    defaultModel?: string;
+    providerName?: string;
+};
+export declare const applyRAGReranking: ({ input, reranker }: {
+    input: RAGRerankerInput;
+    reranker?: RAGRerankerProviderLike;
+}) => Promise<RAGQueryResult[]>;
+export declare const createHeuristicRAGReranker: (options?: HeuristicRAGRerankerOptions) => RAGRerankerProvider;
+export declare const createRAGReranker: (options: CreateRAGRerankerOptions) => RAGRerankerProvider;
+export declare const resolveRAGReranker: (reranker: RAGRerankerProviderLike | undefined) => RAGRerankerProvider | null;

package/dist/src/ai/rag/resolveAbsoluteSQLiteVec.d.ts

@@ -0,0 +1,3 @@
+import type { SQLiteVecResolution } from '@absolutejs/ai';
+export declare const resolveAbsoluteSQLiteVec: () => SQLiteVecResolution;
+export declare const resolveAbsoluteSQLiteVecExtensionPath: () => string | null;

package/dist/src/ai/rag/retrievalStrategies.d.ts

@@ -0,0 +1,6 @@
+import type { RAGRetrievalStrategyProvider } from '@absolutejs/ai';
+export type HeuristicRAGRetrievalStrategyOptions = {
+    providerName?: string;
+    defaultLabel?: string;
+};
+export declare const createHeuristicRAGRetrievalStrategy: (options?: HeuristicRAGRetrievalStrategyOptions) => RAGRetrievalStrategyProvider;