@claritylabs/cl-sdk 3.1.17 → 3.1.19

package/dist/index.mjs

@@ -20,17 +20,19 @@ function isRetryableError(error) {
   }
   return false;
 }
-async function withRetry(fn, log) {
+async function withRetry(fn, log, options) {
+  const maxRetries = options?.maxRetries ?? MAX_RETRIES;
+  const baseDelayMs = options?.baseDelayMs ?? BASE_DELAY_MS;
   for (let attempt = 0; ; attempt++) {
     try {
       return await fn();
     } catch (error) {
-      if (!isRetryableError(error) || attempt >= MAX_RETRIES) {
+      if (!isRetryableError(error) || attempt >= maxRetries) {
         throw error;
       }
       const jitter = Math.random() * 1e3;
-      const delay = BASE_DELAY_MS * Math.pow(2, attempt) + jitter;
-      await log?.(`Retryable error, retrying in ${(delay / 1e3).toFixed(1)}s (attempt ${attempt + 1}/${MAX_RETRIES})...`);
+      const delay = baseDelayMs * Math.pow(2, attempt) + jitter;
+      await log?.(`Retryable error, retrying in ${(delay / 1e3).toFixed(1)}s (attempt ${attempt + 1}/${maxRetries})...`);
       await new Promise((resolve) => setTimeout(resolve, delay));
     }
   }
@@ -157,10 +159,8 @@ async function safeGenerateObject(generateObject, params, options) {
   const strictParams = { ...params, schema: toStrictSchema(params.schema) };
   for (let attempt = 0; attempt <= maxRetries; attempt++) {
     try {
-      const result = await withRetry(
-        () => generateObject(strictParams),
-        options?.log
-      );
+      const generate = () => generateObject(strictParams);
+      const result = options?.retry === false ? await generate() : await withRetry(generate, options?.log, options?.retry);
       return {
         ...result,
         object: params.schema.parse(sanitizeNulls(result.object))
@@ -9210,11 +9210,20 @@ function coverageTextForSelection(coverage) {
     ])
   ].filter(Boolean).join(" ");
 }
+function coverageCleanupEntries(profile, coverageIndexes) {
+  if (!coverageIndexes) {
+    return profile.coverages.map((coverage, coverageIndex) => ({ coverage, coverageIndex }));
+  }
+  return [...new Set(coverageIndexes)].sort((left, right) => left - right).map((coverageIndex) => {
+    const coverage = profile.coverages[coverageIndex];
+    return coverage ? { coverage, coverageIndex } : void 0;
+  }).filter((entry) => Boolean(entry));
+}
 function nodeTextMatchesCoverage(node, coverageTerms) {
   const text = nodeTextForSelection(node).toLowerCase();
   return coverageTerms.some((term) => term.length >= 5 && text.includes(term));
 }
-function selectCoverageCleanupNodes(sourceTree, profile) {
+function selectCoverageCleanupNodes(sourceTree, coverages) {
   const nodeById = new Map(sourceTree.map((node) => [node.id, node]));
   const childrenByParent = /* @__PURE__ */ new Map();
   for (const node of sourceTree) {
@@ -9232,12 +9241,12 @@ function selectCoverageCleanupNodes(sourceTree, profile) {
     const current = selected.get(node.id);
     if (!current || score > current.score) selected.set(node.id, { node, score });
   };
-  const sourceNodeIds = uniqueStrings(profile.coverages.flatMap((coverage) => [
+  const sourceNodeIds = uniqueStrings(coverages.flatMap((coverage) => [
     ...coverage.sourceNodeIds,
     ...coverage.limits.flatMap((term) => term.sourceNodeIds)
   ]));
   const coveragePages2 = /* @__PURE__ */ new Set();
-  const coverageTerms = uniqueStrings(profile.coverages.flatMap(
+  const coverageTerms = uniqueStrings(coverages.flatMap(
     (coverage) => coverageTextForSelection(coverage).toLowerCase().split(/[^a-z0-9$,.]+/i).filter((part) => part.length >= 5)
   ));
   for (const id of sourceNodeIds) {
@@ -9280,8 +9289,9 @@ function selectCoverageCleanupNodes(sourceTree, profile) {
     (left, right) => (left.node.pageStart ?? Number.MAX_SAFE_INTEGER) - (right.node.pageStart ?? Number.MAX_SAFE_INTEGER) || left.node.order - right.node.order
   ).map((entry) => entry.node);
 }
-function buildOperationalProfileCleanupPrompt(sourceTree, profile) {
-  const nodes = selectCoverageCleanupNodes(sourceTree, profile).map((node) => compactNode(
+function buildOperationalProfileCleanupPrompt(sourceTree, profile, options = {}) {
+  const coverageEntries = coverageCleanupEntries(profile, options.coverageIndexes);
+  const nodes = selectCoverageCleanupNodes(sourceTree, coverageEntries.map((entry) => entry.coverage)).map((node) => compactNode(
     node,
     node.kind === "page" || node.kind === "page_group" ? 260 : node.kind === "table_row" || node.kind === "table_cell" ? 520 : 360
   ));
@@ -9289,9 +9299,12 @@ function buildOperationalProfileCleanupPrompt(sourceTree, profile) {
     documentType: profile.documentType,
     policyTypes: profile.policyTypes,
     coverageTypes: profile.coverageTypes,
-    coverages: profile.coverages.map(compactCoverageForCleanup)
+    coverages: coverageEntries.map(({ coverage, coverageIndex }) => compactCoverageForCleanup(coverage, coverageIndex))
   };
   return `Review and clean a source-backed operational profile projection for an insurance policy.
+${options.label ? `
+Coverage group: ${options.label}
+` : ""}
 
 Task:
 - Inspect the candidate coverage projection against the source nodes.
@@ -11376,7 +11389,8 @@ async function runVisualTableRepair(params) {
   if (candidates.length === 0) return { sourceTree: params.sourceTree, warnings: [] };
   let sourceTree = params.sourceTree;
   const warnings = [];
-  for (const [index, candidate] of candidates.entries()) {
+  const repairResults = await Promise.all(candidates.map(async (candidate, index) => {
+    const label = `source_tree_visual_table_repair_p${candidate.page}`;
     try {
       const budget = params.resolveBudget("extraction_source_tree", 1800);
       const maxTokens = Math.min(budget.maxTokens, 2400);
@@ -11390,7 +11404,7 @@ async function runVisualTableRepair(params) {
           taskKind: "extraction_source_tree",
           budgetDiagnostics: { ...budget, maxTokens },
           trace: {
-            label: `source_tree_visual_table_repair_p${candidate.page}`,
+            label,
             startPage: candidate.page,
             endPage: candidate.page,
             batchIndex: index + 1,
@@ -11400,23 +11414,43 @@ async function runVisualTableRepair(params) {
         },
         {
           fallback: { tables: [], warnings: [] },
-          log: params.log
+          maxRetries: 0,
+          log: params.log,
+          retry: false
         }
       );
-      params.trackUsage(response.usage, {
-        taskKind: "extraction_source_tree",
-        label: `source_tree_visual_table_repair_p${candidate.page}`,
+      return {
+        index,
+        candidate,
+        label,
         maxTokens,
-        durationMs: Date.now() - startedAt
-      });
-      const repair = response.object;
-      sourceTree = applyVisualTableRepair(sourceTree, repair);
-      warnings.push(...repair.warnings.map(
-        (warning) => `Visual table repair warning on page ${candidate.page}: ${warning}`
-      ));
+        durationMs: Date.now() - startedAt,
+        usage: response.usage,
+        repair: response.object
+      };
     } catch (error) {
-      warnings.push(`Visual table repair skipped on page ${candidate.page}; parsed table kept (${error instanceof Error ? error.message : String(error)})`);
+      return {
+        index,
+        candidate,
+        error: error instanceof Error ? error.message : String(error)
+      };
     }
+  }));
+  for (const result of repairResults.sort((left, right) => left.index - right.index)) {
+    if ("error" in result) {
+      warnings.push(`Visual table repair skipped on page ${result.candidate.page}; parsed table kept (${result.error})`);
+      continue;
+    }
+    params.trackUsage(result.usage, {
+      taskKind: "extraction_source_tree",
+      label: result.label,
+      maxTokens: result.maxTokens,
+      durationMs: result.durationMs
+    });
+    sourceTree = applyVisualTableRepair(sourceTree, result.repair);
+    warnings.push(...result.repair.warnings.map(
+      (warning) => `Visual table repair warning on page ${result.candidate.page}: ${warning}`
+    ));
   }
   return { sourceTree, warnings };
 }
@@ -11669,9 +11703,9 @@ async function runSourceTreeExtraction(params) {
   };
   if (shouldRunSourceTreeOrganizer(sourceTree, sourceSpans)) {
     try {
-      const organizations = [];
       const batches = organizationBatches(sourceTree);
-      for (const [batchIndex, batch] of batches.entries()) {
+      const organizationResults = await Promise.all(batches.map(async (batch, batchIndex) => {
+        const label = batches.length > 1 ? `source_tree_organizer_${batchIndex + 1}` : "source_tree_organizer";
         const budget = params.resolveBudget("extraction_source_tree", 4096);
         const startedAt = Date.now();
         const response = await safeGenerateObject(
@@ -11681,20 +11715,39 @@ async function runSourceTreeExtraction(params) {
             schema: SourceTreeOrganizationSchema,
             maxTokens: budget.maxTokens,
             taskKind: "extraction_source_tree",
-            budgetDiagnostics: budget
+            budgetDiagnostics: budget,
+            trace: {
+              label,
+              batchIndex: batchIndex + 1,
+              batchCount: batches.length,
+              sourceBacked: true
+            }
           },
           {
             fallback: { labels: [], groups: [] },
-            log: params.log
+            maxRetries: 0,
+            log: params.log,
+            retry: false
           }
         );
-        localTrack(response.usage, {
+        return {
+          batchIndex,
+          label,
+          budget,
+          durationMs: Date.now() - startedAt,
+          usage: response.usage,
+          organization: response.object
+        };
+      }));
+      const organizations = [];
+      for (const result of organizationResults.sort((left, right) => left.batchIndex - right.batchIndex)) {
+        localTrack(result.usage, {
           taskKind: "extraction_source_tree",
-          label: batches.length > 1 ? `source_tree_organizer_${batchIndex + 1}` : "source_tree_organizer",
-          maxTokens: budget.maxTokens,
-          durationMs: Date.now() - startedAt
+          label: result.label,
+          maxTokens: result.budget.maxTokens,
+          durationMs: result.durationMs
         });
-        organizations.push(response.object);
+        organizations.push(result.organization);
       }
       sourceTree = applyOrganization(sourceTree, mergeOrganizationResults(organizations));
     } catch (error) {
@@ -11719,7 +11772,9 @@ async function runSourceTreeExtraction(params) {
         },
         {
           fallback: { labels: [], groups: [] },
-          log: params.log
+          maxRetries: 0,
+          log: params.log,
+          retry: false
         }
       );
       localTrack(response.usage, {
@@ -11761,7 +11816,9 @@ async function runSourceTreeExtraction(params) {
       },
       {
         fallback: emptyProfile,
-        log: params.log
+        maxRetries: 0,
+        log: params.log,
+        retry: false
       }
     );
     localTrack(response.usage, {
@@ -11794,16 +11851,23 @@ async function runSourceTreeExtraction(params) {
           taskKind: "extraction_coverage_cleanup",
           budgetDiagnostics: budget,
           providerOptions: params.providerOptions,
-          trace: { phase: "coverage_cleanup", sourceBacked: true }
+          trace: {
+            phase: "coverage_cleanup",
+            label: "Coverage cleanup",
+            itemCount: operationalProfile.coverages.length,
+            sourceBacked: true
+          }
         },
         {
           fallback: { coverageDecisions: [], warnings: [] },
-          log: params.log
+          maxRetries: 0,
+          log: params.log,
+          retry: false
         }
       );
       localTrack(response.usage, {
         taskKind: "extraction_coverage_cleanup",
-        label: "operational_profile_cleanup",
+        label: "coverage_cleanup",
         maxTokens: budget.maxTokens,
         durationMs: Date.now() - startedAt
       });
@@ -11863,6 +11927,7 @@ function createExtractor(config) {
     sourceStore,
     qualityGate = "warn",
     modelCapabilities,
+    modelCapabilitiesByTaskKind,
     modelBudgetConstraints,
     onCheckpointSave
   } = config;
@@ -11879,10 +11944,11 @@ function createExtractor(config) {
   };
   let activeProviderOptions = providerOptions;
   function resolveBudget(taskKind, hintTokens) {
+    const taskModelCapabilities = modelCapabilitiesByTaskKind?.[taskKind] ?? modelCapabilities;
     return resolveModelBudget({
       taskKind,
       hintTokens,
-      modelCapabilities,
+      modelCapabilities: taskModelCapabilities,
       constraint: modelBudgetConstraints?.[taskKind]
     });
   }
@@ -12205,7 +12271,9 @@ ${sourceText}`;
           },
           {
             fallback: { forms: [] },
+            maxRetries: 0,
             log,
+            retry: false,
             onError: (err, attempt) => log?.(`Form inventory attempt ${attempt + 1} failed: ${err instanceof Error ? err.message : String(err)}`)
           }
         );