@absolutejs/rag 0.0.1

package/dist/src/react/ai/useRAG.d.ts

@@ -0,0 +1,341 @@
+export type UseRAGOptions = {
+    autoLoadOps?: boolean;
+    autoLoadStatus?: boolean;
+    conversationId?: string;
+    streamPath?: string;
+};
+export declare const useRAG: (path: string, options?: UseRAGOptions) => {
+    chunkPreview: {
+        activeChunkId: string | null;
+        activeSectionDiagnostic: import("@absolutejs/ai").RAGSectionRetrievalDiagnostic | null;
+        chunkGraph: import("@absolutejs/ai").RAGChunkGraph | null;
+        clear: () => void;
+        error: string | null;
+        inspect: (id: string) => Promise<{
+            ok: true;
+        } & import("@absolutejs/ai").RAGDocumentChunkPreview>;
+        isLoading: boolean;
+        navigation: import("@absolutejs/ai").RAGChunkGraphNavigation | null;
+        preview: import("@absolutejs/ai").RAGDocumentChunkPreview | null;
+        sectionDiagnostics: import("@absolutejs/ai").RAGSectionRetrievalDiagnostic[];
+        selectChildSection: (sectionId: string) => void;
+        selectChunk: (id: string | null) => void;
+        selectParentSection: () => void;
+        selectSiblingSection: (sectionId: string) => void;
+    };
+    citations: {
+        citationReferenceMap: import("@absolutejs/ai").RAGCitationReferenceMap;
+        citations: import("@absolutejs/ai").RAGCitation[];
+        hasCitations: boolean;
+        sourceGroups: import("@absolutejs/ai").RAGSourceGroup[];
+        sourceSummaries: import("@absolutejs/ai").RAGSourceSummary[];
+    };
+    documents: {
+        documents: import("@absolutejs/ai").RAGIndexedDocument[];
+        error: string | null;
+        isLoading: boolean;
+        lastResponse: import("@absolutejs/ai").RAGDocumentsResponse | null;
+        load: (kind?: string) => Promise<import("@absolutejs/ai").RAGDocumentsResponse>;
+        reset: () => void;
+    };
+    evaluate: {
+        clearRuns: () => void;
+        error: string | null;
+        evaluate: (input: import("@absolutejs/ai").RAGEvaluationInput) => Promise<import("@absolutejs/ai").RAGEvaluationResponse>;
+        isEvaluating: boolean;
+        lastRequest: import("@absolutejs/ai").RAGEvaluationInput | null;
+        lastResponse: import("@absolutejs/ai").RAGEvaluationResponse | null;
+        leaderboard: import("@absolutejs/ai").RAGEvaluationLeaderboardEntry[];
+        removeSuite: (id: string) => void;
+        reset: () => void;
+        runSuite: (suite: import("@absolutejs/ai").RAGEvaluationSuite, overrides?: Partial<import("@absolutejs/ai").RAGEvaluationInput>) => Promise<{
+            caseTraceSnapshots: import("@absolutejs/ai").RAGEvaluationCaseTraceSnapshot[] | undefined;
+            elapsedMs: number;
+            finishedAt: number;
+            id: `${string}-${string}-${string}-${string}-${string}`;
+            label: string;
+            metadata: Record<string, unknown> | undefined;
+            response: import("@absolutejs/ai").RAGEvaluationResponse;
+            startedAt: number;
+            suiteId: string;
+            traceSummary: import("@absolutejs/ai").RAGRetrievalTraceComparisonSummary | undefined;
+        }>;
+        saveSuite: (suite: import("@absolutejs/ai").RAGEvaluationSuite) => import("@absolutejs/ai").RAGEvaluationSuite;
+        suiteRuns: import("@absolutejs/ai").RAGEvaluationSuiteRun[];
+        suites: import("@absolutejs/ai").RAGEvaluationSuite[];
+    };
+    grounding: {
+        coverage: "grounded" | "partial" | "ungrounded";
+        groundedAnswer: import("@absolutejs/ai").RAGGroundedAnswer;
+        hasCitations: boolean;
+        hasGrounding: boolean;
+        references: import("@absolutejs/ai").RAGGroundingReference[];
+        ungroundedReferenceNumbers: number[];
+    };
+    index: {
+        backends: import("@absolutejs/ai").RAGBackendsResponse | null;
+        analyzeBackend: () => Promise<import("@absolutejs/ai").RAGMutationResponse>;
+        clearIndex: () => Promise<{
+            ok: boolean;
+        }>;
+        createDocument: (input: {
+            id?: string;
+            title?: string;
+            source?: string;
+            text: string;
+            format?: import("@absolutejs/ai").RAGContentFormat;
+            metadata?: Record<string, unknown>;
+            chunking?: {
+                maxChunkLength?: number;
+                chunkOverlap?: number;
+                minChunkLength?: number;
+                strategy?: "paragraphs" | "sentences" | "fixed" | "source_aware";
+            };
+        }) => Promise<import("@absolutejs/ai").RAGMutationResponse>;
+        deleteDocument: (id: string) => Promise<import("@absolutejs/ai").RAGMutationResponse>;
+        error: string | null;
+        isLoading: boolean;
+        lastMutation: import("@absolutejs/ai").RAGMutationResponse | null;
+        loadBackends: () => Promise<import("@absolutejs/ai").RAGBackendsResponse>;
+        loadSyncSources: () => Promise<import("@absolutejs/ai").RAGSyncResponse>;
+        rebuildNativeIndex: () => Promise<import("@absolutejs/ai").RAGMutationResponse>;
+        reindexDocument: (id: string) => Promise<import("@absolutejs/ai").RAGMutationResponse>;
+        reindexSource: (source: string) => Promise<import("@absolutejs/ai").RAGMutationResponse>;
+        reseed: () => Promise<import("@absolutejs/ai").RAGMutationResponse>;
+        reset: () => Promise<import("@absolutejs/ai").RAGMutationResponse>;
+        resetState: () => void;
+        syncAllSources: (options?: import("@absolutejs/ai").RAGSyncRunOptions) => Promise<{
+            ok: true;
+            source: import("@absolutejs/ai").RAGSyncSourceRecord;
+            partial?: boolean;
+        } | {
+            ok: true;
+            sources: import("@absolutejs/ai").RAGSyncSourceRecord[];
+            partial?: boolean;
+            failedSourceIds?: string[];
+            errorsBySource?: Record<string, string>;
+        }>;
+        syncSource: (id: string, options?: import("@absolutejs/ai").RAGSyncRunOptions) => Promise<{
+            ok: true;
+            source: import("@absolutejs/ai").RAGSyncSourceRecord;
+            partial?: boolean;
+        } | {
+            ok: true;
+            sources: import("@absolutejs/ai").RAGSyncSourceRecord[];
+            partial?: boolean;
+            failedSourceIds?: string[];
+            errorsBySource?: Record<string, string>;
+        }>;
+        syncSources: import("@absolutejs/ai").RAGSyncResponse | null;
+    };
+    ingest: {
+        clearIndex: () => Promise<void>;
+        error: string | null;
+        ingest: (chunks: import("@absolutejs/ai").RAGDocumentChunk[]) => Promise<import("@absolutejs/ai").RAGIngestResponse>;
+        ingestChunks: (chunks: import("@absolutejs/ai").RAGDocumentChunk[]) => Promise<import("@absolutejs/ai").RAGIngestResponse>;
+        ingestDocuments: (input: import("@absolutejs/ai").RAGDocumentIngestInput) => Promise<import("@absolutejs/ai").RAGIngestResponse>;
+        ingestUploads: (input: import("@absolutejs/ai").RAGDocumentUploadIngestInput) => Promise<import("@absolutejs/ai").RAGIngestResponse>;
+        ingestUrls: (input: import("@absolutejs/ai").RAGDocumentUrlIngestInput) => Promise<import("@absolutejs/ai").RAGIngestResponse>;
+        isIngesting: boolean;
+        lastDocumentCount: number | null;
+        lastIngestCount: number | null;
+        lastResponse: import("@absolutejs/ai").RAGIngestResponse | null;
+        reset: () => void;
+    };
+    ops: {
+        admin: import("@absolutejs/ai").RAGAdminCapabilities | undefined;
+        adminActions: import("@absolutejs/ai").RAGAdminActionRecord[];
+        adminJobs: import("@absolutejs/ai").RAGAdminJobRecord[];
+        capabilities: import("@absolutejs/ai").RAGBackendCapabilities | undefined;
+        documents: import("@absolutejs/ai").RAGDocumentSummary | undefined;
+        error: string | null;
+        health: import("@absolutejs/ai").RAGCorpusHealth | undefined;
+        ingestJobs: import("@absolutejs/ai").RAGIngestJobRecord[];
+        isLoading: boolean;
+        maintenance: import("@absolutejs/ai").RAGBackendMaintenanceSummary | undefined;
+        operations: import("@absolutejs/ai").RAGOperationsResponse | undefined;
+        readiness: import("@absolutejs/ai").RAGExtractorReadiness | undefined;
+        refresh: () => Promise<import("@absolutejs/ai").RAGOperationsResponse>;
+        reset: () => void;
+        status: import("@absolutejs/ai").RAGVectorStoreStatus | undefined;
+        syncSources: import("@absolutejs/ai").RAGSyncSourceRecord[];
+    };
+    search: {
+        error: string | null;
+        hasSearched: boolean;
+        isSearching: boolean;
+        lastRequest: import("@absolutejs/ai").RAGSearchRequest | null;
+        reset: () => void;
+        results: import("@absolutejs/ai").RAGSource[];
+        search: (input: {
+            filter?: Record<string, unknown> | undefined;
+            query: string;
+            candidateTopK?: number | undefined;
+            retrieval?: (import("@absolutejs/ai").RAGHybridSearchOptions | import("@absolutejs/ai").RAGHybridRetrievalMode) | undefined;
+            model?: string | undefined;
+            topK?: number | undefined;
+            scoreThreshold?: number | undefined;
+            nativeQueryProfile?: import("@absolutejs/ai").RAGNativeQueryProfile | undefined;
+            nativeQueryMultiplier?: number | undefined;
+            nativeCandidateLimit?: number | undefined;
+            nativeMaxBackfills?: number | undefined;
+            nativeMinResults?: number | undefined;
+            nativeFillPolicy?: "strict_topk" | "satisfy_min_results" | undefined;
+            queryTransform?: import("@absolutejs/ai").RAGQueryTransformProviderLike | undefined;
+            retrievalStrategy?: import("@absolutejs/ai").RAGRetrievalStrategyProviderLike | undefined;
+            persistTrace?: boolean | undefined;
+            traceGroupKey?: string | undefined;
+            traceTags?: string[] | undefined;
+        }) => Promise<import("@absolutejs/ai").RAGSource[]>;
+        searchWithTrace: (input: {
+            filter?: Record<string, unknown> | undefined;
+            query: string;
+            candidateTopK?: number | undefined;
+            retrieval?: (import("@absolutejs/ai").RAGHybridSearchOptions | import("@absolutejs/ai").RAGHybridRetrievalMode) | undefined;
+            model?: string | undefined;
+            topK?: number | undefined;
+            scoreThreshold?: number | undefined;
+            nativeQueryProfile?: import("@absolutejs/ai").RAGNativeQueryProfile | undefined;
+            nativeQueryMultiplier?: number | undefined;
+            nativeCandidateLimit?: number | undefined;
+            nativeMaxBackfills?: number | undefined;
+            nativeMinResults?: number | undefined;
+            nativeFillPolicy?: "strict_topk" | "satisfy_min_results" | undefined;
+            queryTransform?: import("@absolutejs/ai").RAGQueryTransformProviderLike | undefined;
+            retrievalStrategy?: import("@absolutejs/ai").RAGRetrievalStrategyProviderLike | undefined;
+            persistTrace?: boolean | undefined;
+            traceGroupKey?: string | undefined;
+            traceTags?: string[] | undefined;
+        }) => Promise<import("../../ai/client").RAGDetailedSearchResponse>;
+        setResults: import("react").Dispatch<import("react").SetStateAction<import("@absolutejs/ai").RAGSource[]>>;
+        trace: import("@absolutejs/ai").RAGRetrievalTrace | undefined;
+    };
+    sources: {
+        citationReferenceMap: import("@absolutejs/ai").RAGCitationReferenceMap;
+        chunkGraph: import("@absolutejs/ai").RAGChunkGraph;
+        hasSources: boolean;
+        latestAssistantMessage: import("@absolutejs/ai").AIMessage | undefined;
+        navigationForChunk: (chunkId?: string | null) => import("@absolutejs/ai").RAGChunkGraphNavigation;
+        sectionDiagnostics: import("@absolutejs/ai").RAGSectionRetrievalDiagnostic[];
+        sourceGroups: import("@absolutejs/ai").RAGSourceGroup[];
+        sources: import("@absolutejs/ai").RAGSource[];
+        sourceSummaries: import("@absolutejs/ai").RAGSourceSummary[];
+    };
+    status: {
+        capabilities: import("@absolutejs/ai").RAGBackendCapabilities | undefined;
+        error: string | null;
+        isLoading: boolean;
+        refresh: () => Promise<import("@absolutejs/ai").RAGStatusResponse>;
+        reset: () => void;
+        status: import("@absolutejs/ai").RAGVectorStoreStatus | undefined;
+    };
+    stream: {
+        state: import("@absolutejs/ai").RAGAnswerWorkflowState;
+        citationReferenceMap: import("@absolutejs/ai").RAGCitationReferenceMap;
+        citations: import("@absolutejs/ai").RAGCitation[];
+        coverage: "grounded" | "partial" | "ungrounded";
+        groundedAnswer: import("@absolutejs/ai").RAGGroundedAnswer;
+        groundingReferences: import("@absolutejs/ai").RAGGroundingReference[];
+        hasGrounding: boolean;
+        hasRetrieved: boolean;
+        hasSources: boolean;
+        isAnswerStreaming: boolean;
+        isComplete: boolean;
+        isError: boolean;
+        isRetrieved: boolean;
+        isRetrieving: boolean;
+        isRunning: boolean;
+        latestAssistantMessage: import("@absolutejs/ai").AIMessage | undefined;
+        progress: {
+            conversationId: string | undefined;
+            hasContent: boolean;
+            hasRetrieved: boolean;
+            hasSources: boolean;
+            hasThinking: boolean;
+            hasToolCalls: boolean;
+            isComplete: boolean;
+            isError: boolean;
+            isIdle: boolean;
+            isRetrieved: boolean;
+            isRetrieving: boolean;
+            isStreaming: boolean;
+            isSubmitting: boolean;
+            latestMessage: import("@absolutejs/ai").AIMessage | undefined;
+            messageId: string | undefined;
+            retrievalDurationMs: number | undefined;
+            retrievalStartedAt: number | undefined;
+            retrievedAt: number | undefined;
+            sourceCount: number;
+            stage: import("@absolutejs/ai").RAGStreamStage;
+        };
+        query: (content: string, attachments?: import("@absolutejs/ai").AIAttachment[]) => void;
+        retrieval: import("@absolutejs/ai").RAGRetrievedState | null;
+        sourceGroups: import("@absolutejs/ai").RAGSourceGroup[];
+        sourceSummaries: import("@absolutejs/ai").RAGSourceSummary[];
+        sources: import("@absolutejs/ai").RAGSource[];
+        stage: import("@absolutejs/ai").RAGStreamStage;
+        ungroundedReferenceNumbers: number[];
+        workflow: import("@absolutejs/ai").RAGAnswerWorkflowState;
+        branch: (messageId: string, content: string) => void;
+        cancel: () => void;
+        error: string | null;
+        isStreaming: boolean;
+        messages: import("@absolutejs/ai").AIMessage[];
+        send: (content: string, attachments?: import("@absolutejs/ai").AIAttachment[]) => void;
+    };
+    workflow: {
+        state: import("@absolutejs/ai").RAGAnswerWorkflowState;
+        citationReferenceMap: import("@absolutejs/ai").RAGCitationReferenceMap;
+        citations: import("@absolutejs/ai").RAGCitation[];
+        coverage: "grounded" | "partial" | "ungrounded";
+        groundedAnswer: import("@absolutejs/ai").RAGGroundedAnswer;
+        groundingReferences: import("@absolutejs/ai").RAGGroundingReference[];
+        hasGrounding: boolean;
+        hasRetrieved: boolean;
+        hasSources: boolean;
+        isAnswerStreaming: boolean;
+        isComplete: boolean;
+        isError: boolean;
+        isRetrieved: boolean;
+        isRetrieving: boolean;
+        isRunning: boolean;
+        latestAssistantMessage: import("@absolutejs/ai").AIMessage | undefined;
+        progress: {
+            conversationId: string | undefined;
+            hasContent: boolean;
+            hasRetrieved: boolean;
+            hasSources: boolean;
+            hasThinking: boolean;
+            hasToolCalls: boolean;
+            isComplete: boolean;
+            isError: boolean;
+            isIdle: boolean;
+            isRetrieved: boolean;
+            isRetrieving: boolean;
+            isStreaming: boolean;
+            isSubmitting: boolean;
+            latestMessage: import("@absolutejs/ai").AIMessage | undefined;
+            messageId: string | undefined;
+            retrievalDurationMs: number | undefined;
+            retrievalStartedAt: number | undefined;
+            retrievedAt: number | undefined;
+            sourceCount: number;
+            stage: import("@absolutejs/ai").RAGStreamStage;
+        };
+        query: (content: string, attachments?: import("@absolutejs/ai").AIAttachment[]) => void;
+        retrieval: import("@absolutejs/ai").RAGRetrievedState | null;
+        sourceGroups: import("@absolutejs/ai").RAGSourceGroup[];
+        sourceSummaries: import("@absolutejs/ai").RAGSourceSummary[];
+        sources: import("@absolutejs/ai").RAGSource[];
+        stage: import("@absolutejs/ai").RAGStreamStage;
+        ungroundedReferenceNumbers: number[];
+        workflow: import("@absolutejs/ai").RAGAnswerWorkflowState;
+        branch: (messageId: string, content: string) => void;
+        cancel: () => void;
+        error: string | null;
+        isStreaming: boolean;
+        messages: import("@absolutejs/ai").AIMessage[];
+        send: (content: string, attachments?: import("@absolutejs/ai").AIAttachment[]) => void;
+    };
+};
+export type UseRAGResult = ReturnType<typeof useRAG>;

package/dist/src/react/ai/useRAGChunkPreview.d.ts

@@ -0,0 +1,20 @@
+import type { RAGDocumentChunkPreview } from '@absolutejs/ai';
+export declare const useRAGChunkPreview: (path: string) => {
+    activeChunkId: string | null;
+    activeSectionDiagnostic: import("@absolutejs/ai").RAGSectionRetrievalDiagnostic | null;
+    chunkGraph: import("@absolutejs/ai").RAGChunkGraph | null;
+    clear: () => void;
+    error: string | null;
+    inspect: (id: string) => Promise<{
+        ok: true;
+    } & RAGDocumentChunkPreview>;
+    isLoading: boolean;
+    navigation: import("@absolutejs/ai").RAGChunkGraphNavigation | null;
+    preview: RAGDocumentChunkPreview | null;
+    sectionDiagnostics: import("@absolutejs/ai").RAGSectionRetrievalDiagnostic[];
+    selectChildSection: (sectionId: string) => void;
+    selectChunk: (id: string | null) => void;
+    selectParentSection: () => void;
+    selectSiblingSection: (sectionId: string) => void;
+};
+export type UseRAGChunkPreviewResult = ReturnType<typeof useRAGChunkPreview>;

package/dist/src/react/ai/useRAGCitations.d.ts

@@ -0,0 +1,9 @@
+import type { RAGSource } from '@absolutejs/ai';
+export declare const useRAGCitations: (sources: RAGSource[]) => {
+    citationReferenceMap: import("@absolutejs/ai").RAGCitationReferenceMap;
+    citations: import("@absolutejs/ai").RAGCitation[];
+    hasCitations: boolean;
+    sourceGroups: import("@absolutejs/ai").RAGSourceGroup[];
+    sourceSummaries: import("@absolutejs/ai").RAGSourceSummary[];
+};
+export type UseRAGCitationsResult = ReturnType<typeof useRAGCitations>;

package/dist/src/react/ai/useRAGDocuments.d.ts

@@ -0,0 +1,10 @@
+import type { RAGDocumentsResponse, RAGIndexedDocument } from '@absolutejs/ai';
+export declare const useRAGDocuments: (path: string) => {
+    documents: RAGIndexedDocument[];
+    error: string | null;
+    isLoading: boolean;
+    lastResponse: RAGDocumentsResponse | null;
+    load: (kind?: string) => Promise<RAGDocumentsResponse>;
+    reset: () => void;
+};
+export type UseRAGDocumentsResult = ReturnType<typeof useRAGDocuments>;

package/dist/src/react/ai/useRAGEvaluate.d.ts

@@ -0,0 +1,28 @@
+import type { RAGEvaluationInput, RAGEvaluationResponse, RAGEvaluationSuite, RAGEvaluationSuiteRun } from '@absolutejs/ai';
+export declare const useRAGEvaluate: (path: string) => {
+    clearRuns: () => void;
+    error: string | null;
+    evaluate: (input: RAGEvaluationInput) => Promise<RAGEvaluationResponse>;
+    isEvaluating: boolean;
+    lastRequest: RAGEvaluationInput | null;
+    lastResponse: RAGEvaluationResponse | null;
+    leaderboard: import("@absolutejs/ai").RAGEvaluationLeaderboardEntry[];
+    removeSuite: (id: string) => void;
+    reset: () => void;
+    runSuite: (suite: RAGEvaluationSuite, overrides?: Partial<RAGEvaluationInput>) => Promise<{
+        caseTraceSnapshots: import("@absolutejs/ai").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: import("@absolutejs/ai").RAGRetrievalTraceComparisonSummary | undefined;
+    }>;
+    saveSuite: (suite: RAGEvaluationSuite) => RAGEvaluationSuite;
+    suiteRuns: RAGEvaluationSuiteRun[];
+    suites: RAGEvaluationSuite[];
+};
+export type UseRAGEvaluateResult = ReturnType<typeof useRAGEvaluate>;

package/dist/src/react/ai/useRAGGrounding.d.ts

@@ -0,0 +1,10 @@
+import type { RAGSource } from '@absolutejs/ai';
+export declare const useRAGGrounding: (content: string, sources: RAGSource[]) => {
+    coverage: "grounded" | "partial" | "ungrounded";
+    groundedAnswer: import("@absolutejs/ai").RAGGroundedAnswer;
+    hasCitations: boolean;
+    hasGrounding: boolean;
+    references: import("@absolutejs/ai").RAGGroundingReference[];
+    ungroundedReferenceNumbers: number[];
+};
+export type UseRAGGroundingResult = ReturnType<typeof useRAGGrounding>;

package/dist/src/react/ai/useRAGIndexAdmin.d.ts

@@ -0,0 +1,58 @@
+import type { RAGBackendsResponse, RAGContentFormat, RAGMutationResponse, RAGSyncResponse, RAGSyncRunOptions } from '@absolutejs/ai';
+export declare const useRAGIndexAdmin: (path: string) => {
+    backends: RAGBackendsResponse | null;
+    analyzeBackend: () => Promise<RAGMutationResponse>;
+    clearIndex: () => Promise<{
+        ok: boolean;
+    }>;
+    createDocument: (input: {
+        id?: string;
+        title?: string;
+        source?: string;
+        text: string;
+        format?: RAGContentFormat;
+        metadata?: Record<string, unknown>;
+        chunking?: {
+            maxChunkLength?: number;
+            chunkOverlap?: number;
+            minChunkLength?: number;
+            strategy?: "paragraphs" | "sentences" | "fixed" | "source_aware";
+        };
+    }) => Promise<RAGMutationResponse>;
+    deleteDocument: (id: string) => Promise<RAGMutationResponse>;
+    error: string | null;
+    isLoading: boolean;
+    lastMutation: RAGMutationResponse | null;
+    loadBackends: () => Promise<RAGBackendsResponse>;
+    loadSyncSources: () => Promise<RAGSyncResponse>;
+    rebuildNativeIndex: () => Promise<RAGMutationResponse>;
+    reindexDocument: (id: string) => Promise<RAGMutationResponse>;
+    reindexSource: (source: string) => Promise<RAGMutationResponse>;
+    reseed: () => Promise<RAGMutationResponse>;
+    reset: () => Promise<RAGMutationResponse>;
+    resetState: () => void;
+    syncAllSources: (options?: RAGSyncRunOptions) => Promise<{
+        ok: true;
+        source: import("@absolutejs/ai").RAGSyncSourceRecord;
+        partial?: boolean;
+    } | {
+        ok: true;
+        sources: import("@absolutejs/ai").RAGSyncSourceRecord[];
+        partial?: boolean;
+        failedSourceIds?: string[];
+        errorsBySource?: Record<string, string>;
+    }>;
+    syncSource: (id: string, options?: RAGSyncRunOptions) => Promise<{
+        ok: true;
+        source: import("@absolutejs/ai").RAGSyncSourceRecord;
+        partial?: boolean;
+    } | {
+        ok: true;
+        sources: import("@absolutejs/ai").RAGSyncSourceRecord[];
+        partial?: boolean;
+        failedSourceIds?: string[];
+        errorsBySource?: Record<string, string>;
+    }>;
+    syncSources: RAGSyncResponse | null;
+};
+export type UseRAGIndexAdminResult = ReturnType<typeof useRAGIndexAdmin>;

package/dist/src/react/ai/useRAGIngest.d.ts

@@ -0,0 +1,16 @@
+import type { RAGDocumentChunk, RAGDocumentIngestInput, RAGDocumentUploadIngestInput, RAGDocumentUrlIngestInput, RAGIngestResponse } from '@absolutejs/ai';
+export declare const useRAGIngest: (path: string) => {
+    clearIndex: () => Promise<void>;
+    error: string | null;
+    ingest: (chunks: RAGDocumentChunk[]) => Promise<RAGIngestResponse>;
+    ingestChunks: (chunks: RAGDocumentChunk[]) => Promise<RAGIngestResponse>;
+    ingestDocuments: (input: RAGDocumentIngestInput) => Promise<RAGIngestResponse>;
+    ingestUploads: (input: RAGDocumentUploadIngestInput) => Promise<RAGIngestResponse>;
+    ingestUrls: (input: RAGDocumentUrlIngestInput) => Promise<RAGIngestResponse>;
+    isIngesting: boolean;
+    lastDocumentCount: number | null;
+    lastIngestCount: number | null;
+    lastResponse: RAGIngestResponse | null;
+    reset: () => void;
+};
+export type UseRAGIngestResult = ReturnType<typeof useRAGIngest>;

package/dist/src/react/ai/useRAGOps.d.ts

@@ -0,0 +1,20 @@
+import type { RAGAdminActionRecord, RAGAdminJobRecord, RAGAdminCapabilities, RAGBackendCapabilities, RAGBackendMaintenanceSummary, RAGCorpusHealth, RAGDocumentSummary, RAGExtractorReadiness, RAGIngestJobRecord, RAGOperationsResponse, RAGSyncSourceRecord, RAGVectorStoreStatus } from '@absolutejs/ai';
+export declare const useRAGOps: (path: string, autoLoad?: boolean) => {
+    admin: RAGAdminCapabilities | undefined;
+    adminActions: RAGAdminActionRecord[];
+    adminJobs: RAGAdminJobRecord[];
+    capabilities: RAGBackendCapabilities | undefined;
+    documents: RAGDocumentSummary | undefined;
+    error: string | null;
+    health: RAGCorpusHealth | undefined;
+    ingestJobs: RAGIngestJobRecord[];
+    isLoading: boolean;
+    maintenance: RAGBackendMaintenanceSummary | undefined;
+    operations: RAGOperationsResponse | undefined;
+    readiness: RAGExtractorReadiness | undefined;
+    refresh: () => Promise<RAGOperationsResponse>;
+    reset: () => void;
+    status: RAGVectorStoreStatus | undefined;
+    syncSources: RAGSyncSourceRecord[];
+};
+export type UseRAGOpsResult = ReturnType<typeof useRAGOps>;

package/dist/src/react/ai/useRAGSearch.d.ts

@@ -0,0 +1,17 @@
+import type { RAGSearchRequest, RAGSource } from '@absolutejs/ai';
+import { type RAGDetailedSearchResponse } from '../../ai/client/ragClient';
+type SearchRequest = Omit<RAGSearchRequest, 'includeTrace'>;
+export declare const useRAGSearch: (path: string) => {
+    error: string | null;
+    hasSearched: boolean;
+    isSearching: boolean;
+    lastRequest: RAGSearchRequest | null;
+    reset: () => void;
+    results: RAGSource[];
+    search: (input: SearchRequest) => Promise<RAGSource[]>;
+    searchWithTrace: (input: SearchRequest) => Promise<RAGDetailedSearchResponse>;
+    setResults: import("react").Dispatch<import("react").SetStateAction<RAGSource[]>>;
+    trace: import("@absolutejs/ai").RAGRetrievalTrace | undefined;
+};
+export type UseRAGSearchResult = ReturnType<typeof useRAGSearch>;
+export {};

package/dist/src/react/ai/useRAGSources.d.ts

@@ -0,0 +1,13 @@
+import type { AIMessage } from '@absolutejs/ai';
+export declare const useRAGSources: (messages: AIMessage[]) => {
+    citationReferenceMap: import("@absolutejs/ai").RAGCitationReferenceMap;
+    chunkGraph: import("@absolutejs/ai").RAGChunkGraph;
+    hasSources: boolean;
+    latestAssistantMessage: AIMessage | undefined;
+    navigationForChunk: (chunkId?: string | null) => import("@absolutejs/ai").RAGChunkGraphNavigation;
+    sectionDiagnostics: import("@absolutejs/ai").RAGSectionRetrievalDiagnostic[];
+    sourceGroups: import("@absolutejs/ai").RAGSourceGroup[];
+    sources: import("@absolutejs/ai").RAGSource[];
+    sourceSummaries: import("@absolutejs/ai").RAGSourceSummary[];
+};
+export type UseRAGSourcesResult = ReturnType<typeof useRAGSources>;

package/dist/src/react/ai/useRAGStatus.d.ts

@@ -0,0 +1,10 @@
+import type { RAGBackendCapabilities, RAGVectorStoreStatus } from '@absolutejs/ai';
+export declare const useRAGStatus: (path: string, autoLoad?: boolean) => {
+    capabilities: RAGBackendCapabilities | undefined;
+    error: string | null;
+    isLoading: boolean;
+    refresh: () => Promise<import("@absolutejs/ai").RAGStatusResponse>;
+    reset: () => void;
+    status: RAGVectorStoreStatus | undefined;
+};
+export type UseRAGStatusResult = ReturnType<typeof useRAGStatus>;

package/dist/src/react/ai/useRAGStream.d.ts

@@ -0,0 +1,55 @@
+import type { AIAttachment } from '@absolutejs/ai';
+export declare const useRAGStream: (path?: string, conversationId?: string) => {
+    citationReferenceMap: import("@absolutejs/ai").RAGCitationReferenceMap;
+    citations: import("@absolutejs/ai").RAGCitation[];
+    coverage: "grounded" | "partial" | "ungrounded";
+    groundedAnswer: import("@absolutejs/ai").RAGGroundedAnswer;
+    groundingReferences: import("@absolutejs/ai").RAGGroundingReference[];
+    hasGrounding: boolean;
+    hasRetrieved: boolean;
+    hasSources: boolean;
+    isAnswerStreaming: boolean;
+    isComplete: boolean;
+    isError: boolean;
+    isRetrieved: boolean;
+    isRetrieving: boolean;
+    isRunning: boolean;
+    latestAssistantMessage: import("@absolutejs/ai").AIMessage | undefined;
+    progress: {
+        conversationId: string | undefined;
+        hasContent: boolean;
+        hasRetrieved: boolean;
+        hasSources: boolean;
+        hasThinking: boolean;
+        hasToolCalls: boolean;
+        isComplete: boolean;
+        isError: boolean;
+        isIdle: boolean;
+        isRetrieved: boolean;
+        isRetrieving: boolean;
+        isStreaming: boolean;
+        isSubmitting: boolean;
+        latestMessage: import("@absolutejs/ai").AIMessage | undefined;
+        messageId: string | undefined;
+        retrievalDurationMs: number | undefined;
+        retrievalStartedAt: number | undefined;
+        retrievedAt: number | undefined;
+        sourceCount: number;
+        stage: import("@absolutejs/ai").RAGStreamStage;
+    };
+    query: (content: string, attachments?: AIAttachment[]) => void;
+    retrieval: import("@absolutejs/ai").RAGRetrievedState | null;
+    sourceGroups: import("@absolutejs/ai").RAGSourceGroup[];
+    sourceSummaries: import("@absolutejs/ai").RAGSourceSummary[];
+    sources: import("@absolutejs/ai").RAGSource[];
+    stage: import("@absolutejs/ai").RAGStreamStage;
+    ungroundedReferenceNumbers: number[];
+    workflow: import("@absolutejs/ai").RAGAnswerWorkflowState;
+    branch: (messageId: string, content: string) => void;
+    cancel: () => void;
+    error: string | null;
+    isStreaming: boolean;
+    messages: import("@absolutejs/ai").AIMessage[];
+    send: (content: string, attachments?: AIAttachment[]) => void;
+};
+export type UseRAGStreamResult = ReturnType<typeof useRAGStream>;

package/dist/src/react/ai/useRAGStreamProgress.d.ts

@@ -0,0 +1,9 @@
+import type { AIMessage } from '@absolutejs/ai';
+import { type RAGStreamProgress } from '../../ai/rag/workflowState';
+export declare const useRAGStreamProgress: (params: {
+    error: string | null;
+    isStreaming: boolean;
+    messages: AIMessage[];
+}) => RAGStreamProgress;
+export type UseRAGStreamProgressResult = ReturnType<typeof useRAGStreamProgress>;
+export type { RAGStreamProgress };