@claritylabs/cl-sdk 3.1.16 → 3.1.18

package/dist/index.mjs

@@ -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.
@@ -9355,6 +9368,9 @@ function normalizedTermText(term) {
 function isLimitTerm(term) {
   return ["each_claim_limit", "each_occurrence_limit", "each_loss_limit", "aggregate_limit", "sublimit"].includes(term.kind) || term.kind === "other" && /\b(limit|aggregate|claim|occurrence|loss|proceeding)\b/i.test(normalizedTermText(term));
 }
+function isPrimaryLimitTerm(term) {
+  return ["each_claim_limit", "each_occurrence_limit", "each_loss_limit", "aggregate_limit"].includes(term.kind);
+}
 function isDeductibleTerm(term) {
   return term.kind === "deductible" || term.kind === "retention" || /\b(deductible|retention|sir)\b/i.test(normalizedTermText(term));
 }
@@ -9364,8 +9380,41 @@ function isPremiumTerm(term) {
 function isRetroactiveDateTerm(term) {
   return term.kind === "retroactive_date" || /\bretroactive\b/i.test(normalizedTermText(term));
 }
+function fallbackLimitScope(kind) {
+  switch (kind) {
+    case "each_claim_limit":
+      return "Each Claim";
+    case "each_occurrence_limit":
+      return "Each Occurrence";
+    case "each_loss_limit":
+      return "Each Loss";
+    case "aggregate_limit":
+      return "Aggregate";
+    case "sublimit":
+      return "Sub-Limit";
+    default:
+      return void 0;
+  }
+}
+function displayLabelForLimitTerm(term) {
+  const label = cleanProfileValue(term.label)?.replace(/\s+Limit$/i, "");
+  if (label && !/^(?:limit|amount|value)$/i.test(label)) return label;
+  return fallbackLimitScope(term.kind);
+}
+function displayValueForLimitTerm(term) {
+  const value = cleanProfileValue(term.value);
+  if (!value) return void 0;
+  if (/\b(each|aggregate|occurrence|claim|loss|proceeding|policy|sublimit|sub-limit)\b/i.test(value)) {
+    return value;
+  }
+  const label = displayLabelForLimitTerm(term);
+  return label ? `${value} ${label}` : value;
+}
 function primaryLimitFromTerms(terms) {
-  return terms.find(isLimitTerm)?.value;
+  const primaryTerms = terms.filter(isPrimaryLimitTerm);
+  const candidateTerms = primaryTerms.length > 0 ? primaryTerms : terms.filter(isLimitTerm);
+  const values = uniqueStrings(candidateTerms.map((term) => displayValueForLimitTerm(term)).filter((value) => Boolean(value)));
+  return values.length > 0 ? values.join(" / ") : void 0;
 }
 function deductibleFromTerms(terms) {
   return terms.find(isDeductibleTerm)?.value;
@@ -9376,6 +9425,13 @@ function premiumFromTerms(terms) {
 function retroactiveDateFromTerms(terms) {
   return terms.find(isRetroactiveDateTerm)?.value;
 }
+function shouldUseTermLimitDisplay(currentLimit, termLimit) {
+  const current = cleanProfileValue(currentLimit);
+  if (!current) return true;
+  if (/\s+\/\s*$/.test(current)) return true;
+  if (!/\b(each|aggregate|occurrence|claim|loss|proceeding|policy|sublimit|sub-limit)\b/i.test(current)) return true;
+  return !current.includes("/") && termLimit.includes("/");
+}
 function termDecisionTouches(coverage, decision, predicate) {
   const existing = coverage.limits[decision.termIndex];
   if (existing && predicate(existing)) return true;
@@ -9470,6 +9526,10 @@ function applyCoverageCleanupDecision(coverage, decision, validNodeIds, validSpa
       else delete next.retroactiveDate;
     }
   }
+  const termLimit = primaryLimitFromTerms(next.limits);
+  if (termLimit && shouldUseTermLimitDisplay(next.limit, termLimit)) {
+    next.limit = termLimit;
+  }
   next.sourceNodeIds = uniqueStrings([
     ...next.sourceNodeIds,
     ...next.limits.flatMap((term) => term.sourceNodeIds)
@@ -11329,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);
@@ -11343,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,
@@ -11356,20 +11417,38 @@ async function runVisualTableRepair(params) {
           log: params.log
         }
       );
-      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 };
 }
@@ -11466,6 +11545,32 @@ var NORMALIZED_COMPATIBILITY_FIELDS = /* @__PURE__ */ new Set([
   "insurer",
   "broker"
 ]);
+function coverageBelongsToEndorsementCleanupChunk(coverage) {
+  return coverage.coverageOrigin === "endorsement" || Boolean(coverage.endorsementNumber);
+}
+function coverageCleanupChunks(profile) {
+  const basePolicy = [];
+  const endorsements = [];
+  profile.coverages.forEach((coverage, coverageIndex) => {
+    if (coverageBelongsToEndorsementCleanupChunk(coverage)) {
+      endorsements.push(coverageIndex);
+    } else {
+      basePolicy.push(coverageIndex);
+    }
+  });
+  return [
+    basePolicy.length ? {
+      group: "base_policy",
+      label: "Coverage cleanup: base policy",
+      coverageIndexes: basePolicy
+    } : void 0,
+    endorsements.length ? {
+      group: "endorsements",
+      label: "Coverage cleanup: endorsements",
+      coverageIndexes: endorsements
+    } : void 0
+  ].filter((chunk) => Boolean(chunk));
+}
 function valueOf(profile, key) {
   const value = profile[key];
   if (!value || typeof value !== "object" || Array.isArray(value) || !("value" in value)) return void 0;
@@ -11622,9 +11727,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(
@@ -11634,20 +11739,37 @@ 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
           }
         );
-        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) {
@@ -11736,33 +11858,64 @@ async function runSourceTreeExtraction(params) {
     try {
       const validNodeIds = new Set(sourceTree.map((node) => node.id));
       const validSpanIds = new Set(sourceSpans.map((span) => span.id));
-      const budget = params.resolveBudget("extraction_coverage_cleanup", 4096);
-      const startedAt = Date.now();
-      const response = await safeGenerateObject(
-        params.generateObject,
-        {
-          prompt: buildOperationalProfileCleanupPrompt(sourceTree, operationalProfile),
-          schema: OperationalProfileCleanupSchema,
-          maxTokens: budget.maxTokens,
+      const chunks = coverageCleanupChunks(operationalProfile);
+      if (chunks.length > 1) {
+        await params.log?.(`Operational profile coverage cleanup reviewing ${chunks.length} coverage groups in parallel`);
+      }
+      const cleanupResults = await Promise.all(chunks.map(async (chunk, batchIndex) => {
+        const budget = params.resolveBudget("extraction_coverage_cleanup", 4096);
+        const startedAt = Date.now();
+        const response = await safeGenerateObject(
+          params.generateObject,
+          {
+            prompt: buildOperationalProfileCleanupPrompt(sourceTree, operationalProfile, {
+              coverageIndexes: chunk.coverageIndexes,
+              label: chunk.label
+            }),
+            schema: OperationalProfileCleanupSchema,
+            maxTokens: budget.maxTokens,
+            taskKind: "extraction_coverage_cleanup",
+            budgetDiagnostics: budget,
+            providerOptions: params.providerOptions,
+            trace: {
+              phase: "coverage_cleanup",
+              label: chunk.label,
+              batchIndex: batchIndex + 1,
+              batchCount: chunks.length,
+              coverageGroup: chunk.group,
+              itemCount: chunk.coverageIndexes.length,
+              sourceBacked: true
+            }
+          },
+          {
+            fallback: { coverageDecisions: [], warnings: [] },
+            maxRetries: 0,
+            log: params.log
+          }
+        );
+        return {
+          batchIndex,
+          chunk,
+          budget,
+          durationMs: Date.now() - startedAt,
+          usage: response.usage,
+          cleanup: response.object
+        };
+      }));
+      const cleanup = { coverageDecisions: [], warnings: [] };
+      for (const result of cleanupResults.sort((left, right) => left.batchIndex - right.batchIndex)) {
+        localTrack(result.usage, {
           taskKind: "extraction_coverage_cleanup",
-          budgetDiagnostics: budget,
-          providerOptions: params.providerOptions,
-          trace: { phase: "coverage_cleanup", sourceBacked: true }
-        },
-        {
-          fallback: { coverageDecisions: [], warnings: [] },
-          log: params.log
-        }
-      );
-      localTrack(response.usage, {
-        taskKind: "extraction_coverage_cleanup",
-        label: "operational_profile_cleanup",
-        maxTokens: budget.maxTokens,
-        durationMs: Date.now() - startedAt
-      });
+          label: result.chunk.label,
+          maxTokens: result.budget.maxTokens,
+          durationMs: result.durationMs
+        });
+        cleanup.coverageDecisions.push(...result.cleanup.coverageDecisions);
+        cleanup.warnings.push(...result.cleanup.warnings);
+      }
       operationalProfile = applyOperationalProfileCleanup(
         operationalProfile,
-        response.object,
+        cleanup,
         validNodeIds,
         validSpanIds
       );
@@ -11816,6 +11969,7 @@ function createExtractor(config) {
     sourceStore,
     qualityGate = "warn",
     modelCapabilities,
+    modelCapabilitiesByTaskKind,
     modelBudgetConstraints,
     onCheckpointSave
   } = config;
@@ -11832,10 +11986,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]
     });
   }