fdic-mcp-server 1.10.2 → 1.12.0

package/dist/index.js

@@ -32,7 +32,7 @@ var import_types = require("@modelcontextprotocol/sdk/types.js");
 var import_express2 = __toESM(require("express"));
 
 // src/constants.ts
-var VERSION = true ? "1.10.2" : process.env.npm_package_version ?? "0.0.0-dev";
+var VERSION = true ? "1.12.0" : process.env.npm_package_version ?? "0.0.0-dev";
 var FDIC_API_BASE_URL = "https://banks.data.fdic.gov/api";
 var CHARACTER_LIMIT = 5e4;
 var DEFAULT_FDIC_MAX_RESPONSE_BYTES = 5 * 1024 * 1024;
@@ -34351,6 +34351,1053 @@ Override precedence: cert derives defaults, then explicit params override them.`
   );
 }
 
+// src/tools/bankHealth.ts
+var import_zod9 = require("zod");
+
+// src/tools/shared/camelsScoring.ts
+var SCORING_RULES = {
+  // Capital
+  tier1_leverage: { thresholds: [8, 6, 5, 4], higher_is_better: true, weight: 0.35, label: "Tier 1 Leverage Ratio", unit: "%" },
+  tier1_rbc: { thresholds: [10, 8, 6, 4], higher_is_better: true, weight: 0.35, label: "Tier 1 Risk-Based Capital", unit: "%" },
+  equity_ratio: { thresholds: [10, 8, 7, 5], higher_is_better: true, weight: 0.3, label: "Equity / Assets", unit: "%" },
+  // Asset Quality
+  noncurrent_loans_ratio: { thresholds: [1, 2, 3, 5], higher_is_better: false, weight: 0.3, label: "Noncurrent Loans / Loans", unit: "%" },
+  net_chargeoff_ratio: { thresholds: [0.25, 0.5, 1, 2], higher_is_better: false, weight: 0.25, label: "Net Charge-Off Ratio", unit: "%" },
+  reserve_coverage: { thresholds: [150, 100, 80, 50], higher_is_better: true, weight: 0.25, label: "Reserve Coverage", unit: "%" },
+  noncurrent_assets_ratio: { thresholds: [0.5, 1, 2, 4], higher_is_better: false, weight: 0.2, label: "Noncurrent Assets / Assets", unit: "%" },
+  // Earnings
+  roa: { thresholds: [1, 0.75, 0.5, 0], higher_is_better: true, weight: 0.3, label: "Return on Assets", unit: "%" },
+  nim: { thresholds: [3.5, 3, 2.5, 2], higher_is_better: true, weight: 0.25, label: "Net Interest Margin", unit: "%" },
+  efficiency_ratio: { thresholds: [55, 60, 70, 85], higher_is_better: false, weight: 0.25, label: "Efficiency Ratio", unit: "%" },
+  roe: { thresholds: [10, 8, 5, 0], higher_is_better: true, weight: 0.2, label: "Return on Equity", unit: "%" },
+  // Liquidity
+  core_deposit_ratio: { thresholds: [80, 70, 60, 45], higher_is_better: true, weight: 0.3, label: "Core Deposits / Deposits", unit: "%" },
+  loan_to_deposit: { thresholds: [80, 85, 95, 105], higher_is_better: false, weight: 0.25, label: "Loan-to-Deposit Ratio", unit: "%" },
+  brokered_deposit_ratio: { thresholds: [5, 10, 15, 25], higher_is_better: false, weight: 0.25, label: "Brokered Deposits / Deposits", unit: "%" },
+  cash_ratio: { thresholds: [8, 5, 3, 1], higher_is_better: true, weight: 0.2, label: "Cash / Assets", unit: "%" },
+  // Sensitivity
+  nim_4q_change: { thresholds: [0.1, 0, -0.15, -0.3], higher_is_better: true, weight: 0.5, label: "NIM 4Q Change", unit: "pp" },
+  securities_to_assets: { thresholds: [25, 30, 40, 50], higher_is_better: false, weight: 0.5, label: "Securities / Assets", unit: "%" }
+};
+var COMPONENT_METRIC_MAP = {
+  C: ["tier1_leverage", "tier1_rbc", "equity_ratio"],
+  A: ["noncurrent_loans_ratio", "net_chargeoff_ratio", "reserve_coverage", "noncurrent_assets_ratio"],
+  E: ["roa", "nim", "efficiency_ratio", "roe"],
+  L: ["core_deposit_ratio", "loan_to_deposit", "brokered_deposit_ratio", "cash_ratio"],
+  S: ["nim_4q_change", "securities_to_assets"]
+};
+var RATING_LABELS = {
+  1: "Strong",
+  2: "Satisfactory",
+  3: "Fair",
+  4: "Marginal",
+  5: "Unsatisfactory"
+};
+var CAMELS_FIELDS = [
+  "CERT",
+  "REPDTE",
+  "ASSET",
+  "EQTOT",
+  "EQV",
+  "IDT1CER",
+  "IDT1RWAJR",
+  "NPERFV",
+  "NCLNLSR",
+  "NTLNLSR",
+  "LNATRESR",
+  "LNRESNCR",
+  "ELNATRY",
+  "ROA",
+  "ROAPTX",
+  "ROE",
+  "NIMY",
+  "EEFFR",
+  "NETINC",
+  "INTINC",
+  "EINTEXP",
+  "NONII",
+  "NONIX",
+  "DEP",
+  "COREDEP",
+  "BROR",
+  "LNLSDEPR",
+  "DEPDASTR",
+  "CHBALR",
+  "SC"
+].join(",");
+function safe(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function safeDivide(num, den) {
+  if (num === null || den === null || den === 0) return null;
+  return num / den;
+}
+function computeCamelsMetrics(current, prior) {
+  const dep = safe(current.DEP);
+  const asset = safe(current.ASSET);
+  const coredep = safe(current.COREDEP);
+  const sc = safe(current.SC);
+  const intinc = safe(current.INTINC);
+  const eintexp = safe(current.EINTEXP);
+  const nonii = safe(current.NONII);
+  const nii = intinc !== null && eintexp !== null ? intinc - eintexp : null;
+  const totalRevenue = nii !== null && nonii !== null ? nii + nonii : null;
+  const nimNow = safe(current.NIMY);
+  const nim4qAgo = prior && prior.length >= 4 ? safe(prior[3].NIMY) : null;
+  const nim4qChange = nimNow !== null && nim4qAgo !== null ? nimNow - nim4qAgo : null;
+  const coreDepRatio = safeDivide(coredep, dep);
+  const secToAssets = safeDivide(sc, asset);
+  const niiShare = totalRevenue !== null && totalRevenue > 0 && nonii !== null ? nonii / totalRevenue * 100 : null;
+  return {
+    equity_ratio: safe(current.EQV),
+    tier1_leverage: safe(current.IDT1CER),
+    tier1_rbc: safe(current.IDT1RWAJR),
+    noncurrent_assets_ratio: safe(current.NPERFV),
+    noncurrent_loans_ratio: safe(current.NCLNLSR),
+    net_chargeoff_ratio: safe(current.NTLNLSR),
+    reserve_to_loans: safe(current.LNATRESR),
+    reserve_coverage: safe(current.LNRESNCR),
+    provision_ratio: safe(current.ELNATRY),
+    roa: safe(current.ROA),
+    roe: safe(current.ROE),
+    nim: nimNow,
+    efficiency_ratio: safe(current.EEFFR),
+    pretax_roa: safe(current.ROAPTX),
+    noninterest_income_share: niiShare,
+    loan_to_deposit: safe(current.LNLSDEPR),
+    deposits_to_assets: safe(current.DEPDASTR),
+    core_deposit_ratio: coreDepRatio !== null ? coreDepRatio * 100 : null,
+    brokered_deposit_ratio: safe(current.BROR),
+    cash_ratio: safe(current.CHBALR),
+    securities_to_assets: secToAssets !== null ? secToAssets * 100 : null,
+    nim_4q_change: nim4qChange
+  };
+}
+function scoreMetric(value, rule) {
+  if (value === null) return 3;
+  const [t1, t2, t3, t4] = rule.thresholds;
+  if (rule.higher_is_better) {
+    if (value >= t1) return 1;
+    if (value >= t2) return 2;
+    if (value >= t3) return 3;
+    if (value >= t4) return 4;
+    return 5;
+  }
+  if (value <= t1) return 1;
+  if (value <= t2) return 2;
+  if (value <= t3) return 3;
+  if (value <= t4) return 4;
+  return 5;
+}
+function scoreComponent(component, metrics) {
+  const metricNames = COMPONENT_METRIC_MAP[component];
+  let weightedSum = 0;
+  let totalWeight = 0;
+  const scored = [];
+  const flags = [];
+  for (const metricName of metricNames) {
+    const rule = SCORING_RULES[metricName];
+    const value = metrics[metricName];
+    const rating2 = scoreMetric(value, rule);
+    scored.push({
+      name: metricName,
+      label: rule.label,
+      value,
+      rating: rating2,
+      rating_label: RATING_LABELS[rating2],
+      unit: rule.unit
+    });
+    if (value !== null) {
+      weightedSum += rating2 * rule.weight;
+      totalWeight += rule.weight;
+    }
+    if (rating2 >= 4 && value !== null) {
+      flags.push(`${rule.label} at ${value.toFixed(2)}${rule.unit} rated ${RATING_LABELS[rating2]}`);
+    }
+  }
+  const raw = totalWeight > 0 ? weightedSum / totalWeight : 3;
+  const rating = Math.round(raw);
+  return { component, rating, label: RATING_LABELS[rating], metrics: scored, flags };
+}
+var COMPONENT_WEIGHTS = {
+  C: 0.25,
+  A: 0.25,
+  E: 0.2,
+  L: 0.15,
+  S: 0.15
+};
+function compositeScore(components) {
+  let sum = 0;
+  const allFlags = [];
+  for (const c of components) {
+    sum += c.rating * (COMPONENT_WEIGHTS[c.component] ?? 0);
+    allFlags.push(...c.flags);
+  }
+  const rating = Math.round(sum);
+  return { rating, label: RATING_LABELS[rating], components, flags: allFlags };
+}
+function analyzeTrend(metricName, timeseries, higherIsBetter) {
+  const label = SCORING_RULES[metricName]?.label ?? metricName;
+  const valid = timeseries.filter(
+    (t) => t.value !== null
+  );
+  if (valid.length < 2) {
+    return {
+      metric: metricName,
+      label,
+      values: valid,
+      direction: "stable",
+      magnitude: "minimal",
+      quarters_analyzed: valid.length
+    };
+  }
+  const n = valid.length;
+  const xMean = (n - 1) / 2;
+  const yMean = valid.reduce((s, v) => s + v.value, 0) / n;
+  let num = 0;
+  let den = 0;
+  for (let i = 0; i < n; i++) {
+    num += (i - xMean) * (valid[i].value - yMean);
+    den += (i - xMean) ** 2;
+  }
+  const slope = den !== 0 ? num / den : 0;
+  const relSlope = yMean !== 0 ? slope / Math.abs(yMean) : 0;
+  const direction = higherIsBetter && relSlope > 0.02 || !higherIsBetter && relSlope < -0.02 ? "improving" : higherIsBetter && relSlope < -0.02 || !higherIsBetter && relSlope > 0.02 ? "deteriorating" : "stable";
+  const absMag = Math.abs(relSlope);
+  const magnitude = absMag > 0.1 ? "significant" : absMag > 0.03 ? "moderate" : "minimal";
+  return {
+    metric: metricName,
+    label,
+    values: valid,
+    direction,
+    magnitude,
+    quarters_analyzed: n
+  };
+}
+function isStale(repdte) {
+  const year = Number.parseInt(repdte.slice(0, 4), 10);
+  const month = Number.parseInt(repdte.slice(4, 6), 10);
+  const day = Number.parseInt(repdte.slice(6, 8), 10);
+  const reportDate = new Date(Date.UTC(year, month - 1, day));
+  if (Number.isNaN(reportDate.getTime())) return true;
+  const daysSince = (Date.now() - reportDate.getTime()) / 864e5;
+  return daysSince > 120;
+}
+function formatRating(rating) {
+  return `${rating} - ${RATING_LABELS[rating]}`;
+}
+
+// src/tools/bankHealth.ts
+var COMPONENT_NAMES = {
+  C: "Capital Adequacy",
+  A: "Asset Quality",
+  E: "Earnings",
+  L: "Liquidity",
+  S: "Sensitivity to Market Risk"
+};
+var TREND_METRICS = [
+  { key: "tier1_leverage", fdic_field: "IDT1CER", higher_is_better: true },
+  { key: "noncurrent_loans_ratio", fdic_field: "NCLNLSR", higher_is_better: false },
+  { key: "roa", fdic_field: "ROA", higher_is_better: true },
+  { key: "nim", fdic_field: "NIMY", higher_is_better: true },
+  { key: "efficiency_ratio", fdic_field: "EEFFR", higher_is_better: false },
+  { key: "loan_to_deposit", fdic_field: "LNLSDEPR", higher_is_better: false }
+];
+function formatHealthSummaryText(summary) {
+  const parts = [];
+  const { institution: inst, composite } = summary;
+  parts.push(`CAMELS-Style Health Assessment: ${inst.name} (CERT ${inst.cert})`);
+  parts.push(`${inst.city}, ${inst.state} | Charter: ${inst.charter_class} | Assets: $${Math.round(inst.total_assets).toLocaleString()}k`);
+  parts.push(`Report Date: ${inst.report_date} | Data: ${inst.data_staleness}`);
+  parts.push("");
+  parts.push("NOTE: This is an analytical assessment based on public financial data, not an official regulatory CAMELS rating.");
+  parts.push("");
+  parts.push(`Composite Rating: ${formatRating(composite.rating)}`);
+  parts.push("");
+  for (const comp of summary.components) {
+    const name = COMPONENT_NAMES[comp.component] ?? comp.component;
+    parts.push(`${name} (${comp.component}): ${formatRating(comp.rating)}`);
+    for (const m of comp.metrics) {
+      const val = m.value !== null ? `${m.value.toFixed(2)}${m.unit}` : "n/a";
+      parts.push(`  ${m.label.padEnd(30)} ${val.padStart(10)}  ${m.rating_label}`);
+    }
+    if (comp.flags.length > 0) {
+      for (const flag of comp.flags) {
+        parts.push(`  \u26A0 ${flag}`);
+      }
+    }
+    parts.push("");
+  }
+  if (summary.trends.length > 0) {
+    parts.push("Trend Analysis:");
+    for (const t of summary.trends) {
+      if (t.direction !== "stable") {
+        parts.push(`  ${t.label}: ${t.direction} (${t.magnitude}, ${t.quarters_analyzed}Q analyzed)`);
+      }
+    }
+    parts.push("");
+  }
+  if (summary.risk_signals.length > 0) {
+    parts.push("Risk Signals:");
+    for (const signal of summary.risk_signals) {
+      parts.push(`  \u2022 ${signal}`);
+    }
+    parts.push("");
+  }
+  return parts.join("\n");
+}
+function getPriorQuarterDates(repdte, count) {
+  const dates = [];
+  const suffixes = ["0331", "0630", "0930", "1231"];
+  let year = Number.parseInt(repdte.slice(0, 4), 10);
+  let qIdx = suffixes.indexOf(repdte.slice(4));
+  if (qIdx === -1) return dates;
+  for (let i = 0; i < count; i++) {
+    qIdx--;
+    if (qIdx < 0) {
+      qIdx = 3;
+      year--;
+    }
+    dates.push(`${year}${suffixes[qIdx]}`);
+  }
+  return dates;
+}
+function collectRiskSignals(metrics, components, trends) {
+  const signals = [];
+  if (metrics.tier1_leverage !== null && metrics.tier1_leverage < 5) {
+    signals.push(`Tier 1 leverage ratio at ${metrics.tier1_leverage.toFixed(2)}% \u2014 below well-capitalized threshold (5%)`);
+  }
+  if (metrics.roa !== null && metrics.roa < 0) {
+    signals.push(`Operating losses: ROA at ${metrics.roa.toFixed(2)}%`);
+  }
+  if (metrics.reserve_coverage !== null && metrics.reserve_coverage < 50) {
+    signals.push(`Reserve coverage critically low at ${metrics.reserve_coverage.toFixed(1)}%`);
+  }
+  if (metrics.brokered_deposit_ratio !== null && metrics.brokered_deposit_ratio > 15) {
+    signals.push(`High brokered deposit reliance: ${metrics.brokered_deposit_ratio.toFixed(1)}%`);
+  }
+  if (metrics.noncurrent_loans_ratio !== null && metrics.noncurrent_loans_ratio > 3) {
+    signals.push(`Elevated noncurrent loans: ${metrics.noncurrent_loans_ratio.toFixed(2)}%`);
+  }
+  for (const comp of components) {
+    if (comp.rating >= 4) {
+      const name = COMPONENT_NAMES[comp.component] ?? comp.component;
+      signals.push(`${name} component rated ${comp.rating} (${comp.label})`);
+    }
+  }
+  for (const t of trends) {
+    if (t.direction === "deteriorating" && t.magnitude === "significant") {
+      signals.push(`${t.label} deteriorating significantly over ${t.quarters_analyzed} quarters`);
+    }
+  }
+  return signals;
+}
+var BankHealthInputSchema = import_zod9.z.object({
+  cert: import_zod9.z.number().int().positive().describe("FDIC Certificate Number of the institution to analyze."),
+  repdte: import_zod9.z.string().regex(/^\d{8}$/).optional().describe(
+    "Report Date (YYYYMMDD). Defaults to the most recent quarter likely to have published data."
+  ),
+  quarters: import_zod9.z.number().int().min(1).max(20).default(8).describe("Number of prior quarters to fetch for trend analysis (default 8).")
+});
+function registerBankHealthTools(server) {
+  server.registerTool(
+    "fdic_analyze_bank_health",
+    {
+      title: "Analyze Bank Health (CAMELS-Style)",
+      description: `Produce a CAMELS-style analytical assessment for a single FDIC-insured institution.
+
+Scores five components \u2014 Capital (C), Asset Quality (A), Earnings (E), Liquidity (L), Sensitivity (S) \u2014 using published FDIC financial data and derives a weighted composite rating (1=Strong to 5=Unsatisfactory).
+
+Output includes:
+  - Composite and component ratings with individual metric scores
+  - Trend analysis across prior quarters for key metrics
+  - Risk signals flagging critical and warning-level concerns
+  - Structured JSON for programmatic consumption
+
+NOTE: Management (M) is omitted \u2014 cannot be assessed from public data. Sensitivity (S) uses proxy metrics (NIM trend, securities concentration). This is an analytical tool, not an official regulatory rating.`,
+      inputSchema: BankHealthInputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (rawParams, extra) => {
+      const params = { ...rawParams, repdte: rawParams.repdte ?? getDefaultReportDate() };
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), ANALYSIS_TIMEOUT_MS);
+      const progressToken = extra._meta?.progressToken;
+      try {
+        const dateError = validateQuarterEndDate(params.repdte, "repdte");
+        if (dateError) {
+          return formatToolError(new Error(dateError));
+        }
+        await sendProgressNotification(server.server, progressToken, 0.1, "Fetching institution profile");
+        const [profileResponse, financialsResponse] = await Promise.all([
+          queryEndpoint(
+            ENDPOINTS.INSTITUTIONS,
+            {
+              filters: `CERT:${params.cert}`,
+              fields: "CERT,NAME,CITY,STALP,BKCLASS,ASSET,ACTIVE",
+              limit: 1
+            },
+            { signal: controller.signal }
+          ),
+          queryEndpoint(
+            ENDPOINTS.FINANCIALS,
+            {
+              filters: `CERT:${params.cert} AND REPDTE:${params.repdte}`,
+              fields: CAMELS_FIELDS,
+              limit: 1
+            },
+            { signal: controller.signal }
+          )
+        ]);
+        const profileRecords = extractRecords(profileResponse);
+        if (profileRecords.length === 0) {
+          return formatToolError(new Error(`No institution found with CERT number ${params.cert}.`));
+        }
+        const profile = profileRecords[0];
+        const financialRecords = extractRecords(financialsResponse);
+        if (financialRecords.length === 0) {
+          return formatToolError(
+            new Error(
+              `No financial data for CERT ${params.cert} at report date ${params.repdte}. Try an earlier quarter-end date (0331, 0630, 0930, 1231).`
+            )
+          );
+        }
+        const currentFinancials = financialRecords[0];
+        await sendProgressNotification(server.server, progressToken, 0.3, "Fetching prior quarters for trend analysis");
+        const priorDates = getPriorQuarterDates(params.repdte, params.quarters);
+        let priorQuarters = [];
+        if (priorDates.length > 0) {
+          const dateFilter = priorDates.map((d) => `REPDTE:${d}`).join(" OR ");
+          const priorResponse = await queryEndpoint(
+            ENDPOINTS.FINANCIALS,
+            {
+              filters: `CERT:${params.cert} AND (${dateFilter})`,
+              fields: CAMELS_FIELDS,
+              sort_by: "REPDTE",
+              sort_order: "DESC",
+              limit: params.quarters
+            },
+            { signal: controller.signal }
+          );
+          priorQuarters = extractRecords(priorResponse);
+        }
+        await sendProgressNotification(server.server, progressToken, 0.6, "Computing CAMELS scores");
+        const metrics = computeCamelsMetrics(currentFinancials, priorQuarters);
+        const components = ["C", "A", "E", "L", "S"].map(
+          (c) => scoreComponent(c, metrics)
+        );
+        const composite = compositeScore(components);
+        await sendProgressNotification(server.server, progressToken, 0.8, "Analyzing trends");
+        const allQuarters = [currentFinancials, ...priorQuarters];
+        const trends = [];
+        for (const tm of TREND_METRICS) {
+          const timeseries = allQuarters.map((q) => ({
+            repdte: String(q.REPDTE ?? ""),
+            value: typeof q[tm.fdic_field] === "number" ? q[tm.fdic_field] : null
+          }));
+          timeseries.reverse();
+          trends.push(analyzeTrend(String(tm.key), timeseries, tm.higher_is_better));
+        }
+        const riskSignals = collectRiskSignals(metrics, components, trends);
+        const staleness = isStale(params.repdte) ? "stale (>120 days old)" : "current";
+        const summary = {
+          institution: {
+            cert: params.cert,
+            name: String(profile.NAME ?? ""),
+            city: String(profile.CITY ?? ""),
+            state: String(profile.STALP ?? ""),
+            charter_class: String(profile.BKCLASS ?? ""),
+            total_assets: typeof currentFinancials.ASSET === "number" ? currentFinancials.ASSET : 0,
+            report_date: params.repdte,
+            data_staleness: staleness
+          },
+          composite: { rating: composite.rating, label: composite.label },
+          components,
+          trends,
+          outliers: [],
+          risk_signals: riskSignals
+        };
+        const text = truncateIfNeeded(
+          formatHealthSummaryText(summary),
+          CHARACTER_LIMIT
+        );
+        return {
+          content: [{ type: "text", text }],
+          structuredContent: summary
+        };
+      } catch (err) {
+        return formatToolError(err);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  );
+}
+
+// src/tools/peerHealth.ts
+var import_zod10 = require("zod");
+var PeerHealthInputSchema = import_zod10.z.object({
+  cert: import_zod10.z.number().int().positive().optional().describe("Subject institution CERT to highlight in the ranking. Optional."),
+  certs: import_zod10.z.array(import_zod10.z.number().int().positive()).max(50).optional().describe("Explicit list of CERTs to compare (max 50)."),
+  state: import_zod10.z.string().regex(/^[A-Z]{2}$/).optional().describe('Two-letter state code to select all active institutions (e.g., "WY").'),
+  asset_min: import_zod10.z.number().positive().optional().describe("Minimum total assets ($thousands) for peer selection."),
+  asset_max: import_zod10.z.number().positive().optional().describe("Maximum total assets ($thousands) for peer selection."),
+  repdte: import_zod10.z.string().regex(/^\d{8}$/).optional().describe("Report Date (YYYYMMDD). Defaults to the most recent quarter."),
+  sort_by: import_zod10.z.enum(["composite", "capital", "asset_quality", "earnings", "liquidity", "sensitivity"]).default("composite").describe("Sort results by composite or a specific CAMELS component rating."),
+  limit: import_zod10.z.number().int().min(1).max(100).default(25).describe("Max institutions to return in the response.")
+});
+function sortKeyToComponent(key) {
+  const map = {
+    capital: "C",
+    asset_quality: "A",
+    earnings: "E",
+    liquidity: "L",
+    sensitivity: "S"
+  };
+  return map[key] ?? null;
+}
+function registerPeerHealthTools(server) {
+  server.registerTool(
+    "fdic_compare_peer_health",
+    {
+      title: "Compare Peer Health (CAMELS Rankings)",
+      description: `Compare CAMELS-style health scores across a group of FDIC-insured institutions.
+
+Three usage modes:
+  - Explicit list: provide certs (up to 50) for a specific comparison set
+  - State-wide scan: provide state to compare all active institutions in that state
+  - Asset-based: provide asset_min/asset_max to compare institutions by size
+
+Optionally provide cert to highlight a subject institution's position in the ranking.
+
+Output: Ranked list of institutions with CAMELS composite and component scores, sorted by composite or any individual component.
+
+NOTE: This is an analytical assessment, not official regulatory ratings.`,
+      inputSchema: PeerHealthInputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (rawParams, extra) => {
+      const params = { ...rawParams, repdte: rawParams.repdte ?? getDefaultReportDate() };
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), ANALYSIS_TIMEOUT_MS);
+      const progressToken = extra._meta?.progressToken;
+      try {
+        if (!params.certs && !params.state && params.asset_min === void 0 && params.asset_max === void 0 && !params.cert) {
+          return formatToolError(new Error("At least one selection criteria required: certs, state, asset_min/asset_max, or cert."));
+        }
+        const dateError = validateQuarterEndDate(params.repdte, "repdte");
+        if (dateError) {
+          return formatToolError(new Error(dateError));
+        }
+        await sendProgressNotification(server.server, progressToken, 0.1, "Building peer roster");
+        let peerCerts;
+        if (params.certs) {
+          peerCerts = [...params.certs];
+          if (params.cert && !peerCerts.includes(params.cert)) {
+            peerCerts.push(params.cert);
+          }
+        } else {
+          const filterParts = ["ACTIVE:1"];
+          if (params.state) filterParts.push(`STALP:${params.state}`);
+          if (params.asset_min !== void 0 || params.asset_max !== void 0) {
+            const min = params.asset_min ?? 0;
+            const max = params.asset_max ?? "*";
+            filterParts.push(`ASSET:[${min} TO ${max}]`);
+          }
+          if (params.cert && !params.state && params.asset_min === void 0) {
+            const profileResp = await queryEndpoint(
+              ENDPOINTS.INSTITUTIONS,
+              {
+                filters: `CERT:${params.cert}`,
+                fields: "CERT,ASSET,STALP,BKCLASS",
+                limit: 1
+              },
+              { signal: controller.signal }
+            );
+            const profileRecs = extractRecords(profileResp);
+            if (profileRecs.length === 0) {
+              return formatToolError(new Error(`No institution found with CERT ${params.cert}.`));
+            }
+            const subjectAsset = asNumber(profileRecs[0].ASSET);
+            if (subjectAsset !== null) {
+              filterParts.push(`ASSET:[${subjectAsset * 0.5} TO ${subjectAsset * 2}]`);
+            }
+            const bkclass = profileRecs[0].BKCLASS;
+            if (typeof bkclass === "string") {
+              filterParts.push(`BKCLASS:${bkclass}`);
+            }
+          }
+          const rosterResp = await queryEndpoint(
+            ENDPOINTS.INSTITUTIONS,
+            {
+              filters: filterParts.join(" AND "),
+              fields: "CERT",
+              limit: 1e4,
+              sort_by: "CERT",
+              sort_order: "ASC"
+            },
+            { signal: controller.signal }
+          );
+          peerCerts = extractRecords(rosterResp).map((r) => asNumber(r.CERT)).filter((c) => c !== null);
+        }
+        if (peerCerts.length === 0) {
+          return formatToolError(new Error("No institutions matched the specified criteria."));
+        }
+        await sendProgressNotification(server.server, progressToken, 0.4, `Fetching financials for ${peerCerts.length} institutions`);
+        const certFilters = buildCertFilters(peerCerts);
+        const financialResponses = await mapWithConcurrency(
+          certFilters,
+          MAX_CONCURRENCY,
+          async (certFilter) => queryEndpoint(
+            ENDPOINTS.FINANCIALS,
+            {
+              filters: `(${certFilter}) AND REPDTE:${params.repdte}`,
+              fields: CAMELS_FIELDS,
+              limit: 1e4,
+              sort_by: "CERT",
+              sort_order: "ASC"
+            },
+            { signal: controller.signal }
+          )
+        );
+        const allFinancials = financialResponses.flatMap(extractRecords);
+        const rosterResp2 = await queryEndpoint(
+          ENDPOINTS.INSTITUTIONS,
+          {
+            filters: peerCerts.length <= 25 ? peerCerts.map((c) => `CERT:${c}`).join(" OR ") : `CERT:[${Math.min(...peerCerts)} TO ${Math.max(...peerCerts)}]`,
+            fields: "CERT,NAME,CITY,STALP",
+            limit: 1e4,
+            sort_by: "CERT",
+            sort_order: "ASC"
+          },
+          { signal: controller.signal }
+        );
+        const profileMap = /* @__PURE__ */ new Map();
+        for (const r of extractRecords(rosterResp2)) {
+          const c = asNumber(r.CERT);
+          if (c !== null) profileMap.set(c, r);
+        }
+        await sendProgressNotification(server.server, progressToken, 0.7, "Computing CAMELS scores");
+        const entries = [];
+        for (const fin of allFinancials) {
+          const cert = asNumber(fin.CERT);
+          if (cert === null) continue;
+          const metrics = computeCamelsMetrics(fin);
+          const components = ["C", "A", "E", "L", "S"].map(
+            (c) => scoreComponent(c, metrics)
+          );
+          const comp = compositeScore(components);
+          const profile = profileMap.get(cert);
+          entries.push({
+            cert,
+            name: String(profile?.NAME ?? `CERT ${cert}`),
+            city: profile?.CITY ? String(profile.CITY) : null,
+            state: profile?.STALP ? String(profile.STALP) : null,
+            total_assets: asNumber(fin.ASSET),
+            composite_rating: comp.rating,
+            composite_label: comp.label,
+            component_ratings: Object.fromEntries(components.map((c) => [c.component, c.rating])),
+            flags: comp.flags
+          });
+        }
+        const sortComponent = sortKeyToComponent(params.sort_by);
+        entries.sort((a, b) => {
+          const aVal = sortComponent ? a.component_ratings[sortComponent] ?? 3 : a.composite_rating;
+          const bVal = sortComponent ? b.component_ratings[sortComponent] ?? 3 : b.composite_rating;
+          if (aVal !== bVal) return aVal - bVal;
+          return (b.total_assets ?? 0) - (a.total_assets ?? 0);
+        });
+        const subjectRank = params.cert ? entries.findIndex((e) => e.cert === params.cert) + 1 : null;
+        const returned = entries.slice(0, params.limit);
+        await sendProgressNotification(server.server, progressToken, 0.9, "Formatting results");
+        const parts = [];
+        parts.push(`CAMELS Peer Health Comparison \u2014 ${entries.length} institutions ranked by ${params.sort_by}`);
+        parts.push(`Report Date: ${params.repdte}`);
+        parts.push("NOTE: Analytical assessment, not official regulatory ratings.");
+        parts.push("");
+        if (subjectRank && subjectRank > 0 && params.cert) {
+          const subj = entries[subjectRank - 1];
+          parts.push(`Subject: ${subj.name} (CERT ${subj.cert}) \u2014 Rank ${subjectRank} of ${entries.length}, Composite: ${formatRating(subj.composite_rating)}`);
+          parts.push("");
+        }
+        for (let i = 0; i < returned.length; i++) {
+          const e = returned[i];
+          const rank = entries.indexOf(e) + 1;
+          const marker = params.cert && e.cert === params.cert ? " \u25C4 SUBJECT" : "";
+          const location = [e.city, e.state].filter(Boolean).join(", ");
+          const compStr = ["C", "A", "E", "L", "S"].map((c) => `${c}:${e.component_ratings[c] ?? "?"}`).join(" ");
+          const assetStr = e.total_assets !== null ? `$${Math.round(e.total_assets).toLocaleString()}k` : "n/a";
+          parts.push(
+            `${String(rank).padStart(3)}. ${e.name} (${location}) CERT ${e.cert}${marker}`
+          );
+          parts.push(
+            `     Composite: ${formatRating(e.composite_rating)} | ${compStr} | Assets: ${assetStr}`
+          );
+          if (e.flags.length > 0) {
+            parts.push(`     Flags: ${e.flags.join("; ")}`);
+          }
+        }
+        if (entries.length > returned.length) {
+          parts.push("");
+          parts.push(`Showing ${returned.length} of ${entries.length}. Increase limit to see more.`);
+        }
+        const text = truncateIfNeeded(parts.join("\n"), CHARACTER_LIMIT);
+        return {
+          content: [{ type: "text", text }],
+          structuredContent: {
+            report_date: params.repdte,
+            sort_by: params.sort_by,
+            total_institutions: entries.length,
+            returned_count: returned.length,
+            subject_cert: params.cert ?? null,
+            subject_rank: subjectRank,
+            institutions: returned
+          }
+        };
+      } catch (err) {
+        return formatToolError(err);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  );
+}
+
+// src/tools/riskSignals.ts
+var import_zod11 = require("zod");
+var TREND_METRICS2 = [
+  { key: "tier1_leverage", fdic_field: "IDT1CER", higher_is_better: true, category: "capital" },
+  { key: "noncurrent_loans_ratio", fdic_field: "NCLNLSR", higher_is_better: false, category: "asset_quality" },
+  { key: "roa", fdic_field: "ROA", higher_is_better: true, category: "earnings" },
+  { key: "nim", fdic_field: "NIMY", higher_is_better: true, category: "earnings" },
+  { key: "efficiency_ratio", fdic_field: "EEFFR", higher_is_better: false, category: "earnings" },
+  { key: "loan_to_deposit", fdic_field: "LNLSDEPR", higher_is_better: false, category: "liquidity" }
+];
+function classifyRiskSignals(metrics, trends) {
+  const signals = [];
+  if (metrics.tier1_leverage !== null && metrics.tier1_leverage < 5) {
+    signals.push({ severity: "critical", category: "capital", message: `Tier 1 leverage at ${metrics.tier1_leverage.toFixed(2)}% \u2014 below well-capitalized threshold (5%)` });
+  }
+  if (metrics.tier1_rbc !== null && metrics.tier1_rbc < 6) {
+    signals.push({ severity: "critical", category: "capital", message: `Tier 1 risk-based capital at ${metrics.tier1_rbc.toFixed(2)}% \u2014 below well-capitalized threshold (6%)` });
+  }
+  if (metrics.roa !== null && metrics.roa < 0) {
+    signals.push({ severity: "critical", category: "earnings", message: `Operating losses: ROA at ${metrics.roa.toFixed(2)}%` });
+  }
+  if (metrics.reserve_coverage !== null && metrics.reserve_coverage < 50) {
+    signals.push({ severity: "critical", category: "asset_quality", message: `Reserve coverage critically low at ${metrics.reserve_coverage.toFixed(1)}%` });
+  }
+  if (metrics.noncurrent_loans_ratio !== null && metrics.noncurrent_loans_ratio > 3) {
+    signals.push({ severity: "warning", category: "asset_quality", message: `Noncurrent loans elevated at ${metrics.noncurrent_loans_ratio.toFixed(2)}%` });
+  }
+  if (metrics.brokered_deposit_ratio !== null && metrics.brokered_deposit_ratio > 15) {
+    signals.push({ severity: "warning", category: "liquidity", message: `High brokered deposit reliance: ${metrics.brokered_deposit_ratio.toFixed(1)}%` });
+  }
+  if (metrics.nim_4q_change !== null && metrics.nim_4q_change < -0.3) {
+    signals.push({ severity: "warning", category: "sensitivity", message: `NIM compressed ${Math.abs(metrics.nim_4q_change).toFixed(2)}pp over 4 quarters` });
+  }
+  const components = ["C", "A", "E", "L", "S"].map(
+    (c) => scoreComponent(c, metrics)
+  );
+  const componentCategoryMap = {
+    C: "capital",
+    A: "asset_quality",
+    E: "earnings",
+    L: "liquidity",
+    S: "sensitivity"
+  };
+  const componentNames = {
+    C: "Capital",
+    A: "Asset Quality",
+    E: "Earnings",
+    L: "Liquidity",
+    S: "Sensitivity"
+  };
+  for (const comp of components) {
+    if (comp.rating >= 4) {
+      signals.push({
+        severity: "warning",
+        category: componentCategoryMap[comp.component],
+        message: `${componentNames[comp.component]} component rated ${formatRating(comp.rating)}`
+      });
+    }
+  }
+  const trendCategoryMap = {
+    tier1_leverage: "capital",
+    noncurrent_loans_ratio: "asset_quality",
+    roa: "earnings",
+    nim: "earnings",
+    efficiency_ratio: "earnings",
+    loan_to_deposit: "liquidity"
+  };
+  for (const t of trends) {
+    if (t.direction === "deteriorating") {
+      const cat = trendCategoryMap[t.metric] ?? "trend";
+      if (t.magnitude === "significant") {
+        signals.push({ severity: "warning", category: cat, message: `${t.label} deteriorating significantly over ${t.quarters_analyzed} quarters` });
+      } else if (t.magnitude === "moderate") {
+        signals.push({ severity: "info", category: cat, message: `${t.label} deteriorating moderately over ${t.quarters_analyzed} quarters` });
+      }
+    }
+  }
+  return signals;
+}
+function getPriorQuarterDates2(repdte, count) {
+  const dates = [];
+  const suffixes = ["0331", "0630", "0930", "1231"];
+  let year = Number.parseInt(repdte.slice(0, 4), 10);
+  let qIdx = suffixes.indexOf(repdte.slice(4));
+  if (qIdx === -1) return dates;
+  for (let i = 0; i < count; i++) {
+    qIdx--;
+    if (qIdx < 0) {
+      qIdx = 3;
+      year--;
+    }
+    dates.push(`${year}${suffixes[qIdx]}`);
+  }
+  return dates;
+}
+var SEVERITY_ORDER = { critical: 0, warning: 1, info: 2 };
+var RiskSignalsInputSchema = import_zod11.z.object({
+  state: import_zod11.z.string().regex(/^[A-Z]{2}$/).optional().describe("Scan all active institutions in this state."),
+  certs: import_zod11.z.array(import_zod11.z.number().int().positive()).max(50).optional().describe("Specific CERTs to scan (max 50)."),
+  asset_min: import_zod11.z.number().positive().optional().describe("Minimum total assets ($thousands) filter."),
+  asset_max: import_zod11.z.number().positive().optional().describe("Maximum total assets ($thousands) filter."),
+  repdte: import_zod11.z.string().regex(/^\d{8}$/).optional().describe("Report Date (YYYYMMDD). Defaults to the most recent quarter."),
+  min_severity: import_zod11.z.enum(["info", "warning", "critical"]).default("warning").describe("Minimum severity level to include in results (default: warning)."),
+  quarters: import_zod11.z.number().int().min(1).max(12).default(4).describe("Prior quarters to fetch for trend analysis (default 4)."),
+  limit: import_zod11.z.number().int().min(1).max(100).default(25).describe("Max flagged institutions to return.")
+});
+function registerRiskSignalTools(server) {
+  server.registerTool(
+    "fdic_detect_risk_signals",
+    {
+      title: "Detect Risk Signals (Early Warning)",
+      description: `Scan FDIC-insured institutions for early warning risk signals using CAMELS-style analysis.
+
+Scans institutions for:
+  - Critical: undercapitalized (Tier 1 < 5%), operating losses (ROA < 0), reserve coverage < 50%
+  - Warning: CAMELS component rated 4+, significant deteriorating trends, brokered deposits > 15%, noncurrent loans > 3%
+  - Info: moderate deteriorating trends
+
+Three scan modes:
+  - State-wide: provide state to scan all active institutions
+  - Explicit list: provide certs (up to 50)
+  - Asset-based: provide asset_min/asset_max
+
+Output: Ranked list of flagged institutions sorted by signal severity count.
+
+NOTE: Analytical screening tool, not official supervisory ratings.`,
+      inputSchema: RiskSignalsInputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async (rawParams, extra) => {
+      const params = { ...rawParams, repdte: rawParams.repdte ?? getDefaultReportDate() };
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), ANALYSIS_TIMEOUT_MS);
+      const progressToken = extra._meta?.progressToken;
+      try {
+        if (!params.certs && !params.state && params.asset_min === void 0 && params.asset_max === void 0) {
+          return formatToolError(new Error("At least one selection criteria required: certs, state, or asset_min/asset_max."));
+        }
+        const dateError = validateQuarterEndDate(params.repdte, "repdte");
+        if (dateError) {
+          return formatToolError(new Error(dateError));
+        }
+        await sendProgressNotification(server.server, progressToken, 0.1, "Building institution roster");
+        let targetCerts;
+        if (params.certs) {
+          targetCerts = [...params.certs];
+        } else {
+          const filterParts = ["ACTIVE:1"];
+          if (params.state) filterParts.push(`STALP:${params.state}`);
+          if (params.asset_min !== void 0 || params.asset_max !== void 0) {
+            const min = params.asset_min ?? 0;
+            const max = params.asset_max ?? "*";
+            filterParts.push(`ASSET:[${min} TO ${max}]`);
+          }
+          const rosterResp = await queryEndpoint(
+            ENDPOINTS.INSTITUTIONS,
+            {
+              filters: filterParts.join(" AND "),
+              fields: "CERT",
+              limit: 1e4,
+              sort_by: "CERT",
+              sort_order: "ASC"
+            },
+            { signal: controller.signal }
+          );
+          targetCerts = extractRecords(rosterResp).map((r) => asNumber(r.CERT)).filter((c) => c !== null);
+        }
+        if (targetCerts.length === 0) {
+          return formatToolError(new Error("No institutions matched the specified criteria."));
+        }
+        await sendProgressNotification(server.server, progressToken, 0.3, `Fetching financials for ${targetCerts.length} institutions`);
+        const certFilters = buildCertFilters(targetCerts);
+        const currentResponses = await mapWithConcurrency(
+          certFilters,
+          MAX_CONCURRENCY,
+          async (certFilter) => queryEndpoint(
+            ENDPOINTS.FINANCIALS,
+            {
+              filters: `(${certFilter}) AND REPDTE:${params.repdte}`,
+              fields: CAMELS_FIELDS,
+              limit: 1e4,
+              sort_by: "CERT",
+              sort_order: "ASC"
+            },
+            { signal: controller.signal }
+          )
+        );
+        const allCurrentFinancials = currentResponses.flatMap(extractRecords);
+        const priorDates = getPriorQuarterDates2(params.repdte, params.quarters);
+        let priorByInstitution = /* @__PURE__ */ new Map();
+        if (priorDates.length > 0) {
+          await sendProgressNotification(server.server, progressToken, 0.5, "Fetching prior quarters for trends");
+          const dateFilter = priorDates.map((d) => `REPDTE:${d}`).join(" OR ");
+          const priorResponses = await mapWithConcurrency(
+            certFilters,
+            MAX_CONCURRENCY,
+            async (certFilter) => queryEndpoint(
+              ENDPOINTS.FINANCIALS,
+              {
+                filters: `(${certFilter}) AND (${dateFilter})`,
+                fields: CAMELS_FIELDS,
+                limit: 1e4,
+                sort_by: "REPDTE",
+                sort_order: "DESC"
+              },
+              { signal: controller.signal }
+            )
+          );
+          for (const rec of priorResponses.flatMap(extractRecords)) {
+            const cert = asNumber(rec.CERT);
+            if (cert === null) continue;
+            const existing = priorByInstitution.get(cert) ?? [];
+            existing.push(rec);
+            priorByInstitution.set(cert, existing);
+          }
+        }
+        const profileResp = await queryEndpoint(
+          ENDPOINTS.INSTITUTIONS,
+          {
+            filters: targetCerts.length <= 25 ? targetCerts.map((c) => `CERT:${c}`).join(" OR ") : `CERT:[${Math.min(...targetCerts)} TO ${Math.max(...targetCerts)}]`,
+            fields: "CERT,NAME,CITY,STALP",
+            limit: 1e4,
+            sort_by: "CERT",
+            sort_order: "ASC"
+          },
+          { signal: controller.signal }
+        );
+        const profileMap = /* @__PURE__ */ new Map();
+        for (const r of extractRecords(profileResp)) {
+          const c = asNumber(r.CERT);
+          if (c !== null) profileMap.set(c, r);
+        }
+        await sendProgressNotification(server.server, progressToken, 0.7, "Analyzing risk signals");
+        const minSeverityOrder = SEVERITY_ORDER[params.min_severity];
+        const results = [];
+        for (const fin of allCurrentFinancials) {
+          const cert = asNumber(fin.CERT);
+          if (cert === null) continue;
+          const priorQuarters = priorByInstitution.get(cert) ?? [];
+          const metrics = computeCamelsMetrics(fin, priorQuarters);
+          const allQuarters = [fin, ...priorQuarters];
+          const trends = [];
+          for (const tm of TREND_METRICS2) {
+            const timeseries = allQuarters.map((q) => ({
+              repdte: String(q.REPDTE ?? ""),
+              value: typeof q[tm.fdic_field] === "number" ? q[tm.fdic_field] : null
+            }));
+            timeseries.reverse();
+            trends.push(analyzeTrend(String(tm.key), timeseries, tm.higher_is_better));
+          }
+          const allSignals = classifyRiskSignals(metrics, trends);
+          const filteredSignals = allSignals.filter((s) => SEVERITY_ORDER[s.severity] <= minSeverityOrder);
+          if (filteredSignals.length === 0) continue;
+          const components = ["C", "A", "E", "L", "S"].map((c) => scoreComponent(c, metrics));
+          const comp = compositeScore(components);
+          const profile = profileMap.get(cert);
+          results.push({
+            cert,
+            name: String(profile?.NAME ?? `CERT ${cert}`),
+            city: profile?.CITY ? String(profile.CITY) : null,
+            state: profile?.STALP ? String(profile.STALP) : null,
+            total_assets: asNumber(fin.ASSET),
+            composite_rating: comp.rating,
+            composite_label: comp.label,
+            signals: filteredSignals,
+            critical_count: filteredSignals.filter((s) => s.severity === "critical").length,
+            warning_count: filteredSignals.filter((s) => s.severity === "warning").length
+          });
+        }
+        results.sort((a, b) => {
+          if (a.critical_count !== b.critical_count) return b.critical_count - a.critical_count;
+          if (a.warning_count !== b.warning_count) return b.warning_count - a.warning_count;
+          return b.composite_rating - a.composite_rating;
+        });
+        const returned = results.slice(0, params.limit);
+        await sendProgressNotification(server.server, progressToken, 0.9, "Formatting results");
+        const parts = [];
+        parts.push(`Risk Signal Scan \u2014 ${results.length} flagged of ${allCurrentFinancials.length} institutions scanned`);
+        parts.push(`Report Date: ${params.repdte} | Min Severity: ${params.min_severity}`);
+        parts.push("NOTE: Analytical screening tool, not official supervisory ratings.");
+        parts.push("");
+        if (returned.length === 0) {
+          parts.push("No institutions flagged at the specified severity level.");
+        }
+        for (let i = 0; i < returned.length; i++) {
+          const r = returned[i];
+          const location = [r.city, r.state].filter(Boolean).join(", ");
+          const assetStr = r.total_assets !== null ? `$${Math.round(r.total_assets).toLocaleString()}k` : "n/a";
+          parts.push(`${i + 1}. ${r.name} (${location}) CERT ${r.cert} | Assets: ${assetStr}`);
+          parts.push(`   Composite: ${formatRating(r.composite_rating)} | Critical: ${r.critical_count} | Warnings: ${r.warning_count}`);
+          for (const s of r.signals) {
+            const icon = s.severity === "critical" ? "\u{1F534}" : s.severity === "warning" ? "\u{1F7E1}" : "\u{1F535}";
+            parts.push(`   ${icon} [${s.severity}] ${s.message}`);
+          }
+          parts.push("");
+        }
+        if (results.length > returned.length) {
+          parts.push(`Showing ${returned.length} of ${results.length} flagged institutions. Increase limit to see more.`);
+        }
+        const text = truncateIfNeeded(parts.join("\n"), CHARACTER_LIMIT);
+        return {
+          content: [{ type: "text", text }],
+          structuredContent: {
+            report_date: params.repdte,
+            min_severity: params.min_severity,
+            institutions_scanned: allCurrentFinancials.length,
+            institutions_flagged: results.length,
+            returned_count: returned.length,
+            institutions: returned
+          }
+        };
+      } catch (err) {
+        return formatToolError(err);
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+  );
+}
+
 // src/resources/schemaResources.ts
 var RESOURCE_SCHEME = "fdic";
 var INDEX_URI = `${RESOURCE_SCHEME}://schemas/index`;
@@ -34436,6 +35483,9 @@ function createServer() {
   registerDemographicsTools(server);
   registerAnalysisTools(server);
   registerPeerGroupTools(server);
+  registerBankHealthTools(server);
+  registerPeerHealthTools(server);
+  registerRiskSignalTools(server);
   registerSchemaResources(server);
   return server;
 }