@absolutejs/rag 0.16.0 → 0.18.0

package/dist/src/svelte/index.d.ts

@@ -15,3 +15,4 @@ export { createRAGStream } from "./createRAGStream";
 export { createRAGStreamProgress } from "./createRAGStreamProgress";
 export type { CreateRAGWorkflowResult } from "./createRAGWorkflow";
 export type { CreateRAGStreamResult } from "./createRAGStream";
+export * from "./createResearch";

package/dist/src/vue/index.d.ts

@@ -15,3 +15,4 @@ export { useRAGStreamProgress } from "./useRAGStreamProgress";
 export type { UseRAGStreamResult } from "./useRAGStream";
 export { useRAGSources } from "./useRAGSources";
 export { useRAGStatus } from "./useRAGStatus";
+export * from "./useResearch";

package/dist/src/vue/useResearch.d.ts

@@ -0,0 +1,9 @@
+export declare const useResearch: (path?: string) => {
+    state: import("vue").ShallowRef<import("../client").ResearchState, import("../client").ResearchState>;
+    run: (input: import("../client").ResearchRequest) => Promise<import("../research").ResearchResult>;
+    cancel: () => void;
+    getSnapshot: () => import("../client").ResearchState;
+    subscribe: (listener: () => void) => () => void;
+    reset: () => void;
+    dispose: () => void;
+};

package/dist/src/web/index.d.ts

@@ -50,3 +50,4 @@ export type ReadWebpageOptions = {
 /** Read prepared evidence, escalating thin HTML shells to a host-supplied browser. */
 export declare const readRAGWebpage: (options: ReadWebpageOptions) => Promise<WebReadResult>;
 export { readRAGWebsite } from "./website";
+export { createWebsiteReaderClient, parseWebsiteServiceResult, type WebsiteServiceResult, } from "./remote";

package/dist/src/web/remote.d.ts

@@ -0,0 +1,30 @@
+/** Typed boundary for a host-managed isolated website reader. The service URL is
+ * trusted host configuration; public destination validation stays in the reader. */
+export type WebsiteServiceResult = Record<string, unknown> & {
+    status: "ok" | "partial" | "error";
+    text: string;
+    limitations?: string[];
+    sources?: {
+        url: string;
+        title?: string;
+        citation?: string;
+    }[];
+};
+export declare const parseWebsiteServiceResult: (value: unknown) => WebsiteServiceResult;
+export declare const createWebsiteReaderClient: (options: {
+    endpoint: string;
+    fetch?: typeof fetch;
+    timeoutMs?: number;
+    fallbackReserveMs?: number;
+    fallback: (input: {
+        url: string;
+        maxPages: number;
+        mode: "auto" | "browser";
+        signal: AbortSignal;
+    }) => Promise<WebsiteServiceResult>;
+}) => (input: {
+    url: string;
+    maxPages?: number;
+    mode?: "auto" | "browser";
+    signal?: AbortSignal;
+}) => Promise<WebsiteServiceResult>;

package/dist/svelte/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/svelte/createRAGChunkPreview.ts
 import { derived, writable } from "svelte/store";
 
@@ -4983,6 +5130,20 @@ var createRAG = (path, options = {}) => {
     workflow
   };
 };
+// src/svelte/createResearch.ts
+import { readable as readable2 } from "svelte/store";
+var createResearchStore = (path = "/research") => {
+  const client = createResearchClient({ path });
+  const state = readable2(client.getSnapshot(), (set) => {
+    set(client.getSnapshot());
+    const unsubscribe = client.subscribe(() => set(client.getSnapshot()));
+    return () => {
+      unsubscribe();
+      client.cancel();
+    };
+  });
+  return { ...client, state };
+};
 export {
   createRAG,
   createRAGChunkPreview,
@@ -4998,8 +5159,9 @@ export {
   createRAGStatus,
   createRAGStream,
   createRAGStreamProgress,
-  createRAGWorkflow
+  createRAGWorkflow,
+  createResearchStore
 };
 
-//# debugId=404BF31250240B0064756E2164756E21
+//# debugId=C9A33C19D3BE985B64756E2164756E21
 //# sourceMappingURL=index.js.map