@absolutejs/rag 0.0.4 → 0.0.5

package/dist/src/ai/client/createRAGAnswerWorkflow.d.ts

@@ -0,0 +1,32 @@
+import type { AIAttachment, RAGAnswerWorkflowState } from "@absolutejs/ai";
+export declare const createRAGAnswerWorkflow: (path: string, conversationId?: string) => {
+    state: RAGAnswerWorkflowState;
+    latestAssistantMessage: import("@absolutejs/ai").AIMessage | undefined;
+    retrieval: import("@absolutejs/ai").RAGRetrievedState | null;
+    sources: import("@absolutejs/ai").RAGSource[];
+    sourceGroups: import("@absolutejs/ai").RAGSourceGroup[];
+    sourceSummaries: import("@absolutejs/ai").RAGSourceSummary[];
+    citations: import("@absolutejs/ai").RAGCitation[];
+    citationReferenceMap: import("@absolutejs/ai").RAGCitationReferenceMap;
+    groundingReferences: import("@absolutejs/ai").RAGGroundingReference[];
+    groundedAnswer: import("@absolutejs/ai").RAGGroundedAnswer;
+    stage: import("@absolutejs/ai").RAGStreamStage;
+    isRunning: boolean;
+    isRetrieving: boolean;
+    isRetrieved: boolean;
+    isAnswerStreaming: boolean;
+    isComplete: boolean;
+    isError: boolean;
+    hasSources: boolean;
+    hasRetrieved: boolean;
+    query: (content: string, attachments?: AIAttachment[]) => void;
+    branch: (messageId: string, content: string) => void;
+    cancel: () => void;
+    destroy: () => void;
+    send: (content: string, attachments?: AIAttachment[]) => void;
+    subscribe: (callback: () => void) => () => void;
+    error: string | null;
+    isStreaming: boolean;
+    messages: import("@absolutejs/ai").AIMessage[];
+};
+export type RAGAnswerWorkflow = ReturnType<typeof createRAGAnswerWorkflow>;

package/dist/src/ai/client/createRAGStream.d.ts

@@ -0,0 +1,2 @@
+export { createAIStream as createRAGStream } from "@absolutejs/ai/client";
+export type { CreateAIStream as CreateRAGStream } from "@absolutejs/ai/client";

package/dist/src/ai/client/createRAGWorkflow.d.ts

@@ -0,0 +1,3 @@
+export { createRAGAnswerWorkflow as createRAGWorkflow } from "./createRAGAnswerWorkflow";
+export type { RAGAnswerWorkflow as CreateRAGWorkflow } from "./createRAGAnswerWorkflow";
+export type { RAGAnswerWorkflow as RAGWorkflow } from "./createRAGAnswerWorkflow";

package/dist/src/ai/client/index.d.ts

@@ -0,0 +1,8 @@
+export { createRAGAnswerWorkflow as createRAGWorkflow } from "./createRAGAnswerWorkflow";
+export type { RAGAnswerWorkflow as CreateRAGWorkflow } from "./createRAGAnswerWorkflow";
+export type { RAGAnswerWorkflow as RAGWorkflow } from "./createRAGAnswerWorkflow";
+export { createRAGStream } from "./createRAGStream";
+export type { CreateRAGStream } from "./createRAGStream";
+export { buildRAGMaintenanceOverview, createRAGClient } from "./ragClient";
+export type { RAGClient, RAGClientOptions, RAGDetailedSearchResponse, RAGMaintenanceActionDescriptor, RAGMaintenanceOverview, RAGMaintenancePayload, } from "./ragClient";
+export { buildRAGEvaluationLeaderboard, createRAGEvaluationSuite, runRAGEvaluationSuite, } from "../rag/quality";

package/dist/src/ai/client/ragClient.d.ts

@@ -0,0 +1,349 @@
+import type { RAGBackendsResponse, RAGBackendMaintenanceRecommendation, RAGBackendMaintenanceSummary, RAGDocumentChunksResponse, RAGEvaluationInput, RAGEvaluationResponse, RAGRetrievalBaselinePromotionFromRunRequest, RAGRetrievalBaselinePromotionRequest, RAGRetrievalBaselineRevertRequest, RAGRetrievalReleaseIncidentAcknowledgeRequest, RAGRetrievalReleaseDecisionActionRequest, RAGRetrievalBaselineResponse, RAGRetrievalLaneHandoffDecisionRequest, RAGRetrievalLaneHandoffDecisionResponse, RAGRetrievalLaneHandoffIncidentStatusResponse, RAGRetrievalLaneHandoffStatusResponse, RAGRetrievalIncidentRemediationDecisionRequest, RAGRetrievalIncidentRemediationBulkExecutionRequest, RAGRetrievalIncidentRemediationExecutionRequest, RAGRetrievalIncidentRemediationExecutionResponse, RAGRetrievalIncidentRemediationStatusResponse, RAGRetrievalReleaseGroupHistoryResponse, RAGRetrievalReleaseIncidentStatusResponse, RAGRetrievalReleaseDriftStatusResponse, RAGRetrievalComparisonRequest, RAGAdaptiveNativePlannerBenchmarkResponse, RAGAdaptiveNativePlannerBenchmarkSnapshotResponse, RAGDocumentIngestInput, RAGDocumentChunk, RAGDocumentsResponse, RAGDocumentUrlIngestInput, RAGDocumentUploadIngestInput, RAGIngestResponse, RAGMutationResponse, RAGOperationsResponse, RAGSearchRequest, RAGSearchResponse, RAGSearchTracePruneResponse, RAGSource, RAGStatusResponse, RAGSyncRunOptions, RAGSyncResponse } from "@absolutejs/ai";
+type FetchLike = typeof fetch;
+export type RAGClientOptions = {
+    path: string;
+    fetch?: FetchLike;
+};
+export type RAGDetailedSearchResponse = {
+    results: RAGSource[];
+    trace?: RAGSearchResponse["trace"];
+};
+export type RAGMaintenancePayload = Pick<RAGMutationResponse, "maintenance" | "admin" | "workflowStatus"> | Pick<RAGOperationsResponse, "maintenance" | "admin" | "status"> | Pick<RAGStatusResponse, "maintenance" | "admin" | "status"> | null | undefined;
+export type RAGMaintenanceActionDescriptor = {
+    kind: "analyze_backend" | "rebuild_native_index";
+    label: string;
+    available: boolean;
+    recommended: boolean;
+    reason?: string;
+};
+export type RAGMaintenanceOverview = {
+    activeJobCount: number;
+    actions: RAGMaintenanceActionDescriptor[];
+    availableActions: RAGMaintenanceActionDescriptor[];
+    backend?: RAGBackendMaintenanceSummary["backend"];
+    blockingRecommendations: RAGBackendMaintenanceRecommendation[];
+    criticalCount: number;
+    hasBlockingIssue: boolean;
+    infoCount: number;
+    primaryRecommendation?: RAGBackendMaintenanceRecommendation;
+    recentlyCompletedActions: NonNullable<RAGBackendMaintenanceSummary>["recentActions"];
+    recommendationCount: number;
+    recommendations: RAGBackendMaintenanceRecommendation[];
+    recommendedNow: RAGBackendMaintenanceRecommendation[];
+    warningCount: number;
+};
+export declare const buildRAGMaintenanceOverview: (payload: RAGMaintenancePayload) => RAGMaintenanceOverview;
+export declare const createRAGClient: (options: RAGClientOptions) => {
+    backends(): Promise<RAGBackendsResponse>;
+    clearIndex(): Promise<{
+        ok: boolean;
+    }>;
+    createDocument(input: RAGDocumentIngestInput["documents"][number]): Promise<RAGMutationResponse>;
+    deleteDocument(id: string): Promise<RAGMutationResponse>;
+    documentChunks(id: string): Promise<RAGDocumentChunksResponse>;
+    documents(kind?: string): Promise<RAGDocumentsResponse>;
+    evaluate(input: RAGEvaluationInput): Promise<RAGEvaluationResponse>;
+    compareRetrievals(input: RAGRetrievalComparisonRequest): Promise<import("@absolutejs/ai").RAGRetrievalComparison>;
+    retrievalComparisonHistory(input?: {
+        limit?: number;
+        suiteId?: string;
+        label?: string;
+        winnerId?: string;
+        groupKey?: string;
+        tag?: string;
+    }): Promise<import("@absolutejs/ai").RAGRetrievalComparisonRun[]>;
+    retrievalBaselines(input?: {
+        groupKey?: string;
+        tag?: string;
+        limit?: number;
+        status?: "active" | "superseded";
+    }): Promise<import("@absolutejs/ai").RAGRetrievalBaselineRecord[]>;
+    promoteRetrievalBaseline(input: RAGRetrievalBaselinePromotionRequest): Promise<import("@absolutejs/ai").RAGRetrievalBaselineRecord>;
+    promoteRetrievalBaselineDetailed(input: RAGRetrievalBaselinePromotionRequest): Promise<RAGRetrievalBaselineResponse>;
+    promoteRetrievalBaselineToLane(input: RAGRetrievalBaselinePromotionRequest & {
+        rolloutLabel: "canary" | "stable" | "rollback_target";
+    }): Promise<import("@absolutejs/ai").RAGRetrievalBaselineRecord>;
+    promoteRetrievalBaselineToLaneDetailed(input: RAGRetrievalBaselinePromotionRequest & {
+        rolloutLabel: "canary" | "stable" | "rollback_target";
+    }): Promise<RAGRetrievalBaselineResponse>;
+    promoteRetrievalBaselineFromRun(input: RAGRetrievalBaselinePromotionFromRunRequest): Promise<import("@absolutejs/ai").RAGRetrievalBaselineRecord>;
+    promoteRetrievalBaselineFromRunDetailed(input: RAGRetrievalBaselinePromotionFromRunRequest): Promise<RAGRetrievalBaselineResponse>;
+    revertRetrievalBaseline(input: RAGRetrievalBaselineRevertRequest): Promise<import("@absolutejs/ai").RAGRetrievalBaselineRecord>;
+    retrievalBaselineDecisions(input?: {
+        groupKey?: string;
+        limit?: number;
+        kind?: "approve" | "promote" | "reject" | "revert";
+        freshnessStatus?: "fresh" | "expired" | "not_applicable";
+        targetRolloutLabel?: "canary" | "stable" | "rollback_target";
+    }): Promise<import("@absolutejs/ai").RAGRetrievalReleaseDecisionRecord[]>;
+    retrievalReleaseGroupHistory(input: {
+        groupKey: string;
+        decisionLimit?: number;
+        baselineLimit?: number;
+        benchmarkLimit?: number;
+        runLimit?: number;
+        targetRolloutLabel?: "canary" | "stable" | "rollback_target";
+    }): Promise<RAGRetrievalReleaseGroupHistoryResponse>;
+    adaptiveNativePlannerBenchmark(input?: {
+        limit?: number;
+        runLimit?: number;
+        label?: string;
+        description?: string;
+        groupKey?: string;
+        corpusGroupKey?: string;
+    }): Promise<RAGAdaptiveNativePlannerBenchmarkResponse>;
+    runAdaptiveNativePlannerBenchmark(input?: {
+        limit?: number;
+        runLimit?: number;
+        topK?: number;
+        label?: string;
+        description?: string;
+        groupKey?: string;
+        corpusGroupKey?: string;
+        persistRun?: boolean;
+        baselineRetrievalId?: string;
+        candidateRetrievalId?: string;
+        retrievals?: Array<{
+            id: string;
+            label?: string;
+            retrieval?: Record<string, unknown> | string;
+        }>;
+        tags?: string[];
+        metadata?: Record<string, unknown>;
+    }): Promise<RAGAdaptiveNativePlannerBenchmarkResponse>;
+    saveAdaptiveNativePlannerBenchmarkSnapshot(input?: {
+        limit?: number;
+        label?: string;
+        description?: string;
+        version?: number;
+        createdAt?: number;
+        metadata?: Record<string, unknown>;
+        snapshotMetadata?: Record<string, unknown>;
+    }): Promise<RAGAdaptiveNativePlannerBenchmarkSnapshotResponse>;
+    nativeBackendComparisonBenchmark(input?: {
+        limit?: number;
+        runLimit?: number;
+        label?: string;
+        description?: string;
+        groupKey?: string;
+        corpusGroupKey?: string;
+    }): Promise<RAGAdaptiveNativePlannerBenchmarkResponse>;
+    runNativeBackendComparisonBenchmark(input?: {
+        limit?: number;
+        runLimit?: number;
+        topK?: number;
+        label?: string;
+        description?: string;
+        groupKey?: string;
+        corpusGroupKey?: string;
+        persistRun?: boolean;
+        baselineRetrievalId?: string;
+        candidateRetrievalId?: string;
+        retrievals?: Array<{
+            id: string;
+            label?: string;
+            retrieval?: Record<string, unknown> | string;
+        }>;
+        tags?: string[];
+        metadata?: Record<string, unknown>;
+    }): Promise<RAGAdaptiveNativePlannerBenchmarkResponse>;
+    saveNativeBackendComparisonBenchmarkSnapshot(input?: {
+        limit?: number;
+        label?: string;
+        description?: string;
+        version?: number;
+        createdAt?: number;
+        metadata?: Record<string, unknown>;
+        snapshotMetadata?: Record<string, unknown>;
+    }): Promise<RAGAdaptiveNativePlannerBenchmarkSnapshotResponse>;
+    retrievalLaneHandoffs(input?: {
+        groupKey?: string;
+        sourceRolloutLabel?: "canary" | "stable" | "rollback_target";
+        targetRolloutLabel?: "canary" | "stable" | "rollback_target";
+        limit?: number;
+    }): Promise<import("@absolutejs/ai").RAGRetrievalReleaseLaneHandoffSummary[]>;
+    retrievalLaneHandoffDecisions(input?: {
+        groupKey?: string;
+        sourceRolloutLabel?: "canary" | "stable" | "rollback_target";
+        targetRolloutLabel?: "canary" | "stable" | "rollback_target";
+        kind?: "approve" | "reject" | "complete";
+        limit?: number;
+    }): Promise<import("@absolutejs/ai").RAGRetrievalLaneHandoffDecisionRecord[]>;
+    retrievalLaneHandoffIncidents(input?: {
+        groupKey?: string;
+        limit?: number;
+        status?: "open" | "resolved";
+        severity?: "warning" | "critical";
+        targetRolloutLabel?: "canary" | "stable" | "rollback_target";
+    }): Promise<import("@absolutejs/ai").RAGRetrievalLaneHandoffIncidentRecord[]>;
+    retrievalLaneHandoffIncidentHistory(input?: {
+        action?: "opened" | "acknowledged" | "unacknowledged" | "resolved";
+        groupKey?: string;
+        incidentId?: string;
+        limit?: number;
+        targetRolloutLabel?: "canary" | "stable" | "rollback_target";
+    }): Promise<import("@absolutejs/ai").RAGRetrievalLaneHandoffIncidentHistoryRecord[]>;
+    retrievalLaneHandoffAutoCompletePolicyHistory(input?: {
+        groupKey?: string;
+        limit?: number;
+        targetRolloutLabel?: "canary" | "stable" | "rollback_target";
+    }): Promise<import("@absolutejs/ai").RAGRetrievalLaneHandoffAutoCompletePolicyHistoryRecord[]>;
+    retrievalReleaseLanePolicyHistory(input?: {
+        groupKey?: string;
+        limit?: number;
+        rolloutLabel?: "canary" | "stable" | "rollback_target";
+        scope?: "rollout_label" | "group_rollout_label";
+    }): Promise<import("@absolutejs/ai").RAGRetrievalReleaseLanePolicyHistoryRecord[]>;
+    retrievalBaselineGatePolicyHistory(input?: {
+        groupKey?: string;
+        limit?: number;
+        rolloutLabel?: "canary" | "stable" | "rollback_target";
+        scope?: "rollout_label" | "group_rollout_label";
+    }): Promise<import("@absolutejs/ai").RAGRetrievalBaselineGatePolicyHistoryRecord[]>;
+    retrievalReleaseLaneEscalationPolicyHistory(input?: {
+        groupKey?: string;
+        limit?: number;
+        targetRolloutLabel?: "canary" | "stable" | "rollback_target";
+    }): Promise<import("@absolutejs/ai").RAGRetrievalReleaseLaneEscalationPolicyHistoryRecord[]>;
+    retrievalReleaseIncidentPolicyHistory(input?: {
+        groupKey?: string;
+        limit?: number;
+        targetRolloutLabel?: "canary" | "stable" | "rollback_target";
+    }): Promise<import("@absolutejs/ai").RAGRetrievalReleaseLaneEscalationPolicyHistoryRecord[]>;
+    retrievalReleaseIncidentStatus(): Promise<RAGRetrievalReleaseIncidentStatusResponse>;
+    retrievalIncidentRemediationStatus(): Promise<RAGRetrievalIncidentRemediationStatusResponse>;
+    retrievalLaneHandoffIncidentStatus(): Promise<RAGRetrievalLaneHandoffIncidentStatusResponse>;
+    acknowledgeRetrievalLaneHandoffIncident(input: RAGRetrievalReleaseIncidentAcknowledgeRequest): Promise<import("@absolutejs/ai").RAGRetrievalLaneHandoffIncidentRecord[]>;
+    unacknowledgeRetrievalLaneHandoffIncident(input: {
+        incidentId: string;
+    }): Promise<import("@absolutejs/ai").RAGRetrievalLaneHandoffIncidentRecord[]>;
+    resolveRetrievalLaneHandoffIncident(input: {
+        incidentId: string;
+        resolvedAt?: number;
+        resolvedBy?: string;
+        resolutionNotes?: string;
+    }): Promise<import("@absolutejs/ai").RAGRetrievalLaneHandoffIncidentRecord[]>;
+    decideRetrievalLaneHandoff(input: RAGRetrievalLaneHandoffDecisionRequest): Promise<import("@absolutejs/ai").RAGRetrievalLaneHandoffDecisionRecord>;
+    decideRetrievalLaneHandoffDetailed(input: RAGRetrievalLaneHandoffDecisionRequest): Promise<RAGRetrievalLaneHandoffDecisionResponse>;
+    retrievalReleaseIncidents(input?: {
+        groupKey?: string;
+        limit?: number;
+        status?: "open" | "resolved";
+        severity?: "warning" | "critical";
+        kind?: "approval_expired" | "baseline_regression" | "gate_failure" | "handoff_stale";
+        acknowledged?: boolean;
+        targetRolloutLabel?: "canary" | "stable" | "rollback_target";
+    }): Promise<import("@absolutejs/ai").RAGRetrievalReleaseIncidentRecord[]>;
+    retrievalIncidentRemediationDecisions(input?: {
+        groupKey?: string;
+        incidentId?: string;
+        limit?: number;
+        remediationKind?: RAGRetrievalIncidentRemediationDecisionRequest["remediationKind"];
+        status?: "planned" | "applied" | "dismissed";
+        targetRolloutLabel?: "canary" | "stable" | "rollback_target";
+    }): Promise<import("@absolutejs/ai").RAGRetrievalIncidentRemediationDecisionRecord[]>;
+    retrievalIncidentRemediationExecutions(input?: {
+        groupKey?: string;
+        incidentId?: string;
+        limit?: number;
+        actionKind?: RAGRetrievalIncidentRemediationExecutionRequest["action"]["kind"];
+        code?: NonNullable<RAGRetrievalIncidentRemediationExecutionResponse["execution"]>["code"];
+        blockedByGuardrail?: boolean;
+        idempotentReplay?: boolean;
+        targetRolloutLabel?: "canary" | "stable" | "rollback_target";
+    }): Promise<import("@absolutejs/ai").RAGRetrievalIncidentRemediationExecutionHistoryRecord[]>;
+    recordRetrievalIncidentRemediationDecision(input: RAGRetrievalIncidentRemediationDecisionRequest): Promise<import("@absolutejs/ai").RAGRetrievalIncidentRemediationDecisionRecord[]>;
+    executeRetrievalIncidentRemediation(input: RAGRetrievalIncidentRemediationExecutionRequest): Promise<RAGRetrievalIncidentRemediationExecutionResponse>;
+    bulkExecuteRetrievalIncidentRemediations(input: RAGRetrievalIncidentRemediationBulkExecutionRequest): Promise<{
+        index: number;
+        ok: boolean;
+        execution?: import("@absolutejs/ai").RAGRetrievalIncidentRemediationExecutionResult;
+        record?: import("@absolutejs/ai").RAGRetrievalIncidentRemediationDecisionRecord;
+        error?: string;
+    }[]>;
+    acknowledgeRetrievalReleaseIncident(input: RAGRetrievalReleaseIncidentAcknowledgeRequest): Promise<import("@absolutejs/ai").RAGRetrievalReleaseIncidentRecord[]>;
+    unacknowledgeRetrievalReleaseIncident(input: {
+        incidentId: string;
+    }): Promise<import("@absolutejs/ai").RAGRetrievalReleaseIncidentRecord[]>;
+    resolveRetrievalReleaseIncident(input: {
+        incidentId: string;
+        resolvedAt?: number;
+        resolvedBy?: string;
+        resolutionNotes?: string;
+    }): Promise<import("@absolutejs/ai").RAGRetrievalReleaseIncidentRecord[]>;
+    retrievalPromotionCandidates(input?: {
+        groupKey?: string;
+        limit?: number;
+        tag?: string;
+        targetRolloutLabel?: "canary" | "stable" | "rollback_target";
+        approved?: boolean;
+        ready?: boolean;
+        blocked?: boolean;
+        reviewStatus?: "approved" | "blocked" | "needs_review" | "ready";
+        freshnessStatus?: "fresh" | "expired" | "not_applicable";
+        sortBy?: "approvalFreshness" | "finishedAt" | "gateSeverity" | "priority";
+        sortDirection?: "asc" | "desc";
+    }): Promise<import("@absolutejs/ai").RAGRetrievalPromotionCandidate[]>;
+    approveRetrievalCandidate(input: RAGRetrievalReleaseDecisionActionRequest): Promise<import("@absolutejs/ai").RAGRetrievalReleaseDecisionRecord[]>;
+    rejectRetrievalCandidate(input: RAGRetrievalReleaseDecisionActionRequest): Promise<import("@absolutejs/ai").RAGRetrievalReleaseDecisionRecord[]>;
+    ingest(chunks: RAGDocumentChunk[]): Promise<RAGIngestResponse>;
+    ingestDocuments(input: RAGDocumentIngestInput): Promise<RAGIngestResponse>;
+    ingestUploads(input: RAGDocumentUploadIngestInput): Promise<RAGIngestResponse>;
+    ingestUrls(input: RAGDocumentUrlIngestInput): Promise<RAGIngestResponse>;
+    analyzeBackend(): Promise<RAGMutationResponse>;
+    ops(): Promise<RAGOperationsResponse>;
+    searchTraceHistory(input?: {
+        query?: string;
+        groupKey?: string;
+        tag?: string;
+        limit?: number;
+    }): Promise<import("@absolutejs/ai").RAGSearchTraceHistory>;
+    searchTraceGroups(input?: {
+        tag?: string;
+        limit?: number;
+    }): Promise<import("@absolutejs/ai").RAGSearchTraceGroupHistory>;
+    searchTraceStats(input?: {
+        tag?: string;
+    }): Promise<import("@absolutejs/ai").RAGSearchTraceStats>;
+    previewSearchTracePrune(input?: {
+        maxAgeMs?: number;
+        maxRecordsPerQuery?: number;
+        maxRecordsPerGroup?: number;
+        now?: number;
+        tag?: string;
+    }): Promise<import("@absolutejs/ai").RAGSearchTracePrunePreview>;
+    pruneSearchTraces(input?: {
+        maxAgeMs?: number;
+        maxRecordsPerQuery?: number;
+        maxRecordsPerGroup?: number;
+        now?: number;
+        tag?: string;
+    }): Promise<RAGSearchTracePruneResponse>;
+    searchTracePruneHistory(input?: {
+        limit?: number;
+        trigger?: "manual" | "write" | "schedule";
+    }): Promise<import("@absolutejs/ai").RAGSearchTracePruneRun[]>;
+    syncSources(): Promise<RAGSyncResponse>;
+    syncAllSources(options?: RAGSyncRunOptions): Promise<RAGSyncResponse>;
+    syncSource(id: string, options?: RAGSyncRunOptions): Promise<RAGSyncResponse>;
+    reindexDocument(id: string): Promise<RAGMutationResponse>;
+    reindexSource(source: string): Promise<RAGMutationResponse>;
+    reseed(): Promise<RAGMutationResponse>;
+    reset(): Promise<RAGMutationResponse>;
+    rebuildNativeIndex(): Promise<RAGMutationResponse>;
+    search: <IncludeTrace extends boolean | undefined = undefined>(input: RAGSearchRequest & {
+        includeTrace?: IncludeTrace;
+    }) => Promise<IncludeTrace extends true ? RAGDetailedSearchResponse : RAGSource[]>;
+    searchWithTrace(input: RAGSearchRequest): Promise<RAGDetailedSearchResponse>;
+    /**
+     * @deprecated Use `searchWithTrace` for trace-aware search responses.
+     */
+    searchDetailed(input: RAGSearchRequest): Promise<RAGDetailedSearchResponse>;
+    status(): Promise<RAGStatusResponse>;
+    statusMaintenance(): Promise<RAGStatusResponse>;
+    retrievalReleaseStatus(): Promise<import("@absolutejs/ai").RAGRetrievalComparisonRuntime | undefined>;
+    retrievalReleaseDriftStatus(): Promise<RAGRetrievalReleaseDriftStatusResponse>;
+    retrievalLaneHandoffStatus(): Promise<RAGRetrievalLaneHandoffStatusResponse>;
+};
+export type RAGClient = ReturnType<typeof createRAGClient>;
+export {};

package/dist/src/ai/client/ui.d.ts

@@ -0,0 +1,5 @@
+export { buildRAGAnswerWorkflowState, buildRAGSourceGroups, buildRAGSourceSummaries, buildRAGStreamProgress, getLatestAssistantMessage, resolveRAGStreamStage, } from "../rag/workflowState";
+export { buildRAGStreamProgress as getRAGStreamProgress } from "../rag/workflowState";
+export { buildRAGCitationReferenceMap, buildRAGChunkExcerpts, buildRAGChunkGraphNavigation, buildRAGChunkGraph, buildRAGChunkPreviewGraph, buildRAGChunkPreviewNavigation, buildRAGGroundedAnswer, buildRAGGroundedAnswerSectionSummaries, buildRAGGroundingReferences, buildRAGSectionRetrievalDiagnostics, } from "../rag/presentation";
+export type { RAGStreamProgress, RAGStreamProgressState, } from "../rag/workflowState";
+export type { RAGAnswerWorkflowState } from "@absolutejs/ai";

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

@@ -0,0 +1,2 @@
+import type { CreateRAGAccessControlOptions, RAGChatPluginConfig } from "@absolutejs/ai";
+export declare const createRAGAccessControl: <TContext = unknown>(options: CreateRAGAccessControlOptions<TContext>) => Pick<RAGChatPluginConfig, "authorizeRAGAction" | "resolveRAGAccessScope">;

package/dist/src/ai/rag/adapters/filtering.d.ts

@@ -0,0 +1,2 @@
+export declare const matchesMetadataFilterValue: (actual: unknown, expected: unknown) => boolean;
+export declare const matchesMetadataFilterRecord: (record: Record<string, unknown>, filter?: Record<string, unknown>) => boolean;

package/dist/src/ai/rag/adapters/inMemory.d.ts

@@ -0,0 +1,8 @@
+import { createRAGVector, normalizeVector, querySimilarity } from "./utils";
+import type { RAGVectorStore } from "@absolutejs/ai";
+export type InMemoryRAGStoreOptions = {
+    dimensions?: number;
+    mockEmbedding?: (text: string) => Promise<number[]>;
+};
+export declare const createInMemoryRAGStore: (options?: InMemoryRAGStoreOptions) => RAGVectorStore;
+export { createRAGVector, normalizeVector, querySimilarity };

package/dist/src/ai/rag/adapters/postgres.d.ts

@@ -0,0 +1,20 @@
+import type { RAGVectorStore } from "@absolutejs/ai";
+type BunSQLClient = InstanceType<typeof Bun.SQL>;
+type PostgresDistanceMetric = "cosine" | "l2" | "inner_product";
+type PostgresIndexType = "none" | "hnsw" | "ivfflat";
+export type PostgresRAGStoreOptions = {
+    connectionString?: string;
+    sql?: BunSQLClient;
+    dimensions?: number;
+    mockEmbedding?: (text: string) => Promise<number[]>;
+    tableName?: string;
+    schemaName?: string;
+    distanceMetric?: PostgresDistanceMetric;
+    queryMultiplier?: number;
+    indexType?: PostgresIndexType;
+    indexLists?: number;
+    hnswM?: number;
+    hnswEfConstruction?: number;
+};
+export declare const createPostgresRAGStore: (options?: PostgresRAGStoreOptions) => RAGVectorStore;
+export {};

package/dist/src/ai/rag/adapters/queryPlanning.d.ts

@@ -0,0 +1,26 @@
+export declare const planNativeCandidateSearchK: (input: {
+    topK: number;
+    queryMultiplier: number;
+    candidateLimit: number;
+    filteredCandidateCount?: number;
+}) => number;
+export declare const resolveAdaptiveNativeCandidateLimit: (input: {
+    defaultCandidateLimit: number;
+    explicitCandidateLimit?: number;
+    filteredCandidateCount?: number;
+    plannerProfile?: "latency" | "balanced" | "recall";
+    queryMultiplier: number;
+    topK: number;
+}) => number;
+export declare const planNativeCandidateSearchBackfillK: (input: {
+    currentSearchK: number;
+    candidateLimit: number;
+    filteredCandidateCount?: number;
+    backfillCount?: number;
+    maxBackfills?: number;
+}) => number;
+export declare const summarizeSQLiteCandidateCoverage: (input: {
+    topK: number;
+    filteredCandidateCount?: number;
+    returnedCount?: number;
+}) => "empty" | "under_target" | "target_sized" | "broad";

package/dist/src/ai/rag/adapters/sqlite.d.ts

@@ -0,0 +1,24 @@
+import { Database } from "bun:sqlite";
+import type { RAGVectorStore } from "@absolutejs/ai";
+type NativeDistanceMetric = "cosine" | "l2";
+type NativeRAGMode = "vec0";
+export type NativeSQLiteRAGStoreOptions = {
+    mode: NativeRAGMode;
+    extensionPath?: string;
+    extensionInitSql?: string | string[];
+    distanceMetric?: NativeDistanceMetric;
+    tableName?: string;
+    queryMultiplier?: number;
+    requireAvailable?: boolean;
+    resolveFromAbsolutePackages?: boolean;
+};
+export type SQLiteRAGStoreOptions = {
+    db?: Database;
+    path?: string;
+    dimensions?: number;
+    mockEmbedding?: (text: string) => Promise<number[]>;
+    tableName?: string;
+    native?: NativeSQLiteRAGStoreOptions;
+};
+export declare const createSQLiteRAGStore: (options?: SQLiteRAGStoreOptions) => RAGVectorStore;
+export {};

package/dist/src/ai/rag/adapters/utils.d.ts

@@ -0,0 +1,3 @@
+export declare const createRAGVector: (text: string, dimensions?: number) => any[];
+export declare const normalizeVector: (vector: number[]) => number[];
+export declare const querySimilarity: (left: number[], right: number[]) => number;