@absolutejs/rag 0.0.1

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

@@ -0,0 +1,55 @@
+export declare const useRAGWorkflow: (path?: string, conversationId?: string) => {
+    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 UseRAGWorkflowResult = ReturnType<typeof useRAGWorkflow>;

package/dist/src/svelte/ai/createRAG.d.ts

@@ -0,0 +1,292 @@
+export type CreateRAGOptions = {
+    autoLoadOps?: boolean;
+    autoLoadStatus?: boolean;
+    conversationId?: string;
+    streamPath?: string;
+};
+export declare const createRAG: (path: string, options?: CreateRAGOptions) => {
+    chunkPreview: {
+        activeChunkId: import("svelte/store").Writable<string | null>;
+        activeSectionDiagnostic: import("svelte/store").Readable<import("@absolutejs/ai").RAGSectionRetrievalDiagnostic | null>;
+        clear: () => void;
+        chunkGraph: import("svelte/store").Readable<import("@absolutejs/ai").RAGChunkGraph | null>;
+        error: import("svelte/store").Writable<string | null>;
+        inspect: (id: string) => Promise<{
+            ok: true;
+        } & import("@absolutejs/ai").RAGDocumentChunkPreview>;
+        isLoading: import("svelte/store").Writable<boolean>;
+        navigation: import("svelte/store").Readable<import("@absolutejs/ai").RAGChunkGraphNavigation | null>;
+        preview: import("svelte/store").Writable<import("@absolutejs/ai").RAGDocumentChunkPreview | null>;
+        sectionDiagnostics: import("svelte/store").Readable<import("@absolutejs/ai").RAGSectionRetrievalDiagnostic[]>;
+        selectChildSection: (sectionId: string) => void;
+        selectChunk: (id: string | null) => void;
+        selectParentSection: () => void;
+        selectSiblingSection: (sectionId: string) => void;
+    };
+    citations: {
+        citationReferenceMap: import("svelte/store").Readable<import("@absolutejs/ai").RAGCitationReferenceMap>;
+        citations: import("svelte/store").Readable<import("@absolutejs/ai").RAGCitation[]>;
+        hasCitations: import("svelte/store").Readable<boolean>;
+        sourceGroups: import("svelte/store").Readable<import("@absolutejs/ai").RAGSourceGroup[]>;
+        sourceSummaries: import("svelte/store").Readable<import("@absolutejs/ai").RAGSourceSummary[]>;
+    };
+    documents: {
+        documents: import("svelte/store").Writable<import("@absolutejs/ai").RAGIndexedDocument[]>;
+        error: import("svelte/store").Writable<string | null>;
+        isLoading: import("svelte/store").Writable<boolean>;
+        lastResponse: import("svelte/store").Writable<import("@absolutejs/ai").RAGDocumentsResponse | null>;
+        load: (kind?: string) => Promise<import("@absolutejs/ai").RAGDocumentsResponse>;
+        reset: () => void;
+    };
+    evaluate: {
+        clearRuns: () => void;
+        error: import("svelte/store").Writable<string | null>;
+        evaluate: (input: import("@absolutejs/ai").RAGEvaluationInput) => Promise<import("@absolutejs/ai").RAGEvaluationResponse>;
+        isEvaluating: import("svelte/store").Writable<boolean>;
+        lastRequest: import("svelte/store").Writable<import("@absolutejs/ai").RAGEvaluationInput | null>;
+        lastResponse: import("svelte/store").Writable<import("@absolutejs/ai").RAGEvaluationResponse | null>;
+        leaderboard: import("svelte/store").Readable<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("svelte/store").Writable<import("@absolutejs/ai").RAGEvaluationSuiteRun[]>;
+        suites: import("svelte/store").Writable<import("@absolutejs/ai").RAGEvaluationSuite[]>;
+    };
+    grounding: {
+        coverage: import("svelte/store").Readable<"grounded" | "partial" | "ungrounded">;
+        groundedAnswer: import("svelte/store").Readable<import("@absolutejs/ai").RAGGroundedAnswer>;
+        hasCitations: import("svelte/store").Readable<boolean>;
+        hasGrounding: import("svelte/store").Readable<boolean>;
+        references: import("svelte/store").Readable<import("@absolutejs/ai").RAGGroundingReference[]>;
+        ungroundedReferenceNumbers: import("svelte/store").Readable<number[]>;
+    };
+    index: {
+        backends: import("svelte/store").Writable<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?: import("@absolutejs/ai").RAGChunkingStrategy;
+            };
+        }) => Promise<import("@absolutejs/ai").RAGMutationResponse>;
+        deleteDocument: (id: string) => Promise<import("@absolutejs/ai").RAGMutationResponse>;
+        error: import("svelte/store").Writable<string | null>;
+        isLoading: import("svelte/store").Writable<boolean>;
+        lastMutation: import("svelte/store").Writable<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("svelte/store").Writable<import("@absolutejs/ai").RAGSyncResponse | null>;
+    };
+    ingest: {
+        clearIndex: () => Promise<{
+            ok: boolean;
+        }>;
+        error: import("svelte/store").Writable<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: import("svelte/store").Writable<boolean>;
+        lastDocumentCount: import("svelte/store").Writable<number | null>;
+        lastIngestCount: import("svelte/store").Writable<number | null>;
+        lastResponse: import("svelte/store").Writable<import("@absolutejs/ai").RAGIngestResponse | null>;
+        reset: () => void;
+    };
+    ops: {
+        admin: import("svelte/store").Writable<import("@absolutejs/ai").RAGAdminCapabilities | undefined>;
+        adminActions: import("svelte/store").Writable<import("@absolutejs/ai").RAGAdminActionRecord[]>;
+        adminJobs: import("svelte/store").Writable<import("@absolutejs/ai").RAGAdminJobRecord[]>;
+        capabilities: import("svelte/store").Writable<import("@absolutejs/ai").RAGBackendCapabilities | undefined>;
+        documents: import("svelte/store").Writable<import("@absolutejs/ai").RAGDocumentSummary | undefined>;
+        error: import("svelte/store").Writable<string | null>;
+        health: import("svelte/store").Writable<import("@absolutejs/ai").RAGCorpusHealth | undefined>;
+        ingestJobs: import("svelte/store").Writable<import("@absolutejs/ai").RAGIngestJobRecord[]>;
+        isLoading: import("svelte/store").Writable<boolean>;
+        maintenance: import("svelte/store").Writable<import("@absolutejs/ai").RAGBackendMaintenanceSummary | undefined>;
+        operations: import("svelte/store").Writable<import("@absolutejs/ai").RAGOperationsResponse | undefined>;
+        readiness: import("svelte/store").Writable<import("@absolutejs/ai").RAGExtractorReadiness | undefined>;
+        refresh: () => Promise<import("@absolutejs/ai").RAGOperationsResponse>;
+        reset: () => void;
+        status: import("svelte/store").Writable<import("@absolutejs/ai").RAGVectorStoreStatus | undefined>;
+        syncSources: import("svelte/store").Writable<import("@absolutejs/ai").RAGSyncSourceRecord[]>;
+    };
+    search: {
+        error: import("svelte/store").Writable<string | null>;
+        hasSearched: import("svelte/store").Writable<boolean>;
+        isSearching: import("svelte/store").Writable<boolean>;
+        lastRequest: import("svelte/store").Writable<import("@absolutejs/ai").RAGSearchRequest | null>;
+        reset: () => void;
+        results: import("svelte/store").Writable<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>;
+        trace: import("svelte/store").Writable<import("@absolutejs/ai").RAGRetrievalTrace | undefined>;
+    };
+    sources: {
+        citationReferenceMap: import("svelte/store").Readable<import("@absolutejs/ai").RAGCitationReferenceMap>;
+        chunkGraph: import("svelte/store").Readable<import("@absolutejs/ai").RAGChunkGraph>;
+        hasSources: import("svelte/store").Readable<boolean>;
+        latestAssistantMessage: import("svelte/store").Readable<import("@absolutejs/ai").AIMessage | undefined>;
+        navigationForChunk: (chunkId?: string | null) => import("@absolutejs/ai").RAGChunkGraphNavigation;
+        sectionDiagnostics: import("svelte/store").Readable<import("@absolutejs/ai").RAGSectionRetrievalDiagnostic[]>;
+        sourceGroups: import("svelte/store").Readable<import("@absolutejs/ai").RAGSourceGroup[]>;
+        sources: import("svelte/store").Readable<import("@absolutejs/ai").RAGSource[]>;
+        sourceSummaries: import("svelte/store").Readable<import("@absolutejs/ai").RAGSourceSummary[]>;
+    };
+    status: {
+        capabilities: import("svelte/store").Writable<import("@absolutejs/ai").RAGBackendCapabilities | undefined>;
+        error: import("svelte/store").Writable<string | null>;
+        isLoading: import("svelte/store").Writable<boolean>;
+        refresh: () => Promise<import("@absolutejs/ai").RAGStatusResponse>;
+        reset: () => void;
+        status: import("svelte/store").Writable<import("@absolutejs/ai").RAGVectorStoreStatus | undefined>;
+    };
+    stream: {
+        state: import("svelte/store").Readable<import("@absolutejs/ai").RAGAnswerWorkflowState>;
+        citations: import("svelte/store").Readable<import("@absolutejs/ai").RAGCitation[]>;
+        groundedAnswer: import("svelte/store").Readable<import("@absolutejs/ai").RAGGroundedAnswer>;
+        groundingReferences: import("svelte/store").Readable<import("@absolutejs/ai").RAGGroundingReference[]>;
+        error: import("svelte/store").Readable<string | null>;
+        hasRetrieved: import("svelte/store").Readable<boolean>;
+        hasSources: import("svelte/store").Readable<boolean>;
+        isAnswerStreaming: import("svelte/store").Readable<boolean>;
+        isComplete: import("svelte/store").Readable<boolean>;
+        isRetrieved: import("svelte/store").Readable<boolean>;
+        isRetrieving: import("svelte/store").Readable<boolean>;
+        isStreaming: import("svelte/store").Readable<boolean>;
+        latestAssistantMessage: import("svelte/store").Readable<import("@absolutejs/ai").AIMessage | undefined>;
+        messages: import("svelte/store").Readable<import("@absolutejs/ai").AIMessage[]>;
+        progress: import("svelte/store").Readable<import("../../ai/rag/presentation").RAGStreamProgress>;
+        query: (content: string, attachments?: import("@absolutejs/ai").AIAttachment[]) => void;
+        retrieval: import("svelte/store").Readable<import("@absolutejs/ai").RAGRetrievedState | null>;
+        sourceGroups: import("svelte/store").Readable<import("@absolutejs/ai").RAGSourceGroup[]>;
+        sourceSummaries: import("svelte/store").Readable<import("@absolutejs/ai").RAGSourceSummary[]>;
+        sources: import("svelte/store").Readable<import("@absolutejs/ai").RAGSource[]>;
+        stage: import("svelte/store").Readable<import("@absolutejs/ai").RAGStreamStage>;
+        workflow: import("svelte/store").Readable<import("@absolutejs/ai").RAGAnswerWorkflowState>;
+        branch: (messageId: string, content: string) => void;
+        cancel: () => void;
+        destroy: () => void;
+        send: (content: string, attachments?: import("@absolutejs/ai").AIAttachment[]) => void;
+        subscribe: (callback: () => void) => () => void;
+    };
+    workflow: {
+        state: import("svelte/store").Readable<import("@absolutejs/ai").RAGAnswerWorkflowState>;
+        citations: import("svelte/store").Readable<import("@absolutejs/ai").RAGCitation[]>;
+        groundedAnswer: import("svelte/store").Readable<import("@absolutejs/ai").RAGGroundedAnswer>;
+        groundingReferences: import("svelte/store").Readable<import("@absolutejs/ai").RAGGroundingReference[]>;
+        error: import("svelte/store").Readable<string | null>;
+        hasRetrieved: import("svelte/store").Readable<boolean>;
+        hasSources: import("svelte/store").Readable<boolean>;
+        isAnswerStreaming: import("svelte/store").Readable<boolean>;
+        isComplete: import("svelte/store").Readable<boolean>;
+        isRetrieved: import("svelte/store").Readable<boolean>;
+        isRetrieving: import("svelte/store").Readable<boolean>;
+        isStreaming: import("svelte/store").Readable<boolean>;
+        latestAssistantMessage: import("svelte/store").Readable<import("@absolutejs/ai").AIMessage | undefined>;
+        messages: import("svelte/store").Readable<import("@absolutejs/ai").AIMessage[]>;
+        progress: import("svelte/store").Readable<import("../../ai/rag/presentation").RAGStreamProgress>;
+        query: (content: string, attachments?: import("@absolutejs/ai").AIAttachment[]) => void;
+        retrieval: import("svelte/store").Readable<import("@absolutejs/ai").RAGRetrievedState | null>;
+        sourceGroups: import("svelte/store").Readable<import("@absolutejs/ai").RAGSourceGroup[]>;
+        sourceSummaries: import("svelte/store").Readable<import("@absolutejs/ai").RAGSourceSummary[]>;
+        sources: import("svelte/store").Readable<import("@absolutejs/ai").RAGSource[]>;
+        stage: import("svelte/store").Readable<import("@absolutejs/ai").RAGStreamStage>;
+        workflow: import("svelte/store").Readable<import("@absolutejs/ai").RAGAnswerWorkflowState>;
+        branch: (messageId: string, content: string) => void;
+        cancel: () => void;
+        destroy: () => void;
+        send: (content: string, attachments?: import("@absolutejs/ai").AIAttachment[]) => void;
+        subscribe: (callback: () => void) => () => void;
+    };
+};
+export type CreateRAGResult = ReturnType<typeof createRAG>;

package/dist/src/svelte/ai/createRAGChunkPreview.d.ts

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

package/dist/src/svelte/ai/createRAGCitations.d.ts

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

package/dist/src/svelte/ai/createRAGDocuments.d.ts

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

package/dist/src/svelte/ai/createRAGEvaluate.d.ts

@@ -0,0 +1,28 @@
+import type { RAGEvaluationInput, RAGEvaluationResponse, RAGEvaluationSuite, RAGEvaluationSuiteRun } from '@absolutejs/ai';
+export declare const createRAGEvaluate: (path: string) => {
+    clearRuns: () => void;
+    error: import("svelte/store").Writable<string | null>;
+    evaluate: (input: RAGEvaluationInput) => Promise<RAGEvaluationResponse>;
+    isEvaluating: import("svelte/store").Writable<boolean>;
+    lastRequest: import("svelte/store").Writable<RAGEvaluationInput | null>;
+    lastResponse: import("svelte/store").Writable<RAGEvaluationResponse | null>;
+    leaderboard: import("svelte/store").Readable<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: import("svelte/store").Writable<RAGEvaluationSuiteRun[]>;
+    suites: import("svelte/store").Writable<RAGEvaluationSuite[]>;
+};
+export type CreateRAGEvaluateResult = ReturnType<typeof createRAGEvaluate>;

package/dist/src/svelte/ai/createRAGGrounding.d.ts

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

package/dist/src/svelte/ai/createRAGIndexAdmin.d.ts

@@ -0,0 +1,58 @@
+import type { RAGBackendsResponse, RAGChunkingStrategy, RAGContentFormat, RAGMutationResponse, RAGSyncResponse, RAGSyncRunOptions } from '@absolutejs/ai';
+export declare const createRAGIndexAdmin: (path: string) => {
+    backends: import("svelte/store").Writable<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?: RAGChunkingStrategy;
+        };
+    }) => Promise<RAGMutationResponse>;
+    deleteDocument: (id: string) => Promise<RAGMutationResponse>;
+    error: import("svelte/store").Writable<string | null>;
+    isLoading: import("svelte/store").Writable<boolean>;
+    lastMutation: import("svelte/store").Writable<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: import("svelte/store").Writable<RAGSyncResponse | null>;
+};
+export type CreateRAGIndexAdminResult = ReturnType<typeof createRAGIndexAdmin>;

package/dist/src/svelte/ai/createRAGIngest.d.ts

@@ -0,0 +1,17 @@
+import type { RAGDocumentChunk, RAGDocumentIngestInput, RAGDocumentUploadIngestInput, RAGDocumentUrlIngestInput, RAGIngestResponse } from '@absolutejs/ai';
+export declare const createRAGIngest: (path: string) => {
+    clearIndex: () => Promise<{
+        ok: boolean;
+    }>;
+    error: import("svelte/store").Writable<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: import("svelte/store").Writable<boolean>;
+    lastDocumentCount: import("svelte/store").Writable<number | null>;
+    lastIngestCount: import("svelte/store").Writable<number | null>;
+    lastResponse: import("svelte/store").Writable<RAGIngestResponse | null>;
+    reset: () => void;
+};

package/dist/src/svelte/ai/createRAGOps.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 createRAGOps: (path: string, autoLoad?: boolean) => {
+    admin: import("svelte/store").Writable<RAGAdminCapabilities | undefined>;
+    adminActions: import("svelte/store").Writable<RAGAdminActionRecord[]>;
+    adminJobs: import("svelte/store").Writable<RAGAdminJobRecord[]>;
+    capabilities: import("svelte/store").Writable<RAGBackendCapabilities | undefined>;
+    documents: import("svelte/store").Writable<RAGDocumentSummary | undefined>;
+    error: import("svelte/store").Writable<string | null>;
+    health: import("svelte/store").Writable<RAGCorpusHealth | undefined>;
+    ingestJobs: import("svelte/store").Writable<RAGIngestJobRecord[]>;
+    isLoading: import("svelte/store").Writable<boolean>;
+    maintenance: import("svelte/store").Writable<RAGBackendMaintenanceSummary | undefined>;
+    operations: import("svelte/store").Writable<RAGOperationsResponse | undefined>;
+    readiness: import("svelte/store").Writable<RAGExtractorReadiness | undefined>;
+    refresh: () => Promise<RAGOperationsResponse>;
+    reset: () => void;
+    status: import("svelte/store").Writable<RAGVectorStoreStatus | undefined>;
+    syncSources: import("svelte/store").Writable<RAGSyncSourceRecord[]>;
+};
+export type CreateRAGOpsResult = ReturnType<typeof createRAGOps>;

package/dist/src/svelte/ai/createRAGSearch.d.ts

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

package/dist/src/svelte/ai/createRAGSources.d.ts

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

package/dist/src/svelte/ai/createRAGStatus.d.ts

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

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

@@ -0,0 +1,30 @@
+import type { AIAttachment } from '@absolutejs/ai';
+export declare const createRAGStream: (path: string, conversationId?: string) => {
+    citations: import("svelte/store").Readable<import("@absolutejs/ai").RAGCitation[]>;
+    groundedAnswer: import("svelte/store").Readable<import("@absolutejs/ai").RAGGroundedAnswer>;
+    groundingReferences: import("svelte/store").Readable<import("@absolutejs/ai").RAGGroundingReference[]>;
+    error: import("svelte/store").Readable<string | null>;
+    hasRetrieved: import("svelte/store").Readable<boolean>;
+    hasSources: import("svelte/store").Readable<boolean>;
+    isAnswerStreaming: import("svelte/store").Readable<boolean>;
+    isComplete: import("svelte/store").Readable<boolean>;
+    isRetrieved: import("svelte/store").Readable<boolean>;
+    isRetrieving: import("svelte/store").Readable<boolean>;
+    isStreaming: import("svelte/store").Readable<boolean>;
+    latestAssistantMessage: import("svelte/store").Readable<import("@absolutejs/ai").AIMessage | undefined>;
+    messages: import("svelte/store").Readable<import("@absolutejs/ai").AIMessage[]>;
+    progress: import("svelte/store").Readable<import("../../ai/rag/presentation").RAGStreamProgress>;
+    query: (content: string, attachments?: AIAttachment[]) => void;
+    retrieval: import("svelte/store").Readable<import("@absolutejs/ai").RAGRetrievedState | null>;
+    sourceGroups: import("svelte/store").Readable<import("@absolutejs/ai").RAGSourceGroup[]>;
+    sourceSummaries: import("svelte/store").Readable<import("@absolutejs/ai").RAGSourceSummary[]>;
+    sources: import("svelte/store").Readable<import("@absolutejs/ai").RAGSource[]>;
+    stage: import("svelte/store").Readable<import("@absolutejs/ai").RAGStreamStage>;
+    workflow: import("svelte/store").Readable<import("@absolutejs/ai").RAGAnswerWorkflowState>;
+    branch: (messageId: string, content: string) => void;
+    cancel: () => void;
+    destroy: () => void;
+    send: (content: string, attachments?: AIAttachment[]) => void;
+    subscribe: (callback: () => void) => () => void;
+};
+export type CreateRAGStreamResult = ReturnType<typeof createRAGStream>;

package/dist/src/svelte/ai/createRAGStreamProgress.d.ts

@@ -0,0 +1,8 @@
+import { type Readable } from 'svelte/store';
+import type { AIMessage } from '@absolutejs/ai';
+export declare const createRAGStreamProgress: (params: {
+    error: Readable<string | null>;
+    isStreaming: Readable<boolean>;
+    messages: Readable<AIMessage[]>;
+}) => Readable<import("../../ai/rag/presentation").RAGStreamProgress>;
+export type CreateRAGStreamProgressResult = ReturnType<typeof createRAGStreamProgress>;