fdic-mcp-server 1.23.2 → 1.24.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.23.2" : process.env.npm_package_version ?? "0.0.0-dev";
+var VERSION = true ? "1.24.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;
@@ -31883,50 +31883,7 @@ function registerInstitutionTools(server) {
     "fdic_search_institutions",
     {
       title: "Search FDIC Institutions",
-      description: `Search for FDIC-insured financial institutions (banks and savings institutions) using flexible filters.
-
-Returns institution profile data including name, location, charter class, asset size, deposit totals, profitability metrics, and regulatory status.
-
-Common filter examples:
-  - By state: STNAME:"California"
-  - Active banks only: ACTIVE:1
-  - Large banks: ASSET:[10000000 TO *]  (assets in $thousands)
-  - By bank class: BKCLASS:N (national bank), BKCLASS:SM (state member bank), BKCLASS:NM (state non-member)
-  - By name: NAME:"Wells Fargo"
-  - Commercial banks: CB:1
-  - Savings institutions: MUTUAL:1
-  - Recently established: ESTYMD:[2010-01-01 TO *]
-
-Charter class codes (BKCLASS):
-  N = National commercial bank (OCC-supervised)
-  SM = State-chartered, Federal Reserve member
-  NM = State-chartered, non-member (FDIC-supervised)
-  SB = Federal savings bank (OCC-supervised)
-  SA = State savings association
-  OI = Insured branch of foreign bank
-
-Key returned fields:
-  - CERT: FDIC Certificate Number (unique ID)
-  - NAME: Institution name
-  - CITY, STALP (two-letter state code), STNAME (full state name): Location
-  - ASSET: Total assets ($thousands)
-  - DEP: Total deposits ($thousands)
-  - BKCLASS: Charter class code (see above)
-  - ACTIVE: 1 if currently active, 0 if inactive
-  - ROA, ROE: Profitability ratios
-  - OFFICES: Number of branch offices
-  - ESTYMD: Establishment date (YYYY-MM-DD)
-  - REGAGNT: Primary federal regulator (OCC, FRS, FDIC)
-
-Args:
-  - filters (string, optional): ElasticSearch query filter
-  - fields (string, optional): Comma-separated field names
-  - limit (number): Records to return, 1-10000 (default: 20)
-  - offset (number): Pagination offset (default: 0)
-  - sort_by (string, optional): Field to sort by
-  - sort_order ('ASC'|'DESC'): Sort direction (default: 'ASC')
-
-Prefer concise human-readable summaries or tables when answering users. Structured fields are available for totals, pagination, and institution records.`,
+      description: "Use this when the user needs FDIC-insured institution search results by name, state, CERT, asset size, charter class, or regulatory status. Returns institution profile rows with pagination; use fdic://schemas/institutions for the full field catalog.",
       inputSchema: CommonQuerySchema,
       annotations: {
         readOnlyHint: true,
@@ -31970,15 +31927,7 @@ Prefer concise human-readable summaries or tables when answering users. Structur
     "fdic_get_institution",
     {
       title: "Get Institution by Certificate Number",
-      description: `Retrieve detailed information for a specific FDIC-insured institution using its FDIC Certificate Number (CERT).
-
-Use this when you know the exact CERT number for an institution. To find a CERT number, use fdic_search_institutions first.
-
-Args:
-  - cert (number): FDIC Certificate Number (e.g., 3511 for Bank of America)
-  - fields (string, optional): Comma-separated list of fields to return
-
-Returns a detailed institution profile suitable for concise summaries, with structured fields available for exact values when needed.`,
+      description: "Use this when the user knows an exact FDIC Certificate Number and needs one institution profile. To discover a CERT first, call fdic_search_institutions or the ChatGPT-compatible search tool.",
       inputSchema: CertSchema,
       annotations: {
         readOnlyHint: true,
@@ -38625,6 +38574,884 @@ NOTE: Requires FRED_API_KEY environment variable for reliable data access. Degra
   );
 }
 
+// src/tools/chatgptRetrieval.ts
+var import_zod20 = require("zod");
+
+// src/tools/shared/chatgptUrls.ts
+var FDIC_BANKFIND_BASE_URL = "https://banks.data.fdic.gov/bankfind-suite";
+var FDIC_FAILED_BANK_LIST_URL = "https://www.fdic.gov/bank-failures/failed-bank-list";
+var PROJECT_TOOL_REFERENCE_URL = "https://jflamb.github.io/fdic-mcp-server/tool-reference/";
+function getInstitutionUrl(cert) {
+  return `${FDIC_BANKFIND_BASE_URL}/bankfind/details/${cert}`;
+}
+function getFailedBankListUrl() {
+  return FDIC_FAILED_BANK_LIST_URL;
+}
+function getSchemaDocsUrl(endpoint) {
+  return `${PROJECT_TOOL_REFERENCE_URL}#${encodeURIComponent(endpoint)}`;
+}
+function getBranchCitationUrl() {
+  return `${PROJECT_TOOL_REFERENCE_URL}#fdic_search_locations`;
+}
+
+// src/tools/chatgptRetrieval.ts
+var SearchInputSchema = import_zod20.z.object({
+  query: import_zod20.z.string().min(1).describe("Natural-language search query.")
+});
+var FetchInputSchema = import_zod20.z.object({
+  id: import_zod20.z.string().min(1).describe(
+    "Retrieval item id, such as institution:<CERT>, failure:<CERT>, branch:<UNINUM>, or schema:<endpoint>."
+  )
+});
+var MAX_SEARCH_RESULTS = 8;
+function asString(value) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  return String(value);
+}
+function asNumber2(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+function jsonText(payload) {
+  return JSON.stringify(payload);
+}
+function escapeFilterValue(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').trim();
+}
+function normalizeQuery(query) {
+  return query.replace(/\s+/g, " ").trim();
+}
+function extractCertLikeNumber(query) {
+  const match = query.match(/\b(?:cert(?:ificate)?\s*#?\s*)?(\d{1,7})\b/i);
+  if (!match) {
+    return void 0;
+  }
+  return Number.parseInt(match[1], 10);
+}
+function shouldSearchFailures(query) {
+  return /\b(fail|failed|failure|closed|resolution|receivership)\b/i.test(
+    query
+  );
+}
+function shouldSearchBranches(query) {
+  return /\b(branch|branches|office|offices|location|locations|address|city|county|zip|market|msa)\b/i.test(
+    query
+  );
+}
+function shouldSearchSchemas(query) {
+  return /\b(schema|field|fields|column|columns|endpoint|call report|financials?|sod|summary of deposits|demographics|metadata)\b/i.test(
+    query
+  );
+}
+function getRecordTitle(record, fallback) {
+  return asString(record.NAME) || asString(record.UNINAME) || asString(record.NAMEFULL) || asString(record.OFFNAME) || fallback;
+}
+function formatLocation(record) {
+  return [record.CITY, record.STALP].map(asString).filter(Boolean).join(", ");
+}
+function buildBranchId(record) {
+  const uninum = asString(record.UNINUM);
+  if (uninum) {
+    return `branch:${encodeURIComponent(uninum)}`;
+  }
+  const cert = asString(record.CERT);
+  const brnum = asString(record.BRNUM);
+  const zip = asString(record.ZIP);
+  if (!cert || !brnum) {
+    return void 0;
+  }
+  return `branch:${encodeURIComponent([cert, brnum, zip].join("~"))}`;
+}
+function institutionSearchResult(record) {
+  const cert = asNumber2(record.CERT);
+  if (cert === void 0) {
+    return void 0;
+  }
+  const title = getRecordTitle(record, `FDIC institution ${cert}`);
+  const location = formatLocation(record);
+  return {
+    id: `institution:${cert}`,
+    title: location ? `${title} (${location})` : title,
+    url: getInstitutionUrl(cert)
+  };
+}
+function failureSearchResult(record) {
+  const cert = asNumber2(record.CERT);
+  if (cert === void 0) {
+    return void 0;
+  }
+  const title = getRecordTitle(record, `Failed bank ${cert}`);
+  const failDate = asString(record.FAILDATE);
+  return {
+    id: `failure:${cert}`,
+    title: failDate ? `${title} failed ${failDate}` : `${title} failure record`,
+    url: getFailedBankListUrl()
+  };
+}
+function branchSearchResult(record) {
+  const id = buildBranchId(record);
+  if (!id) {
+    return void 0;
+  }
+  const name = getRecordTitle(record, "FDIC branch location");
+  const address = [record.ADDRESS, record.CITY, record.STALP, record.ZIP].map(asString).filter(Boolean).join(", ");
+  return {
+    id,
+    title: address ? `${name} - ${address}` : name,
+    url: getBranchCitationUrl()
+  };
+}
+function schemaSearchResults(query) {
+  const normalized = normalizeQuery(query).toLowerCase();
+  const metadata = listEndpointMetadata();
+  return metadata.filter((endpoint) => {
+    if (normalized.includes(endpoint.endpoint.toLowerCase())) {
+      return true;
+    }
+    if (endpoint.title.toLowerCase().includes(normalized)) {
+      return true;
+    }
+    return Object.keys(endpoint.fields).some(
+      (field) => normalized.includes(field.toLowerCase())
+    );
+  }).slice(0, 2).map((endpoint) => ({
+    id: `schema:${endpoint.endpoint}`,
+    title: `${endpoint.title} schema`,
+    url: getSchemaDocsUrl(endpoint.endpoint)
+  }));
+}
+async function searchInstitutions(query) {
+  const cert = extractCertLikeNumber(query);
+  const filters = cert !== void 0 ? `CERT:${cert}` : `NAME:"${escapeFilterValue(query)}"`;
+  const response = await queryEndpoint(ENDPOINTS.INSTITUTIONS, {
+    filters,
+    fields: "CERT,NAME,CITY,STALP,ACTIVE",
+    limit: 3,
+    sort_by: "ACTIVE",
+    sort_order: "DESC"
+  });
+  return extractRecords(response).map(institutionSearchResult).filter((result) => result !== void 0);
+}
+async function searchFailures(query) {
+  const cert = extractCertLikeNumber(query);
+  const filters = cert !== void 0 ? `CERT:${cert}` : `NAME:"${escapeFilterValue(query)}"`;
+  const response = await queryEndpoint(ENDPOINTS.FAILURES, {
+    filters,
+    fields: "CERT,NAME,CITY,STALP,FAILDATE,RESTYPE",
+    limit: 2,
+    sort_by: "FAILDATE",
+    sort_order: "DESC"
+  });
+  return extractRecords(response).map(failureSearchResult).filter((result) => result !== void 0);
+}
+async function searchBranches(query) {
+  const cert = extractCertLikeNumber(query);
+  const normalized = normalizeQuery(query);
+  const zip = normalized.match(/\b\d{5}\b/)?.[0];
+  const filters = cert !== void 0 ? `CERT:${cert}` : zip !== void 0 ? `ZIP:${zip}` : `CITY:"${escapeFilterValue(normalized)}"`;
+  const response = await queryEndpoint(ENDPOINTS.LOCATIONS, {
+    filters,
+    fields: "UNINUM,CERT,NAME,OFFNAME,ADDRESS,CITY,STALP,ZIP",
+    limit: 3,
+    sort_by: "UNINUM",
+    sort_order: "ASC"
+  });
+  return extractRecords(response).map(branchSearchResult).filter((result) => result !== void 0);
+}
+async function safeSearch(searcher) {
+  try {
+    return await searcher();
+  } catch {
+    return [];
+  }
+}
+function dedupeResults(results) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const result of results) {
+    if (seen.has(result.id)) {
+      continue;
+    }
+    seen.add(result.id);
+    deduped.push(result);
+  }
+  return deduped.slice(0, MAX_SEARCH_RESULTS);
+}
+function recordText(record, fields) {
+  return fields.map((field) => [field, asString(record[field])]).filter(([, value]) => value !== "").map(([field, value]) => `${field}: ${value}`).join("\n");
+}
+async function fetchInstitution(cert) {
+  const response = await queryEndpoint(ENDPOINTS.INSTITUTIONS, {
+    filters: `CERT:${cert}`,
+    limit: 1
+  });
+  const record = extractRecords(response)[0];
+  if (!record) {
+    throw new Error(`No institution found for CERT ${cert}.`);
+  }
+  const title = getRecordTitle(record, `FDIC institution ${cert}`);
+  return {
+    id: `institution:${cert}`,
+    title,
+    text: recordText(record, [
+      "CERT",
+      "NAME",
+      "CITY",
+      "STALP",
+      "STNAME",
+      "ACTIVE",
+      "ASSET",
+      "DEP",
+      "OFFICES",
+      "BKCLASS",
+      "REGAGNT",
+      "ESTYMD"
+    ]),
+    url: getInstitutionUrl(cert),
+    metadata: { type: "institution", cert, source: "FDIC BankFind Suite" }
+  };
+}
+async function fetchFailure(cert) {
+  const response = await queryEndpoint(ENDPOINTS.FAILURES, {
+    filters: `CERT:${cert}`,
+    limit: 1
+  });
+  const record = extractRecords(response)[0];
+  if (!record) {
+    throw new Error(`No failure record found for CERT ${cert}.`);
+  }
+  const title = getRecordTitle(record, `Failed bank ${cert}`);
+  return {
+    id: `failure:${cert}`,
+    title,
+    text: recordText(record, [
+      "CERT",
+      "NAME",
+      "CITY",
+      "STALP",
+      "FAILDATE",
+      "RESTYPE",
+      "QBFASSET",
+      "COST"
+    ]),
+    url: getFailedBankListUrl(),
+    metadata: { type: "failure", cert, source: "FDIC Failed Bank List" }
+  };
+}
+async function fetchBranch(rawId) {
+  const decoded = decodeURIComponent(rawId);
+  const [cert, brnum, zip] = decoded.split("~");
+  const filters = cert && brnum ? [`CERT:${cert}`, `BRNUM:${brnum}`, zip ? `ZIP:${zip}` : void 0].filter(Boolean).join(" AND ") : `UNINUM:${decoded}`;
+  const response = await queryEndpoint(ENDPOINTS.LOCATIONS, {
+    filters,
+    limit: 1
+  });
+  const record = extractRecords(response)[0];
+  if (!record) {
+    throw new Error(`No branch/location found for id ${rawId}.`);
+  }
+  const title = getRecordTitle(record, `FDIC branch ${rawId}`);
+  const id = buildBranchId(record) ?? `branch:${rawId}`;
+  return {
+    id,
+    title,
+    text: recordText(record, [
+      "UNINUM",
+      "CERT",
+      "UNINAME",
+      "NAMEFULL",
+      "ADDRESS",
+      "CITY",
+      "STALP",
+      "ZIP",
+      "COUNTY",
+      "BRNUM",
+      "BRSERTYP",
+      "ESTYMD",
+      "ENDEFYMD"
+    ]),
+    url: getBranchCitationUrl(),
+    metadata: {
+      type: "branch",
+      cert: record.CERT,
+      uninum: record.UNINUM,
+      source: "FDIC BankFind Suite locations"
+    }
+  };
+}
+function fetchSchema(endpoint) {
+  const metadata = getEndpointMetadata(endpoint);
+  if (!metadata) {
+    throw new Error(`No schema metadata found for endpoint ${endpoint}.`);
+  }
+  const fields = Object.values(metadata.fields).slice(0, 200).map((field) => {
+    const title = field.title ? ` - ${field.title}` : "";
+    return `${field.name}${title}`;
+  }).join("\n");
+  return {
+    id: `schema:${endpoint}`,
+    title: `${metadata.title} schema`,
+    text: [
+      metadata.description ?? metadata.title,
+      "",
+      `Endpoint: ${metadata.endpoint}`,
+      `Source: ${metadata.source.docsBaseUrl}`,
+      "",
+      "Fields:",
+      fields
+    ].join("\n"),
+    url: getSchemaDocsUrl(endpoint),
+    metadata: {
+      type: "schema",
+      endpoint,
+      field_count: Object.keys(metadata.fields).length,
+      source: metadata.source.docsBaseUrl
+    }
+  };
+}
+async function fetchById(id) {
+  const [kind, rawValue] = id.split(":", 2);
+  if (!kind || !rawValue) {
+    throw new Error(
+      "Invalid fetch id. Expected institution:<CERT>, failure:<CERT>, branch:<id>, or schema:<endpoint>."
+    );
+  }
+  if (kind === "institution") {
+    const cert = Number.parseInt(rawValue, 10);
+    if (!Number.isInteger(cert) || cert <= 0) {
+      throw new Error(`Invalid institution CERT in id ${id}.`);
+    }
+    return fetchInstitution(cert);
+  }
+  if (kind === "failure") {
+    const cert = Number.parseInt(rawValue, 10);
+    if (!Number.isInteger(cert) || cert <= 0) {
+      throw new Error(`Invalid failure CERT in id ${id}.`);
+    }
+    return fetchFailure(cert);
+  }
+  if (kind === "branch") {
+    return fetchBranch(rawValue);
+  }
+  if (kind === "schema") {
+    return fetchSchema(rawValue);
+  }
+  throw new Error(`Unsupported fetch id kind: ${kind}.`);
+}
+function registerChatGptRetrievalTools(server) {
+  server.registerTool(
+    "search",
+    {
+      title: "Search FDIC BankFind",
+      description: "Use this when ChatGPT needs citation-friendly FDIC BankFind search results for institutions, failed banks, branches, or schema documentation.",
+      inputSchema: SearchInputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async ({ query }) => {
+      const normalized = normalizeQuery(query);
+      const shouldIncludeFailures = shouldSearchFailures(normalized);
+      const shouldIncludeBranches = shouldSearchBranches(normalized);
+      const shouldIncludeSchemas = shouldSearchSchemas(normalized);
+      const [institutions, failures, branches] = await Promise.all([
+        safeSearch(() => searchInstitutions(normalized)),
+        shouldIncludeFailures ? safeSearch(() => searchFailures(normalized)) : Promise.resolve([]),
+        shouldIncludeBranches ? safeSearch(() => searchBranches(normalized)) : Promise.resolve([])
+      ]);
+      const fallbackFailures = failures.length === 0 && institutions.length === 0 ? await safeSearch(() => searchFailures(normalized)) : [];
+      const fallbackBranches = branches.length === 0 && institutions.length === 0 ? await safeSearch(() => searchBranches(normalized)) : [];
+      const schemas = shouldIncludeSchemas ? schemaSearchResults(normalized) : [];
+      const results = dedupeResults([
+        ...institutions,
+        ...failures,
+        ...branches,
+        ...fallbackFailures,
+        ...fallbackBranches,
+        ...schemas
+      ]);
+      return {
+        content: [{ type: "text", text: jsonText({ results }) }]
+      };
+    }
+  );
+  server.registerTool(
+    "fetch",
+    {
+      title: "Fetch FDIC BankFind Result",
+      description: "Use this when ChatGPT needs the full citation text for a result returned by search.",
+      inputSchema: FetchInputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      }
+    },
+    async ({ id }) => {
+      try {
+        const result = await fetchById(id);
+        return {
+          content: [{ type: "text", text: jsonText(result) }]
+        };
+      } catch (err) {
+        return formatToolError(err);
+      }
+    }
+  );
+}
+
+// src/tools/chatgptBankDeepDive.ts
+var import_zod21 = require("zod");
+
+// src/resources/chatgptAppResources.ts
+var BANK_DEEP_DIVE_WIDGET_URI = "ui://widget/fdic-bank-deep-dive-v1.html";
+var MCP_APP_MIME_TYPE = "text/html;profile=mcp-app";
+var BANK_DEEP_DIVE_WIDGET_HTML = String.raw`
+<div id="root" class="fdic-app">
+  <section class="empty">Loading bank dashboard...</section>
+</div>
+<style>
+  :root {
+    color-scheme: light dark;
+    font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+  }
+
+  body {
+    margin: 0;
+    background: Canvas;
+    color: CanvasText;
+  }
+
+  .fdic-app {
+    box-sizing: border-box;
+    min-height: 100%;
+    padding: 16px;
+  }
+
+  .empty,
+  .panel {
+    border: 1px solid color-mix(in srgb, CanvasText 14%, transparent);
+    border-radius: 8px;
+    padding: 14px;
+  }
+
+  .header {
+    display: grid;
+    gap: 6px;
+    margin-bottom: 14px;
+  }
+
+  .eyebrow {
+    color: color-mix(in srgb, CanvasText 58%, transparent);
+    font-size: 12px;
+    font-weight: 650;
+    text-transform: uppercase;
+  }
+
+  h1,
+  h2,
+  p {
+    margin: 0;
+  }
+
+  h1 {
+    font-size: 20px;
+    line-height: 1.25;
+    letter-spacing: 0;
+  }
+
+  h2 {
+    font-size: 14px;
+    line-height: 1.35;
+    letter-spacing: 0;
+  }
+
+  .subtle {
+    color: color-mix(in srgb, CanvasText 64%, transparent);
+    font-size: 13px;
+  }
+
+  .grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(132px, 1fr));
+    gap: 8px;
+    margin: 12px 0;
+  }
+
+  .metric {
+    border: 1px solid color-mix(in srgb, CanvasText 12%, transparent);
+    border-radius: 8px;
+    padding: 10px;
+  }
+
+  .metric dt {
+    color: color-mix(in srgb, CanvasText 62%, transparent);
+    font-size: 12px;
+    margin: 0 0 6px;
+  }
+
+  .metric dd {
+    font-size: 16px;
+    font-weight: 680;
+    margin: 0;
+  }
+
+  .section {
+    margin-top: 14px;
+  }
+
+  .list {
+    display: grid;
+    gap: 6px;
+    margin: 8px 0 0;
+    padding: 0;
+    list-style: none;
+  }
+
+  .list li {
+    border-left: 3px solid color-mix(in srgb, CanvasText 24%, transparent);
+    padding: 4px 0 4px 8px;
+    font-size: 13px;
+  }
+
+  .actions {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 8px;
+    margin-top: 14px;
+  }
+
+  button {
+    border: 1px solid color-mix(in srgb, CanvasText 18%, transparent);
+    border-radius: 8px;
+    background: Canvas;
+    color: CanvasText;
+    cursor: pointer;
+    font: inherit;
+    font-size: 13px;
+    padding: 8px 10px;
+  }
+</style>
+<script type="module">
+  const root = document.getElementById("root");
+
+  function formatMoney(value) {
+    if (typeof value !== "number") return "n/a";
+    if (Math.abs(value) >= 1000000) return "$" + (value / 1000000).toFixed(1) + "B";
+    if (Math.abs(value) >= 1000) return "$" + (value / 1000).toFixed(1) + "M";
+    return "$" + value.toLocaleString() + "k";
+  }
+
+  function escapeHtml(value) {
+    return String(value ?? "").replace(/[&<>"']/g, (char) => ({
+      "&": "&amp;",
+      "<": "&lt;",
+      ">": "&gt;",
+      '"': "&quot;",
+      "'": "&#39;",
+    }[char]));
+  }
+
+  function render(data) {
+    const institution = data?.institution ?? {};
+    const assessment = data?.assessment ?? {};
+    const metrics = data?.metrics ?? {};
+    const signals = data?.risk_signals ?? [];
+    const warnings = data?.warnings ?? [];
+    const sources = data?.sources ?? [];
+    const title = institution.name || "FDIC bank dashboard";
+
+    const signalItems = signals.length
+      ? signals.map((signal) => "<li>" + escapeHtml(signal) + "</li>").join("")
+      : "<li>No risk signals returned for this dashboard.</li>";
+    const warningSection = warnings.length
+      ? '<section class="section"><h2>Warnings</h2><ul class="list">' +
+        warnings.map((warning) => "<li>" + escapeHtml(warning) + "</li>").join("") +
+        "</ul></section>"
+      : "";
+    const sourceItems = sources
+      .map((source) => '<li><a href="' + escapeHtml(source.url) + '" target="_blank" rel="noreferrer">' + escapeHtml(source.title) + "</a></li>")
+      .join("");
+
+    root.innerHTML = [
+      '<article class="panel">',
+      '<header class="header">',
+      '<p class="eyebrow">FDIC BankFind</p>',
+      "<h1>" + escapeHtml(title) + "</h1>",
+      '<p class="subtle">' + escapeHtml(institution.city) + ", " + escapeHtml(institution.state) + " · CERT " + escapeHtml(institution.cert) + " · " + escapeHtml(institution.active ? "Active" : "Inactive or unknown") + "</p>",
+      '<p class="subtle">Report date: ' + escapeHtml(institution.report_date ?? "latest available") + " · Public analytical proxy, not an official CAMELS rating.</p>",
+      "</header>",
+      '<dl class="grid">',
+      '<div class="metric"><dt>Assets</dt><dd>' + formatMoney(institution.asset_thousands) + "</dd></div>",
+      '<div class="metric"><dt>Deposits</dt><dd>' + formatMoney(institution.deposit_thousands) + "</dd></div>",
+      '<div class="metric"><dt>Offices</dt><dd>' + escapeHtml(institution.offices ?? "n/a") + "</dd></div>",
+      '<div class="metric"><dt>Proxy band</dt><dd>' + escapeHtml(assessment.proxy_band ?? "n/a") + "</dd></div>",
+      '<div class="metric"><dt>ROA</dt><dd>' + escapeHtml(metrics.roa ?? "n/a") + "</dd></div>",
+      '<div class="metric"><dt>Tier 1 leverage</dt><dd>' + escapeHtml(metrics.tier1_leverage ?? "n/a") + "</dd></div>",
+      "</dl>",
+      '<section class="section"><h2>Risk Signals</h2><ul class="list">' + signalItems + "</ul></section>",
+      warningSection,
+      '<section class="section"><h2>Sources</h2><ul class="list">' + sourceItems + "</ul></section>",
+      '<div class="actions">',
+      '<button type="button" data-message="Compare CERT ' + escapeHtml(institution.cert) + ' with peers.">Compare peers</button>',
+      '<button type="button" data-message="Show the branch footprint for CERT ' + escapeHtml(institution.cert) + '.">Branch footprint</button>',
+      '<button type="button" data-message="Analyze the funding profile for CERT ' + escapeHtml(institution.cert) + '.">Funding profile</button>',
+      "</div>",
+      "</article>",
+    ].join("");
+  }
+
+  window.addEventListener("message", (event) => {
+    const message = event.data;
+    if (message?.method === "ui/notifications/tool-result") {
+      render(message.params?.structuredContent);
+    }
+  });
+
+  root.addEventListener("click", (event) => {
+    const button = event.target.closest("button[data-message]");
+    if (!button) return;
+    const text = button.getAttribute("data-message");
+    window.parent.postMessage({
+      jsonrpc: "2.0",
+      method: "ui/message",
+      params: { role: "user", content: [{ type: "text", text }] },
+    }, "*");
+  });
+
+  const initial = window.openai?.toolOutput ?? window.openai?.toolResponse?.structuredContent;
+  if (initial) {
+    render(initial);
+  }
+</script>
+`.trim();
+function registerChatGptAppResources(server) {
+  server.registerResource(
+    "fdic-bank-deep-dive-widget",
+    BANK_DEEP_DIVE_WIDGET_URI,
+    {
+      title: "FDIC Bank Deep Dive Widget",
+      description: "Interactive ChatGPT widget for a public FDIC bank deep-dive dashboard.",
+      mimeType: MCP_APP_MIME_TYPE
+    },
+    async () => ({
+      contents: [
+        {
+          uri: BANK_DEEP_DIVE_WIDGET_URI,
+          mimeType: MCP_APP_MIME_TYPE,
+          text: BANK_DEEP_DIVE_WIDGET_HTML,
+          _meta: {
+            ui: {
+              prefersBorder: true,
+              csp: {
+                connectDomains: [],
+                resourceDomains: []
+              }
+            },
+            "openai/widgetDescription": "Renders an FDIC bank deep-dive dashboard from public BankFind data.",
+            "openai/widgetPrefersBorder": true,
+            "openai/widgetCSP": {
+              connect_domains: [],
+              resource_domains: []
+            }
+          }
+        }
+      ]
+    })
+  );
+}
+
+// src/tools/chatgptBankDeepDive.ts
+var BankDeepDiveInputSchema = import_zod21.z.object({
+  cert: import_zod21.z.number().int().positive().describe("FDIC Certificate Number of the institution to render."),
+  repdte: import_zod21.z.string().regex(/^\d{8}$/).optional().describe(
+    "Quarter-end report date in YYYYMMDD format. Defaults to the most recent likely published quarter."
+  )
+});
+function asNumber3(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function asString2(value) {
+  return value === void 0 || value === null ? "" : String(value);
+}
+function formatRatio(value) {
+  return typeof value === "number" && Number.isFinite(value) ? `${value.toFixed(2)}%` : void 0;
+}
+function collectDashboardRiskSignals(financials) {
+  if (!financials) {
+    return [];
+  }
+  const signals = [];
+  const tier1Leverage = asNumber3(financials.IDT1CER);
+  const roa = asNumber3(financials.ROA);
+  const noncurrentLoans = asNumber3(financials.NCLNLSR);
+  const brokeredDeposits = asNumber3(financials.BRO);
+  if (tier1Leverage !== void 0 && tier1Leverage < 5) {
+    signals.push(
+      `Tier 1 leverage ratio is ${tier1Leverage.toFixed(2)}%, below the 5% well-capitalized threshold.`
+    );
+  }
+  if (roa !== void 0 && roa < 0) {
+    signals.push(`Return on assets is negative at ${roa.toFixed(2)}%.`);
+  }
+  if (noncurrentLoans !== void 0 && noncurrentLoans > 3) {
+    signals.push(
+      `Noncurrent loans ratio is elevated at ${noncurrentLoans.toFixed(2)}%.`
+    );
+  }
+  if (brokeredDeposits !== void 0 && brokeredDeposits > 0) {
+    signals.push(
+      "Brokered deposit fields are present; review funding-profile analysis for reliance context."
+    );
+  }
+  return signals;
+}
+function buildDashboardText(institution, repdte, riskSignals, warnings) {
+  const lines = [
+    `FDIC Bank Deep Dive: ${asString2(institution.NAME)} (CERT ${asString2(institution.CERT)})`,
+    `${asString2(institution.CITY)}, ${asString2(institution.STALP)} | Report date: ${repdte}`,
+    "This dashboard uses public FDIC BankFind data and is not an official CAMELS rating or supervisory conclusion.",
+    "",
+    `Assets: ${asString2(institution.ASSET) || "n/a"} ($thousands)`,
+    `Deposits: ${asString2(institution.DEP) || "n/a"} ($thousands)`,
+    `Offices: ${asString2(institution.OFFICES) || "n/a"}`
+  ];
+  if (riskSignals.length > 0) {
+    lines.push("", "Risk signals:", ...riskSignals.map((signal) => `- ${signal}`));
+  }
+  if (warnings.length > 0) {
+    lines.push("", "Warnings:", ...warnings.map((warning) => `- ${warning}`));
+  }
+  return lines.join("\n");
+}
+function registerChatGptBankDeepDiveTool(server) {
+  server.registerTool(
+    "fdic_show_bank_deep_dive",
+    {
+      title: "Show Bank Deep Dive Dashboard",
+      description: "Use this when the user wants a scannable ChatGPT dashboard for one FDIC-insured institution, including identity, public financial metrics, risk signals, and source links.",
+      inputSchema: BankDeepDiveInputSchema,
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      _meta: {
+        ui: { resourceUri: BANK_DEEP_DIVE_WIDGET_URI },
+        "openai/outputTemplate": BANK_DEEP_DIVE_WIDGET_URI,
+        "openai/toolInvocation/invoking": "Building bank dashboard...",
+        "openai/toolInvocation/invoked": "Bank dashboard ready"
+      }
+    },
+    async (rawParams) => {
+      const repdte = rawParams.repdte ?? getDefaultReportDate();
+      const dateError = validateQuarterEndDate(repdte, "repdte");
+      if (dateError) {
+        return formatToolError(new Error(dateError));
+      }
+      try {
+        const [institutionResponse, financialsResponse] = await Promise.all([
+          queryEndpoint(ENDPOINTS.INSTITUTIONS, {
+            filters: `CERT:${rawParams.cert}`,
+            fields: "CERT,NAME,CITY,STALP,STNAME,ACTIVE,ASSET,DEP,OFFICES,BKCLASS,REGAGNT,ESTYMD",
+            limit: 1
+          }),
+          queryEndpoint(ENDPOINTS.FINANCIALS, {
+            filters: `CERT:${rawParams.cert} AND REPDTE:${repdte}`,
+            fields: "CERT,REPDTE,ASSET,DEP,ROA,ROE,IDT1CER,NCLNLSR,LNLSDEPR,NIMY,EEFFR",
+            limit: 1
+          })
+        ]);
+        const institution = extractRecords(institutionResponse)[0];
+        if (!institution) {
+          return formatToolError(
+            new Error(`No institution found with CERT number ${rawParams.cert}.`)
+          );
+        }
+        const financials = extractRecords(financialsResponse)[0];
+        const warnings = financials ? [] : [
+          `No financial record found for CERT ${rawParams.cert} at ${repdte}. Try an earlier quarter-end date.`
+        ];
+        const riskSignals = collectDashboardRiskSignals(financials);
+        const structuredContent = {
+          institution: {
+            cert: rawParams.cert,
+            name: asString2(institution.NAME),
+            city: asString2(institution.CITY),
+            state: asString2(institution.STALP),
+            active: institution.ACTIVE === 1 || institution.ACTIVE === "1",
+            asset_thousands: asNumber3(financials?.ASSET) ?? asNumber3(institution.ASSET),
+            deposit_thousands: asNumber3(financials?.DEP) ?? asNumber3(institution.DEP),
+            offices: asNumber3(institution.OFFICES),
+            charter_class: asString2(institution.BKCLASS),
+            regulator: asString2(institution.REGAGNT),
+            established: asString2(institution.ESTYMD),
+            report_date: repdte
+          },
+          assessment: {
+            official_rating: false,
+            proxy_band: riskSignals.length > 0 ? "review" : "no major public flags",
+            caveat: "Public off-site analytical dashboard; not an official CAMELS rating or confidential supervisory conclusion."
+          },
+          metrics: {
+            roa: formatRatio(financials?.ROA),
+            roe: formatRatio(financials?.ROE),
+            tier1_leverage: formatRatio(financials?.IDT1CER),
+            noncurrent_loans: formatRatio(financials?.NCLNLSR),
+            loan_to_deposit: formatRatio(financials?.LNLSDEPR),
+            net_interest_margin: formatRatio(financials?.NIMY),
+            efficiency_ratio: formatRatio(financials?.EEFFR)
+          },
+          risk_signals: riskSignals,
+          warnings,
+          sources: [
+            {
+              title: "FDIC BankFind institution profile",
+              url: getInstitutionUrl(rawParams.cert)
+            }
+          ]
+        };
+        return {
+          content: [
+            {
+              type: "text",
+              text: truncateIfNeeded(
+                buildDashboardText(institution, repdte, riskSignals, warnings),
+                CHARACTER_LIMIT
+              )
+            }
+          ],
+          structuredContent,
+          _meta: {
+            widget: {
+              resourceUri: BANK_DEEP_DIVE_WIDGET_URI
+            },
+            raw: {
+              institution,
+              financials: financials ?? null
+            }
+          }
+        };
+      } catch (err) {
+        return formatToolError(err);
+      }
+    }
+  );
+}
+
 // src/resources/schemaResources.ts
 var RESOURCE_SCHEME = "fdic";
 var INDEX_URI = `${RESOURCE_SCHEME}://schemas/index`;
@@ -38721,6 +39548,9 @@ function createServer() {
   registerFranchiseFootprintTools(server);
   registerHoldingCompanyProfileTools(server);
   registerRegionalContextTools(server);
+  registerChatGptRetrievalTools(server);
+  registerChatGptBankDeepDiveTool(server);
+  registerChatGptAppResources(server);
   registerSchemaResources(server);
   return server;
 }