@claritylabs/cl-sdk 3.2.11 → 3.2.12

package/dist/index.mjs

@@ -334,6 +334,10 @@ var PolicyTypeSchema = z2.enum([
   "watercraft",
   "recreational_vehicle",
   "farm_ranch",
+  "life",
+  "critical_illness",
+  "disability",
+  "long_term_care",
   "pet",
   "travel",
   "identity_theft",
@@ -2139,6 +2143,179 @@ var PolicyOperationalProfileSchema = z20.object({
   warnings: z20.array(z20.string()).default([])
 });
 
+// src/source/policy-types.ts
+var POLICY_TYPE_KEYS = new Set(POLICY_TYPES);
+var POLICY_TYPE_ALIASES = {
+  "general liability": "general_liability",
+  "commercial general liability": "general_liability",
+  cgl: "general_liability",
+  "commercial property": "commercial_property",
+  property: "property",
+  "property insurance": "commercial_property",
+  "commercial auto": "commercial_auto",
+  "commercial automobile": "commercial_auto",
+  "business auto": "commercial_auto",
+  "business automobile": "commercial_auto",
+  "auto physical damage": "commercial_auto",
+  "automobile physical damage": "commercial_auto",
+  "hired non owned auto": "non_owned_auto",
+  "hired non-owned auto": "non_owned_auto",
+  "non owned auto": "non_owned_auto",
+  "non-owned auto": "non_owned_auto",
+  "workers comp": "workers_comp",
+  "workers compensation": "workers_comp",
+  "workers' compensation": "workers_comp",
+  umbrella: "umbrella",
+  "excess liability": "excess_liability",
+  "professional liability": "professional_liability",
+  "errors and omissions": "professional_liability",
+  "e&o": "professional_liability",
+  cyber: "cyber",
+  "cyber liability": "cyber",
+  "network security": "cyber",
+  "privacy liability": "cyber",
+  epli: "epli",
+  "employment practices liability": "epli",
+  "directors and officers": "directors_officers",
+  "directors & officers": "directors_officers",
+  "d&o": "directors_officers",
+  "fiduciary liability insurance": "fiduciary_liability",
+  "crime insurance": "crime_fidelity",
+  "fidelity bond": "crime_fidelity",
+  "inland marine insurance": "inland_marine",
+  "motor truck cargo": "inland_marine",
+  "motor truck cargo legal liability": "inland_marine",
+  "builders risk insurance": "builders_risk",
+  "pollution liability": "environmental",
+  "premises pollution liability": "environmental",
+  "environmental liability": "environmental",
+  "ocean marine insurance": "ocean_marine",
+  "surety bond": "surety",
+  "product liability insurance": "product_liability",
+  "life insurance": "life",
+  "permanent life": "life",
+  "term life": "life",
+  "whole life": "life",
+  "universal life": "life",
+  "critical illness": "critical_illness",
+  "critical illness insurance": "critical_illness",
+  "disability insurance": "disability",
+  "long term care": "long_term_care",
+  "long-term care": "long_term_care"
+};
+var POLICY_TYPE_TEXT_PATTERNS = [
+  { type: "general_liability", pattern: /\b(?:commercial\s+)?general\s+liability\b|\bcgl\b/i },
+  { type: "commercial_property", pattern: /\bcommercial\s+property\b|\bproperty\s+insurance\b/i },
+  { type: "commercial_auto", pattern: /\bcommercial\s+auto(?:mobile)?\b|\bbusiness\s+auto(?:mobile)?\b|\bauto(?:mobile)?\s+physical\s+damage\b/i },
+  { type: "non_owned_auto", pattern: /\b(?:hired\s+(?:and\s+)?)?non[-\s]?owned\s+auto\b/i },
+  { type: "workers_comp", pattern: /\bworkers['’]?\s+comp(?:ensation)?\b/i },
+  { type: "umbrella", pattern: /\bcommercial\s+umbrella\b|\bumbrella\s+liability\b/i },
+  { type: "excess_liability", pattern: /\bexcess\s+liability\b/i },
+  { type: "professional_liability", pattern: /\bprofessional\s+liability\b|\berrors?\s*(?:and|&)\s*omissions?\b|\be&o\b/i },
+  { type: "cyber", pattern: /\bcyber\b|\bnetwork\s+security\b|\bprivacy\s+liability\b/i },
+  { type: "epli", pattern: /\bemployment\s+practices?\s+liability\b|\bepli\b/i },
+  { type: "directors_officers", pattern: /\bdirectors?\s*(?:and|&)\s*officers?\b|\bd&o\b/i },
+  { type: "fiduciary_liability", pattern: /\bfiduciary\s+liability\b/i },
+  { type: "crime_fidelity", pattern: /\bcrime\b|\bfidelity\b/i },
+  { type: "inland_marine", pattern: /\binland\s+marine\b|\bmotor\s+truck\s+cargo\b|\bcargo\s+legal\s+liability\b/i },
+  { type: "builders_risk", pattern: /\bbuilders?\s+risk\b/i },
+  { type: "environmental", pattern: /\bpollution\s+liability\b|\benvironmental\s+liability\b/i },
+  { type: "ocean_marine", pattern: /\bocean\s+marine\b/i },
+  { type: "surety", pattern: /\bsurety\b/i },
+  { type: "product_liability", pattern: /\bproduct\s+liability\b|\bproducts?\s+completed\s+operations\b/i },
+  { type: "bop", pattern: /\bbusiness\s*owners?\s+policy\b|\bbop\b/i },
+  { type: "homeowners_ho3", pattern: /\bhomeowners?\s*(?:ho[-\s]?3)?\b/i },
+  { type: "homeowners_ho5", pattern: /\bho[-\s]?5\b/i },
+  { type: "renters_ho4", pattern: /\brenters?\b|\bho[-\s]?4\b/i },
+  { type: "condo_ho6", pattern: /\bcondo(?:minium)?\b|\bho[-\s]?6\b/i },
+  { type: "dwelling_fire", pattern: /\bdwelling\s+fire\b/i },
+  { type: "personal_auto", pattern: /\bpersonal\s+auto\b/i },
+  { type: "personal_umbrella", pattern: /\bpersonal\s+umbrella\b/i },
+  { type: "flood_private", pattern: /\bflood\b/i },
+  { type: "earthquake", pattern: /\bearthquake\b/i },
+  { type: "personal_inland_marine", pattern: /\bpersonal\s+(?:articles|inland\s+marine)\b/i },
+  { type: "watercraft", pattern: /\bwatercraft\b|\bboat\s+insurance\b/i },
+  { type: "recreational_vehicle", pattern: /\brecreational\s+vehicle\b|\brv\s+insurance\b/i },
+  { type: "farm_ranch", pattern: /\bfarm\b|\branch\b/i },
+  { type: "life", pattern: /\blife\s+insurance\b|\bterm\s+life\b|\bwhole\s+life\b|\buniversal\s+life\b/i },
+  { type: "critical_illness", pattern: /\bcritical\s+illness\b/i },
+  { type: "disability", pattern: /\bdisability\s+insurance\b|\btotal\s+disability\b/i },
+  { type: "long_term_care", pattern: /\blong[-\s]?term\s+care\b/i },
+  { type: "pet", pattern: /\bpet\s+insurance\b/i },
+  { type: "travel", pattern: /\btravel\s+insurance\b/i },
+  { type: "identity_theft", pattern: /\bidentity\s+theft\b/i },
+  { type: "title", pattern: /\btitle\s+insurance\b/i }
+];
+var POLICY_TYPES_FROM_COVERAGES_WARNING = "Policy types augmented from extracted coverage labels.";
+function normalizeWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function normalizeOperationalPolicyTypes(values) {
+  const types = Array.isArray(values) ? values.filter((value) => typeof value === "string") : [];
+  const controlled = types.map((type) => type.trim().toLowerCase().replace(/\s+/g, " ")).map((type) => POLICY_TYPE_ALIASES[type] ?? type.replace(/[\s-]+/g, "_")).filter((type) => POLICY_TYPE_KEYS.has(type));
+  const unique = [...new Set(controlled)].slice(0, 6);
+  return unique.length ? unique : ["other"];
+}
+function hasSpecificPolicyType(types) {
+  return types.some((type) => type !== "other");
+}
+function policyTypesFromText(value) {
+  const text = normalizeWhitespace(value ?? "");
+  if (!text) return [];
+  const aliasType = POLICY_TYPE_ALIASES[text.toLowerCase()];
+  if (aliasType && POLICY_TYPE_KEYS.has(aliasType)) return [aliasType];
+  return POLICY_TYPE_TEXT_PATTERNS.filter(({ pattern }) => pattern.test(text)).map(({ type }) => type).filter((type) => POLICY_TYPE_KEYS.has(type));
+}
+function inferPolicyTypesFromOperationalCoverages(coverages) {
+  const inferred = [];
+  for (const coverage of coverages) {
+    const limits = coverage.limits ?? [];
+    const text = [
+      coverage.coverageCode,
+      coverage.formNumber,
+      coverage.name,
+      ...limits.flatMap((term) => [term.appliesTo, term.label])
+    ].filter((value) => typeof value === "string" && value.trim().length > 0);
+    for (const value of text) {
+      for (const type of policyTypesFromText(value)) {
+        if (!inferred.includes(type)) inferred.push(type);
+      }
+    }
+  }
+  return inferred.slice(0, 6);
+}
+function mergePolicyTypes(base, additions) {
+  const merged = [
+    ...base.filter((type) => type !== "other"),
+    ...additions.filter((type) => type !== "other")
+  ];
+  const unique = [...new Set(merged)].slice(0, 6);
+  return unique.length ? unique : base;
+}
+function resolveOperationalProfilePolicyTypes(params) {
+  const inferred = inferPolicyTypesFromOperationalCoverages(params.coverages ?? []);
+  const controlled = normalizeOperationalPolicyTypes(params.profileTypes);
+  if (hasSpecificPolicyType(controlled)) {
+    const policyTypes = mergePolicyTypes(controlled, inferred);
+    return {
+      policyTypes,
+      source: policyTypes.length > controlled.filter((type) => type !== "other").length ? "profile_augmented" : "profile"
+    };
+  }
+  const existingControlled = normalizeOperationalPolicyTypes(params.existingTypes);
+  if (hasSpecificPolicyType(existingControlled)) {
+    const policyTypes = mergePolicyTypes(existingControlled, inferred);
+    return {
+      policyTypes,
+      source: policyTypes.length > existingControlled.filter((type) => type !== "other").length ? "existing_augmented" : "existing"
+    };
+  }
+  if (inferred.length > 0) {
+    return { policyTypes: inferred, source: "inferred" };
+  }
+  return { policyTypes: controlled, source: "profile" };
+}
+
 // src/source/ids.ts
 function normalizeText(text) {
   return text.replace(/\s+/g, " ").trim();
@@ -2205,14 +2382,14 @@ function orderSourceEvidence(evidence) {
 }
 
 // src/source/extraction.ts
-function normalizeWhitespace(value) {
+function normalizeWhitespace2(value) {
   return value.replace(/\s+/g, " ").trim();
 }
 function sanitizeIdPart(value) {
   return value.replace(/[^a-zA-Z0-9_.:-]/g, "_");
 }
 function buildSourceSpan(input, localIndex = 0) {
-  const text = normalizeWhitespace(input.text);
+  const text = normalizeWhitespace2(input.text);
   const textHash = sourceSpanTextHash(text);
   const pagePart = input.pageStart ?? "na";
   const id = [
@@ -2247,7 +2424,7 @@ function buildSourceSpan(input, localIndex = 0) {
   });
 }
 function buildPageSourceSpans(pages) {
-  return pages.filter((page) => normalizeWhitespace(page.text).length > 0).map(
+  return pages.filter((page) => normalizeWhitespace2(page.text).length > 0).map(
     (page, index) => buildSourceSpan(
       {
         documentId: page.documentId,
@@ -2298,7 +2475,7 @@ function buildSectionSourceSpans(pages, options = {}) {
 function buildTextSourceSpans(input, options = {}) {
   const maxChars = options.maxChars ?? 4e3;
   const overlapChars = Math.min(options.overlapChars ?? 0, Math.max(0, maxChars - 1));
-  const text = normalizeWhitespace(input.text);
+  const text = normalizeWhitespace2(input.text);
   if (!text) return [];
   const spans = [];
   let cursor = 0;
@@ -2373,7 +2550,7 @@ function spanPage(span) {
 }
 function normalizeSourceSpanText(span) {
   const unit = sourceUnit(span);
-  const text = normalizeWhitespace(span.text);
+  const text = normalizeWhitespace2(span.text);
   if (!text) return void 0;
   if (isDiscardableBoilerplate(text, unit)) return void 0;
   const cleanedText = cleanBoilerplateLines(text);
@@ -2385,7 +2562,7 @@ function normalizeSourceSpanText(span) {
   });
 }
 function isDiscardableBoilerplate(text, unit) {
-  const cleaned = normalizeWhitespace(text.replace(/\bColumn\s+\d+:\s*/gi, ""));
+  const cleaned = normalizeWhitespace2(text.replace(/\bColumn\s+\d+:\s*/gi, ""));
   if (/^SPECIMEN POLICY\s+[-—]\s+FOR TESTING ONLY$/i.test(cleaned)) return true;
   if (/^Page\s+\d+\s+of\s+\d+$/i.test(cleaned)) return true;
   if (/^[A-Z]{2,}(?:-[A-Z0-9]{2,})+\s+\d{2}\s+\d{2}$/i.test(cleaned)) return true;
@@ -2394,24 +2571,24 @@ function isDiscardableBoilerplate(text, unit) {
   return false;
 }
 function isBoilerplateLine(line) {
-  const cleaned = normalizeWhitespace(line.replace(/\bColumn\s+\d+:\s*/gi, ""));
+  const cleaned = normalizeWhitespace2(line.replace(/\bColumn\s+\d+:\s*/gi, ""));
   return isDiscardableBoilerplate(cleaned) || /^THIS IS A CLAIMS-MADE AND REPORTED POLICY\.? PLEASE READ IT CAREFULLY\.?$/i.test(cleaned);
 }
 function removedBoilerplateLines(text) {
-  return text.split(/\s{2,}|\r?\n/).map(normalizeWhitespace).filter((line) => line && isBoilerplateLine(line));
+  return text.split(/\s{2,}|\r?\n/).map(normalizeWhitespace2).filter((line) => line && isBoilerplateLine(line));
 }
 function cleanBoilerplateLines(text) {
   const withoutInlineBoilerplate = text.replace(/\b(?:Column\s+\d+:\s*)?[A-Z]{2,}(?:-[A-Z0-9]{2,})+\s+\d{2}\s+\d{2}\s+(?:\|\s*)?(?:Column\s+\d+:\s*)?Page\s+\d+\s+of\s+\d+\b/gi, " ").replace(/\bSPECIMEN POLICY\s+[-—]\s+FOR TESTING ONLY\b/gi, " ").replace(/\bPage\s+\d+\s+of\s+\d+\b/gi, " ");
   const lines = withoutInlineBoilerplate.split(/\r?\n/);
-  const filtered = lines.map(normalizeWhitespace).filter((line) => line && !isBoilerplateLine(line));
-  return normalizeWhitespace(filtered.join(" "));
+  const filtered = lines.map(normalizeWhitespace2).filter((line) => line && !isBoilerplateLine(line));
+  return normalizeWhitespace2(filtered.join(" "));
 }
 function shouldMergeTextSpan(left, right) {
   if (sourceUnit(left) !== "text" || sourceUnit(right) !== "text") return false;
   if (spanPage(left) !== spanPage(right)) return false;
   if (left.metadata?.elementType === "title" || right.metadata?.elementType === "title") return false;
-  const leftText = normalizeWhitespace(left.text);
-  const rightText = normalizeWhitespace(right.text);
+  const leftText = normalizeWhitespace2(left.text);
+  const rightText = normalizeWhitespace2(right.text);
   if (!leftText || !rightText) return false;
   if (/[:.;!?)]$/.test(leftText)) return false;
   if (/^(?:[A-Z][A-Z0-9 &/(),.-]{8,}|Item\s+\d+|Section\s+\d+|Part\s+[A-Z]\b)/.test(rightText)) return false;
@@ -2432,7 +2609,7 @@ function mergeTextRuns(spans) {
   return result;
 }
 function mergeTextSpanPair(left, right) {
-  const text = normalizeWhitespace(`${left.text} ${right.text}`);
+  const text = normalizeWhitespace2(`${left.text} ${right.text}`);
   const merged = retextSpan(left, text, {
     mergedSourceSpanIds: [left.metadata?.mergedSourceSpanIds, left.id, right.id, right.metadata?.mergedSourceSpanIds].filter(Boolean).join(","),
     sourceSpanNormalization: "merged_text_run"
@@ -2484,7 +2661,7 @@ function splitPageIntoSections(text, headingPattern, minSectionChars) {
       if (current) sections.push(current);
       const suffix = match[1]?.trim();
       current = {
-        title: normalizeWhitespace(suffix ? `${line}` : line).slice(0, 120),
+        title: normalizeWhitespace2(suffix ? `${line}` : line).slice(0, 120),
         lines: [line]
       };
       continue;
@@ -2494,7 +2671,7 @@ function splitPageIntoSections(text, headingPattern, minSectionChars) {
   if (current) sections.push(current);
   return sections.map((section) => ({
     title: section.title,
-    text: normalizeWhitespace(section.lines.join("\n"))
+    text: normalizeWhitespace2(section.lines.join("\n"))
   })).filter((section) => section.text.length >= minSectionChars);
 }
 function inferFormNumber(text) {
@@ -2595,14 +2772,14 @@ function matchesFilters(span, filters) {
 }
 
 // src/source/tree.ts
-function normalizeWhitespace2(value) {
+function normalizeWhitespace3(value) {
   return value.replace(/\s+/g, " ").trim();
 }
 function sanitizeIdPart2(value) {
   return value.replace(/[^a-zA-Z0-9_.:-]/g, "_");
 }
 function truncate(value, maxChars) {
-  const text = normalizeWhitespace2(value);
+  const text = normalizeWhitespace3(value);
   return text.length > maxChars ? `${text.slice(0, maxChars).trimEnd()}...` : text;
 }
 function pageStart(span) {
@@ -2696,7 +2873,7 @@ function isTitleContentNode(node) {
   if (node.kind !== "text") return false;
   const isMarkedTitle = metadataString(node.metadata, "elementType") === "title" || metadataString(node.metadata, "sourceUnit") === "title";
   if (!isMarkedTitle) return false;
-  const text = normalizeWhitespace2(node.textExcerpt ?? node.title);
+  const text = normalizeWhitespace3(node.textExcerpt ?? node.title);
   if (!text || text.length > 140) return false;
   const words = text.split(/\s+/);
   if (words.length > 14) return false;
@@ -3371,12 +3548,12 @@ function shouldFailQualityGate(mode, status) {
 import { z as z22 } from "zod";
 
 // src/source/operational-profile.ts
-function normalizeWhitespace3(value) {
+function normalizeWhitespace4(value) {
   return value.replace(/\s+/g, " ").trim();
 }
 function cleanValue(value) {
   if (!value) return void 0;
-  return normalizeWhitespace3(value.replace(/^[\s:;#-]+|[\s;,.]+$/g, ""));
+  return normalizeWhitespace4(value.replace(/^[\s:;#-]+|[\s;,.]+$/g, ""));
 }
 var OPERATIONAL_COVERAGE_TERM_KINDS = /* @__PURE__ */ new Set([
   "each_claim_limit",
@@ -3458,6 +3635,7 @@ function mergeOperationalProfile(base, candidate, validNodeIds, validSpanIds) {
       ...keepIds(record.sourceSpanIds, validSpanIds),
       ...limits.flatMap((term) => term.sourceSpanIds)
     ])];
+    if (!name || sourceNodeIds2.length === 0 && sourceSpanIds2.length === 0) return void 0;
     return {
       name,
       coverageCode: typeof record.coverageCode === "string" ? cleanValue(record.coverageCode) : void 0,
@@ -3472,7 +3650,7 @@ function mergeOperationalProfile(base, candidate, validNodeIds, validSpanIds) {
       sourceNodeIds: sourceNodeIds2,
       sourceSpanIds: sourceSpanIds2
     };
-  }).filter((coverage) => coverage.name && (coverage.sourceNodeIds.length > 0 || coverage.sourceSpanIds.length > 0)) : base.coverages;
+  }).filter((coverage) => Boolean(coverage)) : base.coverages;
   const sourceBackedParty = (role, value) => value ? {
     role,
     name: value.normalizedValue ?? value.value,
@@ -3540,10 +3718,18 @@ function mergeOperationalProfile(base, candidate, validNodeIds, validSpanIds) {
     ...base.warnings,
     ...Array.isArray(candidate.warnings) ? candidate.warnings.filter((warning) => typeof warning === "string" && warning.trim().length > 0) : []
   ];
+  const resolvedPolicyTypes = resolveOperationalProfilePolicyTypes({
+    profileTypes: candidate.policyTypes,
+    existingTypes: base.policyTypes,
+    coverages
+  });
+  if (resolvedPolicyTypes.source === "profile_augmented" || resolvedPolicyTypes.source === "existing_augmented" || resolvedPolicyTypes.source === "inferred") {
+    warnings.push(POLICY_TYPES_FROM_COVERAGES_WARNING);
+  }
   return PolicyOperationalProfileSchema.parse({
     ...base,
     documentType: candidate.documentType === "policy" ? "policy" : base.documentType,
-    policyTypes: Array.isArray(candidate.policyTypes) && candidate.policyTypes.length > 0 ? candidate.policyTypes : base.policyTypes,
+    policyTypes: resolvedPolicyTypes.policyTypes,
     policyNumber,
     namedInsured,
     insurer,
@@ -12620,6 +12806,7 @@ export {
   POLICY_SECTION_TYPES,
   POLICY_TERM_TYPES,
   POLICY_TYPES,
+  POLICY_TYPES_FROM_COVERAGES_WARNING,
   ParsedAnswerSchema,
   PaymentInstallmentSchema,
   PaymentPlanSchema,
@@ -12775,6 +12962,7 @@ export {
   getNextApplicationQuestions,
   getPdfPageCount,
   getTemplate,
+  inferPolicyTypesFromOperationalCoverages,
   isDoclingExtractionInput,
   isFileReference,
   mergeQuestionAnswers,
@@ -12783,6 +12971,7 @@ export {
   normalizeDoclingDocument,
   normalizeDocumentSourceTreePaths,
   normalizeForMatch,
+  normalizeOperationalPolicyTypes,
   normalizeSourceSpans,
   orderSourceEvidence,
   overlayTextOnPdf,
@@ -12793,6 +12982,7 @@ export {
   processReply,
   proposeContextWrites,
   resolveModelBudget,
+  resolveOperationalProfilePolicyTypes,
   safeGenerateObject,
   sanitizeNulls,
   scoreCaseProposal,