@claritylabs/cl-sdk 0.10.3 → 0.12.0

package/dist/index.js

@@ -36,6 +36,7 @@ __export(index_exports, {
   ApplicationQualityReportSchema: () => ApplicationQualityReportSchema,
   ApplicationQualityRoundSchema: () => ApplicationQualityRoundSchema,
   ApplicationStateSchema: () => ApplicationStateSchema,
+  AttachmentInterpretationSchema: () => AttachmentInterpretationSchema,
   AuditTypeSchema: () => AuditTypeSchema,
   AutoFillMatchSchema: () => AutoFillMatchSchema,
   AutoFillResultSchema: () => AutoFillResultSchema,
@@ -157,6 +158,8 @@ __export(index_exports, {
   ProducerInfoSchema: () => ProducerInfoSchema,
   ProfessionalLiabilityDeclarationsSchema: () => ProfessionalLiabilityDeclarationsSchema,
   QUOTE_SECTION_TYPES: () => QUOTE_SECTION_TYPES,
+  QueryAttachmentKindSchema: () => QueryAttachmentKindSchema,
+  QueryAttachmentSchema: () => QueryAttachmentSchema,
   QueryClassifyResultSchema: () => QueryClassifyResultSchema,
   QueryIntentSchema: () => QueryIntentSchema,
   QueryResultSchema: () => QueryResultSchema,
@@ -215,6 +218,7 @@ __export(index_exports, {
   buildFormattingPrompt: () => buildFormattingPrompt,
   buildIdentityPrompt: () => buildIdentityPrompt,
   buildIntentPrompt: () => buildIntentPrompt,
+  buildInterpretAttachmentPrompt: () => buildInterpretAttachmentPrompt,
   buildLookupFillPrompt: () => buildLookupFillPrompt,
   buildQueryClassifyPrompt: () => buildQueryClassifyPrompt,
   buildQuestionBatchPrompt: () => buildQuestionBatchPrompt,
@@ -1814,6 +1818,358 @@ async function runExtractor(params) {
   };
 }
 
+// src/extraction/promote.ts
+function getDeclarationFields(doc) {
+  const decl = doc.declarations;
+  return Array.isArray(decl?.fields) ? decl.fields : [];
+}
+function fieldMatches(fieldName, patterns) {
+  const lower = fieldName.toLowerCase().replace(/[\s_-]/g, "");
+  return patterns.some((p) => lower === p.toLowerCase().replace(/[\s_-]/g, ""));
+}
+function findFieldValue(fields, patterns) {
+  const match = fields.find((f) => fieldMatches(f.field, patterns));
+  return match?.value;
+}
+function promoteCarrierFields(doc) {
+  const raw = doc;
+  if (!raw.carrierNaicNumber && raw.naicNumber) {
+    raw.carrierNaicNumber = raw.naicNumber;
+  }
+  if (!raw.carrierAmBestRating && raw.amBestRating) {
+    raw.carrierAmBestRating = raw.amBestRating;
+  }
+  if (!raw.carrierAdmittedStatus && raw.admittedStatus) {
+    raw.carrierAdmittedStatus = raw.admittedStatus;
+  }
+  delete raw.naicNumber;
+  delete raw.amBestRating;
+  delete raw.admittedStatus;
+  if (!raw.insurer && raw.carrierLegalName) {
+    raw.insurer = {
+      legalName: raw.carrierLegalName,
+      ...raw.carrierNaicNumber ? { naicNumber: raw.carrierNaicNumber } : {},
+      ...raw.carrierAmBestRating ? { amBestRating: raw.carrierAmBestRating } : {},
+      ...raw.carrierAdmittedStatus ? { admittedStatus: raw.carrierAdmittedStatus } : {}
+    };
+  }
+}
+var BROKER_NAME_PATTERNS = [
+  "brokerName",
+  "broker",
+  "agentName",
+  "agent",
+  "producerName",
+  "producerAgency",
+  "agencyName",
+  "brokerAgency"
+];
+var BROKER_CONTACT_PATTERNS = [
+  "brokerContactName",
+  "brokerContact",
+  "agentContactName",
+  "producerContactName",
+  "producerContact"
+];
+var BROKER_LICENSE_PATTERNS = [
+  "brokerLicenseNumber",
+  "brokerNumber",
+  "agentLicenseNumber",
+  "producerLicenseNumber",
+  "producerNumber",
+  "agentNumber"
+];
+var BROKER_PHONE_PATTERNS = ["brokerPhone", "agentPhone", "producerPhone"];
+var BROKER_EMAIL_PATTERNS = ["brokerEmail", "agentEmail", "producerEmail"];
+var BROKER_ADDRESS_PATTERNS = ["brokerAddress", "agentAddress", "producerAddress"];
+function promoteBroker(doc) {
+  const raw = doc;
+  const fields = getDeclarationFields(doc);
+  const brokerAgency = raw.brokerAgency || findFieldValue(fields, BROKER_NAME_PATTERNS);
+  const brokerContact = raw.brokerContactName || findFieldValue(fields, BROKER_CONTACT_PATTERNS);
+  const brokerLicense = raw.brokerLicenseNumber || findFieldValue(fields, BROKER_LICENSE_PATTERNS);
+  const brokerPhone = findFieldValue(fields, BROKER_PHONE_PATTERNS);
+  const brokerEmail = findFieldValue(fields, BROKER_EMAIL_PATTERNS);
+  const brokerAddress = findFieldValue(fields, BROKER_ADDRESS_PATTERNS);
+  if (brokerAgency) raw.brokerAgency = brokerAgency;
+  if (brokerContact) raw.brokerContactName = brokerContact;
+  if (brokerLicense) raw.brokerLicenseNumber = brokerLicense;
+  if (!raw.producer && brokerAgency) {
+    raw.producer = {
+      agencyName: brokerAgency,
+      ...brokerContact ? { contactName: brokerContact } : {},
+      ...brokerLicense ? { licenseNumber: brokerLicense } : {},
+      ...brokerPhone ? { phone: brokerPhone } : {},
+      ...brokerEmail ? { email: brokerEmail } : {},
+      ...brokerAddress ? { address: { street1: brokerAddress } } : {}
+    };
+  }
+}
+var LOSS_PAYEE_NAME_PATTERNS = [
+  "lossPayeeName",
+  "lossPayee",
+  "lossPayeeHolder"
+];
+var LOSS_PAYEE_ADDRESS_PATTERNS = ["lossPayeeAddress"];
+var MORTGAGE_HOLDER_NAME_PATTERNS = [
+  "mortgagee",
+  "mortgageHolder",
+  "mortgageHolderName",
+  "mortgageeName",
+  "lienholder",
+  "lienholderName"
+];
+var MORTGAGE_HOLDER_ADDRESS_PATTERNS = [
+  "mortgageeAddress",
+  "mortgageHolderAddress",
+  "lienholderAddress"
+];
+function promoteLossPayees(doc) {
+  const raw = doc;
+  const fields = getDeclarationFields(doc);
+  if (!raw.lossPayees || Array.isArray(raw.lossPayees) && raw.lossPayees.length === 0) {
+    const name = findFieldValue(fields, LOSS_PAYEE_NAME_PATTERNS);
+    if (name) {
+      const address = findFieldValue(fields, LOSS_PAYEE_ADDRESS_PATTERNS);
+      raw.lossPayees = [{
+        name,
+        role: "loss_payee",
+        ...address ? { address: { street1: address } } : {}
+      }];
+    }
+  }
+  if (!raw.mortgageHolders || Array.isArray(raw.mortgageHolders) && raw.mortgageHolders.length === 0) {
+    const name = findFieldValue(fields, MORTGAGE_HOLDER_NAME_PATTERNS);
+    if (name) {
+      const address = findFieldValue(fields, MORTGAGE_HOLDER_ADDRESS_PATTERNS);
+      raw.mortgageHolders = [{
+        name,
+        role: "mortgage_holder",
+        ...address ? { address: { street1: address } } : {}
+      }];
+    }
+  }
+}
+function promoteLocations(doc) {
+  const raw = doc;
+  if (Array.isArray(raw.locations) && raw.locations.length > 0) return;
+  const fields = getDeclarationFields(doc);
+  if (fields.length === 0) return;
+  const locationGroups = /* @__PURE__ */ new Map();
+  for (const f of fields) {
+    const lower = f.field.toLowerCase().replace(/[\s_-]/g, "");
+    if (lower.includes("locationnumber") || lower.includes("locnumber") || lower.includes("locno")) {
+      const key = f.value;
+      if (!locationGroups.has(key)) locationGroups.set(key, /* @__PURE__ */ new Map());
+      locationGroups.get(key).set("number", f.value);
+      continue;
+    }
+    if (lower.includes("buildingnumber") || lower.includes("bldgnumber") || lower.includes("bldgno")) {
+      const lastKey2 = [...locationGroups.keys()].pop();
+      if (lastKey2) locationGroups.get(lastKey2).set("buildingNumber", f.value);
+      continue;
+    }
+    const section = (f.section ?? "").toLowerCase();
+    const isLocationField = section.includes("location") || section.includes("building") || section.includes("premises") || section.includes("schedule of locations");
+    if (!isLocationField) continue;
+    if (locationGroups.size === 0) {
+      locationGroups.set("1", /* @__PURE__ */ new Map([["number", "1"]]));
+    }
+    const lastKey = [...locationGroups.keys()].pop();
+    const group = locationGroups.get(lastKey);
+    if (lower.includes("construction") || lower.includes("constructiontype")) {
+      group.set("constructionType", f.value);
+    } else if (lower.includes("occupancy") || lower.includes("occupancytype")) {
+      group.set("occupancy", f.value);
+    } else if (lower.includes("yearbuilt")) {
+      group.set("yearBuilt", f.value);
+    } else if (lower.includes("squarefootage") || lower.includes("sqft") || lower.includes("area")) {
+      group.set("squareFootage", f.value);
+    } else if (lower.includes("protectionclass") || lower.includes("fireprotection")) {
+      group.set("protectionClass", f.value);
+    } else if (lower.includes("sprinkler")) {
+      group.set("sprinklered", f.value);
+    } else if (lower.includes("buildingvalue") || lower.includes("buildingamt") || lower.includes("buildingcoverage")) {
+      group.set("buildingValue", f.value);
+    } else if (lower.includes("contentsvalue") || lower.includes("contentsamt") || lower.includes("contentscoverage")) {
+      group.set("contentsValue", f.value);
+    } else if (lower.includes("businessincome") || lower.includes("bivalue") || lower.includes("businessincomevalue")) {
+      group.set("businessIncomeValue", f.value);
+    } else if (lower.includes("description") || lower.includes("buildingdescription") || lower.includes("locationdescription")) {
+      group.set("description", f.value);
+    } else if (lower.includes("address") || lower.includes("industryaddress") || lower.includes("locationaddress") || lower.includes("premisesaddress")) {
+      group.set("address", f.value);
+    } else if (lower.includes("alarm") || lower.includes("alarmtype")) {
+      group.set("alarmType", f.value);
+    }
+  }
+  if (locationGroups.size === 0) return;
+  const locations = [];
+  for (const [, group] of locationGroups) {
+    const num = parseInt(group.get("number") ?? "0", 10) || locations.length + 1;
+    const addressStr = group.get("address");
+    locations.push({
+      number: num,
+      address: addressStr ? { street1: addressStr } : { street1: "See declarations" },
+      ...group.get("description") ? { description: group.get("description") } : {},
+      ...group.get("constructionType") ? { constructionType: group.get("constructionType") } : {},
+      ...group.get("occupancy") ? { occupancy: group.get("occupancy") } : {},
+      ...group.get("yearBuilt") ? { yearBuilt: parseInt(group.get("yearBuilt"), 10) || void 0 } : {},
+      ...group.get("squareFootage") ? { squareFootage: parseInt(group.get("squareFootage").replace(/[^0-9]/g, ""), 10) || void 0 } : {},
+      ...group.get("protectionClass") ? { protectionClass: group.get("protectionClass") } : {},
+      ...group.get("sprinklered") ? { sprinklered: /yes|true/i.test(group.get("sprinklered")) } : {},
+      ...group.get("buildingValue") ? { buildingValue: group.get("buildingValue") } : {},
+      ...group.get("contentsValue") ? { contentsValue: group.get("contentsValue") } : {},
+      ...group.get("businessIncomeValue") ? { businessIncomeValue: group.get("businessIncomeValue") } : {},
+      ...group.get("alarmType") ? { alarmType: group.get("alarmType") } : {}
+    });
+  }
+  if (locations.length > 0) {
+    raw.locations = locations;
+  }
+}
+function normalizeName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+var LIMIT_COVERAGE_MAP = [
+  // GL standard
+  [["eachoccurrence", "peroccurrence", "occurrencecombined"], "perOccurrence"],
+  [["generalaggregate"], "generalAggregate"],
+  [["productscompletedoperationsaggregate", "productscompletedopsaggregate", "prodcompopsagg"], "productsCompletedOpsAggregate"],
+  [["personaladvertisinginjury", "personaladvinjury", "pai"], "personalAdvertisingInjury"],
+  [["firedamage", "firedamagelegalliability", "damagetorentedpremises", "damagetopremisesrentedtoyou"], "fireDamage"],
+  [["medicalexpense", "medexp", "medicalexpenseanypersonanyperson", "medicalexpenseanyone"], "medicalExpense"],
+  // Auto
+  [["combinedsingle", "combinedsinglelimit", "csl"], "combinedSingleLimit"],
+  [["bodilyinjuryperperson", "biperperson"], "bodilyInjuryPerPerson"],
+  [["bodilyinjuryperaccident", "biperaccident"], "bodilyInjuryPerAccident"],
+  [["propertydamage", "pdperaccident"], "propertyDamage"],
+  // Umbrella/Excess
+  [["umbrellaoccurrence", "eachoccurrenceumbrella", "excessoccurrence", "excesseachoccurrence"], "eachOccurrenceUmbrella"],
+  [["umbrellaaggregate", "excessaggregate"], "umbrellaAggregate"],
+  [["umbrella retention", "selfinsuredretention", "sir", "excessretention"], "umbrellaRetention"]
+];
+function synthesizeLimits(doc) {
+  const raw = doc;
+  if (raw.limits && typeof raw.limits === "object" && Object.keys(raw.limits).length > 0) return;
+  const coverages = doc.coverages;
+  if (!coverages || coverages.length === 0) return;
+  const limits = {};
+  for (const cov of coverages) {
+    if (!cov.name || !cov.limit) continue;
+    const normalized = normalizeName(cov.name);
+    for (const [patterns, fieldName] of LIMIT_COVERAGE_MAP) {
+      if (patterns.some((p) => normalized.includes(p) || p.includes(normalized))) {
+        if (fieldName.includes("Aggregate") || fieldName.includes("aggregate")) {
+          if (!cov.limitType || cov.limitType === "aggregate") {
+            limits[fieldName] = cov.limit;
+          }
+        } else {
+          if (!limits[fieldName]) {
+            limits[fieldName] = cov.limit;
+          }
+        }
+        break;
+      }
+    }
+  }
+  const hasStatutory = coverages.some(
+    (c) => c.limitType === "statutory" || normalizeName(c.name ?? "").includes("statutory")
+  );
+  if (hasStatutory) {
+    limits.statutory = "true";
+  }
+  const elCoverages = coverages.filter(
+    (c) => normalizeName(c.name ?? "").includes("employersliability")
+  );
+  if (elCoverages.length > 0) {
+    const el = {};
+    for (const c of elCoverages) {
+      if (!c.limit) continue;
+      const n = normalizeName(c.name ?? "");
+      if (n.includes("accident") || n.includes("eachaccident")) el.eachAccident = c.limit;
+      else if (n.includes("diseasepolicy") || n.includes("diseasepolicylimit")) el.diseasePolicyLimit = c.limit;
+      else if (n.includes("diseaseemployee") || n.includes("diseaseeachemployee")) el.diseaseEachEmployee = c.limit;
+      else if (!el.eachAccident) el.eachAccident = c.limit;
+    }
+    if (Object.keys(el).length > 0) {
+      limits.employersLiability = el;
+    }
+  }
+  if (Object.keys(limits).length > 0) {
+    const result = { ...limits };
+    if (result.statutory === "true") result.statutory = true;
+    raw.limits = result;
+  }
+}
+function synthesizeDeductibles(doc) {
+  const raw = doc;
+  if (raw.deductibles && typeof raw.deductibles === "object" && Object.keys(raw.deductibles).length > 0) return;
+  const coverages = doc.coverages;
+  if (!coverages || coverages.length === 0) return;
+  const deductibleValues = coverages.filter((c) => c.deductible && c.deductible.trim() !== "" && c.deductible !== "N/A" && c.deductible !== "None").map((c) => c.deductible);
+  if (deductibleValues.length === 0) return;
+  const freq = /* @__PURE__ */ new Map();
+  for (const d of deductibleValues) {
+    freq.set(d, (freq.get(d) ?? 0) + 1);
+  }
+  let mostCommon = deductibleValues[0];
+  let maxFreq = 0;
+  for (const [val, count] of freq) {
+    if (count > maxFreq) {
+      mostCommon = val;
+      maxFreq = count;
+    }
+  }
+  const deductibles = {};
+  const hasPerClaim = coverages.some(
+    (c) => c.deductible && normalizeName(c.name ?? "").includes("perclaim")
+  );
+  if (hasPerClaim) {
+    deductibles.perClaim = mostCommon;
+  } else {
+    deductibles.perOccurrence = mostCommon;
+  }
+  const sirCoverage = coverages.find(
+    (c) => c.deductible && (normalizeName(c.name ?? "").includes("selfinsuredretention") || normalizeName(c.name ?? "").includes("sir"))
+  );
+  if (sirCoverage?.deductible) {
+    deductibles.selfInsuredRetention = sirCoverage.deductible;
+  }
+  const aggDed = coverages.find(
+    (c) => c.deductible && normalizeName(c.name ?? "").includes("aggregatedeductible")
+  );
+  if (aggDed?.deductible) {
+    deductibles.aggregateDeductible = aggDed.deductible;
+  }
+  if (Object.keys(deductibles).length > 0) {
+    raw.deductibles = deductibles;
+  }
+}
+var PREMIUM_PATTERNS = ["premium", "totalPremium", "annualPremium", "policyPremium", "basePremium"];
+var TOTAL_COST_PATTERNS = ["totalCost", "totalDue", "totalAmount", "totalPolicyPremium"];
+function promotePremium(doc) {
+  const raw = doc;
+  const fields = getDeclarationFields(doc);
+  if (!raw.premium) {
+    const premium = findFieldValue(fields, PREMIUM_PATTERNS);
+    if (premium) raw.premium = premium;
+  }
+  if (!raw.totalCost) {
+    const totalCost = findFieldValue(fields, TOTAL_COST_PATTERNS);
+    if (totalCost) raw.totalCost = totalCost;
+  }
+}
+function promoteExtractedFields(doc) {
+  promoteCarrierFields(doc);
+  promoteBroker(doc);
+  promoteLossPayees(doc);
+  promoteLocations(doc);
+  synthesizeLimits(doc);
+  synthesizeDeductibles(doc);
+  promotePremium(doc);
+}
+
 // src/extraction/assembler.ts
 function assembleDocument(documentId, documentType, memory) {
   const carrier = memory.get("carrier_info");
@@ -1837,6 +2193,9 @@ function assembleDocument(documentId, documentType, memory) {
     policyTypes: classify?.policyTypes,
     ...sanitizeNulls(carrier ?? {}),
     ...sanitizeNulls(insured ?? {}),
+    // Map named_insured extractor's loss payees/mortgage holders to EndorsementParty shape
+    ...Array.isArray(insured?.lossPayees) && insured.lossPayees.length > 0 ? { lossPayees: insured.lossPayees.map((lp) => ({ ...lp, role: "loss_payee" })) } : {},
+    ...Array.isArray(insured?.mortgageHolders) && insured.mortgageHolders.length > 0 ? { mortgageHolders: insured.mortgageHolders.map((mh) => ({ ...mh, role: "mortgage_holder" })) } : {},
     ...sanitizeNulls(coverages ?? {}),
     ...sanitizeNulls(premium ?? {}),
     ...sanitizeNulls(supplementary ?? {}),
@@ -1848,8 +2207,9 @@ function assembleDocument(documentId, documentType, memory) {
     declarations: declarations ? sanitizeNulls(declarations) : void 0,
     ...sanitizeNulls(lossHistory ?? {})
   };
+  let doc;
   if (documentType === "policy") {
-    return {
+    doc = {
       ...base,
       type: "policy",
       policyNumber: carrier?.policyNumber ?? insured?.policyNumber ?? "Unknown",
@@ -1857,17 +2217,20 @@ function assembleDocument(documentId, documentType, memory) {
       expirationDate: carrier?.expirationDate,
       policyTermType: carrier?.policyTermType
     };
+  } else {
+    doc = {
+      ...base,
+      type: "quote",
+      quoteNumber: carrier?.quoteNumber ?? "Unknown",
+      proposedEffectiveDate: carrier?.proposedEffectiveDate,
+      proposedExpirationDate: carrier?.proposedExpirationDate,
+      subjectivities: coverages?.subjectivities,
+      underwritingConditions: coverages?.underwritingConditions,
+      premiumBreakdown: premium?.premiumBreakdown
+    };
   }
-  return {
-    ...base,
-    type: "quote",
-    quoteNumber: carrier?.quoteNumber ?? "Unknown",
-    proposedEffectiveDate: carrier?.proposedEffectiveDate,
-    proposedExpirationDate: carrier?.proposedExpirationDate,
-    subjectivities: coverages?.subjectivities,
-    underwritingConditions: coverages?.underwritingConditions,
-    premiumBreakdown: premium?.premiumBreakdown
-  };
+  promoteExtractedFields(doc);
+  return doc;
 }
 
 // src/prompts/coordinator/format.ts
@@ -3301,21 +3664,69 @@ Use the page map to target follow-up extraction pages precisely. Prefer narrow,
 Respond with JSON only.`;
 }
 
-// src/prompts/extractors/carrier-info.ts
+// src/prompts/coordinator/summarize.ts
 var import_zod22 = require("zod");
-var CarrierInfoSchema = import_zod22.z.object({
-  carrierName: import_zod22.z.string().describe("Primary insurance company name for display"),
-  carrierLegalName: import_zod22.z.string().optional().describe("Legal entity name of insurer"),
-  naicNumber: import_zod22.z.string().optional().describe("NAIC company code"),
-  amBestRating: import_zod22.z.string().optional().describe("AM Best rating, e.g. 'A+ XV'"),
-  admittedStatus: import_zod22.z.enum(["admitted", "non_admitted", "surplus_lines"]).optional().describe("Admitted status of the carrier"),
-  mga: import_zod22.z.string().optional().describe("Managing General Agent or Program Administrator name"),
-  underwriter: import_zod22.z.string().optional().describe("Named individual underwriter"),
-  policyNumber: import_zod22.z.string().optional().describe("Policy or quote reference number"),
-  effectiveDate: import_zod22.z.string().optional().describe("Policy effective date (MM/DD/YYYY)"),
-  expirationDate: import_zod22.z.string().optional().describe("Policy expiration date (MM/DD/YYYY)"),
-  quoteNumber: import_zod22.z.string().optional().describe("Quote or proposal reference number"),
-  proposedEffectiveDate: import_zod22.z.string().optional().describe("Proposed effective date for quotes (MM/DD/YYYY)")
+var SummaryResultSchema = import_zod22.z.object({
+  summary: import_zod22.z.string().describe("A 1-3 sentence overview of this insurance document")
+});
+function buildSummaryPrompt(doc) {
+  const snapshot = {
+    type: doc.type,
+    carrier: doc.carrier,
+    insuredName: doc.insuredName,
+    policyTypes: doc.policyTypes,
+    premium: doc.premium,
+    coverageCount: doc.coverages?.length ?? 0
+  };
+  if (doc.type === "policy") {
+    snapshot.policyNumber = doc.policyNumber;
+    snapshot.effectiveDate = doc.effectiveDate;
+    snapshot.expirationDate = doc.expirationDate;
+  } else {
+    snapshot.quoteNumber = doc.quoteNumber;
+    snapshot.proposedEffectiveDate = doc.proposedEffectiveDate;
+  }
+  const raw = doc;
+  if (raw.limits) snapshot.limits = raw.limits;
+  if (raw.deductibles) snapshot.deductibles = raw.deductibles;
+  if (raw.brokerAgency) snapshot.brokerAgency = raw.brokerAgency;
+  if (doc.endorsements?.length) snapshot.endorsementCount = doc.endorsements.length;
+  if (doc.exclusions?.length) snapshot.exclusionCount = doc.exclusions.length;
+  if (doc.coverages?.length) {
+    snapshot.topCoverages = doc.coverages.slice(0, 5).map((c) => c.name);
+  }
+  return `You are an expert insurance document analyst. Generate a brief summary of this insurance document.
+
+Write 1-3 sentences that capture the essential facts a broker or underwriter would want at a glance:
+- Who is insured and by whom
+- What type of policy/quote and the key coverages
+- Policy period and premium if available
+- Any notable features (high limits, unusual exclusions, etc.)
+
+Document data:
+${JSON.stringify(snapshot, null, 2)}
+
+Return JSON only with a "summary" field.`;
+}
+
+// src/prompts/extractors/carrier-info.ts
+var import_zod23 = require("zod");
+var CarrierInfoSchema = import_zod23.z.object({
+  carrierName: import_zod23.z.string().describe("Primary insurance company name for display"),
+  carrierLegalName: import_zod23.z.string().optional().describe("Legal entity name of insurer"),
+  naicNumber: import_zod23.z.string().optional().describe("NAIC company code"),
+  amBestRating: import_zod23.z.string().optional().describe("AM Best rating, e.g. 'A+ XV'"),
+  admittedStatus: import_zod23.z.enum(["admitted", "non_admitted", "surplus_lines"]).optional().describe("Admitted status of the carrier"),
+  mga: import_zod23.z.string().optional().describe("Managing General Agent or Program Administrator name"),
+  underwriter: import_zod23.z.string().optional().describe("Named individual underwriter"),
+  brokerAgency: import_zod23.z.string().optional().describe("Broker or producer agency name"),
+  brokerContactName: import_zod23.z.string().optional().describe("Broker or producer contact person name"),
+  brokerLicenseNumber: import_zod23.z.string().optional().describe("Broker or producer license number"),
+  policyNumber: import_zod23.z.string().optional().describe("Policy or quote reference number"),
+  effectiveDate: import_zod23.z.string().optional().describe("Policy effective date (MM/DD/YYYY)"),
+  expirationDate: import_zod23.z.string().optional().describe("Policy expiration date (MM/DD/YYYY)"),
+  quoteNumber: import_zod23.z.string().optional().describe("Quote or proposal reference number"),
+  proposedEffectiveDate: import_zod23.z.string().optional().describe("Proposed effective date for quotes (MM/DD/YYYY)")
 });
 function buildCarrierInfoPrompt() {
   return `You are an expert insurance document analyst. Extract carrier and policy identification information from this document.
@@ -3326,27 +3737,30 @@ Focus on:
 - Whether the carrier is admitted, non-admitted, or surplus lines
 - Managing General Agent (MGA) or Program Administrator if applicable
 - Named individual underwriter if listed
+- Broker/producer/agent: agency name, contact person name, and license number
 - Policy number and effective/expiration dates
 - For quotes: quote number and proposed effective date
 
 For carrier vs. security distinction: "carrier" is the primary company name; the legal entity on risk (e.g. "Lloyd's Underwriters") may differ from the display name.
 
+Look for broker/producer/agent information near the carrier or on the declarations page. This may be labeled "Producer", "Agent", "Broker", or similar.
+
 Return JSON only.`;
 }
 
 // src/prompts/extractors/named-insured.ts
-var import_zod23 = require("zod");
-var AddressSchema2 = import_zod23.z.object({
-  street1: import_zod23.z.string(),
-  city: import_zod23.z.string(),
-  state: import_zod23.z.string(),
-  zip: import_zod23.z.string()
+var import_zod24 = require("zod");
+var AddressSchema2 = import_zod24.z.object({
+  street1: import_zod24.z.string(),
+  city: import_zod24.z.string(),
+  state: import_zod24.z.string(),
+  zip: import_zod24.z.string()
 });
-var NamedInsuredSchema2 = import_zod23.z.object({
-  insuredName: import_zod23.z.string().describe("Name of primary named insured"),
-  insuredDba: import_zod23.z.string().optional().describe("Doing-business-as name"),
+var NamedInsuredSchema2 = import_zod24.z.object({
+  insuredName: import_zod24.z.string().describe("Name of primary named insured"),
+  insuredDba: import_zod24.z.string().optional().describe("Doing-business-as name"),
   insuredAddress: AddressSchema2.optional().describe("Primary insured mailing address"),
-  insuredEntityType: import_zod23.z.enum([
+  insuredEntityType: import_zod24.z.enum([
     "corporation",
     "llc",
     "partnership",
@@ -3359,16 +3773,28 @@ var NamedInsuredSchema2 = import_zod23.z.object({
     "married_couple",
     "other"
   ]).optional().describe("Legal entity type of the insured"),
-  insuredFein: import_zod23.z.string().optional().describe("Federal Employer Identification Number"),
-  insuredSicCode: import_zod23.z.string().optional().describe("SIC code"),
-  insuredNaicsCode: import_zod23.z.string().optional().describe("NAICS code"),
-  additionalNamedInsureds: import_zod23.z.array(
-    import_zod23.z.object({
-      name: import_zod23.z.string(),
-      relationship: import_zod23.z.string().optional().describe("e.g. subsidiary, affiliate"),
+  insuredFein: import_zod24.z.string().optional().describe("Federal Employer Identification Number"),
+  insuredSicCode: import_zod24.z.string().optional().describe("SIC code"),
+  insuredNaicsCode: import_zod24.z.string().optional().describe("NAICS code"),
+  additionalNamedInsureds: import_zod24.z.array(
+    import_zod24.z.object({
+      name: import_zod24.z.string(),
+      relationship: import_zod24.z.string().optional().describe("e.g. subsidiary, affiliate"),
+      address: AddressSchema2.optional()
+    })
+  ).optional().describe("Additional named insureds listed on the policy"),
+  lossPayees: import_zod24.z.array(
+    import_zod24.z.object({
+      name: import_zod24.z.string(),
+      address: AddressSchema2.optional()
+    })
+  ).optional().describe("Loss payees listed on the policy"),
+  mortgageHolders: import_zod24.z.array(
+    import_zod24.z.object({
+      name: import_zod24.z.string(),
       address: AddressSchema2.optional()
     })
-  ).optional().describe("Additional named insureds listed on the policy")
+  ).optional().describe("Mortgage holders / lienholders listed on the policy")
 });
 function buildNamedInsuredPrompt() {
   return `You are an expert insurance document analyst. Extract all named insured information from this document.
@@ -3379,21 +3805,23 @@ Focus on:
 - FEIN (Federal Employer Identification Number) if listed
 - SIC code and NAICS code if listed
 - ALL additional named insureds with their relationship (subsidiary, affiliate, etc.) and address if provided
+- ALL loss payees with name and address (e.g. "Loss Payee: BMO Bank of Montreal")
+- ALL mortgage holders / lienholders / mortgagees with name and address
 
-Look on the declarations page, named insured schedule, and any endorsements that add or modify named insureds.
+Look on the declarations page, named insured schedule, loss payee schedule, mortgagee schedule, and any endorsements that add or modify named insureds, loss payees, or mortgage holders.
 
 Return JSON only.`;
 }
 
 // src/prompts/extractors/coverage-limits.ts
-var import_zod24 = require("zod");
+var import_zod25 = require("zod");
 var ExtractorCoverageSchema = CoverageSchema.extend({
-  coverageCode: import_zod24.z.string().optional().describe("Coverage code or class code")
+  coverageCode: import_zod25.z.string().optional().describe("Coverage code or class code")
 });
-var CoverageLimitsSchema = import_zod24.z.object({
-  coverages: import_zod24.z.array(ExtractorCoverageSchema).describe("All coverages with their limits"),
-  coverageForm: import_zod24.z.enum(["occurrence", "claims_made", "accident"]).optional().describe("Primary coverage trigger type"),
-  retroactiveDate: import_zod24.z.string().optional().describe("Retroactive date for claims-made policies (MM/DD/YYYY)")
+var CoverageLimitsSchema = import_zod25.z.object({
+  coverages: import_zod25.z.array(ExtractorCoverageSchema).describe("All coverages with their limits"),
+  coverageForm: import_zod25.z.enum(["occurrence", "claims_made", "accident"]).optional().describe("Primary coverage trigger type"),
+  retroactiveDate: import_zod25.z.string().optional().describe("Retroactive date for claims-made policies (MM/DD/YYYY)")
 });
 function buildCoverageLimitsPrompt() {
   return `You are an expert insurance document analyst. Extract all coverage limits and deductibles from this document.
@@ -3432,14 +3860,14 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/endorsements.ts
-var import_zod25 = require("zod");
-var EndorsementsSchema = import_zod25.z.object({
-  endorsements: import_zod25.z.array(
-    import_zod25.z.object({
-      formNumber: import_zod25.z.string().describe("Form number, e.g. 'CG 21 47'"),
-      editionDate: import_zod25.z.string().optional().describe("Edition date, e.g. '12 07'"),
-      title: import_zod25.z.string().describe("Endorsement title"),
-      endorsementType: import_zod25.z.enum([
+var import_zod26 = require("zod");
+var EndorsementsSchema = import_zod26.z.object({
+  endorsements: import_zod26.z.array(
+    import_zod26.z.object({
+      formNumber: import_zod26.z.string().describe("Form number, e.g. 'CG 21 47'"),
+      editionDate: import_zod26.z.string().optional().describe("Edition date, e.g. '12 07'"),
+      title: import_zod26.z.string().describe("Endorsement title"),
+      endorsementType: import_zod26.z.enum([
         "additional_insured",
         "waiver_of_subrogation",
         "primary_noncontributory",
@@ -3459,12 +3887,12 @@ var EndorsementsSchema = import_zod25.z.object({
         "territorial_extension",
         "other"
       ]).describe("Endorsement type classification"),
-      effectiveDate: import_zod25.z.string().optional().describe("Endorsement effective date"),
-      affectedCoverageParts: import_zod25.z.array(import_zod25.z.string()).optional().describe("Coverage parts affected by this endorsement"),
-      namedParties: import_zod25.z.array(
-        import_zod25.z.object({
-          name: import_zod25.z.string().describe("Party name"),
-          role: import_zod25.z.enum([
+      effectiveDate: import_zod26.z.string().optional().describe("Endorsement effective date"),
+      affectedCoverageParts: import_zod26.z.array(import_zod26.z.string()).optional().describe("Coverage parts affected by this endorsement"),
+      namedParties: import_zod26.z.array(
+        import_zod26.z.object({
+          name: import_zod26.z.string().describe("Party name"),
+          role: import_zod26.z.enum([
             "additional_insured",
             "loss_payee",
             "mortgage_holder",
@@ -3473,15 +3901,15 @@ var EndorsementsSchema = import_zod25.z.object({
             "designated_person",
             "other"
           ]).describe("Party role"),
-          relationship: import_zod25.z.string().optional().describe("Relationship to insured"),
-          scope: import_zod25.z.string().optional().describe("Scope of coverage for this party")
+          relationship: import_zod26.z.string().optional().describe("Relationship to insured"),
+          scope: import_zod26.z.string().optional().describe("Scope of coverage for this party")
         })
       ).optional().describe("Named parties (additional insureds, loss payees, etc.)"),
-      keyTerms: import_zod25.z.array(import_zod25.z.string()).optional().describe("Key terms or notable provisions in the endorsement"),
-      premiumImpact: import_zod25.z.string().optional().describe("Additional premium or credit"),
-      content: import_zod25.z.string().describe("Full verbatim text of the endorsement"),
-      pageStart: import_zod25.z.number().describe("Starting page number of this endorsement"),
-      pageEnd: import_zod25.z.number().optional().describe("Ending page number of this endorsement")
+      keyTerms: import_zod26.z.array(import_zod26.z.string()).optional().describe("Key terms or notable provisions in the endorsement"),
+      premiumImpact: import_zod26.z.string().optional().describe("Additional premium or credit"),
+      content: import_zod26.z.string().describe("Full verbatim text of the endorsement"),
+      pageStart: import_zod26.z.number().describe("Starting page number of this endorsement"),
+      pageEnd: import_zod26.z.number().optional().describe("Ending page number of this endorsement")
     })
   ).describe("All endorsements found in the document")
 });
@@ -3512,20 +3940,20 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/exclusions.ts
-var import_zod26 = require("zod");
-var ExclusionsSchema = import_zod26.z.object({
-  exclusions: import_zod26.z.array(
-    import_zod26.z.object({
-      name: import_zod26.z.string().describe("Exclusion title or short description"),
-      formNumber: import_zod26.z.string().optional().describe("Form number if part of a named endorsement"),
-      excludedPerils: import_zod26.z.array(import_zod26.z.string()).optional().describe("Specific perils excluded"),
-      isAbsolute: import_zod26.z.boolean().optional().describe("Whether the exclusion is absolute (no exceptions)"),
-      exceptions: import_zod26.z.array(import_zod26.z.string()).optional().describe("Exceptions to the exclusion, if any"),
-      buybackAvailable: import_zod26.z.boolean().optional().describe("Whether coverage can be bought back via endorsement"),
-      buybackEndorsement: import_zod26.z.string().optional().describe("Form number of the buyback endorsement if available"),
-      appliesTo: import_zod26.z.array(import_zod26.z.string()).optional().describe("Coverage types this exclusion applies to"),
-      content: import_zod26.z.string().describe("Full verbatim exclusion text"),
-      pageNumber: import_zod26.z.number().optional().describe("Page number where exclusion appears")
+var import_zod27 = require("zod");
+var ExclusionsSchema = import_zod27.z.object({
+  exclusions: import_zod27.z.array(
+    import_zod27.z.object({
+      name: import_zod27.z.string().describe("Exclusion title or short description"),
+      formNumber: import_zod27.z.string().optional().describe("Form number if part of a named endorsement"),
+      excludedPerils: import_zod27.z.array(import_zod27.z.string()).optional().describe("Specific perils excluded"),
+      isAbsolute: import_zod27.z.boolean().optional().describe("Whether the exclusion is absolute (no exceptions)"),
+      exceptions: import_zod27.z.array(import_zod27.z.string()).optional().describe("Exceptions to the exclusion, if any"),
+      buybackAvailable: import_zod27.z.boolean().optional().describe("Whether coverage can be bought back via endorsement"),
+      buybackEndorsement: import_zod27.z.string().optional().describe("Form number of the buyback endorsement if available"),
+      appliesTo: import_zod27.z.array(import_zod27.z.string()).optional().describe("Coverage types this exclusion applies to"),
+      content: import_zod27.z.string().describe("Full verbatim exclusion text"),
+      pageNumber: import_zod27.z.number().optional().describe("Page number where exclusion appears")
     })
   ).describe("All exclusions found in the document")
 });
@@ -3561,12 +3989,12 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/conditions.ts
-var import_zod27 = require("zod");
-var ConditionsSchema = import_zod27.z.object({
-  conditions: import_zod27.z.array(
-    import_zod27.z.object({
-      name: import_zod27.z.string().describe("Condition title"),
-      conditionType: import_zod27.z.enum([
+var import_zod28 = require("zod");
+var ConditionsSchema = import_zod28.z.object({
+  conditions: import_zod28.z.array(
+    import_zod28.z.object({
+      name: import_zod28.z.string().describe("Condition title"),
+      conditionType: import_zod28.z.enum([
         "duties_after_loss",
         "notice_requirements",
         "other_insurance",
@@ -3585,14 +4013,14 @@ var ConditionsSchema = import_zod27.z.object({
         "separation_of_insureds",
         "other"
       ]).describe("Condition category"),
-      content: import_zod27.z.string().describe("Full verbatim condition text"),
-      keyValues: import_zod27.z.array(
-        import_zod27.z.object({
-          key: import_zod27.z.string().describe("Key name (e.g. 'noticePeriod', 'suitDeadline')"),
-          value: import_zod27.z.string().describe("Value (e.g. '30 days', '2 years')")
+      content: import_zod28.z.string().describe("Full verbatim condition text"),
+      keyValues: import_zod28.z.array(
+        import_zod28.z.object({
+          key: import_zod28.z.string().describe("Key name (e.g. 'noticePeriod', 'suitDeadline')"),
+          value: import_zod28.z.string().describe("Value (e.g. '30 days', '2 years')")
         })
       ).optional().describe("Key values extracted from the condition (notice periods, deadlines, etc.)"),
-      pageNumber: import_zod27.z.number().optional().describe("Page number where condition appears")
+      pageNumber: import_zod28.z.number().optional().describe("Page number where condition appears")
     })
   ).describe("All policy conditions found in the document")
 });
@@ -3630,28 +4058,28 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/premium-breakdown.ts
-var import_zod28 = require("zod");
-var PremiumBreakdownSchema = import_zod28.z.object({
-  premium: import_zod28.z.string().optional().describe("Total premium amount, e.g. '$5,000'"),
-  totalCost: import_zod28.z.string().optional().describe("Total cost including taxes and fees, e.g. '$5,250'"),
-  premiumBreakdown: import_zod28.z.array(
-    import_zod28.z.object({
-      line: import_zod28.z.string().describe("Coverage line name"),
-      amount: import_zod28.z.string().describe("Premium amount for this line")
+var import_zod29 = require("zod");
+var PremiumBreakdownSchema = import_zod29.z.object({
+  premium: import_zod29.z.string().optional().describe("Total premium amount, e.g. '$5,000'"),
+  totalCost: import_zod29.z.string().optional().describe("Total cost including taxes and fees, e.g. '$5,250'"),
+  premiumBreakdown: import_zod29.z.array(
+    import_zod29.z.object({
+      line: import_zod29.z.string().describe("Coverage line name"),
+      amount: import_zod29.z.string().describe("Premium amount for this line")
     })
   ).optional().describe("Per-coverage-line premium breakdown"),
-  taxesAndFees: import_zod28.z.array(
-    import_zod28.z.object({
-      name: import_zod28.z.string().describe("Fee or tax name"),
-      amount: import_zod28.z.string().describe("Dollar amount"),
-      type: import_zod28.z.enum(["tax", "fee", "surcharge", "assessment"]).optional().describe("Fee category")
+  taxesAndFees: import_zod29.z.array(
+    import_zod29.z.object({
+      name: import_zod29.z.string().describe("Fee or tax name"),
+      amount: import_zod29.z.string().describe("Dollar amount"),
+      type: import_zod29.z.enum(["tax", "fee", "surcharge", "assessment"]).optional().describe("Fee category")
     })
   ).optional().describe("Taxes, fees, surcharges, and assessments"),
-  minimumPremium: import_zod28.z.string().optional().describe("Minimum premium if stated"),
-  depositPremium: import_zod28.z.string().optional().describe("Deposit premium if stated"),
-  paymentPlan: import_zod28.z.string().optional().describe("Payment plan description"),
-  auditType: import_zod28.z.enum(["annual", "semi_annual", "quarterly", "monthly", "final", "self"]).optional().describe("Premium audit type"),
-  ratingBasis: import_zod28.z.string().optional().describe("Rating basis, e.g. payroll, revenue, area, units")
+  minimumPremium: import_zod29.z.string().optional().describe("Minimum premium if stated"),
+  depositPremium: import_zod29.z.string().optional().describe("Deposit premium if stated"),
+  paymentPlan: import_zod29.z.string().optional().describe("Payment plan description"),
+  auditType: import_zod29.z.enum(["annual", "semi_annual", "quarterly", "monthly", "final", "self"]).optional().describe("Premium audit type"),
+  ratingBasis: import_zod29.z.string().optional().describe("Rating basis, e.g. payroll, revenue, area, units")
 });
 function buildPremiumBreakdownPrompt() {
   return `You are an expert insurance document analyst. Extract all premium and cost information from this document.
@@ -3671,14 +4099,14 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/declarations.ts
-var import_zod29 = require("zod");
-var DeclarationsFieldSchema = import_zod29.z.object({
-  field: import_zod29.z.string().describe("Descriptive field name (e.g. 'policyNumber', 'effectiveDate', 'coverageALimit')"),
-  value: import_zod29.z.string().describe("Extracted value exactly as it appears in the document"),
-  section: import_zod29.z.string().optional().describe("Section or grouping this field belongs to (e.g. 'Coverage Limits', 'Vehicle Schedule')")
+var import_zod30 = require("zod");
+var DeclarationsFieldSchema = import_zod30.z.object({
+  field: import_zod30.z.string().describe("Descriptive field name (e.g. 'policyNumber', 'effectiveDate', 'coverageALimit')"),
+  value: import_zod30.z.string().describe("Extracted value exactly as it appears in the document"),
+  section: import_zod30.z.string().optional().describe("Section or grouping this field belongs to (e.g. 'Coverage Limits', 'Vehicle Schedule')")
 });
-var DeclarationsExtractSchema = import_zod29.z.object({
-  fields: import_zod29.z.array(DeclarationsFieldSchema).describe("All declarations page fields extracted as key-value pairs. Structure varies by line of business.")
+var DeclarationsExtractSchema = import_zod30.z.object({
+  fields: import_zod30.z.array(DeclarationsFieldSchema).describe("All declarations page fields extracted as key-value pairs. Structure varies by line of business.")
 });
 function buildDeclarationsPrompt() {
   return `You are an expert insurance document analyst. Extract all declarations page data from this document into a flexible key-value structure.
@@ -3718,21 +4146,21 @@ Preserve original values exactly as they appear. Return JSON only.`;
 }
 
 // src/prompts/extractors/loss-history.ts
-var import_zod30 = require("zod");
-var LossHistorySchema = import_zod30.z.object({
-  lossSummary: import_zod30.z.string().optional().describe("Summary of loss history, e.g. '3 claims in past 5 years totaling $125,000'"),
-  individualClaims: import_zod30.z.array(
-    import_zod30.z.object({
-      date: import_zod30.z.string().optional().describe("Date of loss or claim"),
-      type: import_zod30.z.string().optional().describe("Type of claim, e.g. 'property damage', 'bodily injury'"),
-      description: import_zod30.z.string().optional().describe("Brief description of the claim"),
-      amountPaid: import_zod30.z.string().optional().describe("Amount paid"),
-      amountReserved: import_zod30.z.string().optional().describe("Amount reserved"),
-      status: import_zod30.z.enum(["open", "closed", "reopened"]).optional().describe("Claim status"),
-      claimNumber: import_zod30.z.string().optional().describe("Claim reference number")
+var import_zod31 = require("zod");
+var LossHistorySchema = import_zod31.z.object({
+  lossSummary: import_zod31.z.string().optional().describe("Summary of loss history, e.g. '3 claims in past 5 years totaling $125,000'"),
+  individualClaims: import_zod31.z.array(
+    import_zod31.z.object({
+      date: import_zod31.z.string().optional().describe("Date of loss or claim"),
+      type: import_zod31.z.string().optional().describe("Type of claim, e.g. 'property damage', 'bodily injury'"),
+      description: import_zod31.z.string().optional().describe("Brief description of the claim"),
+      amountPaid: import_zod31.z.string().optional().describe("Amount paid"),
+      amountReserved: import_zod31.z.string().optional().describe("Amount reserved"),
+      status: import_zod31.z.enum(["open", "closed", "reopened"]).optional().describe("Claim status"),
+      claimNumber: import_zod31.z.string().optional().describe("Claim reference number")
     })
   ).optional().describe("Individual claim records"),
-  experienceMod: import_zod30.z.string().optional().describe("Experience modification factor for workers comp, e.g. '0.85'")
+  experienceMod: import_zod31.z.string().optional().describe("Experience modification factor for workers comp, e.g. '0.85'")
 });
 function buildLossHistoryPrompt() {
   return `You are an expert insurance document analyst. Extract all loss history and claims information from this document.
@@ -3749,18 +4177,18 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/sections.ts
-var import_zod31 = require("zod");
-var SubsectionSchema2 = import_zod31.z.object({
-  title: import_zod31.z.string().describe("Subsection title"),
-  sectionNumber: import_zod31.z.string().optional().describe("Subsection number"),
-  pageNumber: import_zod31.z.number().optional().describe("Page number"),
-  content: import_zod31.z.string().describe("Full verbatim text")
+var import_zod32 = require("zod");
+var SubsectionSchema2 = import_zod32.z.object({
+  title: import_zod32.z.string().describe("Subsection title"),
+  sectionNumber: import_zod32.z.string().optional().describe("Subsection number"),
+  pageNumber: import_zod32.z.number().optional().describe("Page number"),
+  content: import_zod32.z.string().describe("Full verbatim text")
 });
-var SectionsSchema = import_zod31.z.object({
-  sections: import_zod31.z.array(
-    import_zod31.z.object({
-      title: import_zod31.z.string().describe("Section title"),
-      type: import_zod31.z.enum([
+var SectionsSchema = import_zod32.z.object({
+  sections: import_zod32.z.array(
+    import_zod32.z.object({
+      title: import_zod32.z.string().describe("Section title"),
+      type: import_zod32.z.enum([
         "declarations",
         "insuring_agreement",
         "policy_form",
@@ -3774,10 +4202,10 @@ var SectionsSchema = import_zod31.z.object({
         "regulatory",
         "other"
       ]).describe("Section type classification"),
-      content: import_zod31.z.string().describe("Full verbatim text of the section"),
-      pageStart: import_zod31.z.number().describe("Starting page number"),
-      pageEnd: import_zod31.z.number().optional().describe("Ending page number"),
-      subsections: import_zod31.z.array(SubsectionSchema2).optional().describe("Subsections within this section")
+      content: import_zod32.z.string().describe("Full verbatim text of the section"),
+      pageStart: import_zod32.z.number().describe("Starting page number"),
+      pageEnd: import_zod32.z.number().optional().describe("Ending page number"),
+      subsections: import_zod32.z.array(SubsectionSchema2).optional().describe("Subsections within this section")
     })
   ).describe("All document sections")
 });
@@ -3807,20 +4235,20 @@ Return JSON only.`;
 }
 
 // src/prompts/extractors/supplementary.ts
-var import_zod32 = require("zod");
-var ContactSchema2 = import_zod32.z.object({
-  name: import_zod32.z.string().optional().describe("Organization or person name"),
-  phone: import_zod32.z.string().optional().describe("Phone number"),
-  email: import_zod32.z.string().optional().describe("Email address"),
-  address: import_zod32.z.string().optional().describe("Mailing address"),
-  type: import_zod32.z.string().optional().describe("Contact type, e.g. 'State Department of Insurance'")
+var import_zod33 = require("zod");
+var ContactSchema2 = import_zod33.z.object({
+  name: import_zod33.z.string().optional().describe("Organization or person name"),
+  phone: import_zod33.z.string().optional().describe("Phone number"),
+  email: import_zod33.z.string().optional().describe("Email address"),
+  address: import_zod33.z.string().optional().describe("Mailing address"),
+  type: import_zod33.z.string().optional().describe("Contact type, e.g. 'State Department of Insurance'")
 });
-var SupplementarySchema = import_zod32.z.object({
-  regulatoryContacts: import_zod32.z.array(ContactSchema2).optional().describe("Regulatory body contacts (state department of insurance, ombudsman)"),
-  claimsContacts: import_zod32.z.array(ContactSchema2).optional().describe("Claims reporting contacts and instructions"),
-  thirdPartyAdministrators: import_zod32.z.array(ContactSchema2).optional().describe("Third-party administrators for claims handling"),
-  cancellationNoticeDays: import_zod32.z.number().optional().describe("Required notice period for cancellation in days"),
-  nonrenewalNoticeDays: import_zod32.z.number().optional().describe("Required notice period for nonrenewal in days")
+var SupplementarySchema = import_zod33.z.object({
+  regulatoryContacts: import_zod33.z.array(ContactSchema2).optional().describe("Regulatory body contacts (state department of insurance, ombudsman)"),
+  claimsContacts: import_zod33.z.array(ContactSchema2).optional().describe("Claims reporting contacts and instructions"),
+  thirdPartyAdministrators: import_zod33.z.array(ContactSchema2).optional().describe("Third-party administrators for claims handling"),
+  cancellationNoticeDays: import_zod33.z.number().optional().describe("Required notice period for cancellation in days"),
+  nonrenewalNoticeDays: import_zod33.z.number().optional().describe("Required notice period for nonrenewal in days")
 });
 function buildSupplementaryPrompt() {
   return `You are an expert insurance document analyst. Extract supplementary and regulatory information from this document.
@@ -4679,6 +5107,31 @@ function createExtractor(config) {
       memory: Object.fromEntries(memory),
       document
     });
+    if (!document.summary) {
+      onProgress?.("Generating document summary...");
+      try {
+        const summaryResponse = await safeGenerateObject(
+          generateObject,
+          {
+            prompt: buildSummaryPrompt(document),
+            schema: SummaryResultSchema,
+            maxTokens: 512,
+            providerOptions
+          },
+          {
+            fallback: { summary: "" },
+            log,
+            onError: (err, attempt) => log?.(`Summary attempt ${attempt + 1} failed: ${err instanceof Error ? err.message : String(err)}`)
+          }
+        );
+        trackUsage(summaryResponse.usage);
+        if (summaryResponse.object.summary) {
+          document.summary = summaryResponse.object.summary;
+        }
+      } catch (error) {
+        await log?.(`Summary generation failed, skipping: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
     onProgress?.("Formatting extracted content...");
     const formatResult = await formatDocumentContent(document, generateText, {
       providerOptions,
@@ -4922,8 +5375,8 @@ Respond with JSON only:
 }`;
 
 // src/schemas/application.ts
-var import_zod33 = require("zod");
-var FieldTypeSchema = import_zod33.z.enum([
+var import_zod34 = require("zod");
+var FieldTypeSchema = import_zod34.z.enum([
   "text",
   "numeric",
   "currency",
@@ -4932,131 +5385,131 @@ var FieldTypeSchema = import_zod33.z.enum([
   "table",
   "declaration"
 ]);
-var ApplicationFieldSchema = import_zod33.z.object({
-  id: import_zod33.z.string(),
-  label: import_zod33.z.string(),
-  section: import_zod33.z.string(),
+var ApplicationFieldSchema = import_zod34.z.object({
+  id: import_zod34.z.string(),
+  label: import_zod34.z.string(),
+  section: import_zod34.z.string(),
   fieldType: FieldTypeSchema,
-  required: import_zod33.z.boolean(),
-  options: import_zod33.z.array(import_zod33.z.string()).optional(),
-  columns: import_zod33.z.array(import_zod33.z.string()).optional(),
-  requiresExplanationIfYes: import_zod33.z.boolean().optional(),
-  condition: import_zod33.z.object({
-    dependsOn: import_zod33.z.string(),
-    whenValue: import_zod33.z.string()
+  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()
   }).optional(),
-  value: import_zod33.z.string().optional(),
-  source: import_zod33.z.string().optional().describe("Where the value came from: auto-fill, user, lookup"),
-  confidence: import_zod33.z.enum(["confirmed", "high", "medium", "low"]).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()
 });
-var ApplicationClassifyResultSchema = import_zod33.z.object({
-  isApplication: import_zod33.z.boolean(),
-  confidence: import_zod33.z.number().min(0).max(1),
-  applicationType: import_zod33.z.string().nullable()
+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 FieldExtractionResultSchema = import_zod33.z.object({
-  fields: import_zod33.z.array(ApplicationFieldSchema)
+var FieldExtractionResultSchema = import_zod34.z.object({
+  fields: import_zod34.z.array(ApplicationFieldSchema)
 });
-var AutoFillMatchSchema = import_zod33.z.object({
-  fieldId: import_zod33.z.string(),
-  value: import_zod33.z.string(),
-  confidence: import_zod33.z.enum(["confirmed"]),
-  contextKey: import_zod33.z.string()
+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 AutoFillResultSchema = import_zod33.z.object({
-  matches: import_zod33.z.array(AutoFillMatchSchema)
+var AutoFillResultSchema = import_zod34.z.object({
+  matches: import_zod34.z.array(AutoFillMatchSchema)
 });
-var QuestionBatchResultSchema = import_zod33.z.object({
-  batches: import_zod33.z.array(import_zod33.z.array(import_zod33.z.string()).describe("Array of field IDs in this batch"))
+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 LookupRequestSchema = import_zod33.z.object({
-  type: import_zod33.z.string().describe("Type of lookup: 'records', 'website', 'policy'"),
-  description: import_zod33.z.string(),
-  url: import_zod33.z.string().optional(),
-  targetFieldIds: import_zod33.z.array(import_zod33.z.string())
+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 ReplyIntentSchema = import_zod33.z.object({
-  primaryIntent: import_zod33.z.enum(["answers_only", "question", "lookup_request", "mixed"]),
-  hasAnswers: import_zod33.z.boolean(),
-  questionText: import_zod33.z.string().optional(),
-  questionFieldIds: import_zod33.z.array(import_zod33.z.string()).optional(),
-  lookupRequests: import_zod33.z.array(LookupRequestSchema).optional()
+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 ParsedAnswerSchema = import_zod33.z.object({
-  fieldId: import_zod33.z.string(),
-  value: import_zod33.z.string(),
-  explanation: import_zod33.z.string().optional()
+var ParsedAnswerSchema = import_zod34.z.object({
+  fieldId: import_zod34.z.string(),
+  value: import_zod34.z.string(),
+  explanation: import_zod34.z.string().optional()
 });
-var AnswerParsingResultSchema = import_zod33.z.object({
-  answers: import_zod33.z.array(ParsedAnswerSchema),
-  unanswered: import_zod33.z.array(import_zod33.z.string()).describe("Field IDs that were not answered")
+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 LookupFillSchema = import_zod33.z.object({
-  fieldId: import_zod33.z.string(),
-  value: import_zod33.z.string(),
-  source: import_zod33.z.string().describe("Specific citable reference, e.g. 'GL Policy #POL-12345 (Hartford)'")
+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 LookupFillResultSchema = import_zod33.z.object({
-  fills: import_zod33.z.array(LookupFillSchema),
-  unfillable: import_zod33.z.array(import_zod33.z.string()),
-  explanation: import_zod33.z.string().optional()
+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 FlatPdfPlacementSchema = import_zod33.z.object({
-  fieldId: import_zod33.z.string(),
-  page: import_zod33.z.number(),
-  x: import_zod33.z.number().describe("Percentage from left edge (0-100)"),
-  y: import_zod33.z.number().describe("Percentage from top edge (0-100)"),
-  text: import_zod33.z.string(),
-  fontSize: import_zod33.z.number().optional(),
-  isCheckmark: import_zod33.z.boolean().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 AcroFormMappingSchema = import_zod33.z.object({
-  fieldId: import_zod33.z.string(),
-  acroFormName: import_zod33.z.string(),
-  value: import_zod33.z.string()
+var AcroFormMappingSchema = import_zod34.z.object({
+  fieldId: import_zod34.z.string(),
+  acroFormName: import_zod34.z.string(),
+  value: import_zod34.z.string()
 });
-var QualityGateStatusSchema = import_zod33.z.enum(["passed", "warning", "failed"]);
-var QualitySeveritySchema = import_zod33.z.enum(["info", "warning", "blocking"]);
-var ApplicationQualityIssueSchema = import_zod33.z.object({
-  code: import_zod33.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(),
   severity: QualitySeveritySchema,
-  message: import_zod33.z.string(),
-  fieldId: import_zod33.z.string().optional()
+  message: import_zod34.z.string(),
+  fieldId: import_zod34.z.string().optional()
 });
-var ApplicationQualityRoundSchema = import_zod33.z.object({
-  round: import_zod33.z.number(),
-  kind: import_zod33.z.string(),
+var ApplicationQualityRoundSchema = import_zod34.z.object({
+  round: import_zod34.z.number(),
+  kind: import_zod34.z.string(),
   status: QualityGateStatusSchema,
-  summary: import_zod33.z.string().optional()
+  summary: import_zod34.z.string().optional()
 });
-var ApplicationQualityArtifactSchema = import_zod33.z.object({
-  kind: import_zod33.z.string(),
-  label: import_zod33.z.string().optional(),
-  itemCount: import_zod33.z.number().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 ApplicationEmailReviewSchema = import_zod33.z.object({
-  issues: import_zod33.z.array(ApplicationQualityIssueSchema),
+var ApplicationEmailReviewSchema = import_zod34.z.object({
+  issues: import_zod34.z.array(ApplicationQualityIssueSchema),
   qualityGateStatus: QualityGateStatusSchema
 });
-var ApplicationQualityReportSchema = import_zod33.z.object({
-  issues: import_zod33.z.array(ApplicationQualityIssueSchema),
-  rounds: import_zod33.z.array(ApplicationQualityRoundSchema).optional(),
-  artifacts: import_zod33.z.array(ApplicationQualityArtifactSchema).optional(),
+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(),
   emailReview: ApplicationEmailReviewSchema.optional(),
   qualityGateStatus: QualityGateStatusSchema
 });
-var ApplicationStateSchema = import_zod33.z.object({
-  id: import_zod33.z.string(),
-  pdfBase64: import_zod33.z.string().optional().describe("Original PDF, omitted after extraction"),
-  title: import_zod33.z.string().optional(),
-  applicationType: import_zod33.z.string().nullable().optional(),
-  fields: import_zod33.z.array(ApplicationFieldSchema),
-  batches: import_zod33.z.array(import_zod33.z.array(import_zod33.z.string())).optional(),
-  currentBatchIndex: import_zod33.z.number().default(0),
+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),
   qualityReport: ApplicationQualityReportSchema.optional(),
-  status: import_zod33.z.enum(["classifying", "extracting", "auto_filling", "batching", "collecting", "confirming", "mapping", "complete"]),
-  createdAt: import_zod33.z.number(),
-  updatedAt: import_zod33.z.number()
+  status: import_zod34.z.enum(["classifying", "extracting", "auto_filling", "batching", "collecting", "confirming", "mapping", "complete"]),
+  createdAt: import_zod34.z.number(),
+  updatedAt: import_zod34.z.number()
 });
 
 // src/application/agents/classifier.ts
@@ -6126,7 +6579,7 @@ Respond with the explanation text only \u2014 no JSON, no field ID, no extra for
 }
 
 // src/prompts/query/classify.ts
-function buildQueryClassifyPrompt(question, conversationContext) {
+function buildQueryClassifyPrompt(question, conversationContext, attachmentContext) {
   return `You are a query classifier for an insurance document intelligence system.
 
 Analyze the user's question and produce a structured classification.
@@ -6136,6 +6589,9 @@ ${question}
 ${conversationContext ? `
 CONVERSATION CONTEXT:
 ${conversationContext}` : ""}
+${attachmentContext ? `
+ATTACHMENT CONTEXT:
+${attachmentContext}` : ""}
 
 INSTRUCTIONS:
 
@@ -6156,6 +6612,7 @@ INSTRUCTIONS:
    - requiresDocumentLookup: true if a specific document needs to be fetched by ID/number/carrier
    - requiresChunkSearch: true if semantic search over document chunks is needed
    - requiresConversationHistory: true if the question references prior conversation
+   - If the user's attachment already contains critical facts, still request chunk/document lookup when policy or quote details should be cross-checked against stored records
 
 CHUNK TYPES (for chunkTypes filter):
 carrier_info, named_insured, coverage, endorsement, exclusion, condition, section, declaration, loss_history, premium, supplementary
@@ -6189,73 +6646,90 @@ Respond with the final answer, deduplicated citations array, overall confidence
 }
 
 // src/schemas/query.ts
-var import_zod34 = require("zod");
-var QueryIntentSchema = import_zod34.z.enum([
+var import_zod35 = require("zod");
+var QueryIntentSchema = import_zod35.z.enum([
   "policy_question",
   "coverage_comparison",
   "document_search",
   "claims_inquiry",
   "general_knowledge"
 ]);
-var SubQuestionSchema = import_zod34.z.object({
-  question: import_zod34.z.string().describe("Atomic sub-question to retrieve and answer independently"),
+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"),
+  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")
+});
+var SubQuestionSchema = import_zod35.z.object({
+  question: import_zod35.z.string().describe("Atomic sub-question to retrieve and answer independently"),
   intent: QueryIntentSchema,
-  chunkTypes: import_zod34.z.array(import_zod34.z.string()).optional().describe("Chunk types to filter retrieval (e.g. coverage, endorsement, declaration)"),
-  documentFilters: import_zod34.z.object({
-    type: import_zod34.z.enum(["policy", "quote"]).optional(),
-    carrier: import_zod34.z.string().optional(),
-    insuredName: import_zod34.z.string().optional(),
-    policyNumber: import_zod34.z.string().optional(),
-    quoteNumber: import_zod34.z.string().optional()
+  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()
   }).optional().describe("Structured filters to narrow document lookup")
 });
-var QueryClassifyResultSchema = import_zod34.z.object({
+var QueryClassifyResultSchema = import_zod35.z.object({
   intent: QueryIntentSchema,
-  subQuestions: import_zod34.z.array(SubQuestionSchema).min(1).describe("Decomposed atomic sub-questions"),
-  requiresDocumentLookup: import_zod34.z.boolean().describe("Whether structured document lookup is needed"),
-  requiresChunkSearch: import_zod34.z.boolean().describe("Whether semantic chunk search is needed"),
-  requiresConversationHistory: import_zod34.z.boolean().describe("Whether conversation history is relevant")
+  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")
 });
-var EvidenceItemSchema = import_zod34.z.object({
-  source: import_zod34.z.enum(["chunk", "document", "conversation"]),
-  chunkId: import_zod34.z.string().optional(),
-  documentId: import_zod34.z.string().optional(),
-  turnId: import_zod34.z.string().optional(),
-  text: import_zod34.z.string().describe("Text excerpt from the source"),
-  relevance: import_zod34.z.number().min(0).max(1),
-  metadata: import_zod34.z.array(import_zod34.z.object({ key: import_zod34.z.string(), value: import_zod34.z.string() })).optional()
+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 RetrievalResultSchema = import_zod34.z.object({
-  subQuestion: import_zod34.z.string(),
-  evidence: import_zod34.z.array(EvidenceItemSchema)
+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 CitationSchema = import_zod34.z.object({
-  index: import_zod34.z.number().describe("Citation number [1], [2], etc."),
-  chunkId: import_zod34.z.string().describe("Source chunk ID, e.g. doc-123:coverage:2"),
-  documentId: import_zod34.z.string(),
-  documentType: import_zod34.z.enum(["policy", "quote"]).optional(),
-  field: import_zod34.z.string().optional().describe("Specific field path, e.g. coverages[0].deductible"),
-  quote: import_zod34.z.string().describe("Exact text from source that supports the claim"),
-  relevance: import_zod34.z.number().min(0).max(1)
+var RetrievalResultSchema = import_zod35.z.object({
+  subQuestion: import_zod35.z.string(),
+  evidence: import_zod35.z.array(EvidenceItemSchema)
 });
-var SubAnswerSchema = import_zod34.z.object({
-  subQuestion: import_zod34.z.string(),
-  answer: import_zod34.z.string(),
-  citations: import_zod34.z.array(CitationSchema),
-  confidence: import_zod34.z.number().min(0).max(1),
-  needsMoreContext: import_zod34.z.boolean().describe("True if evidence was insufficient to answer fully")
+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 VerifyResultSchema = import_zod34.z.object({
-  approved: import_zod34.z.boolean().describe("Whether all sub-answers are adequately grounded"),
-  issues: import_zod34.z.array(import_zod34.z.string()).describe("Specific grounding or consistency issues found"),
-  retrySubQuestions: import_zod34.z.array(import_zod34.z.string()).optional().describe("Sub-questions that need additional retrieval or re-reasoning")
+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 QueryResultSchema = import_zod34.z.object({
-  answer: import_zod34.z.string(),
-  citations: import_zod34.z.array(CitationSchema),
+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 QueryResultSchema = import_zod35.z.object({
+  answer: import_zod35.z.string(),
+  citations: import_zod35.z.array(CitationSchema),
   intent: QueryIntentSchema,
-  confidence: import_zod34.z.number().min(0).max(1),
-  followUp: import_zod34.z.string().optional().describe("Suggested follow-up question if applicable")
+  confidence: import_zod35.z.number().min(0).max(1),
+  followUp: import_zod35.z.string().optional().describe("Suggested follow-up question if applicable")
 });
 
 // src/query/retriever.ts
@@ -6545,7 +7019,7 @@ async function verify(originalQuestion, subAnswers, allEvidence, config) {
 
 // src/query/quality.ts
 function sourceIdForEvidence(evidence) {
-  return evidence.chunkId ?? evidence.documentId ?? evidence.turnId;
+  return evidence.chunkId ?? evidence.documentId ?? evidence.turnId ?? evidence.attachmentId;
 }
 function citationSourceId(citation) {
   return citation.chunkId || citation.documentId;
@@ -6649,6 +7123,152 @@ function buildQueryReviewReport(params) {
   };
 }
 
+// src/prompts/query/interpret-attachment.ts
+function buildInterpretAttachmentPrompt(question, attachment) {
+  const attachmentLabel = attachment.name ?? attachment.id ?? "attachment";
+  const descriptor = [
+    `Attachment: ${attachmentLabel}`,
+    `Kind: ${attachment.kind}`,
+    attachment.mimeType ? `MIME type: ${attachment.mimeType}` : null,
+    attachment.description ? `Caller description: ${attachment.description}` : null
+  ].filter(Boolean).join("\n");
+  return `You are interpreting a user-supplied attachment for an insurance-support question.
+
+USER QUESTION:
+${question}
+
+ATTACHMENT METADATA:
+${descriptor}
+
+${attachment.kind === "text" && attachment.text ? `ATTACHMENT TEXT:
+${attachment.text}
+` : "The attachment content is provided separately as a file or image input.\n"}
+INSTRUCTIONS:
+1. Describe what the attachment appears to show or contain in a concise summary.
+2. Extract concrete facts that may matter when answering the user's question.
+3. Note the most important details to carry forward into follow-up questions.
+4. If the attachment is a document, identify the key business or insurance details visible.
+5. If the attachment is a photo of damage or a real-world issue, describe the observable issue without guessing beyond what is visible.
+6. Do not invent unreadable text. If something is unclear, say so in the summary or extracted facts.
+
+Respond with the structured interpretation.`;
+}
+
+// src/query/multimodal.ts
+function attachmentSourceId(attachment, index) {
+  return attachment.id ?? `attachment-${index + 1}`;
+}
+function buildAttachmentProviderOptions(attachment, providerOptions) {
+  const merged = {
+    ...providerOptions,
+    attachments: [
+      {
+        kind: attachment.kind,
+        name: attachment.name,
+        mimeType: attachment.mimeType,
+        base64: attachment.base64,
+        text: attachment.text,
+        description: attachment.description
+      }
+    ]
+  };
+  if (attachment.kind === "pdf" && attachment.base64) {
+    merged.pdfBase64 = attachment.base64;
+  }
+  if (attachment.kind === "image" && attachment.base64) {
+    merged.images = [
+      {
+        imageBase64: attachment.base64,
+        mimeType: attachment.mimeType ?? "image/jpeg"
+      }
+    ];
+  }
+  return merged;
+}
+function buildAttachmentEvidenceText(attachment, interpretation) {
+  const lines = [
+    `Attachment kind: ${attachment.kind}`,
+    attachment.name ? `Attachment name: ${attachment.name}` : null,
+    attachment.mimeType ? `MIME type: ${attachment.mimeType}` : null,
+    attachment.description ? `Caller description: ${attachment.description}` : null,
+    `Summary: ${interpretation.summary}`,
+    interpretation.extractedFacts.length > 0 ? `Extracted facts:
+${interpretation.extractedFacts.map((fact) => `- ${fact}`).join("\n")}` : null,
+    interpretation.recommendedFocus.length > 0 ? `Important follow-up details:
+${interpretation.recommendedFocus.map((item) => `- ${item}`).join("\n")}` : null,
+    attachment.kind === "text" && attachment.text ? `Original text:
+${attachment.text}` : null
+  ];
+  return lines.filter(Boolean).join("\n");
+}
+async function interpretAttachments(params) {
+  const { attachments = [], question, generateObject, providerOptions, log, onUsage } = params;
+  if (attachments.length === 0) {
+    return { evidence: [] };
+  }
+  const evidence = [];
+  for (const [index, attachment] of attachments.entries()) {
+    const id = attachmentSourceId(attachment, index);
+    if (attachment.kind === "text" && attachment.text) {
+      const textEvidence = buildAttachmentEvidenceText(attachment, {
+        summary: attachment.description ?? "User supplied text context.",
+        extractedFacts: [attachment.text],
+        recommendedFocus: [],
+        confidence: 1
+      });
+      evidence.push({
+        source: "attachment",
+        attachmentId: id,
+        chunkId: id,
+        documentId: id,
+        text: textEvidence,
+        relevance: 0.95,
+        metadata: [
+          { key: "kind", value: attachment.kind },
+          ...attachment.name ? [{ key: "name", value: attachment.name }] : []
+        ]
+      });
+      continue;
+    }
+    const prompt = buildInterpretAttachmentPrompt(question, attachment);
+    const { object, usage } = await safeGenerateObject(
+      generateObject,
+      {
+        prompt,
+        schema: AttachmentInterpretationSchema,
+        maxTokens: 2048,
+        providerOptions: buildAttachmentProviderOptions(attachment, providerOptions)
+      },
+      {
+        fallback: {
+          summary: attachment.description ?? `User supplied ${attachment.kind} attachment.`,
+          extractedFacts: [],
+          recommendedFocus: [],
+          confidence: 0.2
+        },
+        log,
+        onError: (error, attempt) => log?.(`Attachment interpretation attempt ${attempt + 1} failed for "${attachment.name ?? id}": ${error}`)
+      }
+    );
+    onUsage?.(usage);
+    evidence.push({
+      source: "attachment",
+      attachmentId: id,
+      chunkId: id,
+      documentId: id,
+      text: buildAttachmentEvidenceText(attachment, object),
+      relevance: Math.max(0.7, object.confidence),
+      metadata: [
+        { key: "kind", value: attachment.kind },
+        ...attachment.name ? [{ key: "name", value: attachment.name }] : []
+      ]
+    });
+  }
+  const contextSummary = evidence.map((item, index) => `Attachment ${index + 1}:
+${item.text}`).join("\n\n");
+  return { evidence, contextSummary };
+}
+
 // src/query/coordinator.ts
 function createQueryAgent(config) {
   const {
@@ -6676,13 +7296,23 @@ function createQueryAgent(config) {
   }
   async function query(input) {
     totalUsage = { inputTokens: 0, outputTokens: 0 };
-    const { question, conversationId, context } = input;
+    const { question, conversationId, context, attachments } = input;
     const pipelineCtx = createPipelineContext({
       id: `query-${Date.now()}`
     });
+    onProgress?.("Interpreting attachments...");
+    const { evidence: attachmentEvidence, contextSummary: attachmentContext } = await interpretAttachments({
+      attachments,
+      question,
+      generateObject,
+      providerOptions,
+      log,
+      onUsage: trackUsage
+    });
+    await pipelineCtx.save("attachments", { attachmentEvidence });
     onProgress?.("Classifying query...");
-    const classification = await classify(question, conversationId);
-    await pipelineCtx.save("classify", { classification });
+    const classification = await classify(question, conversationId, attachmentContext);
+    await pipelineCtx.save("classify", { classification, attachmentEvidence });
     onProgress?.(`Retrieving evidence for ${classification.subQuestions.length} sub-question(s)...`);
     const retrieverConfig = {
       documentStore,
@@ -6695,8 +7325,8 @@ function createQueryAgent(config) {
         (sq) => limit(() => retrieve(sq, conversationId, retrieverConfig))
       )
     );
-    const allEvidence = retrievalResults.flatMap((r) => r.evidence);
-    await pipelineCtx.save("retrieve", { classification, evidence: allEvidence });
+    const allEvidence = [...attachmentEvidence, ...retrievalResults.flatMap((r) => r.evidence)];
+    await pipelineCtx.save("retrieve", { classification, attachmentEvidence, evidence: allEvidence });
     onProgress?.("Reasoning over evidence...");
     const reasonerConfig = { generateObject, providerOptions };
     const reasonResults = await Promise.allSettled(
@@ -6705,7 +7335,7 @@ function createQueryAgent(config) {
           const { subAnswer, usage } = await reason(
             sq.question,
             sq.intent,
-            retrievalResults[i].evidence,
+            [...attachmentEvidence, ...retrievalResults[i].evidence],
             reasonerConfig
           );
           trackUsage(usage);
@@ -6729,7 +7359,7 @@ function createQueryAgent(config) {
         });
       }
     }
-    await pipelineCtx.save("reason", { classification, evidence: allEvidence, subAnswers });
+    await pipelineCtx.save("reason", { classification, attachmentEvidence, evidence: allEvidence, subAnswers });
     onProgress?.("Verifying answer grounding...");
     const verifierConfig = { generateObject, providerOptions };
     const verifyRounds = [];
@@ -6777,7 +7407,7 @@ function createQueryAgent(config) {
                 const { subAnswer, usage: u } = await reason(
                   sq.question,
                   sq.intent,
-                  retryRetrievals[i].evidence,
+                  [...attachmentEvidence, ...retryRetrievals[i].evidence],
                   reasonerConfig
                 );
                 trackUsage(u);
@@ -6812,6 +7442,7 @@ function createQueryAgent(config) {
     });
     await pipelineCtx.save("review", {
       classification,
+      attachmentEvidence,
       evidence: allEvidence,
       subAnswers,
       reviewReport
@@ -6844,7 +7475,7 @@ function createQueryAgent(config) {
     }
     return { ...queryResult, tokenUsage: totalUsage, reviewReport };
   }
-  async function classify(question, conversationId) {
+  async function classify(question, conversationId, attachmentContext) {
     let conversationContext;
     if (conversationId) {
       try {
@@ -6855,7 +7486,7 @@ function createQueryAgent(config) {
       } catch {
       }
     }
-    const prompt = buildQueryClassifyPrompt(question, conversationContext);
+    const prompt = buildQueryClassifyPrompt(question, conversationContext, attachmentContext);
     const { object, usage } = await safeGenerateObject(
       generateObject,
       {
@@ -7071,6 +7702,7 @@ var AGENT_TOOLS = [
   ApplicationQualityReportSchema,
   ApplicationQualityRoundSchema,
   ApplicationStateSchema,
+  AttachmentInterpretationSchema,
   AuditTypeSchema,
   AutoFillMatchSchema,
   AutoFillResultSchema,
@@ -7192,6 +7824,8 @@ var AGENT_TOOLS = [
   ProducerInfoSchema,
   ProfessionalLiabilityDeclarationsSchema,
   QUOTE_SECTION_TYPES,
+  QueryAttachmentKindSchema,
+  QueryAttachmentSchema,
   QueryClassifyResultSchema,
   QueryIntentSchema,
   QueryResultSchema,
@@ -7250,6 +7884,7 @@ var AGENT_TOOLS = [
   buildFormattingPrompt,
   buildIdentityPrompt,
   buildIntentPrompt,
+  buildInterpretAttachmentPrompt,
   buildLookupFillPrompt,
   buildQueryClassifyPrompt,
   buildQuestionBatchPrompt,