@absolutejs/absolute 0.19.0-beta.497 → 0.19.0-beta.499

package/dist/types/ai.d.ts

@@ -520,18 +520,19 @@ export type RAGCorpusHealth = {
 };
 export type RAGAdminActionRecord = {
     id: string;
-    action: 'clear_index' | 'create_document' | 'delete_document' | 'reindex_document' | 'reindex_source' | 'reseed' | 'reset';
+    action: 'clear_index' | 'create_document' | 'delete_document' | 'reindex_document' | 'reindex_source' | 'sync_all_sources' | 'sync_source' | 'reseed' | 'reset';
     status: 'completed' | 'failed';
     startedAt: number;
     finishedAt?: number;
     elapsedMs?: number;
     documentId?: string;
+    target?: string;
     error?: string;
 };
 export type RAGAdminJobStatus = 'running' | 'completed' | 'failed';
 export type RAGAdminJobRecord = {
     id: string;
-    action: 'clear_index' | 'create_document' | 'delete_document' | 'reindex_document' | 'reindex_source' | 'reseed' | 'reset';
+    action: 'clear_index' | 'create_document' | 'delete_document' | 'reindex_document' | 'reindex_source' | 'sync_all_sources' | 'sync_source' | 'reseed' | 'reset';
     status: RAGAdminJobStatus;
     startedAt: number;
     finishedAt?: number;
@@ -543,10 +544,129 @@ export type RAGAdminCapabilities = {
     canClearIndex: boolean;
     canCreateDocument: boolean;
     canDeleteDocument: boolean;
+    canListSyncSources: boolean;
     canReindexDocument: boolean;
     canReindexSource: boolean;
     canReseed: boolean;
     canReset: boolean;
+    canSyncAllSources: boolean;
+    canSyncSource: boolean;
+};
+export type RAGSyncSourceStatus = 'idle' | 'running' | 'completed' | 'failed' | 'disabled';
+export type RAGSyncSourceRecord = {
+    id: string;
+    label: string;
+    kind: 'directory' | 'url' | 'storage' | 'email' | 'custom';
+    status: RAGSyncSourceStatus;
+    description?: string;
+    target?: string;
+    lastStartedAt?: number;
+    lastSyncedAt?: number;
+    lastSyncDurationMs?: number;
+    lastError?: string;
+    lastSuccessfulSyncAt?: number;
+    consecutiveFailures?: number;
+    retryAttempts?: number;
+    nextRetryAt?: number;
+    documentCount?: number;
+    chunkCount?: number;
+    metadata?: Record<string, unknown>;
+};
+export type RAGSyncSourceRunResult = {
+    documentCount?: number;
+    chunkCount?: number;
+    metadata?: Record<string, unknown>;
+};
+export type RAGSyncSourceDefinition = {
+    id: string;
+    label: string;
+    kind: RAGSyncSourceRecord['kind'];
+    description?: string;
+    target?: string;
+    metadata?: Record<string, unknown>;
+    retryAttempts?: number;
+    retryDelayMs?: number;
+    sync: (input: RAGSyncSourceContext) => Promise<RAGSyncSourceRunResult> | RAGSyncSourceRunResult;
+};
+export type RAGSyncSourceContext = {
+    collection: RAGCollection;
+    listDocuments?: () => Promise<RAGIndexedDocument[]> | RAGIndexedDocument[];
+    deleteDocument?: (id: string) => Promise<boolean> | boolean;
+    signal?: AbortSignal;
+};
+export type RAGDirectorySyncSourceOptions = {
+    id: string;
+    label: string;
+    directory: string;
+    description?: string;
+    baseMetadata?: Record<string, unknown>;
+    defaultChunking?: RAGChunkingOptions;
+    extractors?: RAGFileExtractor[];
+    includeExtensions?: string[];
+    metadata?: Record<string, unknown>;
+    recursive?: boolean;
+    retryAttempts?: number;
+    retryDelayMs?: number;
+};
+export type RAGUrlSyncSourceOptions = {
+    id: string;
+    label: string;
+    urls: RAGDocumentUrlInput[];
+    description?: string;
+    baseMetadata?: Record<string, unknown>;
+    defaultChunking?: RAGChunkingOptions;
+    extractors?: RAGFileExtractor[];
+    metadata?: Record<string, unknown>;
+    retryAttempts?: number;
+    retryDelayMs?: number;
+};
+export type RAGSyncManager = Pick<RAGIndexManager, 'listSyncSources' | 'syncSource' | 'syncAllSources'>;
+export type RAGSyncRunOptions = {
+    background?: boolean;
+};
+export type CreateRAGSyncManagerOptions = {
+    collection: RAGCollection;
+    deleteDocument?: (id: string) => Promise<boolean> | boolean;
+    listDocuments?: () => Promise<RAGIndexedDocument[]> | RAGIndexedDocument[];
+    loadState?: () => Promise<RAGSyncSourceRecord[]> | RAGSyncSourceRecord[];
+    saveState?: (records: RAGSyncSourceRecord[]) => Promise<void> | void;
+    backgroundByDefault?: boolean;
+    continueOnError?: boolean;
+    retryAttempts?: number;
+    retryDelayMs?: number;
+    sources: RAGSyncSourceDefinition[];
+};
+export type RAGSyncStateStore = {
+    load: () => Promise<RAGSyncSourceRecord[]> | RAGSyncSourceRecord[];
+    save: (records: RAGSyncSourceRecord[]) => Promise<void> | void;
+};
+export type RAGSyncSchedule = {
+    id: string;
+    label?: string;
+    sourceIds?: string[];
+    intervalMs: number;
+    runImmediately?: boolean;
+    background?: boolean;
+};
+export type RAGSyncScheduler = {
+    start: () => Promise<void> | void;
+    stop: () => void;
+    isRunning: () => boolean;
+    listSchedules: () => RAGSyncSchedule[];
+};
+export type RAGSyncResponse = {
+    ok: true;
+    source: RAGSyncSourceRecord;
+    partial?: boolean;
+} | {
+    ok: true;
+    sources: RAGSyncSourceRecord[];
+    partial?: boolean;
+    failedSourceIds?: string[];
+    errorsBySource?: Record<string, string>;
+} | {
+    ok: false;
+    error: string;
 };
 export type RAGExtractorReadiness = {
     providerConfigured: boolean;
@@ -570,6 +690,7 @@ export type RAGOperationsResponse = {
     health: RAGCorpusHealth;
     readiness: RAGExtractorReadiness;
     ingestJobs: RAGIngestJobRecord[];
+    syncSources: RAGSyncSourceRecord[];
 };
 export type RAGStatusResponse = {
     ok: true;
@@ -582,6 +703,7 @@ export type RAGStatusResponse = {
     health?: RAGCorpusHealth;
     readiness?: RAGExtractorReadiness;
     ingestJobs?: RAGIngestJobRecord[];
+    syncSources?: RAGSyncSourceRecord[];
 };
 export type RAGDocumentsResponse = {
     ok: true;
@@ -760,6 +882,9 @@ export type RAGIndexManager = {
     deleteDocument?: (id: string) => Promise<boolean> | boolean;
     reindexDocument?: (id: string) => Promise<RAGMutationResponse | void> | RAGMutationResponse | void;
     reindexSource?: (source: string) => Promise<RAGMutationResponse | void> | RAGMutationResponse | void;
+    listSyncSources?: () => Promise<RAGSyncSourceRecord[]> | RAGSyncSourceRecord[];
+    syncSource?: (id: string, options?: RAGSyncRunOptions) => Promise<RAGSyncResponse | void> | RAGSyncResponse | void;
+    syncAllSources?: (options?: RAGSyncRunOptions) => Promise<RAGSyncResponse | void> | RAGSyncResponse | void;
     reseed?: () => Promise<RAGMutationResponse | void> | RAGMutationResponse | void;
     reset?: () => Promise<RAGMutationResponse | void> | RAGMutationResponse | void;
     listBackends?: () => Promise<Omit<RAGBackendsResponse, 'ok'> | RAGBackendDescriptor[]> | Omit<RAGBackendsResponse, 'ok'> | RAGBackendDescriptor[];

package/dist/vue/ai/index.js

@@ -941,6 +941,41 @@ var createRAGClient = (options) => {
       }
       return parseJson(response);
     },
+    async syncSources() {
+      const response = await fetchImpl(`${basePath}/sync`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    },
+    async syncAllSources(options2) {
+      const response = await fetchImpl(`${basePath}/sync`, {
+        body: options2?.background === true ? JSON.stringify({ background: true }) : undefined,
+        headers: options2?.background === true ? jsonHeaders : undefined,
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          error: await toErrorMessage(response),
+          ok: false
+        };
+      }
+      return parseJson(response);
+    },
+    async syncSource(id, options2) {
+      const response = await fetchImpl(`${basePath}/sync/${encodeURIComponent(id)}`, {
+        body: options2?.background === true ? JSON.stringify({ background: true }) : undefined,
+        headers: options2?.background === true ? jsonHeaders : undefined,
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          error: await toErrorMessage(response),
+          ok: false
+        };
+      }
+      return parseJson(response);
+    },
     async reindexDocument(id) {
       const response = await fetchImpl(`${basePath}/reindex/documents/${encodeURIComponent(id)}`, {
         method: "POST"
@@ -2021,6 +2056,7 @@ var useRAGIndexAdmin = (path) => {
   const error = ref6(null);
   const lastMutation = ref6(null);
   const backends = ref6(null);
+  const syncSources = ref6(null);
   const run = async (operation) => {
     isLoading.value = true;
     error.value = null;
@@ -2086,6 +2122,27 @@ var useRAGIndexAdmin = (path) => {
     backends.value = response;
     return response;
   });
+  const loadSyncSources = async () => run(async () => {
+    const response = await client.syncSources();
+    syncSources.value = response;
+    return response;
+  });
+  const syncAllSources = async () => run(async () => {
+    const response = await client.syncAllSources();
+    syncSources.value = response;
+    if (!response.ok) {
+      throw new Error(response.error ?? "Failed to sync sources");
+    }
+    return response;
+  });
+  const syncSource = async (id) => run(async () => {
+    const response = await client.syncSource(id);
+    syncSources.value = response;
+    if (!response.ok) {
+      throw new Error(response.error ?? "Failed to sync source");
+    }
+    return response;
+  });
   const clearIndex = async () => run(async () => {
     const response = await client.clearIndex();
     const mutation = { ok: response.ok };
@@ -2097,6 +2154,7 @@ var useRAGIndexAdmin = (path) => {
     error.value = null;
     isLoading.value = false;
     lastMutation.value = null;
+    syncSources.value = null;
   };
   return {
     backends,
@@ -2107,11 +2165,15 @@ var useRAGIndexAdmin = (path) => {
     isLoading,
     lastMutation,
     loadBackends,
+    loadSyncSources,
     reindexDocument,
     reindexSource,
     reseed,
     reset,
-    resetState
+    resetState,
+    syncAllSources,
+    syncSource,
+    syncSources
   };
 };
 
@@ -2129,6 +2191,7 @@ var useRAGOps = (path, autoLoad = true) => {
   const readiness = ref7();
   const documents = ref7();
   const ingestJobs = ref7([]);
+  const syncSources = ref7([]);
   const error = ref7(null);
   const isLoading = ref7(autoLoad);
   const refresh = async () => {
@@ -2146,6 +2209,7 @@ var useRAGOps = (path, autoLoad = true) => {
       readiness.value = response.readiness;
       documents.value = response.documents;
       ingestJobs.value = response.ingestJobs ?? [];
+      syncSources.value = response.syncSources ?? [];
       return response;
     } catch (caught) {
       error.value = caught instanceof Error ? caught.message : String(caught);
@@ -2166,6 +2230,7 @@ var useRAGOps = (path, autoLoad = true) => {
     ingestJobs.value = [];
     isLoading.value = false;
     readiness.value = undefined;
+    syncSources.value = [];
     status.value = undefined;
   };
   onMounted(() => {
@@ -2189,7 +2254,8 @@ var useRAGOps = (path, autoLoad = true) => {
     readiness,
     refresh,
     reset,
-    status
+    status,
+    syncSources
   };
 };
 
@@ -2426,5 +2492,5 @@ export {
   AIStreamKey
 };
 
-//# debugId=E21AE4418B18819564756E2164756E21
+//# debugId=E693BD507BF5A9B264756E2164756E21
 //# sourceMappingURL=index.js.map