@absolutejs/absolute 0.19.0-beta.439 → 0.19.0-beta.440

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

@@ -0,0 +1,206 @@
+import type { RAGBackendsResponse, RAGContentFormat, RAGChunkingStrategy, RAGMutationResponse } from '../../../types/ai';
+export declare const useRAGIndexAdmin: (path: string) => {
+    backends: import("vue").Ref<{
+        ok: true;
+        defaultMode?: string | undefined;
+        activeModeCookie?: string | undefined;
+        backends: {
+            id: string;
+            label: string;
+            path?: string | undefined;
+            available: boolean;
+            reason?: string | undefined;
+            lastSeedMs?: number | undefined;
+            status?: {
+                backend: "in_memory" | "sqlite" | "postgres";
+                vectorMode: "in_memory" | "json_fallback" | "native_vec0" | "native_pgvector";
+                dimensions?: number | undefined;
+                native?: {
+                    requested: boolean;
+                    available: boolean;
+                    active: boolean;
+                    mode?: "vec0" | undefined;
+                    tableName?: string | undefined;
+                    distanceMetric?: "cosine" | "l2" | undefined;
+                    resolution?: {
+                        status: import("../..").SQLiteVecResolutionStatus;
+                        source: import("../..").SQLiteVecResolutionSource;
+                        platformKey: string;
+                        packageName?: string | undefined;
+                        packageVersion?: string | undefined;
+                        packageRoot?: string | undefined;
+                        libraryFile?: string | undefined;
+                        libraryPath?: string | undefined;
+                        reason?: string | undefined;
+                    } | undefined;
+                    fallbackReason?: string | undefined;
+                    lastLoadError?: string | undefined;
+                    lastQueryError?: string | undefined;
+                    lastUpsertError?: string | undefined;
+                } | {
+                    requested: boolean;
+                    available: boolean;
+                    active: boolean;
+                    mode?: "pgvector" | undefined;
+                    extensionName?: string | undefined;
+                    schemaName?: string | undefined;
+                    tableName?: string | undefined;
+                    distanceMetric?: "cosine" | "l2" | "inner_product" | undefined;
+                    indexType?: "none" | "hnsw" | "ivfflat" | undefined;
+                    fallbackReason?: string | undefined;
+                    lastInitError?: string | undefined;
+                    lastQueryError?: string | undefined;
+                    lastUpsertError?: string | undefined;
+                    lastMigrationError?: string | undefined;
+                } | undefined;
+            } | undefined;
+            capabilities?: {
+                backend: "in_memory" | "sqlite" | "postgres" | "custom";
+                persistence: "memory_only" | "embedded" | "external";
+                nativeVectorSearch: boolean;
+                serverSideFiltering: boolean;
+                streamingIngestStatus: boolean;
+            } | undefined;
+        }[];
+    } | null, RAGBackendsResponse | {
+        ok: true;
+        defaultMode?: string | undefined;
+        activeModeCookie?: string | undefined;
+        backends: {
+            id: string;
+            label: string;
+            path?: string | undefined;
+            available: boolean;
+            reason?: string | undefined;
+            lastSeedMs?: number | undefined;
+            status?: {
+                backend: "in_memory" | "sqlite" | "postgres";
+                vectorMode: "in_memory" | "json_fallback" | "native_vec0" | "native_pgvector";
+                dimensions?: number | undefined;
+                native?: {
+                    requested: boolean;
+                    available: boolean;
+                    active: boolean;
+                    mode?: "vec0" | undefined;
+                    tableName?: string | undefined;
+                    distanceMetric?: "cosine" | "l2" | undefined;
+                    resolution?: {
+                        status: import("../..").SQLiteVecResolutionStatus;
+                        source: import("../..").SQLiteVecResolutionSource;
+                        platformKey: string;
+                        packageName?: string | undefined;
+                        packageVersion?: string | undefined;
+                        packageRoot?: string | undefined;
+                        libraryFile?: string | undefined;
+                        libraryPath?: string | undefined;
+                        reason?: string | undefined;
+                    } | undefined;
+                    fallbackReason?: string | undefined;
+                    lastLoadError?: string | undefined;
+                    lastQueryError?: string | undefined;
+                    lastUpsertError?: string | undefined;
+                } | {
+                    requested: boolean;
+                    available: boolean;
+                    active: boolean;
+                    mode?: "pgvector" | undefined;
+                    extensionName?: string | undefined;
+                    schemaName?: string | undefined;
+                    tableName?: string | undefined;
+                    distanceMetric?: "cosine" | "l2" | "inner_product" | undefined;
+                    indexType?: "none" | "hnsw" | "ivfflat" | undefined;
+                    fallbackReason?: string | undefined;
+                    lastInitError?: string | undefined;
+                    lastQueryError?: string | undefined;
+                    lastUpsertError?: string | undefined;
+                    lastMigrationError?: string | undefined;
+                } | undefined;
+            } | undefined;
+            capabilities?: {
+                backend: "in_memory" | "sqlite" | "postgres" | "custom";
+                persistence: "memory_only" | "embedded" | "external";
+                nativeVectorSearch: boolean;
+                serverSideFiltering: boolean;
+                streamingIngestStatus: boolean;
+            } | undefined;
+        }[];
+    } | null>;
+    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("vue").Ref<string | null, string | null>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    lastMutation: import("vue").Ref<{
+        ok: boolean;
+        error?: string | undefined;
+        deleted?: string | undefined;
+        inserted?: string | undefined;
+        status?: string | undefined;
+        documents?: number | undefined;
+        backendStats?: Record<string, {
+            chunkCount: number;
+            totalDocuments: number;
+            elapsedMs: number;
+        }> | undefined;
+        document?: {
+            id: string;
+            title: string;
+            source: string;
+            text?: string | undefined;
+            kind?: string | undefined;
+            format?: RAGContentFormat | undefined;
+            chunkStrategy?: RAGChunkingStrategy | undefined;
+            chunkSize?: number | undefined;
+            chunkCount?: number | undefined;
+            createdAt?: number | undefined;
+            updatedAt?: number | undefined;
+            metadata?: Record<string, unknown> | undefined;
+        } | undefined;
+    } | null, RAGMutationResponse | {
+        ok: boolean;
+        error?: string | undefined;
+        deleted?: string | undefined;
+        inserted?: string | undefined;
+        status?: string | undefined;
+        documents?: number | undefined;
+        backendStats?: Record<string, {
+            chunkCount: number;
+            totalDocuments: number;
+            elapsedMs: number;
+        }> | undefined;
+        document?: {
+            id: string;
+            title: string;
+            source: string;
+            text?: string | undefined;
+            kind?: string | undefined;
+            format?: RAGContentFormat | undefined;
+            chunkStrategy?: RAGChunkingStrategy | undefined;
+            chunkSize?: number | undefined;
+            chunkCount?: number | undefined;
+            createdAt?: number | undefined;
+            updatedAt?: number | undefined;
+            metadata?: Record<string, unknown> | undefined;
+        } | undefined;
+    } | null>;
+    loadBackends: () => Promise<RAGBackendsResponse>;
+    reseed: () => Promise<RAGMutationResponse>;
+    reset: () => Promise<RAGMutationResponse>;
+    resetState: () => void;
+};
+export type UseRAGIndexAdminResult = ReturnType<typeof useRAGIndexAdmin>;

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

@@ -1,7 +1,25 @@
-import type { RAGDocumentChunk } from '../../../types/ai';
+import type { RAGDocumentChunk, RAGDocumentIngestInput, RAGIngestResponse } from '../../../types/ai';
 export declare const useRAGIngest: (path: string) => {
+    clearIndex: () => Promise<{
+        ok: boolean;
+    }>;
     error: import("vue").Ref<string | null, string | null>;
-    ingest: (chunks: RAGDocumentChunk[]) => Promise<import("../..").RAGIngestResponse>;
+    ingest: (chunks: RAGDocumentChunk[]) => Promise<RAGIngestResponse>;
+    ingestChunks: (chunks: RAGDocumentChunk[]) => Promise<RAGIngestResponse>;
+    ingestDocuments: (input: RAGDocumentIngestInput) => Promise<RAGIngestResponse>;
     isIngesting: import("vue").Ref<boolean, boolean>;
+    lastDocumentCount: import("vue").Ref<number | null, number | null>;
     lastIngestCount: import("vue").Ref<number | null, number | null>;
+    lastResponse: import("vue").Ref<{
+        ok: boolean;
+        count?: number | undefined;
+        documentCount?: number | undefined;
+        error?: string | undefined;
+    } | null, RAGIngestResponse | {
+        ok: boolean;
+        count?: number | undefined;
+        documentCount?: number | undefined;
+        error?: string | undefined;
+    } | null>;
+    reset: () => void;
 };

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

@@ -1,7 +1,22 @@
 import type { RAGSearchRequest, RAGSource } from '../../../types/ai';
 export declare const useRAGSearch: (path: string) => {
     error: import("vue").Ref<string | null, string | null>;
+    hasSearched: import("vue").Ref<boolean, boolean>;
     isSearching: import("vue").Ref<boolean, boolean>;
+    lastRequest: import("vue").Ref<{
+        filter?: Record<string, unknown> | undefined;
+        query: string;
+        topK?: number | undefined;
+        scoreThreshold?: number | undefined;
+        model?: string | undefined;
+    } | null, RAGSearchRequest | {
+        filter?: Record<string, unknown> | undefined;
+        query: string;
+        topK?: number | undefined;
+        scoreThreshold?: number | undefined;
+        model?: string | undefined;
+    } | null>;
+    reset: () => void;
     results: import("vue").Ref<{
         chunkId: string;
         score: number;

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

@@ -0,0 +1,9 @@
+import { type Ref } from 'vue';
+import type { AIMessage } from '../../../types/ai';
+export declare const useRAGSources: (messages: Ref<AIMessage[]>) => {
+    hasSources: import("vue").ComputedRef<boolean>;
+    latestAssistantMessage: import("vue").ComputedRef<AIMessage | undefined>;
+    sourceGroups: import("vue").ComputedRef<import("../..").RAGSourceGroup[]>;
+    sources: import("vue").ComputedRef<import("../..").RAGSource[]>;
+};
+export type UseRAGSourcesResult = ReturnType<typeof useRAGSources>;

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

@@ -4,5 +4,6 @@ export declare const useRAGStatus: (path: string, autoLoad?: boolean) => {
     error: import("vue").Ref<string | null, string | null>;
     isLoading: import("vue").Ref<boolean, boolean>;
     refresh: () => Promise<import("../..").RAGStatusResponse>;
+    reset: () => void;
     status: import("vue").Ref<RAGVectorStoreStatus | undefined, RAGVectorStoreStatus | undefined>;
 };

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

@@ -1,10 +1,23 @@
+import type { AIAttachment } from '../../../types/ai';
 export declare const useRAGStream: (path: string, conversationId?: string) => {
+    citations: import("vue").ComputedRef<import("../..").RAGCitation[]>;
+    hasRetrieved: import("vue").ComputedRef<boolean>;
+    hasSources: import("vue").ComputedRef<boolean>;
+    isAnswerStreaming: import("vue").ComputedRef<boolean>;
+    isComplete: import("vue").ComputedRef<boolean>;
+    isRetrieving: import("vue").ComputedRef<boolean>;
+    latestAssistantMessage: import("vue").ComputedRef<import("../..").AIMessage | undefined>;
+    query: (content: string, attachments?: AIAttachment[]) => void;
+    retrieval: import("vue").ComputedRef<import("../..").RAGRetrievedState | null>;
+    sourceGroups: import("vue").ComputedRef<import("../..").RAGSourceGroup[]>;
+    sources: import("vue").ComputedRef<import("../..").RAGSource[]>;
+    stage: import("vue").ComputedRef<import("../..").RAGStreamStage>;
     branch: (messageId: string, content: string) => void;
     cancel: () => void;
     destroy: () => void;
     error: import("vue").Ref<string | null, string | null>;
     isStreaming: import("vue").Ref<boolean, boolean>;
     messages: import("vue").ShallowRef<import("../..").AIMessage[], import("../..").AIMessage[]>;
-    send: (content: string, attachments?: import("../..").AIAttachment[]) => void;
+    send: (content: string, attachments?: AIAttachment[]) => void;
 };
 export type UseRAGStreamResult = ReturnType<typeof useRAGStream>;