@claritylabs/cl-sdk 0.14.2 → 0.16.0

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -221,6 +231,7 @@ __export(index_exports, {
   buildIntentPrompt: () => buildIntentPrompt,
   buildInterpretAttachmentPrompt: () => buildInterpretAttachmentPrompt,
   buildLookupFillPrompt: () => buildLookupFillPrompt,
+  buildPdfProviderOptions: () => buildPdfProviderOptions,
   buildQueryClassifyPrompt: () => buildQueryClassifyPrompt,
   buildQuestionBatchPrompt: () => buildQuestionBatchPrompt,
   buildQuotesPoliciesPrompt: () => buildQuotesPoliciesPrompt,
@@ -238,10 +249,14 @@ __export(index_exports, {
   fillAcroForm: () => fillAcroForm,
   getAcroFormFields: () => getAcroFormFields,
   getExtractor: () => getExtractor,
+  getFileIdentifier: () => getFileIdentifier,
   getPdfPageCount: () => getPdfPageCount,
   getTemplate: () => getTemplate,
+  isFileReference: () => isFileReference,
   overlayTextOnPdf: () => overlayTextOnPdf,
   pLimit: () => pLimit,
+  pdfInputToBase64: () => pdfInputToBase64,
+  pdfInputToBytes: () => pdfInputToBytes,
   safeGenerateObject: () => safeGenerateObject,
   sanitizeNulls: () => sanitizeNulls,
   stripFences: () => stripFences,
@@ -1667,34 +1682,134 @@ var CONTEXT_KEY_MAP = [
 
 // src/extraction/pdf.ts
 var import_pdf_lib = require("pdf-lib");
-async function extractPageRange(pdfBase64, startPage, endPage) {
-  const srcBytes = typeof Buffer !== "undefined" ? Buffer.from(pdfBase64, "base64") : Uint8Array.from(atob(pdfBase64), (c) => c.charCodeAt(0));
+function isFileIdRef(input) {
+  return typeof input === "object" && input !== null && "fileId" in input;
+}
+function isUrl(input) {
+  return input instanceof URL;
+}
+function isBytes(input) {
+  return input instanceof Uint8Array;
+}
+async function pdfInputToBytes(input) {
+  if (isFileIdRef(input)) {
+    throw new Error(
+      "Cannot convert fileId reference to bytes. Pass the fileId directly to your provider callback instead."
+    );
+  }
+  if (isUrl(input)) {
+    if (input.protocol === "file:") {
+      if (typeof process !== "undefined" && process.versions?.node) {
+        const fs = await import("fs/promises");
+        const buffer = await fs.readFile(input.pathname);
+        return new Uint8Array(buffer);
+      }
+      throw new Error("File URLs not supported in browser environment");
+    }
+    const response = await fetch(input.toString());
+    if (!response.ok) {
+      throw new Error(`Failed to fetch PDF: ${response.status} ${response.statusText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    return new Uint8Array(arrayBuffer);
+  }
+  if (isBytes(input)) {
+    return input;
+  }
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(input, "base64"));
+  }
+  return Uint8Array.from(atob(input), (c) => c.charCodeAt(0));
+}
+async function pdfInputToBase64(input) {
+  if (isFileIdRef(input)) {
+    throw new Error(
+      "Cannot convert fileId reference to base64. Pass the fileId directly to your provider callback instead."
+    );
+  }
+  if (isUrl(input)) {
+    const bytes = await pdfInputToBytes(input);
+    return bytesToBase64(bytes);
+  }
+  if (isBytes(input)) {
+    return bytesToBase64(input);
+  }
+  return input;
+}
+function bytesToBase64(bytes) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  }
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function isFileReference(input) {
+  return isFileIdRef(input) || isUrl(input);
+}
+function getFileIdentifier(input) {
+  if (isFileIdRef(input)) {
+    return { fileId: input.fileId };
+  }
+  if (isUrl(input)) {
+    return { url: input.toString() };
+  }
+  return void 0;
+}
+async function getPdfPageCount(input) {
+  const bytes = await pdfInputToBytes(input);
+  const doc = await import_pdf_lib.PDFDocument.load(bytes, { ignoreEncryption: true });
+  return doc.getPageCount();
+}
+async function extractPageRange(input, startPage, endPage) {
+  if (isFileIdRef(input)) {
+    throw new Error(
+      "Cannot extract page range from fileId reference. The provider must handle fileId inputs directly or you must pass the full PDF as base64/bytes."
+    );
+  }
+  if (isUrl(input) && (input.protocol === "http:" || input.protocol === "https:")) {
+    throw new Error(
+      "Cannot extract page range from remote URL. Either pass the full PDF as base64/bytes, or download it first."
+    );
+  }
+  const srcBytes = await pdfInputToBytes(input);
   const srcDoc = await import_pdf_lib.PDFDocument.load(srcBytes, { ignoreEncryption: true });
   const totalPages = srcDoc.getPageCount();
   const start = Math.max(startPage - 1, 0);
   const end = Math.min(endPage, totalPages) - 1;
   if (start === 0 && end >= totalPages - 1) {
-    return pdfBase64;
+    if (isBytes(input)) {
+      return bytesToBase64(input);
+    }
+    if (typeof input === "string") {
+      return input;
+    }
+    return bytesToBase64(srcBytes);
   }
   const newDoc = await import_pdf_lib.PDFDocument.create();
   const indices = Array.from({ length: end - start + 1 }, (_, i) => start + i);
   const pages = await newDoc.copyPages(srcDoc, indices);
   pages.forEach((page) => newDoc.addPage(page));
   const bytes = await newDoc.save();
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(bytes).toString("base64");
+  return bytesToBase64(new Uint8Array(bytes));
+}
+async function buildPdfProviderOptions(input, existingOptions) {
+  const options = { ...existingOptions };
+  if (isFileIdRef(input)) {
+    options.fileId = input.fileId;
+    if (input.mimeType) {
+      options.fileMimeType = input.mimeType;
+    }
+    return options;
   }
-  let binary = "";
-  const uint8 = new Uint8Array(bytes);
-  for (let i = 0; i < uint8.length; i++) {
-    binary += String.fromCharCode(uint8[i]);
+  if (isUrl(input)) {
+    options.pdfUrl = input;
+    return options;
   }
-  return btoa(binary);
-}
-async function getPdfPageCount(pdfBase64) {
-  const srcBytes = typeof Buffer !== "undefined" ? Buffer.from(pdfBase64, "base64") : Uint8Array.from(atob(pdfBase64), (c) => c.charCodeAt(0));
-  const doc = await import_pdf_lib.PDFDocument.load(srcBytes, { ignoreEncryption: true });
-  return doc.getPageCount();
+  options.pdfBase64 = await pdfInputToBase64(input);
+  return options;
 }
 function getAcroFormFields(pdfDoc) {
   const form = pdfDoc.getForm();
@@ -1787,7 +1902,7 @@ async function runExtractor(params) {
     name,
     prompt,
     schema,
-    pdfBase64,
+    pdfInput,
     startPage,
     endPage,
     generateObject,
@@ -1797,6 +1912,7 @@ async function runExtractor(params) {
   } = params;
   const extractorProviderOptions = { ...providerOptions };
   let fullPrompt;
+  const pdfBase64 = await pdfInputToBase64(pdfInput);
   if (convertPdfToImages) {
     const images = await convertPdfToImages(pdfBase64, startPage, endPage);
     extractorProviderOptions.images = images;
@@ -2476,10 +2592,13 @@ function chunkDocument(doc) {
   };
   const chunks = [];
   const docId = doc.id;
+  const policyTypesStr = doc.policyTypes?.length ? doc.policyTypes.join(",") : void 0;
   function stringMetadata(entries) {
-    return Object.fromEntries(
+    const base = Object.fromEntries(
       Object.entries(entries).filter(([, value]) => value !== void 0 && value !== null && String(value).length > 0).map(([key, value]) => [key, String(value)])
     );
+    if (policyTypesStr) base.policyTypes = policyTypesStr;
+    return base;
   }
   chunks.push({
     id: `${docId}:carrier_info:0`,
@@ -2840,13 +2959,16 @@ ${exc.content}`.trim(),
       }
     }
     if (declLines.length > 0) {
+      const declMeta = { documentType: doc.type };
+      if (typeof decl.formType === "string") declMeta.formType = decl.formType;
+      if (typeof decl.line === "string") declMeta.declarationLine = decl.line;
       chunks.push({
         id: `${docId}:declaration:0`,
         documentId: docId,
         type: "declaration",
         text: `Declarations
 ${declLines.join("\n")}`,
-        metadata: stringMetadata({ documentType: doc.type })
+        metadata: stringMetadata(declMeta)
       });
     }
   }
@@ -4267,11 +4389,30 @@ COMMERCIAL LINES \u2014 match these values:
 - "property" \u2014 standalone property
 
 PERSONAL LINES \u2014 match these values:
-- "homeowners_ho3" \u2014 HO-3, special form homeowners
-- "homeowners_ho5" \u2014 HO-5, comprehensive form homeowners
-- "renters_ho4" \u2014 HO-4, renters insurance
-- "condo_ho6" \u2014 HO-6, condo unit-owners
-- "dwelling_fire" \u2014 DP-1, DP-3, dwelling fire
+
+HOMEOWNER FORM CLASSIFICATION \u2014 pay close attention to these distinctions:
+- "homeowners_ho3" \u2014 HO-3 Special Form. Standard homeowner policy for OWNER-OCCUPIED dwellings.
+  Key indicators: Coverage A (Dwelling) present, open-peril dwelling coverage, named-peril personal property,
+  references to "special form", "HO 00 03", or "HO-3". The insured OWNS the home.
+- "homeowners_ho5" \u2014 HO-5 Comprehensive Form. Premium homeowner policy for OWNER-OCCUPIED dwellings.
+  Key indicators: Coverage A (Dwelling) present, BOTH dwelling AND personal property on open-peril basis,
+  references to "comprehensive form", "HO 00 05", or "HO-5". Higher coverage than HO-3.
+- "renters_ho4" \u2014 HO-4 Contents Broad Form. Renters/tenants insurance \u2014 NO dwelling coverage.
+  Key indicators: NO Coverage A (Dwelling), only Coverage C (Personal Property) and Coverage E/F (Liability/Medical),
+  references to "contents broad form", "HO 00 04", "HO-4", "renters", "tenants". The insured RENTS, does not own.
+- "condo_ho6" \u2014 HO-6 Unit-Owners Form. Condo/co-op unit-owner insurance.
+  Key indicators: Coverage A applies to interior walls/improvements only (not full structure),
+  references to "unit-owners form", "HO 00 06", "HO-6", "condominium", "co-op unit". The building's
+  master policy covers the structure; HO-6 covers the unit interior, personal property, and liability.
+
+DISAMBIGUATION RULES for homeowner forms:
+1. If the document has Coverage A (Dwelling) with full structure coverage \u2192 HO-3 or HO-5 (check if open-peril on personal property \u2192 HO-5, named-peril \u2192 HO-3)
+2. If NO Coverage A / no dwelling coverage and the insured is a renter/tenant \u2192 renters_ho4
+3. If Coverage A covers only unit interior/improvements and mentions condo/co-op \u2192 condo_ho6
+4. Look for the actual form number (HO 00 03, HO 00 04, HO 00 05, HO 00 06) on the declarations page \u2014 this is the most reliable indicator
+5. Do NOT default to homeowners_ho3 when uncertain \u2014 check for the distinguishing signals above
+
+- "dwelling_fire" \u2014 DP-1, DP-3, dwelling fire (non-owner-occupied or investment property)
 - "mobile_home" \u2014 mobile home, manufactured home
 - "personal_auto" \u2014 personal auto, PAP
 - "personal_umbrella" \u2014 personal umbrella
@@ -4282,7 +4423,10 @@ PERSONAL LINES \u2014 match these values:
 - "watercraft" \u2014 watercraft, boat
 - "recreational_vehicle" \u2014 RV, recreational vehicle, ATV
 - "farm_ranch" \u2014 farm, ranch
-- "pet" \u2014 pet insurance
+- "pet" \u2014 standalone pet insurance policy. Key indicators: named pet, species/breed, accident/illness coverage,
+  wellness plans, per-incident or annual limits for veterinary costs. Do NOT confuse with pet liability endorsements
+  on a homeowners policy \u2014 those are still homeowner policies (ho3/ho4/ho5/ho6), not "pet".
+  Only classify as "pet" when the ENTIRE policy is dedicated to pet health/accident coverage.
 - "travel" \u2014 travel insurance
 - "identity_theft" \u2014 identity theft
 - "title" \u2014 title insurance
@@ -5138,6 +5282,338 @@ function getExtractor(name) {
   return EXTRACTORS[name];
 }
 
+// src/extraction/resolve-referential.ts
+var import_zod35 = require("zod");
+
+// src/prompts/extractors/referential-lookup.ts
+var import_zod34 = require("zod");
+var ReferentialLookupSchema = import_zod34.z.object({
+  resolvedCoverages: import_zod34.z.array(
+    import_zod34.z.object({
+      coverageName: import_zod34.z.string().describe("The coverage name that was referenced"),
+      resolvedLimit: import_zod34.z.string().optional().describe("The concrete limit value found, if any"),
+      resolvedLimitValueType: CoverageValueTypeSchema.optional(),
+      resolvedDeductible: import_zod34.z.string().optional().describe("The concrete deductible value found, if any"),
+      resolvedDeductibleValueType: CoverageValueTypeSchema.optional(),
+      pageNumber: import_zod34.z.number().optional().describe("Page where the resolved value was found"),
+      originalContent: import_zod34.z.string().optional().describe("Verbatim source text for the resolved value"),
+      confidence: import_zod34.z.enum(["high", "medium", "low"]).describe("Confidence in the resolution")
+    })
+  )
+});
+function buildReferentialLookupPrompt(coverages) {
+  const coverageList = coverages.map((c, i) => {
+    const parts = [`  ${i + 1}. Coverage: "${c.name}" \u2014 Limit: "${c.limit}"`];
+    if (c.deductible) {
+      parts.push(`     Deductible: "${c.deductible}"`);
+    }
+    if (c.sectionRef) {
+      parts.push(`     Referenced section: "${c.sectionRef}"`);
+    }
+    return parts.join("\n");
+  }).join("\n");
+  return `You are an expert insurance document analyst. You are looking at a specific section of an insurance document to resolve referential coverage limits.
+
+The following coverages had referential limits or deductibles (e.g. "As stated in Policy", "As stated in Section 4 of Policy", "See Declarations") instead of concrete values:
+
+${coverageList}
+
+Your task:
+- Find the concrete/actual limit and deductible values for each coverage listed above.
+- Search the declarations page, coverage schedules, and any referenced sections for the real numeric or defined values.
+- Only return values you can actually find in the document \u2014 do not guess or infer values that are not explicitly stated.
+- For each resolved coverage, include:
+  - pageNumber: the page where the resolved value appears
+  - originalContent: the verbatim text snippet containing the resolved value
+  - confidence: "high" if the value is clearly and unambiguously stated, "medium" if it requires interpretation, "low" if uncertain
+- If a coverage cannot be resolved (no concrete value found), still include it with confidence "low" and omit the resolved fields.
+- Classify resolvedLimitValueType and resolvedDeductibleValueType as numeric, included, not_included, as_stated, waiting_period, referential, or other.
+
+Return JSON only.`;
+}
+
+// src/extraction/resolve-referential.ts
+function looksReferential(value) {
+  if (typeof value !== "string") return false;
+  const normalized = value.toLowerCase();
+  return normalized.includes("shown in the declarations") || normalized.includes("shown in declarations") || normalized.includes("shown in the schedule") || normalized.includes("as stated") || normalized.includes("if applicable");
+}
+function parseReferenceTarget(text) {
+  if (typeof text !== "string") return void 0;
+  const normalized = text.trim();
+  if (!normalized) return void 0;
+  const sectionMatch = normalized.match(/\b(Section\s+\d+[A-Za-z]?)/i);
+  if (sectionMatch) return sectionMatch[1];
+  if (/declarations/i.test(normalized)) return "Declarations";
+  const scheduleMatch = normalized.match(/\b(Schedule(?:\s+of\s+[A-Za-z ]+)?)/i);
+  if (scheduleMatch) return scheduleMatch[1].trim();
+  const asStatedMatch = normalized.match(/(?:as\s+stated\s+in|see|shown\s+in(?:\s+the)?)\s+(.+)/i);
+  if (asStatedMatch) {
+    let target = asStatedMatch[1].trim().replace(/\s+of\s+the\s+policy$/i, "").trim();
+    target = target.replace(/\.+$/, "").trim();
+    if (target) return target;
+  }
+  if (/if applicable/i.test(normalized)) return void 0;
+  return void 0;
+}
+var PageLocationSchema = import_zod35.z.object({
+  startPage: import_zod35.z.number(),
+  endPage: import_zod35.z.number()
+});
+async function findReferencedPages(params) {
+  const {
+    referenceTarget,
+    sections,
+    formInventory,
+    pdfInput,
+    pageCount,
+    generateObject,
+    providerOptions,
+    log
+  } = params;
+  const targetLower = referenceTarget.toLowerCase();
+  for (const section of sections) {
+    if (section.title && section.pageStart != null && section.title.toLowerCase().includes(targetLower)) {
+      return {
+        startPage: section.pageStart,
+        endPage: section.pageEnd ?? section.pageStart
+      };
+    }
+  }
+  for (const form of formInventory) {
+    const titleMatch = form.title && form.title.toLowerCase().includes(targetLower);
+    const typeMatch = form.formType && form.formType.toLowerCase().includes(targetLower);
+    if ((titleMatch || typeMatch) && form.pageStart != null) {
+      return {
+        startPage: form.pageStart,
+        endPage: form.pageEnd ?? form.pageStart
+      };
+    }
+  }
+  try {
+    const result = await safeGenerateObject(
+      generateObject,
+      {
+        prompt: `You are analyzing an insurance document (${pageCount} pages total).
+
+Find the pages that contain the section or area referenced as "${referenceTarget}".
+
+Return the page range (1-indexed) where this section is located. If the section spans a single page, startPage and endPage should be the same.
+
+If you cannot find the section, return startPage: 0 and endPage: 0.
+
+Return JSON only.`,
+        schema: PageLocationSchema,
+        maxTokens: 256,
+        providerOptions: await buildPdfProviderOptions(pdfInput, providerOptions)
+      },
+      {
+        fallback: { startPage: 0, endPage: 0 },
+        maxRetries: 1,
+        log,
+        onError: (err, attempt) => log?.(
+          `Page location attempt ${attempt + 1} failed for "${referenceTarget}": ${err instanceof Error ? err.message : String(err)}`
+        )
+      }
+    );
+    if (result.object.startPage > 0 && result.object.endPage > 0) {
+      return {
+        startPage: result.object.startPage,
+        endPage: result.object.endPage
+      };
+    }
+  } catch (error) {
+    await log?.(
+      `Failed to locate pages for "${referenceTarget}": ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  return void 0;
+}
+async function resolveReferentialCoverages(params) {
+  const {
+    memory,
+    pdfInput,
+    pageCount,
+    generateObject,
+    convertPdfToImages,
+    concurrency = 2,
+    providerOptions,
+    log,
+    onProgress
+  } = params;
+  const limit = pLimit(concurrency);
+  let totalUsage = { inputTokens: 0, outputTokens: 0 };
+  function trackUsage(usage) {
+    if (usage) {
+      totalUsage.inputTokens += usage.inputTokens;
+      totalUsage.outputTokens += usage.outputTokens;
+    }
+  }
+  const coverageData = memory.get("coverage_limits");
+  const coverages = coverageData?.coverages ?? [];
+  const referentialCoverages = coverages.filter((cov) => {
+    const limitType = cov.limitValueType;
+    const deductibleType = cov.deductibleValueType;
+    return limitType === "referential" || limitType === "as_stated" || deductibleType === "referential" || deductibleType === "as_stated" || looksReferential(cov.limit) || looksReferential(cov.deductible);
+  });
+  const attempts = referentialCoverages.length;
+  if (attempts === 0) {
+    return {
+      resolved: 0,
+      unresolved: 0,
+      attempts: 0,
+      usage: totalUsage,
+      details: []
+    };
+  }
+  onProgress?.(
+    `Found ${attempts} referential coverage(s) to resolve...`
+  );
+  const targetGroups = /* @__PURE__ */ new Map();
+  for (let i = 0; i < referentialCoverages.length; i++) {
+    const cov = referentialCoverages[i];
+    const refString = (looksReferential(cov.limit) ? cov.limit : void 0) ?? (looksReferential(cov.deductible) ? cov.deductible : void 0) ?? cov.limit ?? "";
+    const target = parseReferenceTarget(refString) ?? "unknown";
+    const group = targetGroups.get(target) ?? [];
+    group.push({ coverage: cov, index: i });
+    targetGroups.set(target, group);
+  }
+  const sectionsData = memory.get("sections");
+  const sections = sectionsData?.sections ?? [];
+  const formInventoryData = memory.get("form_inventory");
+  const formInventory = formInventoryData?.forms ?? [];
+  const details = [];
+  let resolved = 0;
+  let unresolved = 0;
+  const targetEntries = Array.from(targetGroups.entries());
+  await Promise.all(
+    targetEntries.map(
+      ([target, group]) => limit(async () => {
+        const pageRange = await findReferencedPages({
+          referenceTarget: target,
+          sections,
+          formInventory,
+          pdfInput,
+          pageCount,
+          generateObject,
+          providerOptions,
+          log
+        });
+        if (!pageRange) {
+          await log?.(
+            `Could not locate pages for reference target "${target}"`
+          );
+          for (const { coverage } of group) {
+            details.push({
+              coverageName: String(coverage.name ?? "unknown"),
+              referenceTarget: target === "unknown" ? void 0 : target,
+              status: "pages_not_found"
+            });
+            unresolved++;
+          }
+          return;
+        }
+        onProgress?.(
+          `Resolving "${target}" from pages ${pageRange.startPage}-${pageRange.endPage}...`
+        );
+        const promptCoverages = group.map(({ coverage }) => ({
+          name: String(coverage.name ?? "unknown"),
+          limit: String(coverage.limit ?? ""),
+          deductible: coverage.deductible ? String(coverage.deductible) : void 0,
+          sectionRef: coverage.sectionRef ? String(coverage.sectionRef) : void 0
+        }));
+        try {
+          const result = await runExtractor({
+            name: "referential_lookup",
+            prompt: buildReferentialLookupPrompt(promptCoverages),
+            schema: ReferentialLookupSchema,
+            pdfInput,
+            startPage: pageRange.startPage,
+            endPage: pageRange.endPage,
+            generateObject,
+            convertPdfToImages,
+            maxTokens: 4096,
+            providerOptions
+          });
+          trackUsage(result.usage);
+          const resolvedMap = /* @__PURE__ */ new Map();
+          for (const rc of result.data.resolvedCoverages) {
+            resolvedMap.set(rc.coverageName.toLowerCase(), rc);
+          }
+          for (const { coverage } of group) {
+            const covName = String(coverage.name ?? "unknown");
+            const rc = resolvedMap.get(covName.toLowerCase());
+            if (!rc) {
+              details.push({
+                coverageName: covName,
+                referenceTarget: target === "unknown" ? void 0 : target,
+                status: "unresolved"
+              });
+              unresolved++;
+              continue;
+            }
+            const limitResolved = rc.resolvedLimit && rc.resolvedLimitValueType !== "referential" && rc.resolvedLimitValueType !== "as_stated" && !looksReferential(rc.resolvedLimit);
+            const deductibleResolved = rc.resolvedDeductible && rc.resolvedDeductibleValueType !== "referential" && rc.resolvedDeductibleValueType !== "as_stated" && !looksReferential(rc.resolvedDeductible);
+            if (limitResolved || deductibleResolved) {
+              if (limitResolved) {
+                coverage.limit = rc.resolvedLimit;
+                coverage.limitValueType = rc.resolvedLimitValueType ?? "numeric";
+              }
+              if (deductibleResolved) {
+                coverage.deductible = rc.resolvedDeductible;
+                coverage.deductibleValueType = rc.resolvedDeductibleValueType ?? "numeric";
+              }
+              if (rc.pageNumber != null) {
+                coverage.resolvedFromPage = rc.pageNumber;
+              }
+              if (rc.originalContent) {
+                coverage.resolvedOriginalContent = rc.originalContent;
+              }
+              details.push({
+                coverageName: covName,
+                referenceTarget: target === "unknown" ? void 0 : target,
+                resolvedLimit: limitResolved ? rc.resolvedLimit : void 0,
+                resolvedDeductible: deductibleResolved ? rc.resolvedDeductible : void 0,
+                status: "resolved"
+              });
+              resolved++;
+            } else {
+              details.push({
+                coverageName: covName,
+                referenceTarget: target === "unknown" ? void 0 : target,
+                status: "unresolved"
+              });
+              unresolved++;
+            }
+          }
+        } catch (error) {
+          await log?.(
+            `Referential lookup extraction failed for target "${target}": ${error instanceof Error ? error.message : String(error)}`
+          );
+          for (const { coverage } of group) {
+            details.push({
+              coverageName: String(coverage.name ?? "unknown"),
+              referenceTarget: target === "unknown" ? void 0 : target,
+              status: "unresolved"
+            });
+            unresolved++;
+          }
+        }
+      })
+    )
+  );
+  onProgress?.(
+    `Referential resolution complete: ${resolved} resolved, ${unresolved} unresolved out of ${attempts} attempts.`
+  );
+  return {
+    resolved,
+    unresolved,
+    attempts,
+    usage: totalUsage,
+    details
+  };
+}
+
 // src/core/quality.ts
 function evaluateQualityGate(params) {
   const { issues, hasRoundWarnings = false } = params;
@@ -5174,7 +5650,7 @@ function addFormEntry(inventory, formNumber, source, extra) {
     sources: [source]
   });
 }
-function looksReferential(value) {
+function looksReferential2(value) {
   if (typeof value !== "string") return false;
   const normalized = value.toLowerCase();
   return normalized.includes("shown in the declarations") || normalized.includes("shown in declarations") || normalized.includes("shown in the schedule") || normalized.includes("as stated") || normalized.includes("if applicable");
@@ -5298,7 +5774,7 @@ function buildExtractionReviewReport(params) {
         itemName: typeof coverage.name === "string" ? coverage.name : void 0
       });
     }
-    if (looksReferential(coverage.limit) || looksReferential(coverage.deductible)) {
+    if (looksReferential2(coverage.limit) || looksReferential2(coverage.deductible)) {
       deterministicIssues.push({
         code: "coverage_referential_value",
         severity: "warning",
@@ -5420,7 +5896,8 @@ function buildExtractionReviewReport(params) {
   }));
   const artifacts = [
     { kind: "form_inventory", label: "Form Inventory", itemCount: formInventory.length },
-    { kind: "page_map", label: "Page Map", itemCount: params.pageAssignments.length }
+    { kind: "page_map", label: "Page Map", itemCount: params.pageAssignments.length },
+    { kind: "referential_resolution", label: "Referential Resolution", itemCount: coverages.filter((c) => c.limitValueType === "referential" || c.limitValueType === "as_stated" || c.deductibleValueType === "referential" || c.deductibleValueType === "as_stated").length }
   ];
   const qualityGateStatus = evaluateQualityGate({
     issues: deterministicIssues,
@@ -5672,7 +6149,7 @@ function createExtractor(config) {
       }))
     };
   }
-  async function extract(pdfBase64, documentId, options) {
+  async function extract(pdfInput, documentId, options) {
     const id = documentId ?? `doc-${Date.now()}`;
     const memory = /* @__PURE__ */ new Map();
     totalUsage = { inputTokens: 0, outputTokens: 0 };
@@ -5690,20 +6167,27 @@ function createExtractor(config) {
         memory.set(k, v);
       }
     }
+    let pdfBase64Cache;
+    async function getPdfBase64ForExtraction() {
+      if (pdfBase64Cache === void 0) {
+        pdfBase64Cache = await pdfInputToBase64(pdfInput);
+      }
+      return pdfBase64Cache;
+    }
     let classifyResult;
     if (resumed?.classifyResult && pipelineCtx.isPhaseComplete("classify")) {
       classifyResult = resumed.classifyResult;
       onProgress?.("Resuming from checkpoint (classify complete)...");
     } else {
       onProgress?.("Classifying document...");
-      const pageCount2 = await getPdfPageCount(pdfBase64);
+      const pageCount2 = await getPdfPageCount(pdfInput);
       const classifyResponse = await safeGenerateObject(
         generateObject,
         {
           prompt: buildClassifyPrompt(),
           schema: ClassifyResultSchema,
           maxTokens: 512,
-          providerOptions: { ...providerOptions, pdfBase64 }
+          providerOptions: await buildPdfProviderOptions(pdfInput, providerOptions)
         },
         {
           fallback: { documentType: "policy", policyTypes: ["other"], confidence: 0 },
@@ -5728,7 +6212,7 @@ function createExtractor(config) {
     const { documentType, policyTypes } = classifyResult;
     const primaryType = policyTypes[0] ?? "other";
     const template = getTemplate(primaryType);
-    const pageCount = resumed?.pageCount ?? await getPdfPageCount(pdfBase64);
+    const pageCount = resumed?.pageCount ?? await getPdfPageCount(pdfInput);
     const templateHints = buildTemplateHints(primaryType, documentType, pageCount, template);
     let formInventory;
     if (resumed?.formInventory && pipelineCtx.isPhaseComplete("form_inventory")) {
@@ -5743,7 +6227,7 @@ function createExtractor(config) {
           prompt: buildFormInventoryPrompt(templateHints),
           schema: FormInventorySchema,
           maxTokens: 2048,
-          providerOptions: { ...providerOptions, pdfBase64 }
+          providerOptions: await buildPdfProviderOptions(pdfInput, providerOptions)
         },
         {
           fallback: { forms: [] },
@@ -5771,9 +6255,10 @@ function createExtractor(config) {
       const chunkSize = 8;
       const collectedAssignments = [];
       const formInventoryHint = formInventory?.forms.length ? formatFormInventoryForPageMap(formInventory.forms) : void 0;
+      const extractionBase64 = await getPdfBase64ForExtraction();
       for (let startPage = 1; startPage <= pageCount; startPage += chunkSize) {
         const endPage = Math.min(pageCount, startPage + chunkSize - 1);
-        const pagesPdf = await extractPageRange(pdfBase64, startPage, endPage);
+        const pagesPdf = await extractPageRange(extractionBase64, startPage, endPage);
         const mapResponse = await safeGenerateObject(
           generateObject,
           {
@@ -5853,7 +6338,7 @@ function createExtractor(config) {
                 name: task.extractorName,
                 prompt: ext.buildPrompt(),
                 schema: ext.schema,
-                pdfBase64,
+                pdfInput,
                 startPage: task.startPage,
                 endPage: task.endPage,
                 generateObject,
@@ -5883,7 +6368,7 @@ function createExtractor(config) {
             name: "supplementary",
             prompt: buildSupplementaryPrompt(alreadyExtractedSummary),
             schema: SupplementarySchema,
-            pdfBase64,
+            pdfInput,
             startPage: 1,
             endPage: pageCount,
             generateObject,
@@ -5907,6 +6392,37 @@ function createExtractor(config) {
         memory: Object.fromEntries(memory)
       });
     }
+    if (!pipelineCtx.isPhaseComplete("resolve_referential")) {
+      onProgress?.("Resolving referential coverage limits...");
+      try {
+        const resolution = await resolveReferentialCoverages({
+          memory,
+          pdfInput,
+          pageCount,
+          generateObject,
+          convertPdfToImages,
+          concurrency,
+          providerOptions,
+          log,
+          onProgress
+        });
+        trackUsage(resolution.usage);
+        if (resolution.attempts > 0) {
+          await log?.(`Referential resolution: ${resolution.resolved}/${resolution.attempts} resolved, ${resolution.unresolved} unresolved`);
+        }
+      } catch (error) {
+        await log?.(`Referential resolution failed, continuing: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      await pipelineCtx.save("resolve_referential", {
+        id,
+        pageCount,
+        classifyResult,
+        formInventory,
+        pageAssignments,
+        plan,
+        memory: Object.fromEntries(memory)
+      });
+    }
     let reviewRounds = resumed?.reviewReport?.reviewRoundRecords ?? [];
     let reviewReport = resumed?.reviewReport;
     if (!pipelineCtx.isPhaseComplete("review")) {
@@ -5921,7 +6437,7 @@ function createExtractor(config) {
             prompt: buildReviewPrompt(template.required, extractedKeys, extractionSummary, pageMapSummary),
             schema: ReviewResultSchema,
             maxTokens: 1536,
-            providerOptions: { ...providerOptions, pdfBase64 }
+            providerOptions: await buildPdfProviderOptions(pdfInput, providerOptions)
           },
           {
             fallback: { complete: true, missingFields: [], qualityIssues: [], additionalTasks: [] },
@@ -5949,7 +6465,7 @@ function createExtractor(config) {
                   name: task.extractorName,
                   prompt: ext.buildPrompt(),
                   schema: ext.schema,
-                  pdfBase64,
+                  pdfInput,
                   startPage: task.startPage,
                   endPage: task.endPage,
                   generateObject,
@@ -6282,8 +6798,8 @@ Respond with JSON only:
 }`;
 
 // src/schemas/application.ts
-var import_zod34 = require("zod");
-var FieldTypeSchema = import_zod34.z.enum([
+var import_zod36 = require("zod");
+var FieldTypeSchema = import_zod36.z.enum([
   "text",
   "numeric",
   "currency",
@@ -6292,131 +6808,131 @@ var FieldTypeSchema = import_zod34.z.enum([
   "table",
   "declaration"
 ]);
-var ApplicationFieldSchema = import_zod34.z.object({
-  id: import_zod34.z.string(),
-  label: import_zod34.z.string(),
-  section: import_zod34.z.string(),
+var ApplicationFieldSchema = import_zod36.z.object({
+  id: import_zod36.z.string(),
+  label: import_zod36.z.string(),
+  section: import_zod36.z.string(),
   fieldType: FieldTypeSchema,
-  required: import_zod34.z.boolean(),
-  options: import_zod34.z.array(import_zod34.z.string()).optional(),
-  columns: import_zod34.z.array(import_zod34.z.string()).optional(),
-  requiresExplanationIfYes: import_zod34.z.boolean().optional(),
-  condition: import_zod34.z.object({
-    dependsOn: import_zod34.z.string(),
-    whenValue: import_zod34.z.string()
+  required: import_zod36.z.boolean(),
+  options: import_zod36.z.array(import_zod36.z.string()).optional(),
+  columns: import_zod36.z.array(import_zod36.z.string()).optional(),
+  requiresExplanationIfYes: import_zod36.z.boolean().optional(),
+  condition: import_zod36.z.object({
+    dependsOn: import_zod36.z.string(),
+    whenValue: import_zod36.z.string()
   }).optional(),
-  value: import_zod34.z.string().optional(),
-  source: import_zod34.z.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
-  confidence: import_zod34.z.enum(["confirmed", "high", "medium", "low"]).optional()
+  value: import_zod36.z.string().optional(),
+  source: import_zod36.z.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
+  confidence: import_zod36.z.enum(["confirmed", "high", "medium", "low"]).optional()
 });
-var ApplicationClassifyResultSchema = import_zod34.z.object({
-  isApplication: import_zod34.z.boolean(),
-  confidence: import_zod34.z.number().min(0).max(1),
-  applicationType: import_zod34.z.string().nullable()
+var ApplicationClassifyResultSchema = import_zod36.z.object({
+  isApplication: import_zod36.z.boolean(),
+  confidence: import_zod36.z.number().min(0).max(1),
+  applicationType: import_zod36.z.string().nullable()
 });
-var FieldExtractionResultSchema = import_zod34.z.object({
-  fields: import_zod34.z.array(ApplicationFieldSchema)
+var FieldExtractionResultSchema = import_zod36.z.object({
+  fields: import_zod36.z.array(ApplicationFieldSchema)
 });
-var AutoFillMatchSchema = import_zod34.z.object({
-  fieldId: import_zod34.z.string(),
-  value: import_zod34.z.string(),
-  confidence: import_zod34.z.enum(["confirmed"]),
-  contextKey: import_zod34.z.string()
+var AutoFillMatchSchema = import_zod36.z.object({
+  fieldId: import_zod36.z.string(),
+  value: import_zod36.z.string(),
+  confidence: import_zod36.z.enum(["confirmed"]),
+  contextKey: import_zod36.z.string()
 });
-var AutoFillResultSchema = import_zod34.z.object({
-  matches: import_zod34.z.array(AutoFillMatchSchema)
+var AutoFillResultSchema = import_zod36.z.object({
+  matches: import_zod36.z.array(AutoFillMatchSchema)
 });
-var QuestionBatchResultSchema = import_zod34.z.object({
-  batches: import_zod34.z.array(import_zod34.z.array(import_zod34.z.string()).describe("Array of field IDs in this batch"))
+var QuestionBatchResultSchema = import_zod36.z.object({
+  batches: import_zod36.z.array(import_zod36.z.array(import_zod36.z.string()).describe("Array of field IDs in this batch"))
 });
-var LookupRequestSchema = import_zod34.z.object({
-  type: import_zod34.z.string().describe("Type of lookup: 'records', 'website', 'policy'"),
-  description: import_zod34.z.string(),
-  url: import_zod34.z.string().optional(),
-  targetFieldIds: import_zod34.z.array(import_zod34.z.string())
+var LookupRequestSchema = import_zod36.z.object({
+  type: import_zod36.z.string().describe("Type of lookup: 'records', 'website', 'policy'"),
+  description: import_zod36.z.string(),
+  url: import_zod36.z.string().optional(),
+  targetFieldIds: import_zod36.z.array(import_zod36.z.string())
 });
-var ReplyIntentSchema = import_zod34.z.object({
-  primaryIntent: import_zod34.z.enum(["answers_only", "question", "lookup_request", "mixed"]),
-  hasAnswers: import_zod34.z.boolean(),
-  questionText: import_zod34.z.string().optional(),
-  questionFieldIds: import_zod34.z.array(import_zod34.z.string()).optional(),
-  lookupRequests: import_zod34.z.array(LookupRequestSchema).optional()
+var ReplyIntentSchema = import_zod36.z.object({
+  primaryIntent: import_zod36.z.enum(["answers_only", "question", "lookup_request", "mixed"]),
+  hasAnswers: import_zod36.z.boolean(),
+  questionText: import_zod36.z.string().optional(),
+  questionFieldIds: import_zod36.z.array(import_zod36.z.string()).optional(),
+  lookupRequests: import_zod36.z.array(LookupRequestSchema).optional()
 });
-var ParsedAnswerSchema = import_zod34.z.object({
-  fieldId: import_zod34.z.string(),
-  value: import_zod34.z.string(),
-  explanation: import_zod34.z.string().optional()
+var ParsedAnswerSchema = import_zod36.z.object({
+  fieldId: import_zod36.z.string(),
+  value: import_zod36.z.string(),
+  explanation: import_zod36.z.string().optional()
 });
-var AnswerParsingResultSchema = import_zod34.z.object({
-  answers: import_zod34.z.array(ParsedAnswerSchema),
-  unanswered: import_zod34.z.array(import_zod34.z.string()).describe("Field IDs that were not answered")
+var AnswerParsingResultSchema = import_zod36.z.object({
+  answers: import_zod36.z.array(ParsedAnswerSchema),
+  unanswered: import_zod36.z.array(import_zod36.z.string()).describe("Field IDs that were not answered")
 });
-var LookupFillSchema = import_zod34.z.object({
-  fieldId: import_zod34.z.string(),
-  value: import_zod34.z.string(),
-  source: import_zod34.z.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'")
+var LookupFillSchema = import_zod36.z.object({
+  fieldId: import_zod36.z.string(),
+  value: import_zod36.z.string(),
+  source: import_zod36.z.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'")
 });
-var LookupFillResultSchema = import_zod34.z.object({
-  fills: import_zod34.z.array(LookupFillSchema),
-  unfillable: import_zod34.z.array(import_zod34.z.string()),
-  explanation: import_zod34.z.string().optional()
+var LookupFillResultSchema = import_zod36.z.object({
+  fills: import_zod36.z.array(LookupFillSchema),
+  unfillable: import_zod36.z.array(import_zod36.z.string()),
+  explanation: import_zod36.z.string().optional()
 });
-var FlatPdfPlacementSchema = import_zod34.z.object({
-  fieldId: import_zod34.z.string(),
-  page: import_zod34.z.number(),
-  x: import_zod34.z.number().describe("Percentage from left edge (0-100)"),
-  y: import_zod34.z.number().describe("Percentage from top edge (0-100)"),
-  text: import_zod34.z.string(),
-  fontSize: import_zod34.z.number().optional(),
-  isCheckmark: import_zod34.z.boolean().optional()
+var FlatPdfPlacementSchema = import_zod36.z.object({
+  fieldId: import_zod36.z.string(),
+  page: import_zod36.z.number(),
+  x: import_zod36.z.number().describe("Percentage from left edge (0-100)"),
+  y: import_zod36.z.number().describe("Percentage from top edge (0-100)"),
+  text: import_zod36.z.string(),
+  fontSize: import_zod36.z.number().optional(),
+  isCheckmark: import_zod36.z.boolean().optional()
 });
-var AcroFormMappingSchema = import_zod34.z.object({
-  fieldId: import_zod34.z.string(),
-  acroFormName: import_zod34.z.string(),
-  value: import_zod34.z.string()
+var AcroFormMappingSchema = import_zod36.z.object({
+  fieldId: import_zod36.z.string(),
+  acroFormName: import_zod36.z.string(),
+  value: import_zod36.z.string()
 });
-var QualityGateStatusSchema = import_zod34.z.enum(["passed", "warning", "failed"]);
-var QualitySeveritySchema = import_zod34.z.enum(["info", "warning", "blocking"]);
-var ApplicationQualityIssueSchema = import_zod34.z.object({
-  code: import_zod34.z.string(),
+var QualityGateStatusSchema = import_zod36.z.enum(["passed", "warning", "failed"]);
+var QualitySeveritySchema = import_zod36.z.enum(["info", "warning", "blocking"]);
+var ApplicationQualityIssueSchema = import_zod36.z.object({
+  code: import_zod36.z.string(),
   severity: QualitySeveritySchema,
-  message: import_zod34.z.string(),
-  fieldId: import_zod34.z.string().optional()
+  message: import_zod36.z.string(),
+  fieldId: import_zod36.z.string().optional()
 });
-var ApplicationQualityRoundSchema = import_zod34.z.object({
-  round: import_zod34.z.number(),
-  kind: import_zod34.z.string(),
+var ApplicationQualityRoundSchema = import_zod36.z.object({
+  round: import_zod36.z.number(),
+  kind: import_zod36.z.string(),
   status: QualityGateStatusSchema,
-  summary: import_zod34.z.string().optional()
+  summary: import_zod36.z.string().optional()
 });
-var ApplicationQualityArtifactSchema = import_zod34.z.object({
-  kind: import_zod34.z.string(),
-  label: import_zod34.z.string().optional(),
-  itemCount: import_zod34.z.number().optional()
+var ApplicationQualityArtifactSchema = import_zod36.z.object({
+  kind: import_zod36.z.string(),
+  label: import_zod36.z.string().optional(),
+  itemCount: import_zod36.z.number().optional()
 });
-var ApplicationEmailReviewSchema = import_zod34.z.object({
-  issues: import_zod34.z.array(ApplicationQualityIssueSchema),
+var ApplicationEmailReviewSchema = import_zod36.z.object({
+  issues: import_zod36.z.array(ApplicationQualityIssueSchema),
   qualityGateStatus: QualityGateStatusSchema
 });
-var ApplicationQualityReportSchema = import_zod34.z.object({
-  issues: import_zod34.z.array(ApplicationQualityIssueSchema),
-  rounds: import_zod34.z.array(ApplicationQualityRoundSchema).optional(),
-  artifacts: import_zod34.z.array(ApplicationQualityArtifactSchema).optional(),
+var ApplicationQualityReportSchema = import_zod36.z.object({
+  issues: import_zod36.z.array(ApplicationQualityIssueSchema),
+  rounds: import_zod36.z.array(ApplicationQualityRoundSchema).optional(),
+  artifacts: import_zod36.z.array(ApplicationQualityArtifactSchema).optional(),
   emailReview: ApplicationEmailReviewSchema.optional(),
   qualityGateStatus: QualityGateStatusSchema
 });
-var ApplicationStateSchema = import_zod34.z.object({
-  id: import_zod34.z.string(),
-  pdfBase64: import_zod34.z.string().optional().describe("Original PDF, omitted after extraction"),
-  title: import_zod34.z.string().optional(),
-  applicationType: import_zod34.z.string().nullable().optional(),
-  fields: import_zod34.z.array(ApplicationFieldSchema),
-  batches: import_zod34.z.array(import_zod34.z.array(import_zod34.z.string())).optional(),
-  currentBatchIndex: import_zod34.z.number().default(0),
+var ApplicationStateSchema = import_zod36.z.object({
+  id: import_zod36.z.string(),
+  pdfBase64: import_zod36.z.string().optional().describe("Original PDF, omitted after extraction"),
+  title: import_zod36.z.string().optional(),
+  applicationType: import_zod36.z.string().nullable().optional(),
+  fields: import_zod36.z.array(ApplicationFieldSchema),
+  batches: import_zod36.z.array(import_zod36.z.array(import_zod36.z.string())).optional(),
+  currentBatchIndex: import_zod36.z.number().default(0),
   qualityReport: ApplicationQualityReportSchema.optional(),
-  status: import_zod34.z.enum(["classifying", "extracting", "auto_filling", "batching", "collecting", "confirming", "mapping", "complete"]),
-  createdAt: import_zod34.z.number(),
-  updatedAt: import_zod34.z.number()
+  status: import_zod36.z.enum(["classifying", "extracting", "auto_filling", "batching", "collecting", "confirming", "mapping", "complete"]),
+  createdAt: import_zod36.z.number(),
+  updatedAt: import_zod36.z.number()
 });
 
 // src/application/agents/classifier.ts
@@ -7553,90 +8069,91 @@ Respond with the final answer, deduplicated citations array, overall confidence
 }
 
 // src/schemas/query.ts
-var import_zod35 = require("zod");
-var QueryIntentSchema = import_zod35.z.enum([
+var import_zod37 = require("zod");
+var QueryIntentSchema = import_zod37.z.enum([
   "policy_question",
   "coverage_comparison",
   "document_search",
   "claims_inquiry",
   "general_knowledge"
 ]);
-var QueryAttachmentKindSchema = import_zod35.z.enum(["image", "pdf", "text"]);
-var QueryAttachmentSchema = import_zod35.z.object({
-  id: import_zod35.z.string().optional().describe("Optional stable attachment ID from the caller"),
+var QueryAttachmentKindSchema = import_zod37.z.enum(["image", "pdf", "text"]);
+var QueryAttachmentSchema = import_zod37.z.object({
+  id: import_zod37.z.string().optional().describe("Optional stable attachment ID from the caller"),
   kind: QueryAttachmentKindSchema,
-  name: import_zod35.z.string().optional().describe("Original filename or user-facing label"),
-  mimeType: import_zod35.z.string().optional().describe("MIME type such as image/jpeg or application/pdf"),
-  base64: import_zod35.z.string().optional().describe("Base64-encoded file content for image/pdf attachments"),
-  text: import_zod35.z.string().optional().describe("Plain-text attachment content when available"),
-  description: import_zod35.z.string().optional().describe("Caller-provided description of the attachment")
+  name: import_zod37.z.string().optional().describe("Original filename or user-facing label"),
+  mimeType: import_zod37.z.string().optional().describe("MIME type such as image/jpeg or application/pdf"),
+  base64: import_zod37.z.string().optional().describe("Base64-encoded file content for image/pdf attachments"),
+  text: import_zod37.z.string().optional().describe("Plain-text attachment content when available"),
+  description: import_zod37.z.string().optional().describe("Caller-provided description of the attachment")
 });
-var SubQuestionSchema = import_zod35.z.object({
-  question: import_zod35.z.string().describe("Atomic sub-question to retrieve and answer independently"),
+var SubQuestionSchema = import_zod37.z.object({
+  question: import_zod37.z.string().describe("Atomic sub-question to retrieve and answer independently"),
   intent: QueryIntentSchema,
-  chunkTypes: import_zod35.z.array(import_zod35.z.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
-  documentFilters: import_zod35.z.object({
-    type: import_zod35.z.enum(["policy", "quote"]).optional(),
-    carrier: import_zod35.z.string().optional(),
-    insuredName: import_zod35.z.string().optional(),
-    policyNumber: import_zod35.z.string().optional(),
-    quoteNumber: import_zod35.z.string().optional()
+  chunkTypes: import_zod37.z.array(import_zod37.z.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
+  documentFilters: import_zod37.z.object({
+    type: import_zod37.z.enum(["policy", "quote"]).optional(),
+    carrier: import_zod37.z.string().optional(),
+    insuredName: import_zod37.z.string().optional(),
+    policyNumber: import_zod37.z.string().optional(),
+    quoteNumber: import_zod37.z.string().optional(),
+    policyTypes: import_zod37.z.array(PolicyTypeSchema).optional().describe("Filter by policy type (e.g. homeowners_ho3, renters_ho4, pet) to avoid mixing up similar policies")
   }).optional().describe("Structured filters to narrow document lookup")
 });
-var QueryClassifyResultSchema = import_zod35.z.object({
+var QueryClassifyResultSchema = import_zod37.z.object({
   intent: QueryIntentSchema,
-  subQuestions: import_zod35.z.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
-  requiresDocumentLookup: import_zod35.z.boolean().describe("Whether structured document lookup is needed"),
-  requiresChunkSearch: import_zod35.z.boolean().describe("Whether semantic chunk search is needed"),
-  requiresConversationHistory: import_zod35.z.boolean().describe("Whether conversation history is relevant")
+  subQuestions: import_zod37.z.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
+  requiresDocumentLookup: import_zod37.z.boolean().describe("Whether structured document lookup is needed"),
+  requiresChunkSearch: import_zod37.z.boolean().describe("Whether semantic chunk search is needed"),
+  requiresConversationHistory: import_zod37.z.boolean().describe("Whether conversation history is relevant")
 });
-var EvidenceItemSchema = import_zod35.z.object({
-  source: import_zod35.z.enum(["chunk", "document", "conversation", "attachment"]),
-  chunkId: import_zod35.z.string().optional(),
-  documentId: import_zod35.z.string().optional(),
-  turnId: import_zod35.z.string().optional(),
-  attachmentId: import_zod35.z.string().optional(),
-  text: import_zod35.z.string().describe("Text excerpt from the source"),
-  relevance: import_zod35.z.number().min(0).max(1),
-  metadata: import_zod35.z.array(import_zod35.z.object({ key: import_zod35.z.string(), value: import_zod35.z.string() })).optional()
+var EvidenceItemSchema = import_zod37.z.object({
+  source: import_zod37.z.enum(["chunk", "document", "conversation", "attachment"]),
+  chunkId: import_zod37.z.string().optional(),
+  documentId: import_zod37.z.string().optional(),
+  turnId: import_zod37.z.string().optional(),
+  attachmentId: import_zod37.z.string().optional(),
+  text: import_zod37.z.string().describe("Text excerpt from the source"),
+  relevance: import_zod37.z.number().min(0).max(1),
+  metadata: import_zod37.z.array(import_zod37.z.object({ key: import_zod37.z.string(), value: import_zod37.z.string() })).optional()
 });
-var AttachmentInterpretationSchema = import_zod35.z.object({
-  summary: import_zod35.z.string().describe("Concise summary of what the attachment shows or contains"),
-  extractedFacts: import_zod35.z.array(import_zod35.z.string()).describe("Specific observable or document facts grounded in the attachment"),
-  recommendedFocus: import_zod35.z.array(import_zod35.z.string()).describe("Important details to incorporate when answering follow-up questions"),
-  confidence: import_zod35.z.number().min(0).max(1)
+var AttachmentInterpretationSchema = import_zod37.z.object({
+  summary: import_zod37.z.string().describe("Concise summary of what the attachment shows or contains"),
+  extractedFacts: import_zod37.z.array(import_zod37.z.string()).describe("Specific observable or document facts grounded in the attachment"),
+  recommendedFocus: import_zod37.z.array(import_zod37.z.string()).describe("Important details to incorporate when answering follow-up questions"),
+  confidence: import_zod37.z.number().min(0).max(1)
 });
-var RetrievalResultSchema = import_zod35.z.object({
-  subQuestion: import_zod35.z.string(),
-  evidence: import_zod35.z.array(EvidenceItemSchema)
+var RetrievalResultSchema = import_zod37.z.object({
+  subQuestion: import_zod37.z.string(),
+  evidence: import_zod37.z.array(EvidenceItemSchema)
 });
-var CitationSchema = import_zod35.z.object({
-  index: import_zod35.z.number().describe("Citation number [1], [2], etc."),
-  chunkId: import_zod35.z.string().describe("Source chunk ID, e.g. doc-123:coverage:2"),
-  documentId: import_zod35.z.string(),
-  documentType: import_zod35.z.enum(["policy", "quote"]).optional(),
-  field: import_zod35.z.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
-  quote: import_zod35.z.string().describe("Exact text from source that supports the claim"),
-  relevance: import_zod35.z.number().min(0).max(1)
+var CitationSchema = import_zod37.z.object({
+  index: import_zod37.z.number().describe("Citation number [1], [2], etc."),
+  chunkId: import_zod37.z.string().describe("Source chunk ID, e.g. doc-123:coverage:2"),
+  documentId: import_zod37.z.string(),
+  documentType: import_zod37.z.enum(["policy", "quote"]).optional(),
+  field: import_zod37.z.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
+  quote: import_zod37.z.string().describe("Exact text from source that supports the claim"),
+  relevance: import_zod37.z.number().min(0).max(1)
 });
-var SubAnswerSchema = import_zod35.z.object({
-  subQuestion: import_zod35.z.string(),
-  answer: import_zod35.z.string(),
-  citations: import_zod35.z.array(CitationSchema),
-  confidence: import_zod35.z.number().min(0).max(1),
-  needsMoreContext: import_zod35.z.boolean().describe("True if evidence was insufficient to answer fully")
+var SubAnswerSchema = import_zod37.z.object({
+  subQuestion: import_zod37.z.string(),
+  answer: import_zod37.z.string(),
+  citations: import_zod37.z.array(CitationSchema),
+  confidence: import_zod37.z.number().min(0).max(1),
+  needsMoreContext: import_zod37.z.boolean().describe("True if evidence was insufficient to answer fully")
 });
-var VerifyResultSchema = import_zod35.z.object({
-  approved: import_zod35.z.boolean().describe("Whether all sub-answers are adequately grounded"),
-  issues: import_zod35.z.array(import_zod35.z.string()).describe("Specific grounding or consistency issues found"),
-  retrySubQuestions: import_zod35.z.array(import_zod35.z.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
+var VerifyResultSchema = import_zod37.z.object({
+  approved: import_zod37.z.boolean().describe("Whether all sub-answers are adequately grounded"),
+  issues: import_zod37.z.array(import_zod37.z.string()).describe("Specific grounding or consistency issues found"),
+  retrySubQuestions: import_zod37.z.array(import_zod37.z.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
 });
-var QueryResultSchema = import_zod35.z.object({
-  answer: import_zod35.z.string(),
-  citations: import_zod35.z.array(CitationSchema),
+var QueryResultSchema = import_zod37.z.object({
+  answer: import_zod37.z.string(),
+  citations: import_zod37.z.array(CitationSchema),
   intent: QueryIntentSchema,
-  confidence: import_zod35.z.number().min(0).max(1),
-  followUp: import_zod35.z.string().optional().describe("Suggested follow-up question if applicable")
+  confidence: import_zod37.z.number().min(0).max(1),
+  followUp: import_zod37.z.string().optional().describe("Suggested follow-up question if applicable")
 });
 
 // src/query/retriever.ts
@@ -8794,6 +9311,7 @@ var AGENT_TOOLS = [
   buildIntentPrompt,
   buildInterpretAttachmentPrompt,
   buildLookupFillPrompt,
+  buildPdfProviderOptions,
   buildQueryClassifyPrompt,
   buildQuestionBatchPrompt,
   buildQuotesPoliciesPrompt,
@@ -8811,10 +9329,14 @@ var AGENT_TOOLS = [
   fillAcroForm,
   getAcroFormFields,
   getExtractor,
+  getFileIdentifier,
   getPdfPageCount,
   getTemplate,
+  isFileReference,
   overlayTextOnPdf,
   pLimit,
+  pdfInputToBase64,
+  pdfInputToBytes,
   safeGenerateObject,
   sanitizeNulls,
   stripFences,