@absolutejs/absolute 0.19.0-beta.442 → 0.19.0-beta.443

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

@@ -4,6 +4,7 @@ export declare const createAIStream: (path: string, conversationId?: string) =>
     cancel: () => void;
     destroy: () => void;
     send: (content: string, attachments?: AIAttachment[]) => void;
+    subscribe(callback: () => void): () => void;
     readonly error: string | null;
     readonly isStreaming: boolean;
     readonly messages: AIMessage[];

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

@@ -0,0 +1,117 @@
+export type CreateRAGOptions = {
+    autoLoadStatus?: boolean;
+    conversationId?: string;
+    streamPath?: string;
+};
+export declare const createRAG: (path: string, options?: CreateRAGOptions) => {
+    citations: {
+        citations: import("svelte/store").Readable<import("../..").RAGCitation[]>;
+        hasCitations: import("svelte/store").Readable<boolean>;
+        sourceGroups: import("svelte/store").Readable<import("../..").RAGSourceGroup[]>;
+    };
+    chunkPreview: {
+        clear: () => void;
+        error: import("svelte/store").Writable<string | null>;
+        inspect: (id: string) => Promise<{
+            ok: true;
+        } & import("../..").RAGDocumentChunkPreview>;
+        isLoading: import("svelte/store").Writable<boolean>;
+        preview: import("svelte/store").Writable<import("../..").RAGDocumentChunkPreview | null>;
+    };
+    documents: {
+        documents: import("svelte/store").Writable<import("../..").RAGIndexedDocument[]>;
+        error: import("svelte/store").Writable<string | null>;
+        isLoading: import("svelte/store").Writable<boolean>;
+        lastResponse: import("svelte/store").Writable<import("../..").RAGDocumentsResponse | null>;
+        load: (kind?: string) => Promise<import("../..").RAGDocumentsResponse>;
+        reset: () => void;
+    };
+    ingest: {
+        clearIndex: () => Promise<{
+            ok: boolean;
+        }>;
+        error: import("svelte/store").Writable<string | null>;
+        ingest: (chunks: import("../..").RAGDocumentChunk[]) => Promise<import("../..").RAGIngestResponse>;
+        ingestChunks: (chunks: import("../..").RAGDocumentChunk[]) => Promise<import("../..").RAGIngestResponse>;
+        ingestDocuments: (input: import("../..").RAGDocumentIngestInput) => Promise<import("../..").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("../..").RAGIngestResponse | null>;
+        reset: () => void;
+    };
+    index: {
+        backends: import("svelte/store").Writable<import("../..").RAGBackendsResponse | null>;
+        clearIndex: () => Promise<{
+            ok: boolean;
+        }>;
+        createDocument: (input: {
+            id?: string;
+            title?: string;
+            source?: string;
+            text: string;
+            format?: import("../..").RAGContentFormat;
+            metadata?: Record<string, unknown>;
+            chunking?: {
+                maxChunkLength?: number;
+                chunkOverlap?: number;
+                minChunkLength?: number;
+                strategy?: import("../..").RAGChunkingStrategy;
+            };
+        }) => Promise<import("../..").RAGMutationResponse>;
+        deleteDocument: (id: string) => Promise<import("../..").RAGMutationResponse>;
+        error: import("svelte/store").Writable<string | null>;
+        isLoading: import("svelte/store").Writable<boolean>;
+        lastMutation: import("svelte/store").Writable<import("../..").RAGMutationResponse | null>;
+        loadBackends: () => Promise<import("../..").RAGBackendsResponse>;
+        reseed: () => Promise<import("../..").RAGMutationResponse>;
+        reset: () => Promise<import("../..").RAGMutationResponse>;
+        resetState: () => void;
+    };
+    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("../..").RAGSearchRequest | null>;
+        reset: () => void;
+        results: import("svelte/store").Writable<import("../..").RAGSource[]>;
+        search: (input: import("../..").RAGSearchRequest) => Promise<import("../..").RAGSource[]>;
+    };
+    sources: {
+        hasSources: import("svelte/store").Readable<boolean>;
+        latestAssistantMessage: import("svelte/store").Readable<import("../..").AIMessage | undefined>;
+        sourceGroups: import("svelte/store").Readable<import("../..").RAGSourceGroup[]>;
+        sources: import("svelte/store").Readable<import("../..").RAGSource[]>;
+    };
+    status: {
+        capabilities: import("svelte/store").Writable<import("../..").RAGBackendCapabilities | undefined>;
+        error: import("svelte/store").Writable<string | null>;
+        isLoading: import("svelte/store").Writable<boolean>;
+        refresh: () => Promise<import("../..").RAGStatusResponse>;
+        reset: () => void;
+        status: import("svelte/store").Writable<import("../..").RAGVectorStoreStatus | undefined>;
+    };
+    stream: {
+        citations: import("svelte/store").Readable<import("../..").RAGCitation[]>;
+        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>;
+        isRetrieving: import("svelte/store").Readable<boolean>;
+        isStreaming: import("svelte/store").Readable<boolean>;
+        latestAssistantMessage: import("svelte/store").Readable<import("../..").AIMessage | undefined>;
+        messages: import("svelte/store").Readable<import("../..").AIMessage[]>;
+        query: (content: string, attachments?: import("../..").AIAttachment[]) => void;
+        retrieval: import("svelte/store").Readable<import("../..").RAGRetrievedState | null>;
+        sourceGroups: import("svelte/store").Readable<import("../..").RAGSourceGroup[]>;
+        sources: import("svelte/store").Readable<import("../..").RAGSource[]>;
+        stage: import("svelte/store").Readable<import("../..").RAGStreamStage>;
+        branch: (messageId: string, content: string) => void;
+        cancel: () => void;
+        destroy: () => void;
+        send: (content: string, attachments?: import("../..").AIAttachment[]) => void;
+        subscribe(callback: () => void): () => void;
+    };
+};
+export type CreateRAGResult = ReturnType<typeof createRAG>;

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

@@ -0,0 +1,11 @@
+import type { RAGDocumentChunkPreview } from '../../../types/ai';
+export declare const createRAGChunkPreview: (path: string) => {
+    clear: () => void;
+    error: import("svelte/store").Writable<string | null>;
+    inspect: (id: string) => Promise<{
+        ok: true;
+    } & RAGDocumentChunkPreview>;
+    isLoading: import("svelte/store").Writable<boolean>;
+    preview: import("svelte/store").Writable<RAGDocumentChunkPreview | null>;
+};
+export type CreateRAGChunkPreviewResult = ReturnType<typeof createRAGChunkPreview>;

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

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

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

@@ -0,0 +1,10 @@
+import type { RAGDocumentsResponse, RAGIndexedDocument } from '../../../types/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/createRAGIndexAdmin.d.ts

@@ -0,0 +1,30 @@
+import type { RAGBackendsResponse, RAGChunkingStrategy, RAGContentFormat, RAGMutationResponse } from '../../../types/ai';
+export declare const createRAGIndexAdmin: (path: string) => {
+    backends: import("svelte/store").Writable<RAGBackendsResponse | 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("svelte/store").Writable<string | null>;
+    isLoading: import("svelte/store").Writable<boolean>;
+    lastMutation: import("svelte/store").Writable<RAGMutationResponse | null>;
+    loadBackends: () => Promise<RAGBackendsResponse>;
+    reseed: () => Promise<RAGMutationResponse>;
+    reset: () => Promise<RAGMutationResponse>;
+    resetState: () => void;
+};
+export type CreateRAGIndexAdminResult = ReturnType<typeof createRAGIndexAdmin>;

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

@@ -1,7 +1,15 @@
-import type { RAGDocumentChunk } from '../../../types/ai';
+import type { RAGDocumentChunk, RAGDocumentIngestInput, RAGIngestResponse } from '../../../types/ai';
 export declare const createRAGIngest: (path: string) => {
+    clearIndex: () => Promise<{
+        ok: boolean;
+    }>;
     error: import("svelte/store").Writable<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("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/createRAGSearch.d.ts

@@ -1,7 +1,10 @@
 import type { RAGSearchRequest, RAGSource } from '../../../types/ai';
 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: RAGSearchRequest) => Promise<RAGSource[]>;
 };

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

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

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

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

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

@@ -1 +1,24 @@
-export { createAIStream as createRAGStream } from './createAIStream';
+import type { AIAttachment } from '../../../types/ai';
+export declare const createRAGStream: (path: string, conversationId?: string) => {
+    citations: import("svelte/store").Readable<import("../..").RAGCitation[]>;
+    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>;
+    isRetrieving: import("svelte/store").Readable<boolean>;
+    isStreaming: import("svelte/store").Readable<boolean>;
+    latestAssistantMessage: import("svelte/store").Readable<import("../..").AIMessage | undefined>;
+    messages: import("svelte/store").Readable<import("../..").AIMessage[]>;
+    query: (content: string, attachments?: AIAttachment[]) => void;
+    retrieval: import("svelte/store").Readable<import("../..").RAGRetrievedState | null>;
+    sourceGroups: import("svelte/store").Readable<import("../..").RAGSourceGroup[]>;
+    sources: import("svelte/store").Readable<import("../..").RAGSource[]>;
+    stage: import("svelte/store").Readable<import("../..").RAGStreamStage>;
+    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/index.d.ts

@@ -1,5 +1,11 @@
 export { createAIStream } from './createAIStream';
+export { createRAG } from './createRAG';
+export { createRAGChunkPreview } from './createRAGChunkPreview';
+export { createRAGCitations } from './createRAGCitations';
+export { createRAGDocuments } from './createRAGDocuments';
 export { createRAGIngest } from './createRAGIngest';
+export { createRAGIndexAdmin } from './createRAGIndexAdmin';
 export { createRAGSearch } from './createRAGSearch';
+export { createRAGSources } from './createRAGSources';
 export { createRAGStatus } from './createRAGStatus';
 export { createRAGStream } from './createRAGStream';