Certificados de seguro (ACORD 25)

import { Constaia, ConstaiaError } from "@constaia/sdk";
import { fromPath } from "@constaia/sdk/node";

const constaia = new Constaia(); // lee CONSTAIA_API_KEY

export async function checkCoi(path: string, vendorName: string, jobStart: string) {
  const analysis = await constaia.analyze(await fromPath(path), {
    expect: "acord_25",
    checks: {
      referenceDate: jobStart,
      holder: { fullName: vendorName },
      requireFields: ["certificate_holder.name"],
    },
    storage: "none",
    metadata: { vendor: vendorName },
  });
  return {
    analysis,
    status: analysis.verdict?.status ?? "pending", // "valid" | "invalid" | "review"
    reasons: analysis.verdict?.reasons.map((r) => `${r.code} (${r.severity}): ${r.message}`) ?? [],
    policyExpiryDate: analysis.fields.policy_expiry_date?.value ?? null,
  };
}

checkCoi(process.argv[2] ?? "./coi.pdf", "Acme Roofing LLC", "2026-11-02")
  .then(({ status, reasons, policyExpiryDate }) => console.log({ status, reasons, policyExpiryDate }))
  .catch((err) => {
    if (err instanceof ConstaiaError) console.error(`Constaia error ${err.status} ${err.code} (request ${err.requestId})`);
    else console.error(err);
    process.exit(1);
  });

import type { Analysis } from "@constaia/sdk";

const minimumLimits: Record<string, Record<string, number>> = {
  "general liability": { "each occurrence": 1_000_000, "general aggregate": 2_000_000 },
};

const requirements = {
  holderMustContain: "YOUR COMPANY INC",
  requiredLines: ["general liability", "workers compensation"],
  additionalInsuredOn: "general liability",
  minimumLimits,
};

type Limit = { name?: string; amount?: number };
type Policy = { type?: string; policy_number?: string; expiry_date?: string; additional_insured?: boolean; limits?: Limit[] };

const has = (text: string | undefined, needle: string) => (text ?? "").toLowerCase().includes(needle);

export function checkContractRules(analysis: Analysis, jobEnd: string) {
  const issues: string[] = (analysis.verdict?.reasons ?? [])
    .filter((r) => r.severity !== "info")
    .map((r) => `${r.code}:${r.severity}`);
  const f = analysis.fields;
  const policies = (f.policies?.value as Policy[] | undefined) ?? [];

  for (const line of requirements.requiredLines) {
    const p = policies.find((x) => has(x.type, line));
    if (!p) issues.push(`missing_line:${line}`);
    else if (!p.expiry_date || p.expiry_date < jobEnd) issues.push(`expires_before_job_end:${line}`);
  }

  const ai = policies.find((x) => has(x.type, requirements.additionalInsuredOn));
  if (ai && ai.additional_insured !== true) issues.push("additional_insured_not_marked");

  for (const [line, mins] of Object.entries(requirements.minimumLimits)) {
    const limits = policies.find((x) => has(x.type, line))?.limits ?? [];
    for (const [name, min] of Object.entries(mins)) {
      const amount = limits.find((l) => has(l.name, name))?.amount;
      if (typeof amount !== "number" || amount < min) issues.push(`limit_below_minimum:${line}:${name}`);
    }
  }

  const holder = (f.certificate_holder?.value as { name?: string } | null)?.name ?? "";
  if (!holder.toUpperCase().includes(requirements.holderMustContain)) issues.push("certificate_holder_mismatch");

  return { ok: analysis.verdict?.status === "valid" && issues.length === 0, issues };
}