@absolutejs/rag 0.22.12 → 0.22.14

package/dist/research/index.js

@@ -114902,15 +114902,18 @@ import {
 import { lookup } from "dns/promises";
 import { isIP } from "net";
 import { brotliDecompressSync, gunzipSync, inflateSync } from "zlib";
+var WEB_READ_ERROR = Symbol.for("@absolutejs/rag/WebReadError");
 
 class WebReadError extends Error {
   code;
+  [WEB_READ_ERROR] = true;
   constructor(code, message) {
     super(message);
     this.code = code;
     this.name = "WebReadError";
   }
 }
+var isWebReadError = (error) => error instanceof Error && Reflect.get(error, WEB_READ_ERROR) === true && typeof Reflect.get(error, "code") === "string";
 var isPublicWebAddress = (address) => isPublicNetworkAddress(address);
 var validatePublicWebUrl = (raw) => {
   let url;
@@ -121780,7 +121783,7 @@ var createWebpageReaderClient = (options) => {
     });
     if (result.status === "error") {
       const error = result.error;
-      throw new Error(error?.message ?? "Isolated page read failed");
+      throw new WebReadError(error?.code ?? "reader_unavailable", error?.message ?? "Isolated page read failed");
     }
     const documents = result.documents;
     const sources = result.sources;
@@ -121814,7 +121817,7 @@ var createWebpageReaderClient = (options) => {
 
 // src/web/index.ts
 var messageFor = (error) => error instanceof Error ? error.message : "Website retrieval failed.";
-var codeFor = (error) => error instanceof WebReadError ? error.code : error instanceof Error && /^(?:AbortError|TimeoutError)$/u.test(error.name) ? "timeout" : "fetch_failed";
+var codeFor = (error) => isWebReadError(error) ? error.code : error instanceof Error && /^(?:AbortError|TimeoutError)$/u.test(error.name) ? "timeout" : "fetch_failed";
 var cleanHtml = websiteHtmlText;
 var titleOf = (html) => {
   const title = /<title\b[^>]*>([\s\S]*?)<\/title>/iu.exec(html)?.[1];
@@ -121861,7 +121864,7 @@ var readRAGWebpage = async (options) => {
       response = await (options.fetchResource ?? fetchPublicWebResource)(options.url, { signal, maxBytes: 5000000 });
     } catch (error) {
       attempts.push({ method: "http", status: codeFor(error) });
-      if (error instanceof WebReadError && error.code === "blocked_url")
+      if (isWebReadError(error) && error.code === "blocked_url")
         throw error;
       if (!options.render)
         throw error;
@@ -122119,6 +122122,8 @@ var createResearch = (config) => {
   const extract = async (task, input) => {
     if (!input.query.trim() || input.query.length > 8000)
       throw new Error("Research query must contain 1\u20138000 characters");
+    if (task.collection && (!/^\/(?:[^~]|~[01])+$/.test(task.collection.path) || !Number.isSafeInteger(task.collection.minimum) || task.collection.minimum < 1 || !task.collection.requiredFields.length || task.collection.requiredFields.some((key) => !key || key.includes("/"))))
+      throw new Error("Invalid research collection requirement");
     const signal = AbortSignal.any([
       AbortSignal.timeout(limits.timeoutMs),
       ...input.signal ? [input.signal] : []
@@ -122132,7 +122137,14 @@ var createResearch = (config) => {
       searches: [],
       limitations: [],
       generatedAt: new Date().toISOString(),
-      operations: []
+      operations: [],
+      ...task.collection ? {
+        coverage: {
+          requested: task.collection.minimum,
+          supported: 0,
+          complete: false
+        }
+      } : {}
     };
     const operationLimit = limits.searches + limits.reads + limits.rounds + 2 + 2 * validationRepairs;
     const operate = async (kind, call, usage = () => ({})) => {
@@ -122305,16 +122317,68 @@ Correct the previous schema-invalid response using the validation diagnostics. T
       if (!discoveredLinks.has(url) && !result.searches.some((search) => search.sources.some((source) => source.url === url)))
         return;
       urls.add(url);
-      const page = await operate("read", () => (config.reader ?? readRAGWebpage)({
-        url,
-        signal,
-        render: config.render,
-        maxChars: Math.min(limits.evidenceChars, 24000)
-      }));
+      const page = await operate("read", async () => {
+        try {
+          return await (config.reader ?? readRAGWebpage)({
+            url,
+            signal,
+            render: config.render,
+            maxChars: Math.min(limits.evidenceChars, 24000)
+          });
+        } catch (error) {
+          signal.throwIfAborted();
+          const messages = {
+            access_blocked: "Website blocked automated access",
+            authentication_required: "Page requires sign-in",
+            http_error: "Page returned an HTTP error",
+            reader_unavailable: "Website reader unavailable",
+            fetch_failed: "Page could not be retrieved",
+            timeout: "Page retrieval timed out"
+          };
+          if (!isWebReadError(error) || !messages[error.code])
+            throw error;
+          return {
+            status: "error",
+            url,
+            finalUrl: url,
+            title: null,
+            text: "",
+            method: "http",
+            truncated: false,
+            attempts: [],
+            fetchedAt: new Date().toISOString(),
+            redirects: [],
+            evidence: { links: [], images: [], media: [], canonicalUrl: null },
+            limitations: [],
+            error: { code: error.code, message: messages[error.code] }
+          };
+        }
+      });
+      if (page.status === "error") {
+        const code = page.error?.code ?? "read_failed";
+        if ([
+          "unsafe_url",
+          "blocked_address",
+          "blocked_url",
+          "invalid_url"
+        ].includes(code))
+          throw new WebReadError(code, "Unsafe research source URL");
+        const message = "Source unavailable (" + code + ")";
+        (result.sourceFailures ??= []).push({ url, code, message });
+        result.limitations.push(`${message}: ${url}`);
+        try {
+          config.onError?.({
+            runId: result.id,
+            phase: "read",
+            error: new WebReadError(code, message)
+          });
+        } catch {}
+        return;
+      }
       result.limitations.push(...page.limitations);
       if (page.status !== "ok")
         result.limitations.push(`Page read ${page.status}: ${url}`);
-      if (page.text && page.status !== "error") {
+      if (page.text) {
         for (const link of page.evidence.links) {
           if (discoveredLinks.size >= 64)
             break;
@@ -122351,7 +122415,7 @@ Correct the previous schema-invalid response using the validation diagnostics. T
     try {
       const needsInitialPlan = !input.queries && (input.queryMode === "task" || boundedQueries(input.query).length > 1) && limits.rounds > 0;
       if (needsInitialPlan) {
-        const initial = await generate("plan", PlanSchema, "Turn the research task into concise search-engine queries. Preserve the requested company identity and target criteria, but never copy instructions, JSON, internal markers, or the whole brief into a query. Prioritize the most useful query first. Return at most remainingSearches queries. Return no URLs: source URLs must be discovered rather than invented.", {
+        const initial = await generate("plan", PlanSchema, "Turn the research task into concise search-engine queries. Search for the requested answer entities, not merely the client named in the brief. For new partners, pursue external candidate companies across the requested categories; client background and existing partnerships do not fulfill that task.  Preserve the requested company identity and target criteria, but never copy instructions, JSON, internal markers, or the whole brief into a query. Prioritize the most useful query first. Return at most remainingSearches queries. Return no URLs: source URLs must be discovered rather than invented.", {
           query: input.query,
           instructions: task.instructions,
           remainingSearches: limits.searches
@@ -122417,12 +122481,32 @@ Correct the previous schema-invalid response using the validation diagnostics. T
         instructions: task.instructions,
         schema: task.schema,
         fields: leaves,
-        sources: reviewSources
+        sources: reviewSources.map(({ passages, ...source }) => ({
+          ...source,
+          passages: passages.map(({ id, text }) => ({ id, text }))
+        }))
       });
       result.fields = bindResearchReview(leaves, reviewed.fields.map((field) => ({
         ...field,
         citations: resolveResearchPassages(field.citations, reviewSources)
       })), result.sources);
+      if (task.collection) {
+        const { path, minimum, requiredFields } = task.collection;
+        const indices = new Set(result.fields.flatMap((field) => {
+          if (!field.path.startsWith(path + "/"))
+            return [];
+          const index = field.path.slice(path.length + 1).split("/")[0];
+          return /^\d+$/.test(index) ? [index] : [];
+        }));
+        const supported = [...indices].filter((index) => requiredFields.every((key) => result.fields.some((field) => field.path === `${path}/${index}/${key}` && field.verdict === "supported" && field.value !== null && field.value !== ""))).length;
+        result.coverage = {
+          requested: minimum,
+          supported,
+          complete: supported >= minimum
+        };
+        if (!result.coverage.complete)
+          result.limitations.push(`Requested ${minimum} evidence-backed items; established ${supported}.`);
+      }
       const complete = result.fields.length > 0 && result.fields.every((field) => field.verdict === "supported");
       result.data = complete ? data : null;
       result.status = complete && !result.limitations.length ? "reviewed" : "partial";
@@ -123298,5 +123382,5 @@ export {
   selectResearchMonitorEvents
 };
 
-//# debugId=A230972C656C21A464756E2164756E21
+//# debugId=7CFBFAA05587CF8964756E2164756E21
 //# sourceMappingURL=index.js.map