@claritylabs/cl-sdk 3.1.18 → 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))
@@ -11414,7 +11414,9 @@ async function runVisualTableRepair(params) {
         },
         {
           fallback: { tables: [], warnings: [] },
-          log: params.log
+          maxRetries: 0,
+          log: params.log,
+          retry: false
         }
       );
       return {
@@ -11545,32 +11547,6 @@ 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;
@@ -11749,7 +11725,9 @@ async function runSourceTreeExtraction(params) {
           },
           {
             fallback: { labels: [], groups: [] },
-            log: params.log
+            maxRetries: 0,
+            log: params.log,
+            retry: false
           }
         );
         return {
@@ -11794,7 +11772,9 @@ async function runSourceTreeExtraction(params) {
         },
         {
           fallback: { labels: [], groups: [] },
-          log: params.log
+          maxRetries: 0,
+          log: params.log,
+          retry: false
         }
       );
       localTrack(response.usage, {
@@ -11836,7 +11816,9 @@ async function runSourceTreeExtraction(params) {
       },
       {
         fallback: emptyProfile,
-        log: params.log
+        maxRetries: 0,
+        log: params.log,
+        retry: false
       }
     );
     localTrack(response.usage, {
@@ -11858,64 +11840,40 @@ async function runSourceTreeExtraction(params) {
     try {
       const validNodeIds = new Set(sourceTree.map((node) => node.id));
       const validSpanIds = new Set(sourceSpans.map((span) => span.id));
-      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, {
+      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,
           taskKind: "extraction_coverage_cleanup",
-          label: result.chunk.label,
-          maxTokens: result.budget.maxTokens,
-          durationMs: result.durationMs
-        });
-        cleanup.coverageDecisions.push(...result.cleanup.coverageDecisions);
-        cleanup.warnings.push(...result.cleanup.warnings);
-      }
+          budgetDiagnostics: budget,
+          providerOptions: params.providerOptions,
+          trace: {
+            phase: "coverage_cleanup",
+            label: "Coverage cleanup",
+            itemCount: operationalProfile.coverages.length,
+            sourceBacked: true
+          }
+        },
+        {
+          fallback: { coverageDecisions: [], warnings: [] },
+          maxRetries: 0,
+          log: params.log,
+          retry: false
+        }
+      );
+      localTrack(response.usage, {
+        taskKind: "extraction_coverage_cleanup",
+        label: "coverage_cleanup",
+        maxTokens: budget.maxTokens,
+        durationMs: Date.now() - startedAt
+      });
       operationalProfile = applyOperationalProfileCleanup(
         operationalProfile,
-        cleanup,
+        response.object,
         validNodeIds,
         validSpanIds
       );
@@ -12313,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)}`)
           }
         );