@absolutejs/absolute 0.19.0-beta.436 → 0.19.0-beta.438

package/dist/react/ai/index.js

@@ -144,13 +144,67 @@ var isValidAIClientMessage = (data) => {
   }
 };
 
-// src/react/ai/AIStreamProvider.tsx
-import {
-  createContext,
-  useContext,
-  useEffect,
-  useRef
-} from "react";
+// src/ai/client/actions.ts
+var serverMessageToAction = (msg) => {
+  switch (msg.type) {
+    case "chunk":
+      return {
+        content: msg.content,
+        conversationId: msg.conversationId,
+        messageId: msg.messageId,
+        type: "chunk"
+      };
+    case "thinking":
+      return {
+        content: msg.content,
+        conversationId: msg.conversationId,
+        messageId: msg.messageId,
+        type: "thinking"
+      };
+    case "tool_status":
+      return {
+        conversationId: msg.conversationId,
+        input: msg.input,
+        messageId: msg.messageId,
+        name: msg.name,
+        result: msg.result,
+        status: msg.status,
+        type: "tool_status"
+      };
+    case "image":
+      return {
+        conversationId: msg.conversationId,
+        data: msg.data,
+        format: msg.format,
+        imageId: msg.imageId,
+        isPartial: msg.isPartial,
+        messageId: msg.messageId,
+        revisedPrompt: msg.revisedPrompt,
+        type: "image"
+      };
+    case "complete":
+      return {
+        conversationId: msg.conversationId,
+        durationMs: msg.durationMs,
+        messageId: msg.messageId,
+        model: msg.model,
+        sources: msg.sources,
+        type: "complete",
+        usage: msg.usage
+      };
+    case "rag_retrieved":
+      return {
+        conversationId: msg.conversationId,
+        messageId: msg.messageId,
+        sources: msg.sources,
+        type: "rag_retrieved"
+      };
+    case "error":
+      return { message: msg.message, type: "error" };
+    default:
+      return null;
+  }
+};
 
 // src/ai/client/connection.ts
 var WS_OPEN = 1;
@@ -556,107 +610,6 @@ var createAIMessageStore = () => {
   };
 };
 
-// src/ai/client/actions.ts
-var serverMessageToAction = (msg) => {
-  switch (msg.type) {
-    case "chunk":
-      return {
-        content: msg.content,
-        conversationId: msg.conversationId,
-        messageId: msg.messageId,
-        type: "chunk"
-      };
-    case "thinking":
-      return {
-        content: msg.content,
-        conversationId: msg.conversationId,
-        messageId: msg.messageId,
-        type: "thinking"
-      };
-    case "tool_status":
-      return {
-        conversationId: msg.conversationId,
-        input: msg.input,
-        messageId: msg.messageId,
-        name: msg.name,
-        result: msg.result,
-        status: msg.status,
-        type: "tool_status"
-      };
-    case "image":
-      return {
-        conversationId: msg.conversationId,
-        data: msg.data,
-        format: msg.format,
-        imageId: msg.imageId,
-        isPartial: msg.isPartial,
-        messageId: msg.messageId,
-        revisedPrompt: msg.revisedPrompt,
-        type: "image"
-      };
-    case "complete":
-      return {
-        conversationId: msg.conversationId,
-        durationMs: msg.durationMs,
-        messageId: msg.messageId,
-        model: msg.model,
-        sources: msg.sources,
-        type: "complete",
-        usage: msg.usage
-      };
-    case "rag_retrieved":
-      return {
-        conversationId: msg.conversationId,
-        messageId: msg.messageId,
-        sources: msg.sources,
-        type: "rag_retrieved"
-      };
-    case "error":
-      return { message: msg.message, type: "error" };
-    default:
-      return null;
-  }
-};
-
-// src/react/ai/AIStreamProvider.tsx
-import { jsxDEV } from "react/jsx-dev-runtime";
-var AIStreamContext = createContext(null);
-var AIStreamProvider = ({
-  children,
-  path
-}) => {
-  const ref = useRef(null);
-  if (!ref.current) {
-    const connection = createAIConnection(path);
-    const store = createAIMessageStore();
-    ref.current = { connection, store };
-  }
-  useEffect(() => {
-    const { current } = ref;
-    if (!current) {
-      return;
-    }
-    const { connection, store } = current;
-    const unsubscribe = connection.subscribe((msg) => {
-      const action = serverMessageToAction(msg);
-      if (action) {
-        store.dispatch(action);
-      }
-    });
-    return () => {
-      unsubscribe();
-      connection.close();
-    };
-  }, []);
-  return /* @__PURE__ */ jsxDEV(AIStreamContext.Provider, {
-    value: ref.current,
-    children
-  }, undefined, false, undefined, this);
-};
-var useAIStreamContext = () => useContext(AIStreamContext);
-// src/react/ai/useAIStream.ts
-import { useCallback, useEffect as useEffect2, useRef as useRef2, useSyncExternalStore } from "react";
-
 // src/ai/protocol.ts
 var generateId = () => crypto.randomUUID();
 var parseAIMessage = (raw) => {
@@ -690,42 +643,59 @@ var parseAIMessage = (raw) => {
 };
 var serializeAIMessage = (msg) => JSON.stringify(msg);
 
-// src/react/ai/useAIStream.ts
-var useAIStream = (path, conversationId) => {
-  const context = useAIStreamContext();
-  const standaloneRef = useRef2(null);
-  const isStandalone = !context;
-  if (isStandalone && !standaloneRef.current && path) {
-    const connection2 = createAIConnection(path);
-    const store2 = createAIMessageStore();
-    standaloneRef.current = { connection: connection2, store: store2 };
-  }
-  const resolved = context ?? standaloneRef.current;
-  if (!resolved) {
-    throw new Error("useAIStream requires either an AIStreamProvider or a path argument");
-  }
-  const { connection, store } = resolved;
-  useEffect2(() => {
-    if (!isStandalone) {
-      return;
+// src/ai/client/createAIStream.ts
+var createAIStream = (path, conversationId) => {
+  const connection = createAIConnection(path);
+  const store = createAIMessageStore();
+  const listeners = new Set;
+  let currentError = null;
+  let currentIsStreaming = false;
+  let currentMessages = [];
+  let activeConversationId = conversationId ?? null;
+  const syncState = () => {
+    const snapshot = store.getSnapshot();
+    const convId = activeConversationId ?? snapshot.activeConversationId;
+    const conversation = convId ? snapshot.conversations.get(convId) : undefined;
+    activeConversationId = convId ?? snapshot.activeConversationId;
+    currentError = snapshot.error;
+    currentIsStreaming = snapshot.isStreaming;
+    currentMessages = conversation?.messages ?? [];
+    listeners.forEach((listener) => listener());
+  };
+  const unsubscribeStore = store.subscribe(syncState);
+  const unsubscribeConnection = connection.subscribe((msg) => {
+    const action = serverMessageToAction(msg);
+    if (action) {
+      store.dispatch(action);
     }
-    const unsubscribe = connection.subscribe((msg) => {
-      const action = serverMessageToAction(msg);
-      if (action) {
-        store.dispatch(action);
-      }
-    });
-    return () => {
-      unsubscribe();
-      connection.close();
-    };
-  }, [connection, isStandalone, store]);
-  const state = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getServerSnapshot);
-  const activeConvId = conversationId ?? state.activeConversationId;
-  const conversation = activeConvId ? state.conversations.get(activeConvId) : undefined;
-  const messages = conversation?.messages ?? [];
-  const send = useCallback((content, attachments) => {
-    const convId = activeConvId ?? generateId();
+  });
+  const branch = (messageId, content) => {
+    if (activeConversationId) {
+      connection.send({
+        content,
+        conversationId: activeConversationId,
+        messageId,
+        type: "branch"
+      });
+    }
+  };
+  const cancel = () => {
+    if (activeConversationId) {
+      store.dispatch({ type: "cancel" });
+      connection.send({
+        conversationId: activeConversationId,
+        type: "cancel"
+      });
+    }
+  };
+  const destroy = () => {
+    unsubscribeStore();
+    unsubscribeConnection();
+    connection.close();
+    listeners.clear();
+  };
+  const send = (content, attachments) => {
+    const convId = activeConversationId ?? generateId();
     const msgId = generateId();
     store.dispatch({
       attachments,
@@ -740,37 +710,348 @@ var useAIStream = (path, conversationId) => {
       conversationId: convId,
       type: "message"
     });
-  }, [activeConvId, connection, store]);
-  const cancel = useCallback(() => {
-    if (activeConvId) {
-      store.dispatch({ type: "cancel" });
-      connection.send({ conversationId: activeConvId, type: "cancel" });
-    }
-  }, [activeConvId, connection, store]);
-  const branch = useCallback((messageId, content) => {
-    if (activeConvId) {
-      connection.send({
-        content,
-        conversationId: activeConvId,
-        messageId,
-        type: "branch"
-      });
-    }
-  }, [activeConvId, connection]);
+  };
+  const subscribe = (callback) => {
+    listeners.add(callback);
+    return () => {
+      listeners.delete(callback);
+    };
+  };
   return {
     branch,
     cancel,
-    error: state.error,
-    isStreaming: state.isStreaming,
-    messages,
-    send
+    destroy,
+    send,
+    subscribe,
+    get error() {
+      return currentError;
+    },
+    get isStreaming() {
+      return currentIsStreaming;
+    },
+    get messages() {
+      return currentMessages;
+    }
   };
 };
-// src/react/ai/useRAG.ts
-import { useMemo as useMemo7 } from "react";
-
-// src/react/ai/useRAGCitations.ts
-import { useMemo } from "react";
+// src/ai/client/ragClient.ts
+var jsonHeaders = {
+  "Content-Type": "application/json"
+};
+var normalizeBasePath = (path) => path.endsWith("/") ? path.slice(0, -1) : path;
+var parseJson = async (response) => {
+  const payload = await response.json();
+  return payload;
+};
+var toErrorMessage = async (response) => {
+  try {
+    const payload = await response.json();
+    if (typeof payload.error === "string" && payload.error) {
+      return payload.error;
+    }
+  } catch {}
+  return `Request failed with status ${response.status}`;
+};
+var createRAGClient = (options) => {
+  const basePath = normalizeBasePath(options.path);
+  const fetchImpl = options.fetch ?? fetch;
+  return {
+    async ingest(chunks) {
+      const response = await fetchImpl(`${basePath}/ingest`, {
+        body: JSON.stringify({ chunks }),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          ok: false,
+          error: await toErrorMessage(response)
+        };
+      }
+      return parseJson(response);
+    },
+    async ingestDocuments(input) {
+      const response = await fetchImpl(`${basePath}/ingest`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          ok: false,
+          error: await toErrorMessage(response)
+        };
+      }
+      return parseJson(response);
+    },
+    async search(input) {
+      const response = await fetchImpl(`${basePath}/search`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      const payload = await parseJson(response);
+      if (!payload.ok) {
+        throw new Error(payload.error ?? "RAG search failed");
+      }
+      return payload.results ?? [];
+    },
+    async status() {
+      const response = await fetchImpl(`${basePath}/status`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    },
+    async documents(kind) {
+      const query = kind ? `?kind=${encodeURIComponent(kind)}` : "";
+      const response = await fetchImpl(`${basePath}/documents${query}`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    },
+    async createDocument(input) {
+      const response = await fetchImpl(`${basePath}/documents`, {
+        body: JSON.stringify(input),
+        headers: jsonHeaders,
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          ok: false,
+          error: await toErrorMessage(response)
+        };
+      }
+      return parseJson(response);
+    },
+    async documentChunks(id) {
+      const response = await fetchImpl(`${basePath}/documents/${encodeURIComponent(id)}/chunks`);
+      if (!response.ok) {
+        const error = await toErrorMessage(response);
+        return { ok: false, error };
+      }
+      return parseJson(response);
+    },
+    async deleteDocument(id) {
+      const response = await fetchImpl(`${basePath}/documents/${encodeURIComponent(id)}`, {
+        method: "DELETE"
+      });
+      if (!response.ok) {
+        return {
+          ok: false,
+          error: await toErrorMessage(response)
+        };
+      }
+      return parseJson(response);
+    },
+    async reseed() {
+      const response = await fetchImpl(`${basePath}/reseed`, {
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          ok: false,
+          error: await toErrorMessage(response)
+        };
+      }
+      return parseJson(response);
+    },
+    async reset() {
+      const response = await fetchImpl(`${basePath}/reset`, {
+        method: "POST"
+      });
+      if (!response.ok) {
+        return {
+          ok: false,
+          error: await toErrorMessage(response)
+        };
+      }
+      return parseJson(response);
+    },
+    async backends() {
+      const response = await fetchImpl(`${basePath}/backends`);
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    },
+    async clearIndex() {
+      const response = await fetchImpl(`${basePath}/index`, {
+        method: "DELETE"
+      });
+      if (!response.ok) {
+        throw new Error(await toErrorMessage(response));
+      }
+      return parseJson(response);
+    }
+  };
+};
+// src/react/ai/AIStreamProvider.tsx
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useRef
+} from "react";
+import { jsxDEV } from "react/jsx-dev-runtime";
+var AIStreamContext = createContext(null);
+var AIStreamProvider = ({
+  children,
+  path
+}) => {
+  const ref = useRef(null);
+  if (!ref.current) {
+    const connection = createAIConnection(path);
+    const store = createAIMessageStore();
+    ref.current = { connection, store };
+  }
+  useEffect(() => {
+    const { current } = ref;
+    if (!current) {
+      return;
+    }
+    const { connection, store } = current;
+    const unsubscribe = connection.subscribe((msg) => {
+      const action = serverMessageToAction(msg);
+      if (action) {
+        store.dispatch(action);
+      }
+    });
+    return () => {
+      unsubscribe();
+      connection.close();
+    };
+  }, []);
+  return /* @__PURE__ */ jsxDEV(AIStreamContext.Provider, {
+    value: ref.current,
+    children
+  }, undefined, false, undefined, this);
+};
+var useAIStreamContext = () => useContext(AIStreamContext);
+// src/react/ai/useAIStream.ts
+import { useCallback, useEffect as useEffect2, useRef as useRef2, useSyncExternalStore } from "react";
+var useAIStream = (path, conversationId) => {
+  const context = useAIStreamContext();
+  const standaloneRef = useRef2(null);
+  const isStandalone = !context;
+  if (isStandalone && !standaloneRef.current && path) {
+    const connection2 = createAIConnection(path);
+    const store2 = createAIMessageStore();
+    standaloneRef.current = { connection: connection2, store: store2 };
+  }
+  const resolved = context ?? standaloneRef.current;
+  if (!resolved) {
+    throw new Error("useAIStream requires either an AIStreamProvider or a path argument");
+  }
+  const { connection, store } = resolved;
+  useEffect2(() => {
+    if (!isStandalone) {
+      return;
+    }
+    const unsubscribe = connection.subscribe((msg) => {
+      const action = serverMessageToAction(msg);
+      if (action) {
+        store.dispatch(action);
+      }
+    });
+    return () => {
+      unsubscribe();
+      connection.close();
+    };
+  }, [connection, isStandalone, store]);
+  const state = useSyncExternalStore(store.subscribe, store.getSnapshot, store.getServerSnapshot);
+  const activeConvId = conversationId ?? state.activeConversationId;
+  const conversation = activeConvId ? state.conversations.get(activeConvId) : undefined;
+  const messages = conversation?.messages ?? [];
+  const send = useCallback((content, attachments) => {
+    const convId = activeConvId ?? generateId();
+    const msgId = generateId();
+    store.dispatch({
+      attachments,
+      content,
+      conversationId: convId,
+      messageId: msgId,
+      type: "send"
+    });
+    connection.send({
+      attachments,
+      content,
+      conversationId: convId,
+      type: "message"
+    });
+  }, [activeConvId, connection, store]);
+  const cancel = useCallback(() => {
+    if (activeConvId) {
+      store.dispatch({ type: "cancel" });
+      connection.send({ conversationId: activeConvId, type: "cancel" });
+    }
+  }, [activeConvId, connection, store]);
+  const branch = useCallback((messageId, content) => {
+    if (activeConvId) {
+      connection.send({
+        content,
+        conversationId: activeConvId,
+        messageId,
+        type: "branch"
+      });
+    }
+  }, [activeConvId, connection]);
+  return {
+    branch,
+    cancel,
+    error: state.error,
+    isStreaming: state.isStreaming,
+    messages,
+    send
+  };
+};
+// src/react/ai/useRAGChunkPreview.ts
+import { useCallback as useCallback2, useMemo, useState } from "react";
+var useRAGChunkPreview = (path) => {
+  const client = useMemo(() => createRAGClient({ path }), [path]);
+  const [preview, setPreview] = useState(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const inspect = useCallback2(async (id) => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await client.documentChunks(id);
+      if (!response.ok) {
+        throw new Error(response.error);
+      }
+      setPreview(response);
+      return response;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to load RAG chunk preview";
+      setError(message);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const clear = useCallback2(() => {
+    setPreview(null);
+    setError(null);
+    setIsLoading(false);
+  }, []);
+  return {
+    clear,
+    error,
+    inspect,
+    isLoading,
+    preview
+  };
+};
+// src/react/ai/useRAG.ts
+import { useMemo as useMemo10 } from "react";
+
+// src/react/ai/useRAGCitations.ts
+import { useMemo as useMemo2 } from "react";
 
 // src/ai/rag/presentation.ts
 var buildSourceGroupKey = (source) => source.source ?? source.title ?? source.chunkId;
@@ -864,8 +1145,8 @@ var resolveRAGStreamStage = ({
 
 // src/react/ai/useRAGCitations.ts
 var useRAGCitations = (sources) => {
-  const citations = useMemo(() => buildRAGCitations(sources), [sources]);
-  const sourceGroups = useMemo(() => buildRAGSourceGroups(sources), [sources]);
+  const citations = useMemo2(() => buildRAGCitations(sources), [sources]);
+  const sourceGroups = useMemo2(() => buildRAGSourceGroups(sources), [sources]);
   return {
     citations,
     hasCitations: citations.length > 0,
@@ -873,102 +1154,56 @@ var useRAGCitations = (sources) => {
   };
 };
 
-// src/react/ai/useRAGIngest.ts
-import { useCallback as useCallback2, useMemo as useMemo2, useState } from "react";
-
-// src/ai/client/ragClient.ts
-var jsonHeaders = {
-  "Content-Type": "application/json"
-};
-var normalizeBasePath = (path) => path.endsWith("/") ? path.slice(0, -1) : path;
-var parseJson = async (response) => {
-  const payload = await response.json();
-  return payload;
-};
-var toErrorMessage = async (response) => {
-  try {
-    const payload = await response.json();
-    if (typeof payload.error === "string" && payload.error) {
-      return payload.error;
+// src/react/ai/useRAGDocuments.ts
+import { useCallback as useCallback3, useMemo as useMemo3, useState as useState2 } from "react";
+var useRAGDocuments = (path) => {
+  const client = useMemo3(() => createRAGClient({ path }), [path]);
+  const [documents, setDocuments] = useState2([]);
+  const [isLoading, setIsLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const [lastResponse, setLastResponse] = useState2(null);
+  const load = useCallback3(async (kind) => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await client.documents(kind);
+      setDocuments(response.documents);
+      setLastResponse(response);
+      return response;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Failed to load RAG documents";
+      setError(message);
+      throw err;
+    } finally {
+      setIsLoading(false);
     }
-  } catch {}
-  return `Request failed with status ${response.status}`;
-};
-var createRAGClient = (options) => {
-  const basePath = normalizeBasePath(options.path);
-  const fetchImpl = options.fetch ?? fetch;
+  }, [client]);
+  const reset = useCallback3(() => {
+    setDocuments([]);
+    setError(null);
+    setLastResponse(null);
+    setIsLoading(false);
+  }, []);
   return {
-    async ingest(chunks) {
-      const response = await fetchImpl(`${basePath}/ingest`, {
-        body: JSON.stringify({ chunks }),
-        headers: jsonHeaders,
-        method: "POST"
-      });
-      if (!response.ok) {
-        return {
-          ok: false,
-          error: await toErrorMessage(response)
-        };
-      }
-      return parseJson(response);
-    },
-    async ingestDocuments(input) {
-      const response = await fetchImpl(`${basePath}/ingest`, {
-        body: JSON.stringify(input),
-        headers: jsonHeaders,
-        method: "POST"
-      });
-      if (!response.ok) {
-        return {
-          ok: false,
-          error: await toErrorMessage(response)
-        };
-      }
-      return parseJson(response);
-    },
-    async search(input) {
-      const response = await fetchImpl(`${basePath}/search`, {
-        body: JSON.stringify(input),
-        headers: jsonHeaders,
-        method: "POST"
-      });
-      if (!response.ok) {
-        throw new Error(await toErrorMessage(response));
-      }
-      const payload = await parseJson(response);
-      if (!payload.ok) {
-        throw new Error(payload.error ?? "RAG search failed");
-      }
-      return payload.results ?? [];
-    },
-    async status() {
-      const response = await fetchImpl(`${basePath}/status`);
-      if (!response.ok) {
-        throw new Error(await toErrorMessage(response));
-      }
-      return parseJson(response);
-    },
-    async clearIndex() {
-      const response = await fetchImpl(`${basePath}/index`, {
-        method: "DELETE"
-      });
-      if (!response.ok) {
-        throw new Error(await toErrorMessage(response));
-      }
-      return parseJson(response);
-    }
+    documents,
+    error,
+    isLoading,
+    lastResponse,
+    load,
+    reset
   };
 };
 
 // src/react/ai/useRAGIngest.ts
+import { useCallback as useCallback4, useMemo as useMemo4, useState as useState3 } from "react";
 var useRAGIngest = (path) => {
-  const client = useMemo2(() => createRAGClient({ path }), [path]);
-  const [error, setError] = useState(null);
-  const [isIngesting, setIsIngesting] = useState(false);
-  const [lastIngestCount, setLastIngestCount] = useState(null);
-  const [lastDocumentCount, setLastDocumentCount] = useState(null);
-  const [lastResponse, setLastResponse] = useState(null);
-  const ingestChunks = useCallback2(async (chunks) => {
+  const client = useMemo4(() => createRAGClient({ path }), [path]);
+  const [error, setError] = useState3(null);
+  const [isIngesting, setIsIngesting] = useState3(false);
+  const [lastIngestCount, setLastIngestCount] = useState3(null);
+  const [lastDocumentCount, setLastDocumentCount] = useState3(null);
+  const [lastResponse, setLastResponse] = useState3(null);
+  const ingestChunks = useCallback4(async (chunks) => {
     setIsIngesting(true);
     setError(null);
     try {
@@ -988,7 +1223,7 @@ var useRAGIngest = (path) => {
       setIsIngesting(false);
     }
   }, [client]);
-  const ingestDocuments = useCallback2(async (input) => {
+  const ingestDocuments = useCallback4(async (input) => {
     setIsIngesting(true);
     setError(null);
     try {
@@ -1008,7 +1243,7 @@ var useRAGIngest = (path) => {
       setIsIngesting(false);
     }
   }, [client]);
-  const clearIndex = useCallback2(async () => {
+  const clearIndex = useCallback4(async () => {
     setIsIngesting(true);
     setError(null);
     try {
@@ -1024,7 +1259,7 @@ var useRAGIngest = (path) => {
       setIsIngesting(false);
     }
   }, [client]);
-  const reset = useCallback2(() => {
+  const reset = useCallback4(() => {
     setError(null);
     setLastDocumentCount(null);
     setLastIngestCount(null);
@@ -1044,16 +1279,101 @@ var useRAGIngest = (path) => {
   };
 };
 
+// src/react/ai/useRAGIndexAdmin.ts
+import { useCallback as useCallback5, useMemo as useMemo5, useState as useState4 } from "react";
+var useRAGIndexAdmin = (path) => {
+  const client = useMemo5(() => createRAGClient({ path }), [path]);
+  const [isLoading, setIsLoading] = useState4(false);
+  const [error, setError] = useState4(null);
+  const [lastMutation, setLastMutation] = useState4(null);
+  const [backends, setBackends] = useState4(null);
+  const run = useCallback5(async (operation) => {
+    setIsLoading(true);
+    setError(null);
+    try {
+      return await operation();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "RAG index administration failed";
+      setError(message);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const deleteDocument = useCallback5(async (id) => run(async () => {
+    const response = await client.deleteDocument(id);
+    setLastMutation(response);
+    if (!response.ok) {
+      throw new Error(response.error ?? "Failed to delete document");
+    }
+    return response;
+  }), [client, run]);
+  const createDocument = useCallback5(async (input) => run(async () => {
+    const response = await client.createDocument(input);
+    setLastMutation(response);
+    if (!response.ok) {
+      throw new Error(response.error ?? "Failed to create document");
+    }
+    return response;
+  }), [client, run]);
+  const reseed = useCallback5(async () => run(async () => {
+    const response = await client.reseed();
+    setLastMutation(response);
+    if (!response.ok) {
+      throw new Error(response.error ?? "Failed to reseed index");
+    }
+    return response;
+  }), [client, run]);
+  const reset = useCallback5(async () => run(async () => {
+    const response = await client.reset();
+    setLastMutation(response);
+    if (!response.ok) {
+      throw new Error(response.error ?? "Failed to reset index");
+    }
+    return response;
+  }), [client, run]);
+  const loadBackends = useCallback5(async () => run(async () => {
+    const response = await client.backends();
+    setBackends(response);
+    return response;
+  }), [client, run]);
+  const clearIndex = useCallback5(async () => run(async () => {
+    const response = await client.clearIndex();
+    const mutation = { ok: response.ok };
+    setLastMutation(mutation);
+    return mutation;
+  }), [client, run]);
+  const resetState = useCallback5(() => {
+    setIsLoading(false);
+    setError(null);
+    setLastMutation(null);
+    setBackends(null);
+  }, []);
+  return {
+    backends,
+    clearIndex,
+    createDocument,
+    deleteDocument,
+    error,
+    isLoading,
+    lastMutation,
+    loadBackends,
+    reseed,
+    reset,
+    resetState
+  };
+};
+
 // src/react/ai/useRAGSearch.ts
-import { useCallback as useCallback3, useMemo as useMemo3, useState as useState2 } from "react";
+import { useCallback as useCallback6, useMemo as useMemo6, useState as useState5 } from "react";
 var useRAGSearch = (path) => {
-  const client = useMemo3(() => createRAGClient({ path }), [path]);
-  const [results, setResults] = useState2([]);
-  const [error, setError] = useState2(null);
-  const [isSearching, setIsSearching] = useState2(false);
-  const [hasSearched, setHasSearched] = useState2(false);
-  const [lastRequest, setLastRequest] = useState2(null);
-  const search = useCallback3(async (input) => {
+  const client = useMemo6(() => createRAGClient({ path }), [path]);
+  const [results, setResults] = useState5([]);
+  const [error, setError] = useState5(null);
+  const [isSearching, setIsSearching] = useState5(false);
+  const [hasSearched, setHasSearched] = useState5(false);
+  const [lastRequest, setLastRequest] = useState5(null);
+  const search = useCallback6(async (input) => {
     setIsSearching(true);
     setError(null);
     setLastRequest(input);
@@ -1070,7 +1390,7 @@ var useRAGSearch = (path) => {
       setIsSearching(false);
     }
   }, [client]);
-  const reset = useCallback3(() => {
+  const reset = useCallback6(() => {
     setError(null);
     setHasSearched(false);
     setLastRequest(null);
@@ -1089,11 +1409,11 @@ var useRAGSearch = (path) => {
 };
 
 // src/react/ai/useRAGSources.ts
-import { useMemo as useMemo4 } from "react";
+import { useMemo as useMemo7 } from "react";
 var useRAGSources = (messages) => {
-  const latestAssistantMessage = useMemo4(() => getLatestAssistantMessage(messages), [messages]);
-  const sources = useMemo4(() => getLatestRAGSources(messages), [messages]);
-  const sourceGroups = useMemo4(() => buildRAGSourceGroups(sources), [sources]);
+  const latestAssistantMessage = useMemo7(() => getLatestAssistantMessage(messages), [messages]);
+  const sources = useMemo7(() => getLatestRAGSources(messages), [messages]);
+  const sourceGroups = useMemo7(() => buildRAGSourceGroups(sources), [sources]);
   return {
     hasSources: sources.length > 0,
     latestAssistantMessage,
@@ -1103,14 +1423,14 @@ var useRAGSources = (messages) => {
 };
 
 // src/react/ai/useRAGStatus.ts
-import { useCallback as useCallback4, useEffect as useEffect3, useMemo as useMemo5, useState as useState3 } from "react";
+import { useCallback as useCallback7, useEffect as useEffect3, useMemo as useMemo8, useState as useState6 } from "react";
 var useRAGStatus = (path, autoLoad = true) => {
-  const client = useMemo5(() => createRAGClient({ path }), [path]);
-  const [status, setStatus] = useState3();
-  const [capabilities, setCapabilities] = useState3();
-  const [error, setError] = useState3(null);
-  const [isLoading, setIsLoading] = useState3(autoLoad);
-  const refresh = useCallback4(async () => {
+  const client = useMemo8(() => createRAGClient({ path }), [path]);
+  const [status, setStatus] = useState6();
+  const [capabilities, setCapabilities] = useState6();
+  const [error, setError] = useState6(null);
+  const [isLoading, setIsLoading] = useState6(autoLoad);
+  const refresh = useCallback7(async () => {
     setIsLoading(true);
     setError(null);
     try {
@@ -1126,7 +1446,7 @@ var useRAGStatus = (path, autoLoad = true) => {
       setIsLoading(false);
     }
   }, [client]);
-  const reset = useCallback4(() => {
+  const reset = useCallback7(() => {
     setCapabilities(undefined);
     setError(null);
     setIsLoading(false);
@@ -1150,19 +1470,19 @@ var useRAGStatus = (path, autoLoad = true) => {
 };
 
 // src/react/ai/useRAGStream.ts
-import { useCallback as useCallback5, useMemo as useMemo6 } from "react";
+import { useCallback as useCallback8, useMemo as useMemo9 } from "react";
 var useRAGStream = (path, conversationId) => {
   const stream = useAIStream(path, conversationId);
-  const latestAssistantMessage = useMemo6(() => getLatestAssistantMessage(stream.messages), [stream.messages]);
-  const sources = useMemo6(() => getLatestRAGSources(stream.messages), [stream.messages]);
-  const sourceGroups = useMemo6(() => buildRAGSourceGroups(sources), [sources]);
-  const citations = useMemo6(() => buildRAGCitations(sources), [sources]);
-  const stage = useMemo6(() => resolveRAGStreamStage({
+  const latestAssistantMessage = useMemo9(() => getLatestAssistantMessage(stream.messages), [stream.messages]);
+  const sources = useMemo9(() => getLatestRAGSources(stream.messages), [stream.messages]);
+  const sourceGroups = useMemo9(() => buildRAGSourceGroups(sources), [sources]);
+  const citations = useMemo9(() => buildRAGCitations(sources), [sources]);
+  const stage = useMemo9(() => resolveRAGStreamStage({
     error: stream.error,
     isStreaming: stream.isStreaming,
     messages: stream.messages
   }), [stream.error, stream.isStreaming, stream.messages]);
-  const query = useCallback5((content, attachments) => {
+  const query = useCallback8((content, attachments) => {
     stream.send(content, attachments);
   }, [stream]);
   return {
@@ -1182,17 +1502,23 @@ var useRAG = (path, options = {}) => {
   const search = useRAGSearch(path);
   const ingest = useRAGIngest(path);
   const status = useRAGStatus(path, options.autoLoadStatus ?? true);
+  const documents = useRAGDocuments(path);
+  const chunkPreview = useRAGChunkPreview(path);
+  const index = useRAGIndexAdmin(path);
   const stream = useRAGStream(options.streamPath ?? path, options.conversationId);
   const sources = useRAGSources(stream.messages);
   const citations = useRAGCitations(sources.sources);
-  return useMemo7(() => ({
+  return useMemo10(() => ({
     citations,
+    chunkPreview,
+    documents,
     ingest,
+    index,
     search,
     sources,
     status,
     stream
-  }), [citations, ingest, search, sources, status, stream]);
+  }), [citations, chunkPreview, documents, ingest, index, search, sources, status, stream]);
 };
 export {
   useRAGStream,
@@ -1200,11 +1526,14 @@ export {
   useRAGSources,
   useRAGSearch,
   useRAGIngest,
+  useRAGIndexAdmin,
+  useRAGDocuments,
   useRAGCitations,
+  useRAGChunkPreview,
   useRAG,
   useAIStream,
   AIStreamProvider
 };
 
-//# debugId=D0ADC407D5CCE73D64756E2164756E21
+//# debugId=55AD95E07D2CA2EF64756E2164756E21
 //# sourceMappingURL=index.js.map