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

package/dist/svelte/ai/index.js

@@ -648,6 +648,7 @@ var serializeAIMessage = (msg) => JSON.stringify(msg);
 var createAIStream = (path, conversationId) => {
   const connection = createAIConnection(path);
   const store = createAIMessageStore();
+  const subscribers = new Set;
   let currentError = null;
   let currentIsStreaming = false;
   let currentMessages = [];
@@ -660,6 +661,7 @@ var createAIStream = (path, conversationId) => {
     currentError = snapshot.error;
     currentIsStreaming = snapshot.isStreaming;
     currentMessages = conversation?.messages ?? [];
+    subscribers.forEach((callback) => callback());
   };
   const unsubscribeStore = store.subscribe(syncState);
   const unsubscribeConnection = connection.subscribe((msg) => {
@@ -714,6 +716,12 @@ var createAIStream = (path, conversationId) => {
     cancel,
     destroy,
     send,
+    subscribe(callback) {
+      subscribers.add(callback);
+      return () => {
+        subscribers.delete(callback);
+      };
+    },
     get error() {
       return currentError;
     },
@@ -725,7 +733,7 @@ var createAIStream = (path, conversationId) => {
     }
   };
 };
-// src/svelte/ai/createRAGIngest.ts
+// src/svelte/ai/createRAGChunkPreview.ts
 import { writable } from "svelte/store";
 
 // src/ai/client/ragClient.ts
@@ -885,13 +893,221 @@ var createRAGClient = (options) => {
   };
 };
 
+// src/svelte/ai/createRAGChunkPreview.ts
+var createRAGChunkPreview = (path) => {
+  const client = createRAGClient({ path });
+  const preview = writable(null);
+  const error = writable(null);
+  const isLoading = writable(false);
+  const inspect = async (id) => {
+    isLoading.set(true);
+    error.set(null);
+    try {
+      const response = await client.documentChunks(id);
+      if (!response.ok) {
+        throw new Error(response.error);
+      }
+      preview.set(response);
+      return response;
+    } catch (caught) {
+      error.set(caught instanceof Error ? caught.message : String(caught));
+      throw caught;
+    } finally {
+      isLoading.set(false);
+    }
+  };
+  const clear = () => {
+    error.set(null);
+    isLoading.set(false);
+    preview.set(null);
+  };
+  return {
+    clear,
+    error,
+    inspect,
+    isLoading,
+    preview
+  };
+};
+
+// src/svelte/ai/createRAGCitations.ts
+import { derived } from "svelte/store";
+
+// src/ai/rag/presentation.ts
+var buildSourceGroupKey = (source) => source.source ?? source.title ?? source.chunkId;
+var buildSourceLabel = (source) => source.source ?? source.title ?? source.chunkId;
+var getLatestAssistantMessage = (messages) => {
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role === "assistant") {
+      return message;
+    }
+  }
+  return;
+};
+var getLatestRAGSources = (messages) => getLatestAssistantMessage(messages)?.sources ?? [];
+var getLatestRetrievedMessage = (messages) => {
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message?.role === "assistant" && (message.sources?.length ?? 0) > 0) {
+      return message;
+    }
+  }
+  return;
+};
+var buildRAGSourceGroups = (sources) => {
+  const groups = new Map;
+  for (const source of sources) {
+    const key = buildSourceGroupKey(source);
+    const existing = groups.get(key);
+    if (existing) {
+      existing.bestScore = Math.max(existing.bestScore, source.score);
+      existing.count += 1;
+      existing.chunks.push(source);
+      continue;
+    }
+    groups.set(key, {
+      bestScore: source.score,
+      chunks: [source],
+      count: 1,
+      key,
+      label: buildSourceLabel(source),
+      source: source.source,
+      title: source.title
+    });
+  }
+  return [...groups.values()].sort((left, right) => {
+    if (right.bestScore !== left.bestScore) {
+      return right.bestScore - left.bestScore;
+    }
+    return left.label.localeCompare(right.label);
+  });
+};
+var buildRAGCitations = (sources) => {
+  const unique = new Map;
+  for (const source of sources) {
+    const key = source.chunkId;
+    const existing = unique.get(key);
+    if (existing && existing.score >= source.score) {
+      continue;
+    }
+    unique.set(key, {
+      chunkId: source.chunkId,
+      key,
+      label: buildSourceLabel(source),
+      metadata: source.metadata,
+      score: source.score,
+      source: source.source,
+      text: source.text,
+      title: source.title
+    });
+  }
+  return [...unique.values()].sort((left, right) => {
+    if (right.score !== left.score) {
+      return right.score - left.score;
+    }
+    return left.label.localeCompare(right.label);
+  });
+};
+var buildRAGRetrievedState = (messages) => {
+  const message = getLatestRetrievedMessage(messages);
+  if (!message) {
+    return null;
+  }
+  const sources = message.sources ?? [];
+  return {
+    citations: buildRAGCitations(sources),
+    conversationId: message.conversationId,
+    messageId: message.id,
+    retrievedAt: message.retrievedAt,
+    sourceGroups: buildRAGSourceGroups(sources),
+    sources
+  };
+};
+var resolveRAGStreamStage = ({
+  error,
+  isStreaming,
+  messages
+}) => {
+  if (error) {
+    return "error";
+  }
+  const assistantMessage = getLatestAssistantMessage(messages);
+  if (!assistantMessage) {
+    return isStreaming ? "submitting" : "idle";
+  }
+  if (!isStreaming) {
+    return "complete";
+  }
+  const hasSources = (assistantMessage.sources?.length ?? 0) > 0;
+  const hasContent = assistantMessage.content.trim().length > 0 || assistantMessage.thinking?.trim().length || (assistantMessage.toolCalls?.length ?? 0) > 0 || (assistantMessage.images?.length ?? 0) > 0;
+  if (hasSources && !hasContent) {
+    return "retrieved";
+  }
+  return "streaming";
+};
+
+// src/svelte/ai/createRAGCitations.ts
+var createRAGCitations = (sources) => {
+  const citations = derived(sources, ($sources) => buildRAGCitations($sources));
+  const sourceGroups = derived(sources, ($sources) => buildRAGSourceGroups($sources));
+  const hasCitations = derived(citations, ($citations) => $citations.length > 0);
+  return {
+    citations,
+    hasCitations,
+    sourceGroups
+  };
+};
+
+// src/svelte/ai/createRAGDocuments.ts
+import { writable as writable2 } from "svelte/store";
+var createRAGDocuments = (path) => {
+  const client = createRAGClient({ path });
+  const documents = writable2([]);
+  const error = writable2(null);
+  const isLoading = writable2(false);
+  const lastResponse = writable2(null);
+  const load = async (kind) => {
+    isLoading.set(true);
+    error.set(null);
+    try {
+      const response = await client.documents(kind);
+      documents.set(response.documents);
+      lastResponse.set(response);
+      return response;
+    } catch (caught) {
+      error.set(caught instanceof Error ? caught.message : String(caught));
+      throw caught;
+    } finally {
+      isLoading.set(false);
+    }
+  };
+  const reset = () => {
+    documents.set([]);
+    error.set(null);
+    isLoading.set(false);
+    lastResponse.set(null);
+  };
+  return {
+    documents,
+    error,
+    isLoading,
+    lastResponse,
+    load,
+    reset
+  };
+};
+
 // src/svelte/ai/createRAGIngest.ts
+import { writable as writable3 } from "svelte/store";
 var createRAGIngest = (path) => {
   const client = createRAGClient({ path });
-  const error = writable(null);
-  const isIngesting = writable(false);
-  const lastIngestCount = writable(null);
-  const ingest = async (chunks) => {
+  const error = writable3(null);
+  const isIngesting = writable3(false);
+  const lastIngestCount = writable3(null);
+  const lastDocumentCount = writable3(null);
+  const lastResponse = writable3(null);
+  const ingestChunks = async (chunks) => {
     isIngesting.set(true);
     error.set(null);
     try {
@@ -900,6 +1116,27 @@ var createRAGIngest = (path) => {
         throw new Error(response.error ?? "RAG ingest failed");
       }
       lastIngestCount.set(response.count ?? chunks.length);
+      lastDocumentCount.set(null);
+      lastResponse.set(response);
+      return response;
+    } catch (caught) {
+      error.set(caught instanceof Error ? caught.message : String(caught));
+      throw caught;
+    } finally {
+      isIngesting.set(false);
+    }
+  };
+  const ingestDocuments = async (input) => {
+    isIngesting.set(true);
+    error.set(null);
+    try {
+      const response = await client.ingestDocuments(input);
+      if (!response.ok) {
+        throw new Error(response.error ?? "RAG document ingest failed");
+      }
+      lastDocumentCount.set(response.documentCount ?? input.documents.length);
+      lastIngestCount.set(response.count ?? null);
+      lastResponse.set(response);
       return response;
     } catch (caught) {
       error.set(caught instanceof Error ? caught.message : String(caught));
@@ -908,26 +1145,140 @@ var createRAGIngest = (path) => {
       isIngesting.set(false);
     }
   };
+  const clearIndex = async () => {
+    isIngesting.set(true);
+    error.set(null);
+    try {
+      return await client.clearIndex();
+    } catch (caught) {
+      error.set(caught instanceof Error ? caught.message : String(caught));
+      throw caught;
+    } finally {
+      isIngesting.set(false);
+    }
+  };
+  const reset = () => {
+    error.set(null);
+    isIngesting.set(false);
+    lastDocumentCount.set(null);
+    lastIngestCount.set(null);
+    lastResponse.set(null);
+  };
   return {
+    clearIndex,
     error,
-    ingest,
+    ingest: ingestChunks,
+    ingestChunks,
+    ingestDocuments,
     isIngesting,
-    lastIngestCount
+    lastDocumentCount,
+    lastIngestCount,
+    lastResponse,
+    reset
+  };
+};
+
+// src/svelte/ai/createRAGIndexAdmin.ts
+import { writable as writable4 } from "svelte/store";
+var createRAGIndexAdmin = (path) => {
+  const client = createRAGClient({ path });
+  const isLoading = writable4(false);
+  const error = writable4(null);
+  const lastMutation = writable4(null);
+  const backends = writable4(null);
+  const run = async (operation) => {
+    isLoading.set(true);
+    error.set(null);
+    try {
+      return await operation();
+    } catch (caught) {
+      error.set(caught instanceof Error ? caught.message : String(caught));
+      throw caught;
+    } finally {
+      isLoading.set(false);
+    }
+  };
+  const createDocument = async (input) => run(async () => {
+    const response = await client.createDocument(input);
+    lastMutation.set(response);
+    if (!response.ok) {
+      throw new Error(response.error ?? "Failed to create document");
+    }
+    return response;
+  });
+  const deleteDocument = async (id) => run(async () => {
+    const response = await client.deleteDocument(id);
+    lastMutation.set(response);
+    if (!response.ok) {
+      throw new Error(response.error ?? "Failed to delete document");
+    }
+    return response;
+  });
+  const reseed = async () => run(async () => {
+    const response = await client.reseed();
+    lastMutation.set(response);
+    if (!response.ok) {
+      throw new Error(response.error ?? "Failed to reseed index");
+    }
+    return response;
+  });
+  const reset = async () => run(async () => {
+    const response = await client.reset();
+    lastMutation.set(response);
+    if (!response.ok) {
+      throw new Error(response.error ?? "Failed to reset index");
+    }
+    return response;
+  });
+  const loadBackends = async () => run(async () => {
+    const response = await client.backends();
+    backends.set(response);
+    return response;
+  });
+  const clearIndex = async () => run(async () => {
+    const response = await client.clearIndex();
+    const mutation = { ok: response.ok };
+    lastMutation.set(mutation);
+    return mutation;
+  });
+  const resetState = () => {
+    backends.set(null);
+    error.set(null);
+    isLoading.set(false);
+    lastMutation.set(null);
+  };
+  return {
+    backends,
+    clearIndex,
+    createDocument,
+    deleteDocument,
+    error,
+    isLoading,
+    lastMutation,
+    loadBackends,
+    reseed,
+    reset,
+    resetState
   };
 };
+
 // src/svelte/ai/createRAGSearch.ts
-import { writable as writable2 } from "svelte/store";
+import { writable as writable5 } from "svelte/store";
 var createRAGSearch = (path) => {
   const client = createRAGClient({ path });
-  const results = writable2([]);
-  const error = writable2(null);
-  const isSearching = writable2(false);
+  const results = writable5([]);
+  const error = writable5(null);
+  const isSearching = writable5(false);
+  const hasSearched = writable5(false);
+  const lastRequest = writable5(null);
   const search = async (input) => {
     isSearching.set(true);
     error.set(null);
+    lastRequest.set(input);
     try {
       const nextResults = await client.search(input);
       results.set(nextResults);
+      hasSearched.set(true);
       return nextResults;
     } catch (caught) {
       error.set(caught instanceof Error ? caught.message : String(caught));
@@ -936,21 +1287,47 @@ var createRAGSearch = (path) => {
       isSearching.set(false);
     }
   };
+  const reset = () => {
+    error.set(null);
+    hasSearched.set(false);
+    isSearching.set(false);
+    lastRequest.set(null);
+    results.set([]);
+  };
   return {
     error,
+    hasSearched,
     isSearching,
+    lastRequest,
+    reset,
     results,
     search
   };
 };
+
+// src/svelte/ai/createRAGSources.ts
+import { derived as derived2 } from "svelte/store";
+var createRAGSources = (messages) => {
+  const latestAssistantMessage = derived2(messages, ($messages) => getLatestAssistantMessage($messages));
+  const sources = derived2(messages, ($messages) => getLatestRAGSources($messages));
+  const sourceGroups = derived2(sources, ($sources) => buildRAGSourceGroups($sources));
+  const hasSources = derived2(sources, ($sources) => $sources.length > 0);
+  return {
+    hasSources,
+    latestAssistantMessage,
+    sourceGroups,
+    sources
+  };
+};
+
 // src/svelte/ai/createRAGStatus.ts
-import { writable as writable3 } from "svelte/store";
+import { writable as writable6 } from "svelte/store";
 var createRAGStatus = (path, autoLoad = true) => {
   const client = createRAGClient({ path });
-  const status = writable3(undefined);
-  const capabilities = writable3(undefined);
-  const error = writable3(null);
-  const isLoading = writable3(autoLoad);
+  const status = writable6(undefined);
+  const capabilities = writable6(undefined);
+  const error = writable6(null);
+  const isLoading = writable6(autoLoad);
   const refresh = async () => {
     isLoading.set(true);
     error.set(null);
@@ -966,6 +1343,12 @@ var createRAGStatus = (path, autoLoad = true) => {
       isLoading.set(false);
     }
   };
+  const reset = () => {
+    capabilities.set(undefined);
+    error.set(null);
+    isLoading.set(false);
+    status.set(undefined);
+  };
   if (autoLoad) {
     refresh();
   } else {
@@ -976,16 +1359,101 @@ var createRAGStatus = (path, autoLoad = true) => {
     error,
     isLoading,
     refresh,
+    reset,
     status
   };
 };
+
+// src/svelte/ai/createRAGStream.ts
+import { derived as derived3, readable } from "svelte/store";
+var createRAGStream = (path, conversationId) => {
+  const stream = createAIStream(path, conversationId);
+  const messages = readable(stream.messages, (set) => {
+    set(stream.messages);
+    return stream.subscribe(() => set(stream.messages));
+  });
+  const error = readable(stream.error, (set) => {
+    set(stream.error);
+    return stream.subscribe(() => set(stream.error));
+  });
+  const isStreaming = readable(stream.isStreaming, (set) => {
+    set(stream.isStreaming);
+    return stream.subscribe(() => set(stream.isStreaming));
+  });
+  const latestAssistantMessage = derived3(messages, ($messages) => getLatestAssistantMessage($messages));
+  const sources = derived3(messages, ($messages) => getLatestRAGSources($messages));
+  const sourceGroups = derived3(sources, ($sources) => buildRAGSourceGroups($sources));
+  const citations = derived3(sources, ($sources) => buildRAGCitations($sources));
+  const retrieval = derived3(messages, ($messages) => buildRAGRetrievedState($messages));
+  const stage = derived3([messages, error, isStreaming], ([$messages, $error, $isStreaming]) => resolveRAGStreamStage({
+    error: $error,
+    isStreaming: $isStreaming,
+    messages: $messages
+  }));
+  const hasRetrieved = derived3(retrieval, ($retrieval) => ($retrieval?.sources.length ?? 0) > 0);
+  const hasSources = derived3(sources, ($sources) => $sources.length > 0);
+  const isRetrieving = derived3(stage, ($stage) => $stage === "submitting" || $stage === "retrieved");
+  const isAnswerStreaming = derived3(stage, ($stage) => $stage === "streaming");
+  const isComplete = derived3(stage, ($stage) => $stage === "complete");
+  const query = (content, attachments) => {
+    stream.send(content, attachments);
+  };
+  return {
+    ...stream,
+    citations,
+    error,
+    hasRetrieved,
+    hasSources,
+    isAnswerStreaming,
+    isComplete,
+    isRetrieving,
+    isStreaming,
+    latestAssistantMessage,
+    messages,
+    query,
+    retrieval,
+    sourceGroups,
+    sources,
+    stage
+  };
+};
+
+// src/svelte/ai/createRAG.ts
+var createRAG = (path, options = {}) => {
+  const search = createRAGSearch(path);
+  const ingest = createRAGIngest(path);
+  const status = createRAGStatus(path, options.autoLoadStatus ?? true);
+  const documents = createRAGDocuments(path);
+  const chunkPreview = createRAGChunkPreview(path);
+  const index = createRAGIndexAdmin(path);
+  const stream = createRAGStream(options.streamPath ?? path, options.conversationId);
+  const sources = createRAGSources(stream.messages);
+  const citations = createRAGCitations(sources.sources);
+  return {
+    citations,
+    chunkPreview,
+    documents,
+    ingest,
+    index,
+    search,
+    sources,
+    status,
+    stream
+  };
+};
 export {
-  createAIStream as createRAGStream,
+  createRAGStream,
   createRAGStatus,
+  createRAGSources,
   createRAGSearch,
   createRAGIngest,
+  createRAGIndexAdmin,
+  createRAGDocuments,
+  createRAGCitations,
+  createRAGChunkPreview,
+  createRAG,
   createAIStream
 };
 
-//# debugId=11199D7A1007552864756E2164756E21
+//# debugId=B44067D7D4FBEF1464756E2164756E21
 //# sourceMappingURL=index.js.map