@absolutejs/rag 0.22.12 → 0.22.13

package/dist/web-index/index.js

@@ -123063,7 +123063,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;
@@ -123402,6 +123402,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] : []
@@ -123415,7 +123417,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 = () => ({})) => {
@@ -123588,16 +123597,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 (!(error instanceof WebReadError) || !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;
@@ -123634,7 +123695,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
@@ -123700,12 +123761,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";
@@ -123837,5 +123918,5 @@ export {
   webIndexPostgresSchemaSql
 };
 
-//# debugId=4D7B2DFFF0C94C4C64756E2164756E21
+//# debugId=7BD42C26110FB33364756E2164756E21
 //# sourceMappingURL=index.js.map