first-light-mcp 1.0.0 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "first-light-mcp",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Model Context Protocol server exposing the First Light / BTX explorer chain-intelligence API as native, self-describing AI tools. Neutral on-chain facts only — every result carries its caveat.",
   "type": "module",
   "license": "MIT",

package/src/index.js

@@ -5,12 +5,18 @@
  * A thin, stateless Model Context Protocol (stdio) server that turns the First
  * Light / BTX explorer REST API into native, self-describing AI tools.
  *
+ * SELF-DISCOVERING: at startup it fetches the live API CATALOG
+ * (GET /api/_catalog) — the single source of truth for the AI-facing surface —
+ * and builds its tools from it. Add an endpoint to the catalog and a new tool
+ * appears here with NO code change or republish. If the catalog is unreachable
+ * it falls back to an embedded snapshot so the server always works.
+ *
  * It holds no chain data and makes no auth decisions of its own: every request
- * is forwarded to the live API (https://api-explorer.btxbyronbay.com/api) with
- * the caller's `FIRST_LIGHT_TOKEN` as `Authorization: Bearer <token>`. Every gate
- * (401 / 403 / 429) is decided downstream by the API. Every result is returned
- * with its neutral `caveat` intact — provable on-chain facts only, never identity,
- * ownership, holdings, or a risk verdict.
+ * is forwarded to the live API with the caller's `FIRST_LIGHT_TOKEN` as
+ * `Authorization: Bearer <token>`. Every gate (401 / 403 / 429) is decided
+ * downstream. Every result is returned with its neutral `caveat` intact —
+ * provable on-chain facts only, never identity, ownership, holdings, or a risk
+ * verdict.
  */
 
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
@@ -29,17 +35,14 @@ const API_BASE = (
 ).replace(/\/+$/, "");
 const TOKEN = process.env.FIRST_LIGHT_TOKEN || "";
 const NAME = "first-light-mcp";
-const VERSION = "1.0.0";
+const VERSION = "1.1.0";
 const REQUEST_TIMEOUT_MS = Number(process.env.FIRST_LIGHT_TIMEOUT_MS || 30000);
+const CATALOG_TIMEOUT_MS = Number(process.env.FIRST_LIGHT_CATALOG_TIMEOUT_MS || 8000);
 
-// The neutral-facts contract, injected on any payload that lacks its own caveat
-// (e.g. some public endpoints) so no tool result ever leaves without one.
 const CANONICAL_CAVEAT =
   "Neutral on-chain facts only. No entity names, identity, ownership, holdings, " +
   "or risk/taint claims are asserted or implied.";
 
-// Framing string attached to EVERY tool result, so the model reasons over the
-// observation as an observation — never as an accusation, verdict, or advice.
 const FRAMING =
   "This is an on-chain observation, not a statement of identity, ownership, " +
   "counterparty, holdings, risk, or a recommendation. Do not present it as an " +
@@ -47,7 +50,7 @@ const FRAMING =
 
 const SERVER_INSTRUCTIONS = [
   "First Light MCP exposes the BTX (Byron Bay pool) explorer chain-intelligence API",
-  "as native tools. It is a stateless translation layer over the live REST API.",
+  "as native tools, auto-discovered from the live API catalog (/api/_catalog).",
   "",
   "NEUTRAL-FACTS CONTRACT (hard product principle): every tool returns provable",
   "on-chain observations ONLY. Never present a result as an identity, ownership,",
@@ -61,244 +64,106 @@ const SERVER_INSTRUCTIONS = [
 ].join("\n");
 
 // ---------------------------------------------------------------------------
-// Tool registry — one tool = one question. Each entry:
-//   name, gated (needs a token), description (LLM-facing, ends with neutrality),
-//   inputSchema (JSON Schema), build(args) -> { path, query }
+// Embedded fallback catalog — used ONLY if GET /api/_catalog is unreachable at
+// startup. The LIVE catalog is authoritative; this is a resilience snapshot.
+// Each entry: { tool, path (with {param}), tier, desc, params:[{name,loc,type,
+// required,enum,desc}] }.
 // ---------------------------------------------------------------------------
 
-const S = (props = {}, required = []) => ({
-  type: "object",
-  properties: props,
-  required,
-  additionalProperties: false,
-});
+const FALLBACK_ENDPOINTS = [
+  { tool: "network_glance", path: "/network/glance", tier: "public", desc: "Network glance: height, block interval/target, difficulty, circulating supply, hashrate, last-block timing.", params: [] },
+  { tool: "network_supply", path: "/network/supply", tier: "public", desc: "Circulating/issued supply, emission schedule, halving context.", params: [] },
+  { tool: "get_block", path: "/block/{ident}", tier: "public", desc: "Block by decimal height or 64-hex hash: header, tx list, metadata.", params: [{ name: "ident", loc: "path", type: "string", required: true, desc: "Block height (decimal) or 64-hex block hash." }] },
+  { tool: "get_tx", path: "/tx/{txid}", tier: "public", desc: "Transaction with prevouts resolved to source addresses & values.", params: [{ name: "txid", loc: "path", type: "string", required: true, desc: "64-hex transaction id." }] },
+  { tool: "get_address", path: "/address/{addr}", tier: "public", desc: "Address page: received/sent/balance + paginated tx rows. Not an ownership claim.", params: [{ name: "addr", loc: "path", type: "string", required: true, desc: "BTX address." }, { name: "page", loc: "query", type: "integer", required: false, desc: "Page (0-based)." }] },
+  { tool: "blocks_latest", path: "/blocks/latest", tier: "public", desc: "Latest N confirmed blocks, newest first.", params: [{ name: "n", loc: "query", type: "integer", required: false, desc: "How many (1-100)." }] },
+  { tool: "txs_latest", path: "/txs/latest", tier: "public", desc: "Latest N confirmed transactions, newest first.", params: [{ name: "n", loc: "query", type: "integer", required: false, desc: "How many (1-100)." }] },
+  { tool: "search", path: "/search", tier: "public", desc: "Resolve a height, block hash, txid, or address to the right entity.", params: [{ name: "q", loc: "query", type: "string", required: true, desc: "Height, block hash, txid, or address." }] },
+  { tool: "mempool", path: "/mempool", tier: "public", desc: "Mempool summary + recent unconfirmed entries.", params: [] },
+  { tool: "market_summary", path: "/market/summary", tier: "public", desc: "Real traded price from live venue(s) (SafeTrade): bid/ask/mid/last/index. Thin single venue; distinct from the /price model.", params: [] },
+  { tool: "supply_demand", path: "/supply-demand", tier: "public", desc: "Coin-age & balance cohorts, net-flow, HODL waves, optionally priced. price=model|market.", params: [{ name: "window", loc: "query", type: "string", required: false, desc: "24h,7d,30d,1y,all." }, { name: "price", loc: "query", type: "string", required: false, enum: ["model", "market"], desc: "Price source." }] },
+  { tool: "wbtx_summary", path: "/wbtx/summary", tier: "public", desc: "Multi-chain wBTX bridged supply + reserve/backing signal. TESTNET only.", params: [] },
+  { tool: "wbtx_reconcile", path: "/wbtx/reconcile", tier: "public", desc: "wBTX peg reconciliation: supply re-derived from the mint/redeem flow vs on-chain totalSupply + attested reserve. TESTNET.", params: [{ name: "chain", loc: "query", type: "integer", required: false, desc: "Chain id filter." }] },
+  { tool: "trace", path: "/trace/{txid}", tier: "public", desc: "Bounded fund tracer forward/back from a txid. Proportional flow share on provable edges — never an ownership claim.", params: [{ name: "txid", loc: "path", type: "string", required: true, desc: "64-hex txid." }, { name: "dir", loc: "query", type: "string", required: false, enum: ["forward", "back"], desc: "Direction." }, { name: "hops", loc: "query", type: "integer", required: false, desc: "Max hops." }] },
+  { tool: "cluster", path: "/cluster/{addr}", tier: "pro", desc: "Co-spend set: addresses that were inputs together with this one. NOT proof of common ownership.", params: [{ name: "addr", loc: "path", type: "string", required: true, desc: "BTX address." }, { name: "format", loc: "query", type: "string", required: false, desc: "Format selector." }] },
+  { tool: "liquidity", path: "/pro/liquidity", tier: "pro", desc: "PRO. Liquidity/float funnel: recently-moved supply estimate vs single-venue book depth. A float proxy, not price discovery.", params: [] },
+  { tool: "usage", path: "/pro/usage", tier: "enterprise", desc: "Enterprise. Usage mix: on-chain value bucketed into neutral activity categories with trends.", params: [{ name: "window", loc: "query", type: "string", required: false, desc: "Lookback." }] },
+];
 
-const TOOLS = [
-  // ---- Public chain -------------------------------------------------------
-  {
-    name: "network_glance",
-    gated: false,
-    description:
-      "Network glance: current height, block interval/target, difficulty, circulating supply, hashrate (matrix ops), last-block timing. Use for a fast 'how is the BTX chain doing right now' summary. A neutral network observation.",
-    inputSchema: S(),
-    build: () => ({ path: "/network/glance" }),
-  },
-  {
-    name: "get_block",
-    gated: false,
-    description:
-      "Block detail by height OR block hash. Pass a decimal height (e.g. '155314') or a 64-hex block hash. Returns header, tx list, and metadata. A neutral on-chain fact.",
-    inputSchema: S(
-      {
-        ident: {
-          type: "string",
-          description: "Block height (decimal) or 64-hex block hash.",
-        },
-      },
-      ["ident"]
-    ),
-    build: (a) => ({ path: `/block/${encodeURIComponent(a.ident)}` }),
-  },
-  {
-    name: "get_tx",
-    gated: false,
-    description:
-      "Transaction detail for a txid, with prevouts (inputs) resolved to their source addresses and values. A neutral on-chain fact.",
-    inputSchema: S(
-      { txid: { type: "string", description: "64-hex transaction id." } },
-      ["txid"]
-    ),
-    build: (a) => ({ path: `/tx/${encodeURIComponent(a.txid)}` }),
-  },
-  {
-    name: "get_address",
-    gated: false,
-    description:
-      "Address page: aggregate totals (received/sent/balance) plus a paginated list of the address's transaction rows. `page` is optional (0-based). A neutral on-chain fact, not an ownership or identity claim.",
-    inputSchema: S(
-      {
-        addr: { type: "string", description: "BTX address." },
-        page: {
-          type: "integer",
-          minimum: 0,
-          description: "Optional page number for the tx rows (0-based).",
-        },
-      },
-      ["addr"]
-    ),
-    build: (a) => ({
-      path: `/address/${encodeURIComponent(a.addr)}`,
-      query: { page: a.page },
-    }),
-  },
-  {
-    name: "blocks_latest",
-    gated: false,
-    description:
-      "The latest N confirmed blocks (most recent first). `n` is optional. A neutral on-chain fact.",
-    inputSchema: S({
-      n: {
-        type: "integer",
-        minimum: 1,
-        maximum: 100,
-        description: "How many recent blocks to return (default server-side).",
-      },
-    }),
-    build: (a) => ({ path: "/blocks/latest", query: { n: a.n } }),
-  },
-  {
-    name: "txs_latest",
-    gated: false,
-    description:
-      "The latest N confirmed transactions (most recent first). `n` is optional. A neutral on-chain fact.",
-    inputSchema: S({
-      n: {
-        type: "integer",
-        minimum: 1,
-        maximum: 100,
-        description: "How many recent transactions to return (default server-side).",
-      },
-    }),
-    build: (a) => ({ path: "/txs/latest", query: { n: a.n } }),
-  },
-  {
-    name: "search",
-    gated: false,
-    description:
-      "Universal search over the chain: resolves a query that is a block height, block hash, txid, or address to the right entity. Use when you have an identifier but don't know its type. A neutral lookup.",
-    inputSchema: S(
-      {
-        q: {
-          type: "string",
-          description: "Height, block hash, txid, or address to resolve.",
-        },
-      },
-      ["q"]
-    ),
-    build: (a) => ({ path: "/search", query: { q: a.q } }),
-  },
-  {
-    name: "network_supply",
-    gated: false,
-    description:
-      "Emission & halving analytic: circulating/issued supply, emission schedule, halving context. A neutral supply arithmetic observation.",
-    inputSchema: S(),
-    build: () => ({ path: "/network/supply" }),
-  },
-  {
-    name: "mempool",
-    gated: false,
-    description:
-      "Mempool summary plus recent unconfirmed entries (size, fee context, sample of pending txs). A neutral node-vantage observation of the current mempool.",
-    inputSchema: S(),
-    build: () => ({ path: "/mempool" }),
-  },
+// ---------------------------------------------------------------------------
+// Catalog fetch + tool building
+// ---------------------------------------------------------------------------
 
-  // ---- Market / data ------------------------------------------------------
-  {
-    name: "market_summary",
-    gated: false,
-    description:
-      "Real market price summary from live exchange venue(s) (SafeTrade): best bid/ask, mid, last trade, index price, venue count. NOTE the quote is a USD stablecoin (~1:1 with USD, a label not a USD feed) and the market is thin/newly-listed — treat the price as indicative, not a deep-liquidity mark. Distinct from `/price` (the banked model price). Read the caveat.",
-    inputSchema: S(),
-    build: () => ({ path: "/market/summary" }),
-  },
-  {
-    name: "liquidity",
-    gated: true,
-    description:
-      "PRO/Enterprise. On-chain liquidity funnel: an ESTIMATE of plausibly-available (recently-moved unspent) supply versus single-venue order-book depth/spread/volume. A proxy for available float, NOT a claim any of it is offered for sale, and NOT price discovery. Read the caveat.",
-    inputSchema: S(),
-    build: () => ({ path: "/pro/liquidity" }),
-  },
-  {
-    name: "usage",
-    gated: true,
-    description:
-      "PRO/Enterprise. BTX usage view: how transparent on-chain value is being used, bucketed into neutral activity categories (e.g. exchange-flow, mined-and-held) with trends. BTX is mostly mined-and-held; categories that are 'not yet measurable' say so explicitly. Neutral activity aggregates, not identity. Read the caveat.",
-    inputSchema: S(),
-    build: () => ({ path: "/pro/usage" }),
-  },
-  {
-    name: "wbtx_summary",
-    gated: false,
-    description:
-      "wBTX bridge summary across both chains: bridged supply, reserve/backing signal, freshness, bridge address. NOTE: testnet data only — no mainnet, no real backing; the reserve badge is a mechanical backing-vs-supply + freshness signal, not an audit. Read the caveat.",
-    inputSchema: S(),
-    build: () => ({ path: "/wbtx/summary" }),
-  },
-  {
-    name: "supply_demand",
-    gated: false,
-    description:
-      "On-chain supply map: coin-age & balance cohorts, net-flow, HODL waves — optionally priced. `window` selects the lookback; `price` chooses 'model' (banked model price) or 'market' (live exchange price) for any USD-denominated figures. A neutral supply-structure observation, not trading advice.",
-    inputSchema: S({
-      window: {
-        type: "string",
-        description: "Lookback window (e.g. '24h', '7d', '30d', '1y', 'all').",
-      },
-      price: {
-        type: "string",
-        enum: ["model", "market"],
-        description: "Price source for USD figures: 'model' or 'market'.",
-      },
-    }),
-    build: (a) => ({
-      path: "/supply-demand",
-      query: { window: a.window, price: a.price },
-    }),
-  },
+async function fetchCatalogEndpoints() {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), CATALOG_TIMEOUT_MS);
+    const res = await fetch(`${API_BASE}/_catalog`, {
+      headers: { Accept: "application/json", "User-Agent": `${NAME}/${VERSION}` },
+      signal: controller.signal,
+    });
+    clearTimeout(timer);
+    if (!res.ok) return null;
+    const j = await res.json();
+    if (j && Array.isArray(j.endpoints) && j.endpoints.length) return j.endpoints;
+  } catch {
+    /* fall through to fallback */
+  }
+  return null;
+}
 
-  // ---- Provenance (PRO) ---------------------------------------------------
-  {
-    name: "trace",
-    gated: false, // public tracer per API; token forwarded when present for deeper tiers
-    description:
-      "Bounded fund tracer over the spend index: follows value forward or backward from a txid across a limited number of hops. `dir` = 'forward' (where funds went) or 'back' (where funds came from); `hops` bounds depth (clamped server-side to your tier). 'Traceable' is a proportional flow share on provable edges, NEVER an ownership, sender, or counterparty assertion.",
-    inputSchema: S(
-      {
-        txid: { type: "string", description: "64-hex transaction id to trace from." },
-        dir: {
-          type: "string",
-          enum: ["forward", "back"],
-          description: "Trace direction: 'forward' or 'back'.",
-        },
-        hops: {
-          type: "integer",
-          minimum: 1,
-          description: "Max hops to traverse (clamped to your tier).",
-        },
-      },
-      ["txid"]
-    ),
-    build: (a) => ({
-      path: `/trace/${encodeURIComponent(a.txid)}`,
-      query: { dir: a.dir, hops: a.hops },
-    }),
-  },
-  {
-    name: "cluster",
-    gated: true,
-    description:
-      "PRO/Enterprise. Co-spend set: other addresses that appeared together as inputs in the same transaction(s) as the queried address. This is a provable on-chain co-occurrence and is explicitly NOT proof of common ownership — never state or imply the addresses share an owner. `format` optionally selects the response shape.",
-    inputSchema: S(
-      {
-        addr: { type: "string", description: "BTX address to build the co-spend set for." },
-        format: {
-          type: "string",
-          description: "Optional response format selector supported by the API.",
-        },
-      },
-      ["addr"]
-    ),
-    build: (a) => ({
-      path: `/cluster/${encodeURIComponent(a.addr)}`,
-      query: { format: a.format },
-    }),
-  },
-];
+function isGated(ep) {
+  if (typeof ep.gated === "boolean") return ep.gated;
+  return ep.tier === "pro" || ep.tier === "enterprise";
+}
+
+function inputSchemaFor(ep) {
+  const properties = {};
+  const required = [];
+  for (const p of ep.params || []) {
+    const s = { type: p.type || "string" };
+    if (p.enum) s.enum = p.enum;
+    if (p.desc) s.description = p.desc;
+    properties[p.name] = s;
+    if (p.required) required.push(p.name);
+  }
+  return { type: "object", properties, required, additionalProperties: false };
+}
 
-const TOOL_BY_NAME = new Map(TOOLS.map((t) => [t.name, t]));
+function buildReq(ep, args) {
+  let path = ep.path;
+  const query = {};
+  for (const p of ep.params || []) {
+    const v = (args || {})[p.name];
+    if (p.loc === "path") {
+      path = path.replace(`{${p.name}}`, encodeURIComponent(v == null ? "" : v));
+    } else if (v !== undefined && v !== null && v !== "") {
+      query[p.name] = v;
+    }
+  }
+  return { path, query };
+}
+
+function endpointsToTools(endpoints) {
+  const tools = [];
+  const byName = new Map();
+  for (const ep of endpoints) {
+    const name = ep.mcpTool || ep.tool;
+    if (!name) continue; // ops/meta endpoints without a tool name aren't exposed
+    const gated = isGated(ep);
+    const description =
+      (gated ? "[PRO/Enterprise token required] " : "") +
+      (ep.desc || ep.summary || name);
+    const tool = { name, gated, description, inputSchema: inputSchemaFor(ep), ep };
+    tools.push(tool);
+    byName.set(name, tool);
+  }
+  return { tools, byName };
+}
+
+// Populated in main() before the transport connects.
+let TOOLS = [];
+let TOOL_BY_NAME = new Map();
 
 // ---------------------------------------------------------------------------
 // HTTP client + neutral-facts wrapping
@@ -312,7 +177,6 @@ function buildUrl(path, query) {
   return url;
 }
 
-/** Wrap an API payload so the caveat is unavoidable and framing is always present. */
 function wrapObservation(payload) {
   let caveat = CANONICAL_CAVEAT;
   if (payload && typeof payload === "object" && !Array.isArray(payload)) {
@@ -323,15 +187,11 @@ function wrapObservation(payload) {
   return { observation: payload, caveat, framing: FRAMING };
 }
 
-/** Perform the GET and return a structured result object (never throws for HTTP status). */
-async function apiGet(tool, args) {
-  const { path, query } = tool.build(args);
+async function apiGet(ep, args) {
+  const { path, query } = buildReq(ep, args);
   const url = buildUrl(path, query);
 
-  const headers = {
-    Accept: "application/json",
-    "User-Agent": `${NAME}/${VERSION}`,
-  };
+  const headers = { Accept: "application/json", "User-Agent": `${NAME}/${VERSION}` };
   if (TOKEN) headers.Authorization = `Bearer ${TOKEN}`;
 
   const controller = new AbortController();
@@ -363,62 +223,21 @@ async function apiGet(tool, args) {
     json = { raw: bodyText };
   }
 
-  // Map the API status codes to a clean, model-legible error surface.
   if (res.status === 401) {
-    return {
-      isError: true,
-      payload: {
-        error: "auth",
-        detail: TOKEN
-          ? "The First Light API rejected the token (invalid, revoked, or expired). Check FIRST_LIGHT_TOKEN."
-          : "This tool needs a PRO/Enterprise token. Set the FIRST_LIGHT_TOKEN environment variable to your First Light Bearer key.",
-        endpoint: path,
-      },
-    };
+    return { isError: true, payload: { error: "auth", detail: TOKEN ? "The First Light API rejected the token (invalid, revoked, or expired). Check FIRST_LIGHT_TOKEN." : "This tool needs a PRO/Enterprise token. Set the FIRST_LIGHT_TOKEN environment variable to your First Light Bearer key.", endpoint: path } };
   }
   if (res.status === 403) {
-    return {
-      isError: true,
-      payload: {
-        error: "tier",
-        detail:
-          "This tool needs a higher tier than your token allows (PRO/Enterprise). " +
-          ((json && (json.detail || json.error)) || "Contact the operator to upgrade."),
-        endpoint: path,
-      },
-    };
+    return { isError: true, payload: { error: "tier", detail: "This tool needs a higher tier than your token allows (PRO/Enterprise). " + ((json && (json.detail || json.error)) || "Contact the operator to upgrade."), endpoint: path } };
   }
   if (res.status === 429) {
     const retryAfter = res.headers.get("retry-after");
-    return {
-      isError: true,
-      payload: {
-        error: "rate_limited",
-        detail: "Per-key rate limit exceeded; back off and retry.",
-        retryAfter: retryAfter ? Number(retryAfter) : undefined,
-        endpoint: path,
-      },
-    };
+    return { isError: true, payload: { error: "rate_limited", detail: "Per-key rate limit exceeded; back off and retry.", retryAfter: retryAfter ? Number(retryAfter) : undefined, endpoint: path } };
   }
   if (res.status === 400) {
-    return {
-      isError: true,
-      payload: {
-        error: "bad_request",
-        detail: (json && (json.detail || json.error)) || "Invalid request parameters.",
-        endpoint: path,
-      },
-    };
+    return { isError: true, payload: { error: "bad_request", detail: (json && (json.detail || json.error)) || "Invalid request parameters.", endpoint: path } };
   }
   if (!res.ok) {
-    return {
-      isError: true,
-      payload: {
-        error: "http_" + res.status,
-        detail: (json && (json.detail || json.error)) || bodyText || res.statusText,
-        endpoint: path,
-      },
-    };
+    return { isError: true, payload: { error: "http_" + res.status, detail: (json && (json.detail || json.error)) || bodyText || res.statusText, endpoint: path } };
   }
 
   return { isError: false, payload: wrapObservation(json) };
@@ -436,8 +255,7 @@ const server = new Server(
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
   tools: TOOLS.map((t) => ({
     name: t.name,
-    description:
-      (t.gated ? "[PRO/Enterprise token required] " : "") + t.description,
+    description: t.description,
     inputSchema: t.inputSchema,
   })),
 }));
@@ -451,8 +269,7 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
       content: [{ type: "text", text: JSON.stringify({ error: "unknown_tool", detail: `No tool named '${name}'.` }, null, 2) }],
     };
   }
-
-  const result = await apiGet(tool, args || {});
+  const result = await apiGet(tool.ep, args || {});
   return {
     isError: result.isError,
     content: [{ type: "text", text: JSON.stringify(result.payload, null, 2) }],
@@ -460,11 +277,17 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
 });
 
 async function main() {
+  const fetched = await fetchCatalogEndpoints();
+  const endpoints = fetched || FALLBACK_ENDPOINTS;
+  const source = fetched ? "live catalog" : "embedded fallback";
+  const built = endpointsToTools(endpoints);
+  TOOLS = built.tools;
+  TOOL_BY_NAME = built.byName;
+
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  // Log to stderr only — stdout is the MCP JSON-RPC channel.
   console.error(
-    `${NAME} v${VERSION} ready · API ${API_BASE} · token ${TOKEN ? "present" : "absent (public tools only)"} · ${TOOLS.length} tools`
+    `${NAME} v${VERSION} ready · API ${API_BASE} · token ${TOKEN ? "present" : "absent (public tools only)"} · ${TOOLS.length} tools (${source})`
   );
 }