@absolutejs/rag 0.16.0 → 0.18.0

package/dist/react/index.js

@@ -68,6 +68,153 @@ var __decorateElement = (array, flags, name, decorators, target, extra) => {
   return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
 };
 
+// src/client/research.ts
+var createResearchClient = (options = {}) => {
+  let state = {
+    status: "idle",
+    result: null,
+    progress: null,
+    error: null
+  };
+  let active;
+  let generation = 0;
+  const listeners = new Set;
+  const publish = (next) => {
+    state = next;
+    listeners.forEach((listener) => listener());
+  };
+  const cancel = () => {
+    generation++;
+    active?.abort();
+    active = undefined;
+    if (state.status === "running")
+      publish({ ...state, status: "cancelled" });
+  };
+  const run = async (input) => {
+    active?.abort();
+    const id = ++generation;
+    const controller = new AbortController;
+    active = controller;
+    publish({ status: "running", result: null, progress: null, error: null });
+    let reader;
+    try {
+      const headers = new Headers(options.headers?.());
+      headers.set("content-type", "application/json");
+      const response = await (options.fetch ?? fetch)(`${options.path ?? "/research"}/stream`, {
+        method: "POST",
+        body: JSON.stringify(input),
+        headers,
+        credentials: "same-origin",
+        signal: controller.signal
+      });
+      if (!response.ok || !response.body)
+        throw new Error(`Research request failed (${response.status})`);
+      reader = response.body.getReader();
+      const decoder = new TextDecoder;
+      let pending = "";
+      let result;
+      const processLine = (line) => {
+        if (!line.trim())
+          return;
+        const event = JSON.parse(line);
+        if (event.type === "error")
+          throw new Error("Research request failed");
+        if (event.type === "result") {
+          if (!event.result || !["reviewed", "partial", "empty", "unavailable"].includes(event.result.status) || !Array.isArray(event.result.fields) || !Array.isArray(event.result.sources))
+            throw new Error("Invalid research result");
+          result = event.result;
+        }
+        if (event.type === "progress" && id === generation)
+          publish({ ...state, progress: event.progress });
+      };
+      while (true) {
+        controller.signal.throwIfAborted();
+        const chunk = await reader.read();
+        pending += decoder.decode(chunk.value, { stream: !chunk.done });
+        if (pending.length > 4000000)
+          throw new Error("Research response too large");
+        let newline;
+        while ((newline = pending.indexOf(`
+`)) >= 0) {
+          processLine(pending.slice(0, newline));
+          pending = pending.slice(newline + 1);
+        }
+        if (chunk.done)
+          break;
+      }
+      if (pending)
+        processLine(pending);
+      controller.signal.throwIfAborted();
+      if (!result)
+        throw new Error("Research stream ended without a result");
+      if (id === generation)
+        publish({ ...state, status: "complete", result });
+      return result;
+    } catch (error) {
+      if (id === generation)
+        publish({
+          ...state,
+          status: controller.signal.aborted ? "cancelled" : "error",
+          error: controller.signal.aborted ? null : error instanceof Error ? error.message : "Research request failed"
+        });
+      throw error;
+    } finally {
+      await reader?.cancel().catch(() => {
+        return;
+      });
+      reader?.releaseLock();
+      if (id === generation)
+        active = undefined;
+    }
+  };
+  return {
+    run,
+    cancel,
+    getSnapshot: () => state,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    reset: () => {
+      cancel();
+      publish({ status: "idle", result: null, progress: null, error: null });
+    },
+    dispose: () => {
+      cancel();
+      listeners.clear();
+    }
+  };
+};
+var bindResearchForm = (form, output, options = {}) => {
+  const client = createResearchClient(options);
+  const unsubscribe = client.subscribe(() => {
+    const state = client.getSnapshot();
+    output.setAttribute("aria-busy", String(state.status === "running"));
+    output.textContent = state.result ? JSON.stringify(state.result, null, 2) : state.error ?? state.status;
+  });
+  const submit = (event) => {
+    event.preventDefault();
+    const data = new FormData(form);
+    client.run({
+      query: String(data.get("query") ?? ""),
+      ...data.get("task") ? { task: String(data.get("task")) } : {}
+    }).catch(() => {
+      return;
+    });
+  };
+  form.addEventListener("submit", submit);
+  return {
+    ...client,
+    dispose: () => {
+      form.removeEventListener("submit", submit);
+      unsubscribe();
+      client.dispose();
+    }
+  };
+};
+
 // src/react/useRAGChunkPreview.ts
 import { useCallback, useMemo, useState } from "react";
 
@@ -5025,6 +5172,14 @@ var useRAGStreamProgress = (params) => useMemo15(() => buildRAGStreamProgress({
   isStreaming: params.isStreaming,
   messages: params.messages
 }), [params.error, params.isStreaming, params.messages]);
+// src/react/useResearch.ts
+import { useEffect as useEffect3, useMemo as useMemo16, useSyncExternalStore } from "react";
+var useResearch = (path = "/research") => {
+  const client = useMemo16(() => createResearchClient({ path }), [path]);
+  const state = useSyncExternalStore(client.subscribe, client.getSnapshot, client.getSnapshot);
+  useEffect3(() => () => client.cancel(), [client]);
+  return { ...client, state };
+};
 export {
   useRAG,
   useRAGChunkPreview,
@@ -5040,8 +5195,9 @@ export {
   useRAGStatus,
   useRAGStream,
   useRAGStreamProgress,
-  useRAGWorkflow
+  useRAGWorkflow,
+  useResearch
 };
 
-//# debugId=58A3E0E0D2F57F7B64756E2164756E21
+//# debugId=7FD1ED9FF1C8AD0364756E2164756E21
 //# sourceMappingURL=index.js.map