hive-intelligence 1.9.0 → 1.10.0

package/build/{chunk-MVO6LL3H.js → chunk-Z42XNN47.js}

@@ -4457,6 +4457,52 @@ var handler42 = async (client2, args) => {
 };
 var get_timeframe_pools_networks_onchain_ohlcv_default = { metadata: metadata42, tool: tool42, handler: handler42 };
 
+// src/tools/onchain/tradeSummary.ts
+var UPSTREAM_TRADE_CAP = 300;
+function usd(value) {
+  const n = typeof value === "string" ? Number(value) : value;
+  return typeof n === "number" && Number.isFinite(n) ? n : 0;
+}
+function withTradeSummary(payload, minTradeUsd) {
+  const rows = payload?.data;
+  if (!Array.isArray(rows)) return payload;
+  let buys = 0;
+  let sells = 0;
+  let buyVolume = 0;
+  let sellVolume = 0;
+  const timestamps = [];
+  for (const row of rows) {
+    const attrs = row?.attributes ?? {};
+    if (attrs.kind === "buy") {
+      buys += 1;
+      buyVolume += usd(attrs.volume_in_usd);
+    } else if (attrs.kind === "sell") {
+      sells += 1;
+      sellVolume += usd(attrs.volume_in_usd);
+    }
+    if (typeof attrs.block_timestamp === "string") {
+      timestamps.push(attrs.block_timestamp);
+    }
+  }
+  timestamps.sort();
+  const filtered = usd(minTradeUsd) > 0;
+  return {
+    summary: {
+      trade_count: rows.length,
+      buys,
+      sells,
+      buy_volume_usd: buyVolume,
+      sell_volume_usd: sellVolume,
+      oldest_trade_at: timestamps[0] ?? null,
+      newest_trade_at: timestamps.at(-1) ?? null,
+      min_trade_usd: filtered ? usd(minTradeUsd) : 0,
+      upstream_capped: rows.length >= UPSTREAM_TRADE_CAP,
+      note: `Counts cover every trade GeckoTerminal returned: at most ${UPSTREAM_TRADE_CAP}, newest first, within the last 24h${filtered ? `, trades of at least $${usd(minTradeUsd)} only` : ""}. The data array may be cut to the newest rows by the response budget, so count buys and sells from this summary, not from data. Pool transactions.h24 (get_token_pools) counts every swap and can exceed trade_count when the cap or the minimum-size filter applies.`
+    },
+    ...payload
+  };
+}
+
 // src/tools/onchain/networks/pools/trades/get-pools-networks-onchain-trades.ts
 var metadata43 = {
   resource: "onchain.networks.pools.trades",
@@ -4555,7 +4601,12 @@ Error Handling:
 };
 var handler43 = async (client2, args) => {
   const { pool_address, ...body } = args;
-  return asTextContentResult(await client2.onchain.networks.pools.trades.get(pool_address, body));
+  return asTextContentResult(
+    withTradeSummary(
+      await client2.onchain.networks.pools.trades.get(pool_address, body),
+      body.trade_volume_in_usd_greater_than
+    )
+  );
 };
 var get_pools_networks_onchain_trades_default = { metadata: metadata43, tool: tool43, handler: handler43 };
 
@@ -4745,6 +4796,8 @@ var handler45 = async (client2, args) => {
 var get_tokens_networks_onchain_info_default = { metadata: metadata45, tool: tool45, handler: handler45 };
 
 // src/tools/onchain/networks/tokens/top-holders/get-tokens-networks-onchain-top-holders.ts
+var TOP_HOLDERS_MAX = 50;
+var SOLANA_TOP_HOLDERS_MAX = 40;
 var metadata46 = {
   resource: "onchain.networks.tokens.top_holders",
   operation: "read",
@@ -4769,7 +4822,8 @@ Returns a ranked list of addresses holding the largest amounts of a token. Essen
 Args:
   - network (string, required): Network ID (e.g., "eth", "bsc", "solana"). Use coingecko_get_onchain_networks to find valid IDs.
   - address (string, required): Token contract address.
-  - holders (string, optional): Number of top holders to return. Use any integer or "max". Default: 10.
+  - limit (integer, optional): Number of top holders to return, 1-50 (Solana: 1-40, the most Hive's CoinGecko plan serves). Default: the plan maximum.
+  - holders (string, optional): Legacy alias for limit; an integer or "max". Values above the plan maximum, and "max", are capped to it.
   - include_pnl_details (boolean, optional): Include realized/unrealized P&L per holder (pnl_usd, cost_basis_usd, avg_buy_price_usd). Default: false.
 
 Returns:
@@ -4793,9 +4847,8 @@ Returns:
   }
 
 Examples:
-  - Top 10 USDC holders: {"network": "eth", "address": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"}
-  - Top 50 holders: {"network": "eth", "address": "0xa0b86991...", "holders": "50"}
-  - All holders: {"network": "bsc", "address": "0x...", "holders": "max"}
+  - Top 50 USDC holders: {"network": "eth", "address": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"}
+  - Top 10 holders: {"network": "eth", "address": "0xa0b86991...", "limit": 10}
 
 Use when:
   - You need to identify major token holders (whales)
@@ -4804,6 +4857,7 @@ Use when:
   - You're tracking institutional or smart money positions
 
 Don't use when:
+  - You need the total holder count or how many holders are above a USD size (use get_token_holder_distribution)
   - You need historical holder count (use coingecko_get_onchain_token_holders_chart)
   - You need token metadata (use coingecko_get_onchain_token_info)
   - You need trading data (use coingecko_get_onchain_token_trades)
@@ -4825,9 +4879,15 @@ Error Handling:
         type: "string",
         description: "Token contract address. Required."
       },
+      limit: {
+        type: "integer",
+        minimum: 1,
+        maximum: TOP_HOLDERS_MAX,
+        description: `Number of top holders to return, 1-${TOP_HOLDERS_MAX} (Solana: 1-${SOLANA_TOP_HOLDERS_MAX}). Default: the plan maximum.`
+      },
       holders: {
         type: "string",
-        description: 'Number of top holders to return, or "max". Default: 10.'
+        description: 'Legacy alias for limit: an integer or "max". Capped to the plan maximum.'
       },
       include_pnl_details: {
         type: "boolean",
@@ -4838,10 +4898,19 @@ Error Handling:
   },
   annotations: VOLATILE_READ_ANNOTATIONS
 };
+function resolveTopHoldersCount(network, limit, holders) {
+  const cap = String(network ?? "").toLowerCase() === "solana" ? SOLANA_TOP_HOLDERS_MAX : TOP_HOLDERS_MAX;
+  const requested = Number(limit ?? (holders === "max" ? cap : holders ?? cap));
+  if (!Number.isFinite(requested) || requested < 1) return String(cap);
+  return String(Math.min(Math.floor(requested), cap));
+}
 var handler46 = async (client2, args) => {
-  const { address, ...body } = args;
+  const { address, limit, holders, ...body } = args ?? {};
   return asTextContentResult(
-    await client2.onchain.networks.tokens.topHolders.get(address, body)
+    await client2.onchain.networks.tokens.topHolders.get(address, {
+      ...body,
+      holders: resolveTopHoldersCount(body.network, limit, holders)
+    })
   );
 };
 var get_tokens_networks_onchain_top_holders_default = { metadata: metadata46, tool: tool46, handler: handler46 };
@@ -5255,7 +5324,12 @@ Error Handling:
 };
 var handler50 = async (client2, args) => {
   const { token_address, ...body } = args;
-  return asTextContentResult(await client2.onchain.networks.tokens.trades.get(token_address, body));
+  return asTextContentResult(
+    withTradeSummary(
+      await client2.onchain.networks.tokens.trades.get(token_address, body),
+      body.trade_volume_in_usd_greater_than
+    )
+  );
 };
 var get_tokens_networks_onchain_trades_default = { metadata: metadata50, tool: tool50, handler: handler50 };
 
@@ -18117,6 +18191,16 @@ var wrapper = {
         oldToolName: "ccxt_fetch_convert_quote"
       }
     }
+  ],
+  // Blockscout tools describe themselves; these entries only admit the
+  // unprefixed name (src/tools/blockscout/tools.ts).
+  getAllBlockscoutEndpoints: [
+    {
+      tool: {
+        name: "get_token_holder_distribution",
+        oldToolName: "get_token_holder_distribution"
+      }
+    }
   ]
 };
 
@@ -46134,7 +46218,7 @@ function getAllAlchemyEndpoints() {
 import axios3 from "axios";
 var HYPERLIQUID_API_URL = "https://api.hyperliquid.xyz";
 var DEFAULT_LEADERBOARD_LIMIT = 20;
-var MAX_LEADERBOARD_LIMIT = 100;
+var MAX_LEADERBOARD_LIMIT = 500;
 var FUNDING_HISTORY_PAGE_SIZE = 500;
 var DEFAULT_FUNDING_HISTORY_RETURN_POINTS = 500;
 var MAX_FUNDING_HISTORY_RETURN_POINTS = 500;
@@ -46177,7 +46261,7 @@ var HyperliquidAPI = class {
    *   Omit (or pass empty) for the main Hyperliquid DEX.
    * @param limit - top N pairs by 24h notional volume (1-100, default 20).
    */
-  async getPerpVolumeLeaderboard(dex, limit = DEFAULT_LEADERBOARD_LIMIT) {
+  async getPerpVolumeLeaderboard(dex, limit = DEFAULT_LEADERBOARD_LIMIT, offset = 0) {
     const body = { type: "metaAndAssetCtxs" };
     if (dex) body.dex = dex;
     const { data } = await this.client.post("/info", body);
@@ -46202,6 +46286,7 @@ var HyperliquidAPI = class {
       Math.max(1, Math.floor(limit || DEFAULT_LEADERBOARD_LIMIT)),
       MAX_LEADERBOARD_LIMIT
     );
+    const safeOffset = Math.max(0, Math.floor(offset || 0));
     return {
       dex: dex || "main",
       pairCount: rows.length,
@@ -46209,7 +46294,8 @@ var HyperliquidAPI = class {
         (sum, row) => sum + row.dayNotionalVolume,
         0
       ),
-      leaderboard: rows.slice(0, safeLimit)
+      offset: safeOffset,
+      leaderboard: rows.slice(safeOffset, safeOffset + safeLimit)
     };
   }
   /**
@@ -46438,6 +46524,85 @@ var HyperliquidAPI = class {
   }
 };
 
+// src/config/responseLimits.ts
+var RESPONSE_LIMITS = {
+  // Maximum tokens allowed in a response (MCP constraint)
+  MAX_RESPONSE_TOKENS: 25e3,
+  // Estimated characters per token (rough approximation)
+  CHARS_PER_TOKEN: 4,
+  // Maximum characters allowed (25000 * 4 = 100,000)
+  MAX_RESPONSE_CHARS: 1e5,
+  // Default pagination limits for different endpoints
+  DEFAULT_LIMITS: {
+    tokens: 100,
+    pools: 50,
+    trades: 100,
+    holders: 100,
+    events: 200,
+    nfts: 50
+  },
+  // Maximum allowed limits to prevent oversized responses
+  MAX_LIMITS: {
+    tokens: 100,
+    pools: 50,
+    trades: 200,
+    holders: 200,
+    events: 300,
+    nfts: 100
+  },
+  // Size thresholds for automatic truncation (in characters)
+  TRUNCATION_THRESHOLDS: {
+    warning: 8e4,
+    // Start warning at 80KB
+    truncate: 1e5
+    // Force truncation at 100KB
+  }
+};
+
+// src/utils/responseHeadroom.ts
+var MAX_RESULT_SIZE_META_KEY = "anthropic/maxResultSizeChars";
+var ANNOTATED_MAX_RESULT_SIZE_CHARS = RESPONSE_LIMITS.MAX_RESPONSE_CHARS;
+var DEFAULT_RESULT_SIZE_GUARD_CHARS = 2e4;
+var HEADROOM_TOOL_PATTERNS = [
+  // Depth-of-book: order books, l2/l3 books.
+  /orderbook|order_book|l2_book|l3_orderbook/i,
+  // Holder / owner lists.
+  /holders?(?:_|$)|owners_for/i,
+  // OHLCV, candles, charts, and history/time-series families.
+  /ohlc|candle|kline|market_chart|chart|history|timeseries/i
+];
+function toolNeedsResponseHeadroom(toolName) {
+  return HEADROOM_TOOL_PATTERNS.some((pattern) => pattern.test(toolName));
+}
+function getAnnotatedMaxResultSizeChars(tool96) {
+  const meta2 = tool96?._meta;
+  const value = meta2?.[MAX_RESULT_SIZE_META_KEY];
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : null;
+}
+function withResponseHeadroomMeta(tool96) {
+  if (!toolNeedsResponseHeadroom(tool96.name)) return tool96;
+  const existing = tool96._meta;
+  if (existing && existing[MAX_RESULT_SIZE_META_KEY] !== void 0) return tool96;
+  return {
+    ...tool96,
+    _meta: {
+      ...existing ?? {},
+      [MAX_RESULT_SIZE_META_KEY]: ANNOTATED_MAX_RESULT_SIZE_CHARS
+    }
+  };
+}
+function largestFittingRowCount(max, fits) {
+  if (max <= 0 || fits(max)) return Math.max(0, max);
+  let lo = 1;
+  let hi = max - 1;
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    if (fits(mid)) lo = mid;
+    else hi = mid - 1;
+  }
+  return lo;
+}
+
 // src/tools/hyperliquid/infoTools.ts
 var MAX_ARRAY_ITEMS = 500;
 var SPOT_TOKEN_TTL_MS = 10 * 60 * 1e3;
@@ -47376,14 +47541,19 @@ Hyperliquid is the dominant on-chain perpetual DEX. This reads the venue's own p
 
 Args:
   - dex (string, optional): Builder DEX name to scope the leaderboard to (e.g. "xyz" for tokenized-stock / pre-IPO perps like SPCX, MU, XYZ100). Omit for Hyperliquid's main perp DEX. Call hyperliquid_get_perp_dexs to discover builder DEX names.
-  - limit (number, optional): Number of top pairs to return, ranked by 24h notional volume (1-100, default 20).
+  - limit (number, optional): Number of top pairs to return, ranked by 24h notional volume (1-${MAX_LEADERBOARD_LIMIT}, default 20). A page also stops at the ~${DEFAULT_RESULT_SIZE_GUARD_CHARS / 1e3}k-character response budget (about 100 pairs); page on with offset=next_offset to read every pair.
+  - offset (number, optional): Rank to start from (0 = top pair, default 0).
 
 Returns:
   JSON object:
   {
     "dex": string,                       // "main" or the builder DEX name
     "pairCount": number,                 // total pairs on this DEX
-    "totalDayNotionalVolume": number,    // summed 24h notional volume (USD)
+    "totalDayNotionalVolume": number,    // summed 24h notional volume over ALL pairs (USD), not just this page
+    "offset": number,                    // rank of the first row
+    "returnedCount": number,             // rows in this response
+    "next_offset": number | null,        // pass as offset for the next page; null after the last pair
+    "pagination_note"?: string,          // present when the response budget cut the requested page short
     "leaderboard": [{
       "coin": string,                    // perp symbol (e.g. "BTC", "HYPE", "SPCX")
       "dayNotionalVolume": number,       // 24h notional volume (USD)
@@ -47414,8 +47584,13 @@ Don't use when:
             limit: {
               type: "integer",
               minimum: 1,
-              maximum: 100,
-              description: "Top N pairs by 24h notional volume (1-100, default 20)."
+              maximum: MAX_LEADERBOARD_LIMIT,
+              description: `Top N pairs by 24h notional volume (1-${MAX_LEADERBOARD_LIMIT}, default 20). One page carries about 100 pairs (response budget); returnedCount and next_offset say what shipped.`
+            },
+            offset: {
+              type: "integer",
+              minimum: 0,
+              description: "Rank to start from (0 = top pair). Pass the previous response's next_offset for the next page."
             }
           }
         },
@@ -47424,8 +47599,29 @@ Don't use when:
       handler: async (_client, args) => {
         const dex = typeof args?.dex === "string" ? args.dex : void 0;
         const limit = typeof args?.limit === "number" ? args.limit : void 0;
-        const data = await api.getPerpVolumeLeaderboard(dex, limit);
-        return asTextContentResult(data);
+        const offset = typeof args?.offset === "number" ? args.offset : 0;
+        const data = await api.getPerpVolumeLeaderboard(dex, limit, offset);
+        const requested = data.leaderboard;
+        const page = (kept) => {
+          const next = data.offset + kept;
+          return {
+            ...data,
+            returnedCount: kept,
+            next_offset: next < data.pairCount ? next : null,
+            ...kept < requested.length && {
+              pagination_note: `${kept} of the ${requested.length} requested pairs fit the response budget. Re-call with offset=${next} for the next page.`
+            },
+            leaderboard: requested.slice(0, kept)
+          };
+        };
+        return asTextContentResult(
+          page(
+            largestFittingRowCount(
+              requested.length,
+              (kept) => JSON.stringify(page(kept)).length <= DEFAULT_RESULT_SIZE_GUARD_CHARS - 500
+            )
+          )
+        );
       }
     },
     {
@@ -48599,6 +48795,7 @@ async function collectRwaRows(deps, venues = RWA_VENUE_IDS) {
 // src/tools/rwa/tools.ts
 var DEFAULT_LIMIT = 100;
 var MAX_LIMIT = 500;
+var PAGE_BUDGET_CHARS = DEFAULT_RESULT_SIZE_GUARD_CHARS - 500;
 var ASSET_CLASSES = [
   "equity",
   "pre_ipo",
@@ -48620,6 +48817,10 @@ function clampLimit2(value) {
   if (!Number.isFinite(parsed)) return DEFAULT_LIMIT;
   return Math.min(Math.max(parsed, 1), MAX_LIMIT);
 }
+function clampOffset(value) {
+  const parsed = typeof value === "number" ? Math.floor(value) : NaN;
+  return Number.isFinite(parsed) ? Math.max(parsed, 0) : 0;
+}
 function sortRows(rows) {
   return [...rows].sort((a, b) => {
     const oiA = a.open_interest_usd ?? -1;
@@ -48657,15 +48858,30 @@ function applyFilters(rows, args) {
     }
   };
 }
-function boundedEnvelope(rows, limit) {
+function boundedPayload(rows, args, render) {
   const sorted = sortRows(rows);
-  const items = sorted.slice(0, limit);
-  return {
-    count: sorted.length,
-    returnedCount: items.length,
-    truncated: items.length < sorted.length,
-    rows: items
+  const offset = clampOffset(args?.offset);
+  const requested = sorted.slice(offset, offset + clampLimit2(args?.limit));
+  const build = (kept) => {
+    const next = offset + kept;
+    const page = {
+      count: sorted.length,
+      offset,
+      returnedCount: kept,
+      truncated: next < sorted.length,
+      next_offset: next < sorted.length ? next : null,
+      ...kept < requested.length && {
+        pagination_note: `${kept} of the ${requested.length} requested rows fit the response budget. Re-call with offset=${next} for the next page.`
+      }
+    };
+    return render(page, requested.slice(0, kept));
   };
+  return build(
+    largestFittingRowCount(
+      requested.length,
+      (kept) => JSON.stringify(build(kept)).length <= PAGE_BUDGET_CHARS
+    )
+  );
 }
 var FILTER_PARAM_PROPERTIES = {
   underlying: {
@@ -48685,7 +48901,12 @@ var FILTER_PARAM_PROPERTIES = {
     type: "integer",
     minimum: 1,
     maximum: MAX_LIMIT,
-    description: `Maximum rows to return (1-${MAX_LIMIT}, default ${DEFAULT_LIMIT}). Rows are ordered by open interest (deepest first).`
+    description: `Maximum rows to return (1-${MAX_LIMIT}, default ${DEFAULT_LIMIT}). Rows are ordered by open interest (deepest first). A page also stops at the ~${DEFAULT_RESULT_SIZE_GUARD_CHARS / 1e3}k-character response budget (about 30 full rows); returnedCount is what shipped and next_offset continues.`
+  },
+  offset: {
+    type: "integer",
+    minimum: 0,
+    description: "Rows to skip in the open-interest order (default 0). Pass the previous response's next_offset to read the next page."
   }
 };
 function toMarketRow(row) {
@@ -48733,9 +48954,10 @@ Args:
   - underlying (string, optional): filter to one canonical underlying ticker.
   - asset_class (string, optional): filter to one asset class.
   - limit (integer, optional): max rows (1-${MAX_LIMIT}, default ${DEFAULT_LIMIT}), deepest open interest first.
+  - offset (integer, optional): rows to skip; pass next_offset to page.
 
 Returns:
-  Bounded JSON envelope: { "venue", "count", "returnedCount", "truncated", "rows": [normalized rows] }. ${returnsNote}
+  Bounded JSON envelope: { "venue", "count", "offset", "returnedCount", "truncated", "next_offset", "pagination_note"?, "rows": [normalized rows] }. A page holds at most what fits the response budget (about 30 rows): returnedCount is the rows shipped, next_offset is null on the last page. ${returnsNote}
 
 Use when:
 ${useWhen.map((line) => `  - ${line}`).join("\n")}
@@ -48747,7 +48969,8 @@ ${dontUseWhen.map((line) => `  - ${line}`).join("\n")}`,
         properties: {
           underlying: FILTER_PARAM_PROPERTIES.underlying,
           asset_class: FILTER_PARAM_PROPERTIES.asset_class,
-          limit: FILTER_PARAM_PROPERTIES.limit
+          limit: FILTER_PARAM_PROPERTIES.limit,
+          offset: FILTER_PARAM_PROPERTIES.offset
         }
       },
       annotations: VOLATILE_READ_ANNOTATIONS
@@ -48756,13 +48979,15 @@ ${dontUseWhen.map((line) => `  - ${line}`).join("\n")}`,
       const { rows, note } = await fetchRwaVenueRows(venueId, deps);
       stampPriceSuspect(rows);
       const { filtered, filters } = applyFilters(rows, args);
-      const envelope = boundedEnvelope(filtered, clampLimit2(args?.limit));
-      return asTextContentResult({
-        venue: venueId,
-        ...note ? { note } : {},
-        filters,
-        ...envelope
-      });
+      return asTextContentResult(
+        boundedPayload(filtered, args, (page, pageRows) => ({
+          venue: venueId,
+          ...note ? { note } : {},
+          filters,
+          ...page,
+          rows: pageRows
+        }))
+      );
     }
   };
 }
@@ -48798,6 +49023,7 @@ Args:
   - venue (string, optional): filter to one venue ("ostium", "avantis", "lighter", "extended", "hyperliquid", or "hyperliquid:xyz").
   - asset_class (string, optional): filter to one asset class (equity, pre_ipo, etf, index, commodity, fx, crypto).
   - limit (integer, optional): max rows (1-${MAX_LIMIT}, default ${DEFAULT_LIMIT}), deepest open interest first.
+  - offset (integer, optional): rows to skip; pass next_offset to page.
 
 Returns:
   JSON object:
@@ -48805,9 +49031,11 @@ Returns:
     "filters": { "underlying", "venue", "asset_class" },
     "venueCount": number, "okCount": number,
     "venues": [{ "venue", "runtime_status", "rowCount", "error"? }],
-    "count": number, "returnedCount": number, "truncated": boolean,
+    "count": number, "offset": number, "returnedCount": number, "truncated": boolean,
+    "next_offset": number | null, "pagination_note"?: string,
     "rows": [normalized funding rows]
   }
+  A page holds at most what fits the response budget (about 30 rows): returnedCount is the rows shipped; re-call with offset=next_offset for more.
 
 Use when:
   - "TSLA perp funding across venues" / tokenized-stock or equity perp funding questions
@@ -48827,17 +49055,19 @@ Don't use when:
       handler: async (_client, args) => {
         const { results, rows } = await collectRwaRows(deps);
         const { filtered, filters } = applyFilters(rows, args);
-        const envelope = boundedEnvelope(filtered, clampLimit2(args?.limit));
         const okCount = results.filter(
           (result2) => result2.runtime_status === "ok"
         ).length;
-        return asTextContentResult({
-          filters,
-          venueCount: results.length,
-          okCount,
-          venues: results,
-          ...envelope
-        });
+        return asTextContentResult(
+          boundedPayload(filtered, args, (page, pageRows) => ({
+            filters,
+            venueCount: results.length,
+            okCount,
+            venues: results,
+            ...page,
+            rows: pageRows
+          }))
+        );
       }
     },
     {
@@ -48864,6 +49094,7 @@ Args:
   - venue (string, optional): filter to one venue.
   - asset_class (string, optional): filter to one asset class (equity, pre_ipo, etf, index, commodity, fx, crypto).
   - limit (integer, optional): max rows (1-${MAX_LIMIT}, default ${DEFAULT_LIMIT}), deepest open interest first.
+  - offset (integer, optional): rows to skip; pass next_offset to page.
 
 Returns:
   JSON object:
@@ -48871,7 +49102,7 @@ Returns:
     "filters": {...},
     "venueCount": number, "okCount": number,
     "venues": [{ "venue", "runtime_status", "rowCount", "error"? }],
-    "count", "returnedCount", "truncated",
+    "count", "offset", "returnedCount", "truncated", "next_offset", "pagination_note"?,
     "rows": [{ "venue", "market", "symbol", "underlying", "asset_class", "funding_mechanism", "is_delisted", "mark_price", "oracle_price", "open_interest_usd", "volume_24h_usd", "is_price_suspect", "price_suspect_basis", "price_deviation_pct", "meta" }]
   }
 
@@ -48892,20 +49123,19 @@ Don't use when:
       handler: async (_client, args) => {
         const { results, rows } = await collectRwaRows(deps);
         const { filtered, filters } = applyFilters(rows, args);
-        const envelope = boundedEnvelope(filtered, clampLimit2(args?.limit));
         const okCount = results.filter(
           (result2) => result2.runtime_status === "ok"
         ).length;
-        return asTextContentResult({
-          filters,
-          venueCount: results.length,
-          okCount,
-          venues: results,
-          count: envelope.count,
-          returnedCount: envelope.returnedCount,
-          truncated: envelope.truncated,
-          rows: envelope.rows.map(toMarketRow)
-        });
+        return asTextContentResult(
+          boundedPayload(filtered, args, (page, pageRows) => ({
+            filters,
+            venueCount: results.length,
+            okCount,
+            venues: results,
+            ...page,
+            rows: pageRows.map(toMarketRow)
+          }))
+        );
       }
     },
     // -----------------------------------------------------------------
@@ -49685,74 +49915,6 @@ async function fetchPolymarketJson(url, label, timeoutMs = POLYMARKET_TIMEOUT_MS
   }
 }
 
-// src/config/responseLimits.ts
-var RESPONSE_LIMITS = {
-  // Maximum tokens allowed in a response (MCP constraint)
-  MAX_RESPONSE_TOKENS: 25e3,
-  // Estimated characters per token (rough approximation)
-  CHARS_PER_TOKEN: 4,
-  // Maximum characters allowed (25000 * 4 = 100,000)
-  MAX_RESPONSE_CHARS: 1e5,
-  // Default pagination limits for different endpoints
-  DEFAULT_LIMITS: {
-    tokens: 100,
-    pools: 50,
-    trades: 100,
-    holders: 100,
-    events: 200,
-    nfts: 50
-  },
-  // Maximum allowed limits to prevent oversized responses
-  MAX_LIMITS: {
-    tokens: 100,
-    pools: 50,
-    trades: 200,
-    holders: 200,
-    events: 300,
-    nfts: 100
-  },
-  // Size thresholds for automatic truncation (in characters)
-  TRUNCATION_THRESHOLDS: {
-    warning: 8e4,
-    // Start warning at 80KB
-    truncate: 1e5
-    // Force truncation at 100KB
-  }
-};
-
-// src/utils/responseHeadroom.ts
-var MAX_RESULT_SIZE_META_KEY = "anthropic/maxResultSizeChars";
-var ANNOTATED_MAX_RESULT_SIZE_CHARS = RESPONSE_LIMITS.MAX_RESPONSE_CHARS;
-var DEFAULT_RESULT_SIZE_GUARD_CHARS = 2e4;
-var HEADROOM_TOOL_PATTERNS = [
-  // Depth-of-book: order books, l2/l3 books.
-  /orderbook|order_book|l2_book|l3_orderbook/i,
-  // Holder / owner lists.
-  /holders?(?:_|$)|owners_for/i,
-  // OHLCV, candles, charts, and history/time-series families.
-  /ohlc|candle|kline|market_chart|chart|history|timeseries/i
-];
-function toolNeedsResponseHeadroom(toolName) {
-  return HEADROOM_TOOL_PATTERNS.some((pattern) => pattern.test(toolName));
-}
-function getAnnotatedMaxResultSizeChars(tool96) {
-  const meta2 = tool96?._meta;
-  const value = meta2?.[MAX_RESULT_SIZE_META_KEY];
-  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : null;
-}
-function withResponseHeadroomMeta(tool96) {
-  if (!toolNeedsResponseHeadroom(tool96.name)) return tool96;
-  const existing = tool96._meta;
-  if (existing && existing[MAX_RESULT_SIZE_META_KEY] !== void 0) return tool96;
-  return {
-    ...tool96,
-    _meta: {
-      ...existing ?? {},
-      [MAX_RESULT_SIZE_META_KEY]: ANNOTATED_MAX_RESULT_SIZE_CHARS
-    }
-  };
-}
-
 // src/tools/polymarket/api.ts
 var DEFAULT_LIMIT3 = 10;
 var MAX_LIMIT3 = 50;
@@ -49760,9 +49922,14 @@ var MAX_OFFSET = 1e4;
 var DEFAULT_BOOK_DEPTH = 10;
 var MAX_BOOK_DEPTH = 50;
 var MAX_HISTORY_POINTS = 500;
-var SEARCH_SCAN_LIMIT = 100;
+var SEARCH_EVENT_LIMIT = 20;
 var EVENT_MARKETS_PREVIEW = 10;
-var EVENT_RESPONSE_BUDGET_CHARS = DEFAULT_RESULT_SIZE_GUARD_CHARS;
+var EVENT_RESPONSE_BUDGET_CHARS = (
+  // Rows only: the okResult envelope (odds note, source URL twice, filters)
+  // adds ~1k, and at the full 20k the guard still trimmed 48 rows to 45
+  // (order=volume, limit=50, 2026-10-09).
+  DEFAULT_RESULT_SIZE_GUARD_CHARS - 2e3
+);
 var DESCRIPTION_MAX_CHARS = 1200;
 var PRICE_INTERVALS = ["1d", "1w", "1m", "max"];
 var DEFAULT_FIDELITY_MINUTES = {
@@ -49962,6 +50129,21 @@ function parseInterval(value) {
   }
   return interval;
 }
+var EVENT_ORDERS = [
+  "volume24hr",
+  "volume",
+  "liquidity",
+  "endDate"
+];
+function eventOrderParams(value, now = /* @__PURE__ */ new Date()) {
+  const order = value === void 0 || value === null ? "volume24hr" : value;
+  if (typeof order !== "string" || !EVENT_ORDERS.includes(order)) {
+    invalid(
+      `order must be one of ${EVENT_ORDERS.map((o) => `"${o}"`).join(", ")}; got ${JSON.stringify(value)}.`
+    );
+  }
+  return order === "endDate" ? { order, ascending: true, end_date_min: now.toISOString() } : { order, ascending: false };
+}
 function parseFidelity(value, interval) {
   return parseBoundedInteger(
     value,
@@ -50290,6 +50472,22 @@ async function fetchGammaEvents(params) {
   const data = await fetchPolymarketJson(url, "Gamma /events");
   return { url, rows: asRecordArray(data, "Gamma /events") };
 }
+async function searchGammaMarkets(query, closed) {
+  const url = buildUrl(GAMMA_BASE_URL, "/public-search", {
+    q: query,
+    limit_per_type: SEARCH_EVENT_LIMIT,
+    events_status: closed ? "closed" : "active"
+  });
+  const data = asRecord(await fetchPolymarketJson(url, "Gamma /public-search"));
+  const events = asRecordArray(data?.events ?? [], "Gamma /public-search");
+  const rows = events.flatMap(
+    (event) => (Array.isArray(event.markets) ? event.markets : []).map(asRecord).filter((market) => market !== null).map((market) => ({
+      ...market,
+      events: [{ slug: event.slug, title: event.title }]
+    }))
+  );
+  return { url, rows, eventCount: events.length };
+}
 async function resolveMarket(selector) {
   if (selector.slug) {
     const { url, rows } = await fetchGammaMarkets({ slug: selector.slug });
@@ -50466,7 +50664,7 @@ function getAllPolymarketEndpoints() {
       },
       tool: {
         name: "polymarket_search_markets",
-        description: `Search Polymarket prediction markets by free text and list their market-implied odds, liquidity, volume, CLOB token ids, and end dates (Gamma API, keyless). With a query the tool scans the top ${SEARCH_SCAN_LIMIT} markets by 24h volume (honoring the active/closed filters) and keeps rows where every query term appears in the question, slug, bracket title, or event title. Without a query it returns the top markets by 24h volume.
+        description: `Search Polymarket prediction markets by free text and list their market-implied odds, liquidity, volume, CLOB token ids, and end dates (Gamma API, keyless). With a query the tool runs Polymarket's own search across every event (up to ${SEARCH_EVENT_LIMIT} events, honoring the active/closed filters), keeps markets where every query term appears in the question, slug, bracket title, or event title, and orders them by 24h volume; when no market contains every term it returns Polymarket's relevance order instead and says so in scan.order. Without a query it returns the top markets by 24h volume.
 
 Args:
   - query (string, optional): free-text terms, all must match (case-insensitive), e.g. "fed rate" or "bitcoin 2026".
@@ -50477,7 +50675,7 @@ Args:
 Returns:
   ${ENVELOPE_DOC}
   "filters", "scan" { "scanned", "scan_limit", "matched", "order" }, and "rows": [{ "id", "slug", "question", "groupItemTitle", "conditionId", "eventSlug", "eventTitle", "outcomes", "outcomePrices" (0-1 per outcome, same order as outcomes), "clobTokenIds" (same order; pass to polymarket_get_orderbook / polymarket_get_price_history), "liquidity", "volume", "volume24hr", "endDate", "active", "closed" }].
-  may_have_more is true when more rows matched than were returned or the scan window was full; narrow the query or use polymarket_get_events with a tag.
+  scan.scan_limit is the event cap for a query and the row limit without one. may_have_more is true when more rows matched than were returned or the search page was full; narrow the query or use polymarket_get_events with a tag.
 
 Examples:
   - { "query": "fed decision", "limit": 5 } \u2014 Fed-rate brackets with current odds.
@@ -50514,16 +50712,20 @@ Don't use when:
           const limit = parseLimit(args?.limit);
           const active = parseOptionalBoolean(args?.active, "active", true);
           const closed = parseOptionalBoolean(args?.closed, "closed", false);
-          const scanLimit = query ? SEARCH_SCAN_LIMIT : limit;
-          const { url, rows } = await fetchGammaMarkets({
-            limit: scanLimit,
+          const scanLimit = query ? SEARCH_EVENT_LIMIT : limit;
+          const search = query ? await searchGammaMarkets(query, closed) : null;
+          const listing = search ?? await fetchGammaMarkets({
+            limit,
             active,
             closed,
             order: "volume24hr",
             ascending: false
           });
-          const mapped = rows.map(toMarketRow2);
-          const matched = query ? mapped.filter(
+          const { url, rows } = listing;
+          const mapped = rows.map(toMarketRow2).filter(
+            (row) => !query || row.active === active && row.closed === closed
+          );
+          const exact = query ? mapped.filter(
             (row) => matchesQuery(
               [
                 row.question,
@@ -50534,19 +50736,22 @@ Don't use when:
               ],
               query
             )
-          ) : mapped;
+          ).sort((a, b) => (b.volume24hr ?? 0) - (a.volume24hr ?? 0)) : mapped;
+          const fuzzy = Boolean(query) && exact.length === 0;
+          const matched = fuzzy ? mapped : exact;
+          const scanned = search ? search.eventCount : rows.length;
           const items = matched.slice(0, limit);
           return okResult(url, {
             filters: { query, active, closed, limit },
             scan: {
-              scanned: rows.length,
+              scanned,
               scan_limit: scanLimit,
               matched: matched.length,
-              order: "volume24hr desc"
+              order: fuzzy ? "relevance (no market contains every term)" : "volume24hr desc"
             },
             rows: items,
             returnedCount: items.length,
-            may_have_more: matched.length > limit || rows.length >= scanLimit
+            may_have_more: matched.length > limit || scanned >= scanLimit
           });
         } catch (error) {
           return errorResult3(toolName, error);
@@ -50568,14 +50773,16 @@ Args:
   - slug (string, optional): one event's URL slug (exact); other filters are ignored.
   - active (boolean, optional): Polymarket active flag filter (default true).
   - closed (boolean, optional): Polymarket closed flag filter (default false).
+  - order (string, optional): "volume24hr" (default, trending: most traded in the last 24h), "volume" (biggest by lifetime volume), "liquidity" (deepest books), or "endDate" (closing soonest, from now on). Biggest first for the volume and liquidity sorts.
 ${PAGING_ARGS_DOC}
 
 Returns:
   ${ENVELOPE_DOC}
-  "filters", "markets_preview_limit" (nested previews actually kept per event, ${EVENT_MARKETS_PREVIEW} unless the size budget forced fewer), "rows_dropped_for_size" (0 unless headline data alone overran the budget), and "rows": [{ "id", "slug", "title", "active", "closed", "endDate", "liquidity", "volume", "volume24hr", "negRisk", "tags", "marketCount", "markets": [{ "slug", "question", "groupItemTitle", "conditionId", "outcomes", "outcomePrices", "clobTokenIds", "volume24hr" }], "marketsTruncated" }]. Rows are ordered by 24h volume (desc). returnedCount is always the number of rows actually in the response. Large limits are slow because Gamma nests every market of every event.
+  "filters" (including the order applied), "markets_preview_limit" (nested previews actually kept per event, ${EVENT_MARKETS_PREVIEW} unless the size budget forced fewer), "rows_dropped_for_size" (0 unless headline data alone overran the budget), and "rows": [{ "id", "slug", "title", "active", "closed", "endDate", "liquidity", "volume", "volume24hr", "negRisk", "tags", "marketCount", "markets": [{ "slug", "question", "groupItemTitle", "conditionId", "outcomes", "outcomePrices", "clobTokenIds", "volume24hr" }], "marketsTruncated" }]. Rows follow the requested order (24h volume, desc, by default). returnedCount is always the number of rows actually in the response. Large limits are slow because Gamma nests every market of every event.
 
 Examples:
   - { "tag": "crypto", "limit": 5 } \u2014 the busiest crypto events.
+  - { "order": "volume", "limit": 5 } \u2014 the biggest events by all-time volume (not just today's trend).
   - { "slug": "presidential-election-winner-2028" } \u2014 one event with its top-${EVENT_MARKETS_PREVIEW} candidates by odds.
   - { "limit": 10, "offset": 10 } \u2014 the next page of the most active events.
 
@@ -50600,6 +50807,11 @@ Don't use when:
             },
             active: ACTIVE_SCHEMA,
             closed: CLOSED_SCHEMA,
+            order: {
+              type: "string",
+              enum: [...EVENT_ORDERS],
+              description: 'Sort: "volume24hr" (default, trending), "volume" (biggest all-time), "liquidity", or "endDate" (closing soonest from now).'
+            },
             limit: LIMIT_SCHEMA,
             offset: OFFSET_SCHEMA
           }
@@ -50615,19 +50827,19 @@ Don't use when:
           const offset = parseOffset(args?.offset);
           const active = parseOptionalBoolean(args?.active, "active", true);
           const closed = parseOptionalBoolean(args?.closed, "closed", false);
+          const sort = eventOrderParams(args?.order);
           const { url, rows } = slug ? await fetchGammaEvents({ slug }) : await fetchGammaEvents({
             limit,
             offset,
             active,
             closed,
             tag_slug: tag ?? void 0,
-            order: "volume24hr",
-            ascending: false
+            ...sort
           });
           const bounded = boundEventRows(rows);
           const items = bounded.rows;
           return okResult(url, {
-            filters: slug ? { slug } : { tag, active, closed, limit, offset },
+            filters: slug ? { slug } : { tag, active, closed, order: sort.order, limit, offset },
             markets_preview_limit: bounded.marketsPreviewLimit,
             rows_dropped_for_size: bounded.rowsDropped,
             rows: items,
@@ -51039,7 +51251,7 @@ function isAbortError(error) {
   const name = error?.name;
   return name === "AbortError" || name === "TimeoutError";
 }
-async function fetchJsonWithTimeout(url, label, timeoutMs = SIGNALS_FETCH_TIMEOUT_MS) {
+async function fetchJsonWithTimeout(url, label, timeoutMs = SIGNALS_FETCH_TIMEOUT_MS, headers = {}) {
   const controller = new AbortController();
   const timer = setTimeout(() => controller.abort(), timeoutMs);
   try {
@@ -51049,7 +51261,8 @@ async function fetchJsonWithTimeout(url, label, timeoutMs = SIGNALS_FETCH_TIMEOU
         signal: controller.signal,
         headers: {
           Accept: "application/json",
-          "User-Agent": "hive-mcp-server/1.0.0"
+          "User-Agent": "hive-mcp-server/1.0.0",
+          ...headers
         }
       });
     } catch (error) {
@@ -52294,6 +52507,334 @@ Don't use when:
   ];
 }
 
+// src/tools/blockscout/tools.ts
+import Coingecko2 from "@coingecko/coingecko-typescript";
+var BLOCKSCOUT_PROVIDER = "Blockscout";
+var HOLDERS_PAGE_SIZE = 50;
+var DEFAULT_MAX_PAGES = 20;
+var MAX_PAGES = 40;
+var TIME_BUDGET_MS = 2e4;
+var CHAINS = {
+  eth: { chainId: 1, host: "eth.blockscout.com", gecko: "eth" },
+  base: { chainId: 8453, host: "base.blockscout.com", gecko: "base" },
+  optimism: { chainId: 10, host: "explorer.optimism.io", gecko: "optimism" },
+  arbitrum: {
+    chainId: 42161,
+    host: "arbitrum.blockscout.com",
+    gecko: "arbitrum"
+  },
+  polygon: {
+    chainId: 137,
+    host: "polygon.blockscout.com",
+    gecko: "polygon_pos"
+  }
+};
+var CHAIN_ALIASES = {
+  ethereum: "eth",
+  mainnet: "eth",
+  "1": "eth",
+  "8453": "base",
+  op: "optimism",
+  "10": "optimism",
+  arb: "arbitrum",
+  "42161": "arbitrum",
+  matic: "polygon",
+  polygon_pos: "polygon",
+  "137": "polygon"
+};
+var USD_TIERS = [
+  { label: ">$10k", min_usd: 1e4, max_usd: null },
+  { label: "$1k-$10k", min_usd: 1e3, max_usd: 1e4 },
+  { label: "$100-$1k", min_usd: 100, max_usd: 1e3 },
+  { label: "$1-$100", min_usd: 1, max_usd: 100 },
+  { label: "<$1", min_usd: 0, max_usd: 1 }
+];
+function tallyTiers(rows, totalHolders, stop) {
+  const reachedBottom = stop === "end_of_holders";
+  const smallest = rows.length > 0 ? rows[rows.length - 1].usd : null;
+  const tiers = USD_TIERS.map((tier) => {
+    const members = rows.filter(
+      (row) => row.usd >= tier.min_usd && (tier.max_usd === null || row.usd < tier.max_usd)
+    );
+    const exact = reachedBottom || smallest !== null && smallest < tier.min_usd;
+    const reached = smallest !== null && smallest < (tier.max_usd ?? Infinity);
+    return {
+      ...tier,
+      count: exact || reached ? members.length : null,
+      contracts: exact || reached ? members.filter((r) => r.is_contract).length : null,
+      exact,
+      lower_bound: !exact && reached
+    };
+  });
+  const dust = tiers[tiers.length - 1];
+  if (!dust.exact && stop === "below_smallest_tier" && totalHolders !== null) {
+    const above = rows.filter((row) => row.usd >= 1).length;
+    dust.count = Math.max(totalHolders - above, 0);
+    dust.contracts = null;
+    dust.exact = true;
+    dust.lower_bound = false;
+  }
+  const real = tiers.filter((tier) => tier.min_usd >= 100);
+  return {
+    tiers,
+    holders_100_usd_plus: {
+      count: real.reduce((sum, tier) => sum + (tier.count ?? 0), 0),
+      exact: real.every((tier) => tier.exact)
+    },
+    exhaustive: tiers.every((tier) => tier.exact),
+    smallest_scanned_usd: smallest
+  };
+}
+function parseArgs(args) {
+  const rawNetwork = String(args?.network ?? args?.chain ?? "").trim().toLowerCase();
+  const key = CHAIN_ALIASES[rawNetwork] ?? rawNetwork;
+  const chain = CHAINS[key];
+  if (!chain) {
+    throw new SignalsInputError(
+      `network must be one of ${Object.keys(CHAINS).join(", ")} (or a chain id); got ${JSON.stringify(args?.network ?? null)}.`
+    );
+  }
+  const address = String(args?.address ?? "").trim();
+  if (!/^0x[0-9a-fA-F]{40}$/.test(address)) {
+    throw new SignalsInputError(
+      `address must be a 0x token contract address; got ${JSON.stringify(args?.address ?? null)}.`
+    );
+  }
+  const priceOverride = args?.price_usd === void 0 || args?.price_usd === null ? null : parseNumberArg(args.price_usd, "price_usd", Number.MIN_VALUE, 1e12, 0);
+  return {
+    network: key,
+    chain,
+    address,
+    maxPages: parseIntegerArg(
+      args?.max_pages,
+      "max_pages",
+      1,
+      MAX_PAGES,
+      DEFAULT_MAX_PAGES
+    ),
+    priceOverride
+  };
+}
+function blockscoutGet(chain, path) {
+  const apiKey = getEnvVar("BLOCKSCOUT_API_KEY");
+  const url = apiKey ? `https://api.blockscout.com/${chain.chainId}/api/v2${path}` : `https://${chain.host}/api/v2${path}`;
+  return fetchJsonWithTimeout(
+    url,
+    `Blockscout (${chain.chainId})`,
+    void 0,
+    apiKey ? { Authorization: `Bearer ${apiKey}` } : {}
+  ).catch((error) => {
+    if (error instanceof SignalsHttpError && error.status === 404) {
+      throw new SignalsInputError(
+        `Blockscout has no token at this address on chain ${chain.chainId}.`
+      );
+    }
+    if (!apiKey && error instanceof SignalsHttpError && (error.status === 403 || error.status === 402)) {
+      throw new Error(
+        `Blockscout's public explorer for chain ${chain.chainId} refused the request (HTTP ${error.status}, bot protection). Set BLOCKSCOUT_API_KEY (free API key at dev.blockscout.com) to use the Blockscout PRO API.`
+      );
+    }
+    throw error;
+  });
+}
+var ownCoinGecko = null;
+async function resolvePrice(chain, address, token) {
+  const blockscoutRate = parseFiniteNumber3(token.exchange_rate);
+  if (blockscoutRate !== null && blockscoutRate > 0) {
+    return { price: blockscoutRate, source: "blockscout_exchange_rate" };
+  }
+  try {
+    if (!ownCoinGecko)
+      ownCoinGecko = new Coingecko2(getCoinGeckoClientOptions());
+    const result2 = await ownCoinGecko.onchain.simple.networks.tokenPrice.getAddresses(
+      address,
+      { network: chain.gecko }
+    );
+    const prices = result2?.data?.attributes?.token_prices ?? {};
+    const price = parseFiniteNumber3(
+      prices[address.toLowerCase()] ?? prices[address]
+    );
+    if (price !== null && price > 0) {
+      return { price, source: "coingecko_onchain_price" };
+    }
+  } catch {
+  }
+  return { price: null, source: null };
+}
+async function getTokenHolderDistribution(args, now = Date.now) {
+  const { network, chain, address, maxPages, priceOverride } = parseArgs(args);
+  const started = now();
+  const token = await blockscoutGet(chain, `/tokens/${address}`) ?? {};
+  if (token.type !== void 0 && token.type !== "ERC-20") {
+    throw new SignalsInputError(
+      `this address is a ${String(token.type)} token; holder tiers are computed for ERC-20 tokens only.`
+    );
+  }
+  const decimals = parseFiniteNumber3(token.decimals);
+  if (decimals === null) {
+    throw new Error("Blockscout returned no decimals for this token");
+  }
+  const totalHolders = parseFiniteNumber3(token.holders_count ?? token.holders);
+  const { price, source: priceSource } = priceOverride !== null ? { price: priceOverride, source: "caller" } : await resolvePrice(chain, address, token);
+  const base = {
+    provider: BLOCKSCOUT_PROVIDER,
+    network,
+    chain_id: chain.chainId,
+    address,
+    token: {
+      name: token.name ?? null,
+      symbol: token.symbol ?? null,
+      decimals,
+      total_supply: token.total_supply ?? null
+    },
+    total_holders: totalHolders,
+    price_usd: price,
+    price_source: priceSource
+  };
+  if (price === null) {
+    return {
+      ...base,
+      runtime_status: "degraded",
+      fetched_at: (/* @__PURE__ */ new Date()).toISOString(),
+      tiers: null,
+      note: "No USD price was found for this token, so holders could not be tiered by value. total_holders counts every address with a positive balance, dust included. Pass price_usd to tier anyway."
+    };
+  }
+  const rows = [];
+  let pages = 0;
+  let cursor = "";
+  let stop = "end_of_holders";
+  for (; ; ) {
+    if (pages >= maxPages) {
+      stop = "max_pages";
+      break;
+    }
+    if (now() - started > TIME_BUDGET_MS) {
+      stop = "time_budget";
+      break;
+    }
+    const page = await blockscoutGet(
+      chain,
+      `/tokens/${address}/holders${cursor}`
+    ) ?? {};
+    pages += 1;
+    const items = Array.isArray(page.items) ? page.items : [];
+    let belowFloor = false;
+    for (const item of items) {
+      const holder = item ?? {};
+      const units = parseFiniteNumber3(holder.value);
+      if (units === null) continue;
+      const usd2 = units / 10 ** decimals * price;
+      rows.push({ usd: usd2, is_contract: holder.address?.is_contract === true });
+      if (usd2 < 1) {
+        belowFloor = true;
+        break;
+      }
+    }
+    if (belowFloor) {
+      stop = "below_smallest_tier";
+      break;
+    }
+    const next = page.next_page_params;
+    if (!next || typeof next !== "object" || items.length === 0) break;
+    cursor = `?${new URLSearchParams(
+      Object.entries(next).map(([k, v]) => [
+        k,
+        String(v)
+      ])
+    ).toString()}`;
+  }
+  const tally = tallyTiers(rows, totalHolders, stop);
+  return {
+    ...base,
+    runtime_status: "ok",
+    fetched_at: (/* @__PURE__ */ new Date()).toISOString(),
+    holders_scanned: rows.length,
+    pages_fetched: pages,
+    stopped_reason: stop,
+    ...tally,
+    lower_bound: !tally.exhaustive,
+    note: (tally.exhaustive ? "Every tier is exact." : `The walk stopped (${stop}) at a holder worth $${tally.smallest_scanned_usd?.toFixed(2)}; tiers marked exact are complete, lower_bound tiers are at least the count shown, and null tiers were not reached. Raise max_pages (up to ${MAX_PAGES}) to go deeper.`) + " Counts include contracts (pools, vesting, treasuries); each tier's contracts field says how many. USD values use price_usd at fetch time."
+  };
+}
+function getAllBlockscoutEndpoints() {
+  return [
+    {
+      metadata: {
+        resource: "blockscout.tokens.holders",
+        operation: "read",
+        tags: ["blockscout", "tokens", "holders", "distribution", "onchain"]
+      },
+      tool: {
+        name: "get_token_holder_distribution",
+        description: `Count a token's holders by USD balance: total holders plus how many hold >$10k, $1k-$10k, $100-$1k, $1-$100, and under $1 (dust), from Blockscout's holder list. Answers "how many real (non-dust) holders does this token have?". Keyless on EVM chains: ${Object.keys(CHAINS).join(", ")}.
+
+Args:
+  - network (string, required): ${Object.keys(CHAINS).join(", ")}, or a chain id (1, 8453, 10, 42161, 137).
+  - address (string, required): ERC-20 token contract address.
+  - max_pages (integer, optional): holder pages of ${HOLDERS_PAGE_SIZE} to walk, 1-${MAX_PAGES} (default ${DEFAULT_MAX_PAGES}). The walk also stops after ${TIME_BUDGET_MS / 1e3} s, at the end of the list, or at the first holder under $1.
+  - price_usd (number, optional): USD price to tier with. Default: Blockscout's exchange rate, then the GeckoTerminal on-chain price.
+
+Returns:
+  { "provider": "Blockscout", "runtime_status", "fetched_at", "network", "chain_id", "address", "token": { "name", "symbol", "decimals", "total_supply" }, "total_holders", "price_usd", "price_source", "holders_scanned", "pages_fetched", "stopped_reason", "tiers": [{ "label", "min_usd", "max_usd", "count", "contracts", "exact", "lower_bound" }], "holders_100_usd_plus": { "count", "exact" }, "exhaustive", "lower_bound", "smallest_scanned_usd", "note" }. A tier with exact=false and lower_bound=true holds at least count holders; count null means the walk never reached it.
+
+Examples:
+  - { "network": "base", "address": "0x91dA780BC7f4B7Cf19ABE90411a2a296Ec5FF787" }
+  - { "network": "eth", "address": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", "max_pages": 5 }
+
+Use when:
+  - You need holder counts above a USD size, or how much of the holder count is dust.
+Don't use when:
+  - You need the largest holders and their share of supply (use get_token_top_holders).`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            network: {
+              type: "string",
+              description: `Chain: ${Object.keys(CHAINS).join(", ")}, or a chain id.`
+            },
+            address: {
+              type: "string",
+              description: "ERC-20 token contract address (0x...)."
+            },
+            max_pages: {
+              type: "integer",
+              minimum: 1,
+              maximum: MAX_PAGES,
+              default: DEFAULT_MAX_PAGES,
+              description: `Holder pages of ${HOLDERS_PAGE_SIZE} to walk (1-${MAX_PAGES}).`
+            },
+            price_usd: {
+              type: "number",
+              exclusiveMinimum: 0,
+              description: "USD price to tier with; default Blockscout's rate, then GeckoTerminal."
+            }
+          },
+          required: ["network", "address"],
+          additionalProperties: false
+        },
+        annotations: VOLATILE_READ_ANNOTATIONS
+      },
+      handler: async (_client, args) => {
+        try {
+          return asTextContentResult(await getTokenHolderDistribution(args));
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return asTextContentResult(
+            {
+              error: message,
+              runtime_status: error instanceof SignalsInputError ? "invalid_input" : classifyRuntimeStatusFromError(message),
+              tool: "get_token_holder_distribution",
+              provider: BLOCKSCOUT_PROVIDER
+            },
+            true
+          );
+        }
+      }
+    }
+  ];
+}
+
 // src/freeWriteEndpoints.ts
 var FREE_WRITE_ENDPOINTS = /* @__PURE__ */ new Set([
   // Feedback is a bounded, rate-limited insert into Hive's own table. It
@@ -52863,7 +53404,7 @@ Don't use when:
 }
 
 // src/wrapper/index.ts
-import Coingecko2 from "@coingecko/coingecko-typescript";
+import Coingecko3 from "@coingecko/coingecko-typescript";
 
 // src/utils/descriptionGenerator.ts
 function needsEnrichment(description) {
@@ -53634,6 +54175,11 @@ var CHECK_TOKEN_SAFETY_OUTPUT_SCHEMA = {
       additionalProperties: true,
       description: "Raw provider risk datapoints; '1' means flagged. A missing key means the provider did not report that signal, not that it passed."
     },
+    summary: {
+      type: "object",
+      additionalProperties: true,
+      description: "Concise scam signals: verdicts (plain-language list), lp (lock state and top LP holder), top_holders (largest holder and top-10 share, DEX pairs excluded), creator, owner. Percents are 0-100."
+    },
     holder_count: {},
     token_name: { type: "string" },
     note: { type: "string" }
@@ -54177,6 +54723,15 @@ var PROVIDER_CATALOG = [
     alwaysAvailable: true,
     matches: (_toolName, metadata100) => metadata100.tags.includes("blockchain-com")
   },
+  {
+    id: "blockscout",
+    name: "Blockscout",
+    prefix: "blockscout_",
+    type: "EVM token holder lists and counts from Blockscout explorers (keyless public API; BLOCKSCOUT_API_KEY switches to the PRO API)",
+    clientStrategy: "internal",
+    alwaysAvailable: true,
+    matches: (_toolName, metadata100) => metadata100.tags.includes("blockscout")
+  },
   {
     id: "fetch",
     name: "Open Data Fetch",
@@ -54414,7 +54969,9 @@ var HELIUS_WALLET_PLAN = "because Helius answers 403 for it on Hive's current He
 var DEFILLAMA_PRO = "because it needs a DeFiLlama Pro plan, which Hive does not have";
 var DEFILLAMA_DERIVATIVES_REPLACEMENT = "Use defillama_get_open_interest, defillama_get_derivatives_aggregator_volumes, or get_derivatives_exchanges for derivatives activity.";
 var ALCHEMY_PAYG = "because Alchemy offers it only on Pay As You Go and Enterprise plans, and Hive's key is on the Free tier";
-var ALCHEMY_BUNDLE_REPLACEMENT = "Use tenderly_simulate_bundle for multi-transaction simulation, or alchemy_simulate_asset_changes and alchemy_simulate_execution one transaction at a time.";
+var ALCHEMY_BUNDLE_REPLACEMENT = "Use tenderly_simulate_bundle or tenderly_node_simulate_bundle for multi-transaction simulation.";
+var ALCHEMY_SIMULATION_SUNSET = 'because Alchemy shut down its Transaction Simulation API on 2026-09-30 and now answers "Unsupported method" on every plan';
+var ALCHEMY_SIMULATION_REPLACEMENT = "Use tenderly_simulate_transaction or tenderly_node_simulate_transaction; both return the execution trace, logs, and asset and balance changes without broadcasting.";
 var CCXT_PRIVATE = "because every exchange that serves it requires an authenticated exchange account";
 var CCXT_BORROW_REPLACEMENT = "Use ccxt_fetch_borrow_rate_history or ccxt_fetch_borrow_rate_histories (public) and read the latest point.";
 var UNSERVABLE_TOOLS = {
@@ -54498,6 +55055,21 @@ var UNSERVABLE_TOOLS = {
     reason: CCXT_PRIVATE,
     replacement: CCXT_BORROW_REPLACEMENT
   },
+  alchemy_simulate_asset_changes: {
+    reason: ALCHEMY_SIMULATION_SUNSET,
+    replacement: ALCHEMY_SIMULATION_REPLACEMENT,
+    date: "2026-10-09"
+  },
+  alchemy_simulate_execution: {
+    reason: ALCHEMY_SIMULATION_SUNSET,
+    replacement: ALCHEMY_SIMULATION_REPLACEMENT,
+    date: "2026-10-09"
+  },
+  alchemy_is_holder_of_contract: {
+    reason: 'because Alchemy deprecated the isHolderOfContract endpoint, which now answers 404 "This API endpoint has been deprecated"',
+    replacement: "Use alchemy_get_nfts_for_owner for the wallet and look for the contract, or alchemy_get_owners_for_contract and look for the wallet.",
+    date: "2026-10-09"
+  },
   goplus_simulate_solana_transaction: {
     reason: 'because GoPlus answers "system error" to every Solana pre-execution request, including a fresh valid transfer',
     replacement: "Use get_solana_token_security for the tokens the transaction touches; Hive has no other Solana pre-signing simulation."
@@ -54510,7 +55082,7 @@ function getRetiredTool(toolName) {
   if (isUnservableTool(toolName)) {
     const entry2 = UNSERVABLE_TOOLS[toolName];
     return {
-      date: UNSERVABLE_TOOLS_DATE,
+      date: entry2.date ?? UNSERVABLE_TOOLS_DATE,
       cause: entry2.reason,
       replacement: entry2.replacement
     };
@@ -54687,7 +55259,40 @@ function boundedJsonTruncationStub(originalLength, note, characterLimit) {
   ];
   return candidates.find((candidate) => candidate.length <= characterLimit) ?? "";
 }
-function smartTruncate(text, characterLimit = CHARACTER_LIMIT) {
+function inputSchemaParamNames(schema) {
+  const properties = schema?.properties;
+  return properties && typeof properties === "object" ? Object.keys(properties) : [];
+}
+function truncationRecallHint(params = [], nextOffset) {
+  const names = new Set(params);
+  if (names.has("offset")) {
+    return `Re-call with offset=${nextOffset ?? "_pagination.next_offset"} to continue, or add filters.`;
+  }
+  const sizeParam = ["limit", "per_page", "page_size", "count"].find(
+    (name) => names.has(name)
+  );
+  return sizeParam ? `This tool has no offset parameter: a smaller ${sizeParam} returns an untruncated page; narrower filters reach the remaining rows.` : "This tool has no paging parameter: narrow the request with its filters to see the rest.";
+}
+function truncationPagination(kept, original, context) {
+  const params = [...context.params ?? []];
+  const head = `Response truncated from ${original} to ${kept} items to fit the response budget.`;
+  const base = {
+    count: kept,
+    total_count: original,
+    has_more: kept < original
+  };
+  if (!params.includes("offset")) {
+    return { ...base, note: `${head} ${truncationRecallHint(params)}` };
+  }
+  const start = typeof context.offset === "number" && Number.isFinite(context.offset) ? Math.max(0, Math.floor(context.offset)) : 0;
+  return {
+    ...base,
+    offset: start,
+    next_offset: start + kept,
+    note: `${head} ${truncationRecallHint(params, start + kept)}`
+  };
+}
+function smartTruncate(text, characterLimit = CHARACTER_LIMIT, pagination = {}) {
   if (text.length <= characterLimit) return text;
   const originalLength = text.length;
   const head = text.trimStart();
@@ -54748,14 +55353,11 @@ function smartTruncate(text, characterLimit = CHARACTER_LIMIT) {
   if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
     const obj = parsed;
     if (pagInfo && pagInfo.kept < pagInfo.original) {
-      obj._pagination = {
-        count: pagInfo.kept,
-        total_count: pagInfo.original,
-        offset: 0,
-        has_more: pagInfo.kept < pagInfo.original,
-        next_offset: pagInfo.kept,
-        note: `Response truncated from ${pagInfo.original} to ${pagInfo.kept} items. Re-call with offset=${pagInfo.kept} or add filters to see more.`
-      };
+      obj._pagination = truncationPagination(
+        pagInfo.kept,
+        pagInfo.original,
+        pagination
+      );
     }
     if (dropped.length > 0) {
       obj._dropped_fields = dropped;
@@ -54872,14 +55474,15 @@ function stripProviderPrefix(toolName) {
 var fallbackCoinGeckoClient = null;
 function getFallbackCoinGeckoClient() {
   if (!fallbackCoinGeckoClient) {
-    fallbackCoinGeckoClient = new Coingecko2(getCoinGeckoClientOptions());
+    fallbackCoinGeckoClient = new Coingecko3(getCoinGeckoClientOptions());
   }
   return fallbackCoinGeckoClient;
 }
 function isKeylessCoinGeckoClient(client2) {
-  return client2 instanceof Coingecko2 && !client2.proAPIKey && !client2.demoAPIKey;
+  return client2 instanceof Coingecko3 && !client2.proAPIKey && !client2.demoAPIKey;
 }
-function createSafeHandler(handler96, metadata100, toolName) {
+function createSafeHandler(handler96, metadata100, toolName, inputSchema) {
+  const schemaParams = inputSchemaParamNames(inputSchema);
   const credentialRequirement = getCredentialRequirementForTool(
     toolName,
     metadata100
@@ -54975,7 +55578,15 @@ function createSafeHandler(handler96, metadata100, toolName) {
           withExecMarker(
             {
               ...result2,
-              content: [{ type: "text", text: smartTruncate(text) }]
+              content: [
+                {
+                  type: "text",
+                  text: smartTruncate(text, CHARACTER_LIMIT, {
+                    params: schemaParams,
+                    offset: safeArgs.offset
+                  })
+                }
+              ]
             },
             {
               truncated: true,
@@ -55138,6 +55749,7 @@ function getAllWrappedEndpoints() {
     ...getAllArchiveEndpoints(),
     ...getAllPolymarketEndpoints(),
     ...getAllSignalsEndpoints(),
+    ...getAllBlockscoutEndpoints(),
     ...getAllFetchEndpoints()
   ];
   const allEndpointsJSON = wrapper;
@@ -55193,7 +55805,8 @@ function getAllWrappedEndpoints() {
         handler: createSafeHandler(
           endpoint.handler,
           endpoint.metadata,
-          toolInstanse.name
+          toolInstanse.name,
+          toolInstanse.inputSchema
         ),
         metadata: endpoint.metadata,
         tool: toolInstanse
@@ -55237,7 +55850,8 @@ function getAllWrappedEndpoints() {
           handler: createSafeHandler(
             endpoint.handler,
             endpoint.metadata,
-            toolInstanse.name
+            toolInstanse.name,
+            toolInstanse.inputSchema
           ),
           metadata: endpoint.metadata,
           tool: toolInstanse
@@ -55594,6 +56208,7 @@ var ToolRegistry = [
       "get_tokens_by_address",
       "get_token_info",
       "get_token_top_holders",
+      "get_token_holder_distribution",
       "get_token_holders_chart",
       "get_multi_tokens",
       "get_recently_updated_tokens",
@@ -55696,7 +56311,6 @@ var ToolRegistry = [
       "alchemy_get_floor_price",
       "alchemy_get_contracts_for_owner",
       "alchemy_is_spam_contract",
-      "alchemy_is_holder_of_contract",
       "alchemy_solana_get_asset",
       "alchemy_solana_get_asset_proof",
       "alchemy_solana_get_asset_proofs",
@@ -55798,9 +56412,7 @@ var ToolRegistry = [
       "tenderly_get_contract_abi",
       "tenderly_get_storage_changes",
       "tenderly_get_transactions_range",
-      "alchemy_get_token_allowance",
-      "alchemy_simulate_asset_changes",
-      "alchemy_simulate_execution"
+      "alchemy_get_token_allowance"
     ]
   },
   {
@@ -55973,7 +56585,7 @@ import {
 import { existsSync, readFileSync, readdirSync } from "fs";
 import { dirname, resolve as resolvePath } from "path";
 import { fileURLToPath } from "url";
-import Coingecko4 from "@coingecko/coingecko-typescript";
+import Coingecko5 from "@coingecko/coingecko-typescript";
 
 // src/tools/dynamic-tools.ts
 import { z as z4 } from "zod";
@@ -56289,20 +56901,51 @@ function isUnmarkedErrorResponse(result2) {
   }
   return false;
 }
+var PROVIDER_SIDE_ERROR_COPY = {
+  plan_required: {
+    message: "The upstream provider declined this call: the endpoint is outside this deployment's provider plan or quota (runtime_status plan_required). The arguments were not the problem.",
+    suggestion: "Use search_tools to pick another tool for the same data. Retrying unchanged will fail again."
+  },
+  rate_limited: {
+    message: "The upstream provider rate limit was hit (runtime_status rate_limited).",
+    suggestion: "Wait about 60 seconds before one retry, or narrow the request with this tool's filters."
+  },
+  missing_key: {
+    suggestion: "This provider has no working credential on this deployment. Use search_tools to pick another tool for the same data; self-hosted deployments can configure the provider's API key."
+  }
+};
+var VENDOR_ACCOUNT_URL = /https?:\/\/[^\s"')\]]*(?:billing|pricing|plan|upgrade|admin|dashboard|account|subscri|checkout)[^\s"')\]]*/gi;
+function sanitizeProviderError(message, suggestion) {
+  const copy = PROVIDER_SIDE_ERROR_COPY[classifyRuntimeStatusFromError(message)];
+  return {
+    message: (copy?.message ?? message).replace(
+      VENDOR_ACCOUNT_URL,
+      "[link removed]"
+    ),
+    suggestion: copy?.suggestion ?? suggestion,
+    providerSide: Boolean(copy)
+  };
+}
+function collapseErrorMarkers(text) {
+  return text.replace(/(?:\*\*Error:\*\*\s*){2,}/g, "**Error:** ");
+}
 function normalizeErrorText(text, toolName, args) {
   let errorMsg = "";
   let code = "";
   let suggestion = "";
-  let alternatives = "";
+  let alternatives = [];
   let documentation = "";
   try {
     const parsed = JSON.parse(text);
     if (parsed && typeof parsed === "object" && typeof parsed.error === "string") {
       errorMsg = parsed.error;
+      if (typeof parsed.message === "string" && parsed.message.trim() && !errorMsg.includes(parsed.message)) {
+        errorMsg += `: ${parsed.message.replace(/https?:\/\/\S+/g, "[url]")}`;
+      }
       code = typeof parsed.code === "string" ? parsed.code : "";
       suggestion = parsed.suggestion || "";
       if (Array.isArray(parsed.alternatives) && parsed.alternatives.length > 0) {
-        alternatives = parsed.alternatives.join(", ");
+        alternatives = parsed.alternatives.map(String);
       }
       documentation = parsed.documentation || "";
     }
@@ -56310,7 +56953,18 @@ function normalizeErrorText(text, toolName, args) {
   }
   if (errorMsg) {
     const bareErrorMsg = errorMsg.replace(/^(?:\s*\*\*Error:\*\*\s*)+/, "");
-    let normalized = `**Error:** ${bareErrorMsg}`;
+    if (bareErrorMsg.includes("\n\n**Code:**")) {
+      return collapseErrorMarkers(`**Error:** ${bareErrorMsg}`);
+    }
+    const safe = sanitizeProviderError(bareErrorMsg, suggestion);
+    suggestion = safe.suggestion;
+    const prefix = toolName?.split("_")[0];
+    if (safe.providerSide && prefix) {
+      alternatives = alternatives.filter(
+        (name) => !name.startsWith(`${prefix}_`)
+      );
+    }
+    let normalized = `**Error:** ${safe.message}`;
     normalized += `
 
 **Code:** ${code || "API_ERROR"}`;
@@ -56326,15 +56980,29 @@ function normalizeErrorText(text, toolName, args) {
 
 **Params:** ${truncated}`;
     }
-    if (alternatives) normalized += `
+    if (alternatives.length > 0) {
+      normalized += `
 
-**Alternatives:** ${alternatives}`;
+**Alternatives:** ${alternatives.join(", ")}`;
+    }
     if (documentation) normalized += `
 
 **Documentation:** ${documentation}`;
     return normalized;
   }
-  let result2 = text;
+  let result2 = collapseErrorMarkers(text);
+  const head = /^\*\*Error:\*\* (.*?)(?=\n\n\*\*|$)/s.exec(result2);
+  if (head) {
+    const safe = sanitizeProviderError(head[1], "");
+    result2 = result2.replace(head[0], `**Error:** ${safe.message}`);
+    if (safe.suggestion) {
+      result2 = result2.replace(
+        /\*\*Suggestion:\*\* [^\n]*/,
+        `**Suggestion:** ${safe.suggestion}`
+      );
+    }
+  }
+  result2 = result2.replace(VENDOR_ACCOUNT_URL, "[link removed]");
   if (toolName && !result2.includes("**Tool:**")) {
     result2 += `
 
@@ -57039,7 +57707,7 @@ function agentErrorCopy(status, context = {}) {
     case "plan_required":
       return {
         cause: `This ${provider} endpoint needs a paid plan, quota, or credits that this deployment does not have.`,
-        next_action: "Use search_tools to pick an alternative provider tool for the same data, or upgrade the plan. Retrying unchanged will fail again."
+        next_action: "Use search_tools to pick an alternative provider tool for the same data. Retrying unchanged will fail again."
       };
     case "rate_limited":
       return {
@@ -57613,17 +58281,17 @@ function fitPayloadWithinReceiptBudget(value, hive, isError = false) {
   const payloadBudget = Math.max(256, CHARACTER_LIMIT - receiptLength + 1);
   const truncated = smartTruncate(JSON.stringify(payload), payloadBudget);
   const parsed = parseToolText(truncated);
-  let boundedPayload = toHiveResultPayload(parsed);
-  hive.result_digest = digestHiveCanonicalJson(boundedPayload);
-  if (JSON.stringify({ ...boundedPayload, _hive: hive }).length > CHARACTER_LIMIT) {
-    boundedPayload = {
+  let boundedPayload2 = toHiveResultPayload(parsed);
+  hive.result_digest = digestHiveCanonicalJson(boundedPayload2);
+  if (JSON.stringify({ ...boundedPayload2, _hive: hive }).length > CHARACTER_LIMIT) {
+    boundedPayload2 = {
       _truncated: true,
       _original_length: JSON.stringify(payload).length,
       _note: "Response omitted because the provider payload plus its execution receipt exceeded the response limit. Re-call with narrower parameters or filters."
     };
-    hive.result_digest = digestHiveCanonicalJson(boundedPayload);
+    hive.result_digest = digestHiveCanonicalJson(boundedPayload2);
   }
-  return boundedPayload;
+  return boundedPayload2;
 }
 function createHiveExecutionMetadata(endpoint, durationMs, runtimeStatus, source, warnings = [], exec, integrity = {}, credit = {}) {
   const fetchedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -58162,6 +58830,17 @@ function executionGateFailureResult(endpoint, gate, durationMs, args, credit = {
   };
 }
 async function executeEndpoint(endpoint, args, context) {
+  const result2 = await executeEndpointUnchecked(endpoint, args, context);
+  if (result2.mcpResult.isError && endpoint.tool.outputSchema && result2.mcpResult.structuredContent !== void 0 && validateJsonSchema(
+    result2.mcpResult.structuredContent,
+    endpoint.tool.outputSchema
+  ).length > 0) {
+    const { structuredContent: _omitted, ...textOnly } = result2.mcpResult;
+    return { ...result2, mcpResult: textOnly };
+  }
+  return result2;
+}
+async function executeEndpointUnchecked(endpoint, args, context) {
   const start = context.startMs ?? Date.now();
   const validationErrors = validateEndpointArgs(endpoint, args);
   if (validationErrors.length > 0) {
@@ -58277,15 +58956,22 @@ async function executeEndpoint(endpoint, args, context) {
       const guardLimit = getAnnotatedMaxResultSizeChars(endpoint.tool) ?? DEFAULT_RESULT_SIZE_GUARD_CHARS;
       const successText = getTextContent(normalized);
       if (successText && successText.length > guardLimit) {
+        const guardParams = inputSchemaParamNames(endpoint.tool.inputSchema);
         bounded = {
           ...normalized,
           content: [
-            { type: "text", text: smartTruncate(successText, guardLimit) }
+            {
+              type: "text",
+              text: smartTruncate(successText, guardLimit, {
+                params: guardParams,
+                offset: args?.offset
+              })
+            }
           ]
         };
         execForHive = { ...exec, truncated: true };
         guardWarnings.push(
-          `Response exceeded ${guardLimit} characters and was truncated for model-context safety. Narrow the request with limit/page parameters or response_format="concise"; tools annotated with anthropic/maxResultSizeChars keep full headroom.`
+          `Response exceeded ${guardLimit} characters and was truncated for model-context safety. ${truncationRecallHint(guardParams)}`
         );
       }
     }
@@ -58498,7 +59184,7 @@ var CHAIN_ID_NAMES = {};
 for (const [name, id] of Object.entries(GOPLUS_CHAIN_IDS)) {
   if (!(id in CHAIN_ID_NAMES)) CHAIN_ID_NAMES[id] = name;
 }
-var CHAIN_ALIASES = [
+var CHAIN_ALIASES2 = [
   "chain",
   "network",
   "chain_id",
@@ -58535,7 +59221,7 @@ var HERO_ARG_ALIASES = {
       "name"
     ],
     address: CONTRACT_ADDRESS_ALIASES,
-    chain: CHAIN_ALIASES,
+    chain: CHAIN_ALIASES2,
     vs_currency: [
       "vs_currency",
       "vsCurrency",
@@ -58548,7 +59234,7 @@ var HERO_ARG_ALIASES = {
   },
   check_token_safety: {
     address: [...CONTRACT_ADDRESS_ALIASES, "token"],
-    chain: CHAIN_ALIASES,
+    chain: CHAIN_ALIASES2,
     response_format: RESPONSE_FORMAT_ALIASES
   },
   get_wallet_portfolio: {
@@ -58561,7 +59247,8 @@ var HERO_ARG_ALIASES = {
       "account_address",
       "owner"
     ],
-    chain: CHAIN_ALIASES,
+    chain: CHAIN_ALIASES2,
+    include_spam: ["include_spam", "includeSpam", "show_spam"],
     response_format: RESPONSE_FORMAT_ALIASES
   }
 };
@@ -58848,9 +59535,10 @@ function heroTools(endpoints, options = {}) {
       address,
       chain: chainLabel,
       risk_flags: flags,
+      ...isRecord3(entry2) ? { summary: summarizeTokenSafety(entry2) } : {},
       ...isRecord3(entry2) && entry2.holder_count !== void 0 ? { holder_count: entry2.holder_count } : {},
       ...isRecord3(entry2) && entry2.token_name !== void 0 ? { token_name: entry2.token_name } : {},
-      note: "risk_flags are raw GoPlus datapoints; treat '1' as flagged. Use response_format=detailed for the full report."
+      note: "risk_flags are raw GoPlus datapoints; treat '1' as flagged. summary.verdicts restates the scam signals in plain language; an empty list means none fired, not that the token is safe. Use response_format=detailed for the full report."
     };
   };
   const checkTokenSafety = {
@@ -58862,7 +59550,7 @@ function heroTools(endpoints, options = {}) {
     tool: {
       name: "check_token_safety",
       title: "Check Token Safety",
-      description: "Token security screen for a contract address: honeypot, taxes, ownership, and related GoPlus risk datapoints. EVM chains use chain + address; Solana addresses are detected automatically.",
+      description: "Token security screen for a contract address: honeypot, taxes, ownership, and related GoPlus risk datapoints, plus a summary of LP lock status, top-holder concentration, and creator/owner balances with plain-language verdicts. EVM chains use chain + address; Solana addresses are detected automatically.",
       inputSchema: zodToInputSchema(tokenSafetySchema),
       outputSchema: heroOutputSchema("check_token_safety"),
       annotations: VOLATILE_READ_ANNOTATIONS
@@ -58906,9 +59594,13 @@ function heroTools(endpoints, options = {}) {
     chain: z2.string().trim().max(40).optional().describe(
       'Chain name, for example "eth", "base", "arbitrum", or "solana". Defaults to eth for 0x addresses; Solana is auto-detected.'
     ),
+    include_spam: z2.boolean().optional().describe(
+      "Show likely spam airdrops (tokens with a URL or claim lure in the name, and on EVM chains tokens with no market price). Default false; the response says how many were hidden."
+    ),
     response_format: RESPONSE_FORMAT
   });
   const MAX_CONCISE_TOKENS = 15;
+  const SPAM_LURE = /(https?:\/\/|www\.|t\.me\/|\.(com|xyz|io|org|net|app|site|top|lol|info|claim|gift)\b|\bclaim|\bvisit\b|airdrop|\breward)/i;
   const NATIVE_SYMBOLS = {
     eth: "ETH",
     ethereum: "ETH",
@@ -58948,10 +59640,10 @@ function heroTools(endpoints, options = {}) {
   };
   const usdFromPrices = (token, balance) => {
     if (!Array.isArray(token.tokenPrices)) return null;
-    const usd = token.tokenPrices.find(
+    const usd2 = token.tokenPrices.find(
       (price) => isRecord3(price) && price.currency === "usd"
     );
-    const rate = usd && isRecord3(usd) ? Number(usd.value) : NaN;
+    const rate = usd2 && isRecord3(usd2) ? Number(usd2.value) : NaN;
     const quantity = balance == null ? NaN : Number(balance);
     const value = rate * quantity;
     if (!Number.isFinite(value)) return null;
@@ -58968,7 +59660,7 @@ function heroTools(endpoints, options = {}) {
     }
     return [];
   };
-  const trimWalletPortfolio = (address, chainLabel) => (payload) => {
+  const trimWalletPortfolio = (address, chainLabel, includeSpam = false, priced = false) => (payload) => {
     const walletLower = address.trim().toLowerCase();
     const tokens = firstArray(payload, ["tokens", "items", "balances"]);
     const summarized = tokens.map((token) => {
@@ -58991,18 +59683,28 @@ function heroTools(endpoints, options = {}) {
         usd_value: token.totalValueUsd ?? token.valueUsd ?? token.usd_value ?? (typeof token.totalValueUsdCents === "number" ? token.totalValueUsdCents / 100 : usdFromPrices(token, balance))
       };
     });
-    const held = summarized.filter(
+    const nonZero = summarized.filter(
       (token) => !isRecord3(token) || token.balance !== "0"
     );
+    const isSpam = (token) => isRecord3(token) && token.address != null && (SPAM_LURE.test(`${token.name ?? ""} ${token.symbol ?? ""}`) || priced && token.usd_value == null);
+    const held = includeSpam ? nonZero : nonZero.filter((t) => !isSpam(t));
+    const hidden = nonZero.length - held.length;
     return {
       address,
       chain: chainLabel,
       token_count: held.length,
+      ...hidden > 0 ? {
+        spam_hidden: {
+          count: hidden,
+          reason: priced ? "no market price, or a URL/claim lure in the name" : "a URL/claim lure in the name",
+          note: "Likely spam airdrops; pass include_spam=true to show them."
+        }
+      } : {},
       tokens: held.slice(0, MAX_CONCISE_TOKENS),
       ...held.length > MAX_CONCISE_TOKENS ? {
         note: `Showing the first ${MAX_CONCISE_TOKENS} of ${held.length} held tokens (zero balances omitted). Use response_format=detailed for the full provider payload.`
-      } : summarized.length > held.length ? {
-        note: `${summarized.length - held.length} zero-balance tokens omitted. Use response_format=detailed for the full provider payload.`
+      } : summarized.length > nonZero.length ? {
+        note: `${summarized.length - nonZero.length} zero-balance tokens omitted. Use response_format=detailed for the full provider payload.`
       } : {}
     };
   };
@@ -59015,7 +59717,7 @@ function heroTools(endpoints, options = {}) {
     tool: {
       name: "get_wallet_portfolio",
       title: "Get Wallet Portfolio",
-      description: "Token holdings for a wallet with balances and USD values where available. EVM chains route through Alchemy; Solana wallets are detected automatically and route through Helius.",
+      description: "Token holdings for a wallet with balances and USD values where available. Likely spam airdrops are hidden and counted (include_spam=true shows them). EVM chains route through Alchemy; Solana wallets are detected automatically and route through Helius.",
       inputSchema: zodToInputSchema(walletPortfolioSchema),
       outputSchema: heroOutputSchema("get_wallet_portfolio"),
       annotations: VOLATILE_READ_ANNOTATIONS
@@ -59031,14 +59733,18 @@ function heroTools(endpoints, options = {}) {
           `Invalid arguments: ${formatSchemaIssues(parsed.error)}`
         );
       }
-      const { address, chain } = parsed.data;
+      const { address, chain, include_spam: includeSpam } = parsed.data;
       const format = heroFormat(parsed.data.response_format);
       if (looksLikeNameService(address)) return nameServiceError(address);
       if (isSolanaChain(chain, address)) {
         const result3 = await executeUnderlying("helius_get_wallet_balances", {
           wallet: address
         }, "get_wallet_portfolio");
-        return respond(result3, format, trimWalletPortfolio(address, "solana"));
+        return respond(
+          result3,
+          format,
+          trimWalletPortfolio(address, "solana", includeSpam)
+        );
       }
       const normalized = normalizeChain(chain);
       const network = ALCHEMY_NETWORKS[normalized];
@@ -59053,11 +59759,107 @@ function heroTools(endpoints, options = {}) {
         withMetadata: true,
         withPrices: true
       }, "get_wallet_portfolio");
-      return respond(result2, format, trimWalletPortfolio(address, normalized));
+      return respond(
+        result2,
+        format,
+        trimWalletPortfolio(address, normalized, includeSpam, true)
+      );
     }
   };
   return [getTokenPrice, checkTokenSafety, getWalletPortfolio];
 }
+var FLAG_VERDICTS = {
+  is_honeypot: "Honeypot: GoPlus says this token cannot be sold",
+  cannot_sell_all: "Holders cannot sell their whole balance",
+  hidden_owner: "The contract has a hidden owner",
+  can_take_back_ownership: "Ownership can be taken back after renouncing",
+  is_mintable: "The owner can mint more supply",
+  transfer_pausable: "Transfers can be paused",
+  is_blacklisted: "The contract can blacklist addresses",
+  owner_change_balance: "The owner can change balances",
+  selfdestruct: "The contract can self-destruct",
+  is_airdrop_scam: "GoPlus flags this as an airdrop scam"
+};
+function percentOf(value, fraction) {
+  const n = typeof value === "string" || typeof value === "number" ? Number(value) : NaN;
+  if (!Number.isFinite(n)) return null;
+  return Math.round((fraction ? n * 100 : n) * 1e3) / 1e3;
+}
+function holderView(holder) {
+  return {
+    address: holder.address ?? holder.account ?? null,
+    // Solana rows use account
+    percent: percentOf(holder.percent, true),
+    is_contract: holder.is_contract === 1 || holder.is_contract === "1",
+    is_locked: holder.is_locked === 1 || holder.is_locked === "1",
+    tag: holder.tag || null
+  };
+}
+function summarizeTokenSafety(entry2) {
+  const verdicts = [];
+  for (const [key, sentence] of Object.entries(FLAG_VERDICTS)) {
+    if (entry2[key] === "1") verdicts.push(sentence);
+  }
+  for (const side of ["buy", "sell"]) {
+    const tax = percentOf(entry2[`${side}_tax`], true);
+    if (tax !== null && tax >= 10) verdicts.push(`${side === "buy" ? "Buy" : "Sell"} tax is ${tax}%`);
+  }
+  const lpRows = Array.isArray(entry2.lp_holders) ? entry2.lp_holders.filter(isRecord3) : [];
+  let lp = null;
+  if (lpRows.length > 0) {
+    const views = lpRows.map(holderView);
+    const top = views.reduce((a, b) => (b.percent ?? 0) > (a.percent ?? 0) ? b : a);
+    const locked = views.reduce((sum, v) => sum + (v.is_locked ? v.percent ?? 0 : 0), 0);
+    lp = {
+      holder_count: entry2.lp_holder_count ?? lpRows.length,
+      locked_percent: Math.round(locked * 1e3) / 1e3,
+      top_holder: top
+    };
+    if (locked < 50 && !top.is_locked && (top.percent ?? 0) >= 50) {
+      verdicts.push(
+        `LP not locked: ${top.percent}% held by one ${top.is_contract ? "contract" : "EOA"}`
+      );
+    } else if (locked < 50) {
+      verdicts.push(`LP mostly unlocked: only ${Math.round(locked * 1e3) / 1e3}% of LP is locked`);
+    }
+  }
+  const holderRows = Array.isArray(entry2.holders) ? entry2.holders.filter(isRecord3) : [];
+  let topHolders = null;
+  if (holderRows.length > 0) {
+    const views = holderRows.map(holderView);
+    const pairs = new Set(
+      (Array.isArray(entry2.dex) ? entry2.dex.filter(isRecord3) : []).map((d) => String(d.pair ?? "").toLowerCase())
+    );
+    const owners = views.filter((v) => !pairs.has(String(v.address).toLowerCase()));
+    const top10 = owners.slice(0, 10).reduce((sum, v) => sum + (v.percent ?? 0), 0);
+    const largest = owners[0] ?? null;
+    topHolders = {
+      largest,
+      top10_percent: Math.round(top10 * 1e3) / 1e3,
+      excludes_dex_pairs: pairs.size > 0
+    };
+    if (largest && (largest.percent ?? 0) >= 20) {
+      verdicts.push(
+        `One address holds ${largest.percent}% of supply (${largest.is_contract ? "contract" : "EOA"}, ${largest.is_locked ? "locked" : "not locked"})`
+      );
+    }
+    if (top10 >= 50) verdicts.push(`Top 10 holders hold ${Math.round(top10 * 10) / 10}% of supply`);
+  }
+  const creator = entry2.creator_address ? {
+    address: entry2.creator_address,
+    balance: entry2.creator_balance ?? null,
+    percent: percentOf(entry2.creator_percent, true)
+  } : null;
+  const owner = entry2.owner_address ? {
+    address: entry2.owner_address,
+    balance: entry2.owner_balance ?? null,
+    percent: percentOf(entry2.owner_percent, true)
+  } : null;
+  for (const [label, who] of [["Creator", creator], ["Owner", owner]]) {
+    if (who && (who.percent ?? 0) >= 5) verdicts.push(`${label} still holds ${who.percent}% of supply`);
+  }
+  return { verdicts, lp, top_holders: topHolders, creator, owner };
+}
 function heroOutputSchema(name) {
   return HERO_TOOL_OUTPUT_SCHEMAS[name];
 }
@@ -59199,7 +60001,7 @@ var TASK_TOOLSET_ROUTES = {
           "holders",
           "Measure holder concentration with a bounded holder read.",
           "get_token_top_holders",
-          "moralis_get_token_holder_metrics",
+          "get_token_holder_distribution",
           PROVIDER_FALLBACK
         ),
         step(
@@ -59359,15 +60161,14 @@ var TASK_TOOLSET_ROUTES = {
           "simulation",
           "Simulate execution without broadcasting.",
           "tenderly_simulate_transaction",
-          "alchemy_simulate_execution",
+          "tenderly_node_simulate_transaction",
           PROVIDER_FALLBACK
         ),
         step(
           "risk",
           "Inspect simulated asset changes.",
-          "alchemy_simulate_asset_changes",
           "simulate_evm_transaction",
-          PROVIDER_FALLBACK
+          null
         )
       ],
       stopCondition: "Stop after decoding, execution outcome, and asset effects are clear; never broadcast or mutate chain state."
@@ -60191,6 +60992,7 @@ var TASK_TOOLSET_CATALOG = [
     optionalIdentifiers: ["symbol", "pair address", "time range"],
     recommendedTools: [
       "get_token_top_holders",
+      "get_token_holder_distribution",
       "get_token_pools",
       "get_token_ohlcv",
       "get_token_info",
@@ -60359,8 +61161,6 @@ var TASK_TOOLSET_CATALOG = [
       "alchemy_solana_get_compression_indexer_slot",
       "alchemy_solana_get_latest_compression_signatures",
       "alchemy_solana_get_latest_non_voting_signatures",
-      "alchemy_simulate_asset_changes",
-      "alchemy_simulate_execution",
       "simulate_evm_transaction",
       "defillama_get_hacks"
     ],
@@ -61590,7 +62390,11 @@ function getTaskOutputSchema(taskToolsetId) {
 }
 
 // src/services/execution-fallback.ts
-var FALLBACK_TRIGGER_STATUSES = /* @__PURE__ */ new Set(["failing", "missing_key"]);
+var FALLBACK_TRIGGER_STATUSES = /* @__PURE__ */ new Set([
+  "failing",
+  "missing_key",
+  "plan_required"
+]);
 function findRouteFallback(primaryToolName) {
   for (const toolset of TASK_TOOLSETS) {
     if (toolset.fallbackTools.length === 0) continue;
@@ -61633,9 +62437,7 @@ async function executeEndpointWithRouteFallback(endpoints, endpoint, args, conte
   const fallbackProviderStatus = getProviderRuntimeStatus(
     getProviderDescriptorForEndpoint(fallback)
   );
-  if (fallbackProviderStatus === "missing_key" || fallbackProviderStatus === "failing") {
-    return primary;
-  }
+  if (FALLBACK_TRIGGER_STATUSES.has(fallbackProviderStatus)) return primary;
   if (!argsMapCleanly(fallback, args)) return primary;
   const fallbackResult = await executeEndpoint(fallback, args, {
     ...context,
@@ -64421,7 +65223,7 @@ async function runOAuthLifecycleHealth(overrides = {}) {
 }
 
 // src/health/selfTest.ts
-import Coingecko3 from "@coingecko/coingecko-typescript";
+import Coingecko4 from "@coingecko/coingecko-typescript";
 
 // src/tools/goplus/goplusClient.ts
 import { createHash as createHash8 } from "crypto";
@@ -65766,6 +66568,87 @@ var CCXTClient = class {
   }
 };
 
+// src/health/answerProbes.ts
+var ETH_WETH = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
+var ETH_PEPE = "0x6982508145454Ce325dDbE47a25d4ec3d2311933";
+function isRecord4(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function largestArray(value, depth = 0) {
+  if (Array.isArray(value)) return value;
+  if (!isRecord4(value) || depth > 4) return [];
+  let best = [];
+  for (const child of Object.values(value)) {
+    const candidate = largestArray(child, depth + 1);
+    if (candidate.length > best.length) best = candidate;
+  }
+  return best;
+}
+function rowsOf(payload) {
+  return isRecord4(payload) && Array.isArray(payload.rows) ? payload.rows : largestArray(payload);
+}
+function returnedCountMismatch(payload, rows) {
+  const returned = isRecord4(payload) ? payload.returnedCount : void 0;
+  return typeof returned === "number" && returned !== rows.length ? `returnedCount ${returned} != rows.length ${rows.length}` : null;
+}
+var ANSWER_PROBES = {
+  polymarket_search_markets: {
+    // The "JD Vance wins 2028" market resolves 2028-11-07; the event-level
+    // fixture in selfTest's TOOL_PROBE_ARGS points at the same market.
+    args: { query: "vance 2028", limit: 3 },
+    check: (payload) => {
+      const rows = rowsOf(payload);
+      if (rows.length === 0)
+        return "text search for 'vance 2028' found no markets";
+      const unmatched = rows.filter((row) => {
+        const text = JSON.stringify(row).toLowerCase();
+        return !text.includes("vance") || !text.includes("2028");
+      });
+      if (unmatched.length > 0) {
+        return `${unmatched.length} of ${rows.length} rows do not match every query term`;
+      }
+      return returnedCountMismatch(payload, rows);
+    }
+  },
+  get_token_top_holders: {
+    args: { network: "eth", address: ETH_WETH, limit: 20 },
+    check: (payload) => {
+      const holders = largestArray(payload);
+      return holders.length > 10 ? null : `asked for 20 WETH holders, got ${holders.length}`;
+    }
+  },
+  rwa_get_hyperliquid_dex_perps: {
+    args: { limit: 100 },
+    check: (payload) => {
+      const rows = rowsOf(payload);
+      if (rows.length === 0) return "no HIP-3 builder-dex rows";
+      return returnedCountMismatch(payload, rows);
+    }
+  },
+  // check_token_safety builds its LP verdict on this GoPlus read.
+  get_token_security: {
+    args: { chainId: "1", contract_addresses: ETH_PEPE },
+    check: (payload) => {
+      const result2 = isRecord4(payload) ? payload.result : void 0;
+      const token = isRecord4(result2) ? Object.values(result2).find(isRecord4) : void 0;
+      if (!token) return "no token entry in the GoPlus result";
+      const lpHolders = token.lp_holders;
+      return Array.isArray(lpHolders) && lpHolders.length > 0 ? null : "PEPE came back without lp_holders";
+    }
+  }
+};
+function checkAnswer(probe, result2) {
+  const text = isRecord4(result2) ? result2.content?.[0]?.text : void 0;
+  if (typeof text !== "string") return "response has no text content";
+  let payload;
+  try {
+    payload = JSON.parse(text);
+  } catch {
+    return "response is not JSON";
+  }
+  return probe.check(payload);
+}
+
 // src/health/selfTest.ts
 function positiveTimeout(name, fallbackMs) {
   const configured = Number(process.env[name]);
@@ -65779,7 +66662,7 @@ var QUICK_PROBE_TIMEOUT = Math.min(
 var ETH_WALLET = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045";
 var MORALIS_EVM_WALLET = "0xF977814e90dA44bFA03b6295A0616a897441aceC";
 var ETH_USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
-var ETH_WETH = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
+var ETH_WETH2 = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
 var ETH_USDT = "0xdAC17F958D2ee523a2206206994597C13D831ec7";
 var ETH_BAYC = "0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D";
 var ETH_USDC_WETH_PAIR = "0xB4e16d0168e52d35CaCD2c6185b44281Ec28C9Dc";
@@ -65836,6 +66719,7 @@ var PROVIDER_RESOURCE_PATTERNS = [
   ["polymarket", /^polymarket(?:[.-]|$)/],
   ["alternative", /^signals-fear-greed$/],
   ["blockchain", /^signals-onchain/],
+  ["blockscout", /^blockscout(?:[.-]|$)/],
   ["fetch", /^fetch(?:[.-]|$)/],
   ["helius", /^helius\./],
   ["moralis", /^moralis\./],
@@ -65906,6 +66790,11 @@ var QUICK_PROBE_ARGS = {
     toolName: "signals_get_onchain_metrics",
     args: { metrics: ["hash_rate"], days: 1 }
   },
+  // One token read plus one holder page on Ethereum (keyless public host).
+  blockscout: {
+    toolName: "get_token_holder_distribution",
+    args: { network: "eth", address: ETH_USDC, max_pages: 1 }
+  },
   fetch: {
     toolName: "fetch_public_api",
     args: { host: "api.coingecko.com", path: "/api/v3/ping" }
@@ -65944,7 +66833,7 @@ var FULL_MODE_DEFAULT_ARGS = {
     vs_currency: "usd",
     vs_currencies: "usd",
     network: "eth",
-    address: ETH_WETH,
+    address: ETH_WETH2,
     days: "7"
   },
   defillama: {
@@ -66026,7 +66915,11 @@ var TOOL_PROBE_ARGS = {
   get_rwa_market_chart: { id: "gold", days: "7" },
   get_rwa_issuer: { id: "ondo-tokenized-assets" },
   // Polymarket fixtures verified live 2026-09-16; the event ends 2028-11-07.
-  polymarket_search_markets: { query: "election", limit: 3 },
+  get_token_holder_distribution: {
+    network: "eth",
+    address: ETH_USDC,
+    max_pages: 1
+  },
   polymarket_get_events: { slug: "presidential-election-winner-2028" },
   polymarket_get_market: {
     slug: "will-jd-vance-win-the-2028-us-presidential-election"
@@ -67235,7 +68128,7 @@ function getClientForProvider(provider, clients) {
   }
 }
 function buildClients() {
-  const coinGeckoClient = new Coingecko3(getCoinGeckoClientOptions());
+  const coinGeckoClient = new Coingecko4(getCoinGeckoClientOptions());
   return {
     coinGeckoClient,
     goplusClient: new GoPlusClient(
@@ -67481,7 +68374,7 @@ async function getEffectiveProbeArgs(toolName, provider, clients, args) {
       return { [idFixture.field]: id };
     });
   }
-  const toolFixture = TOOL_PROBE_ARGS[toolName];
+  const toolFixture = ANSWER_PROBES[toolName]?.args ?? TOOL_PROBE_ARGS[toolName];
   if (toolFixture) return toolFixture;
   return projectArgsToToolSchema(
     FULL_MODE_DEFAULT_ARGS[provider] || {},
@@ -67573,6 +68466,16 @@ async function runEndpointProbe(endpoint, provider, clients, args, timeoutMs = P
           );
         }
       }
+      const answerProbe = args ? void 0 : ANSWER_PROBES[toolName];
+      const answerProblem = answerProbe ? checkAnswer(answerProbe, result2) : null;
+      if (answerProblem) {
+        return {
+          name: toolName,
+          status: "failed",
+          duration,
+          error: `Answer check failed: ${answerProblem}`
+        };
+      }
       return { name: toolName, status: "passed", duration };
     } catch (err) {
       const errorMsg = err instanceof Error ? err.message : "Unknown error";
@@ -69627,6 +70530,11 @@ var TOOLSET_INTENT_HINTS = {
   ],
   security_risk: [
     "rugpull",
+    "rug pull",
+    "rug check",
+    "rugcheck",
+    "honeypot",
+    "scam",
     "safe to buy",
     "phishing",
     "malicious",
@@ -69986,6 +70894,9 @@ function catalogEntry(endpoint) {
     material: getMcpCreditCost(endpoint.tool.name) === 1,
     credit_cost: getMcpCreditCost(endpoint.tool.name),
     summary: summarizeToolDescription(endpoint.tool.description ?? ""),
+    // Ranking text: the summary minus its negative guidance, so "Not
+    // recommended for: ... holder info" never counts as a holder match.
+    rankText: summarizeToolDescription(endpoint.tool.description ?? "").split(/not recommended for:|don't use when:|common mistakes:/i)[0].toLowerCase(),
     searchText: [
       endpoint.tool.name,
       endpoint.tool.title ?? getToolTitle(endpoint.tool.name),
@@ -70004,7 +70915,11 @@ function catalogEntry(endpoint) {
   };
 }
 function publicCatalogEntry(entry2) {
-  const { searchText: _searchText, ...publicEntry } = entry2;
+  const {
+    searchText: _searchText,
+    rankText: _rankText,
+    ...publicEntry
+  } = entry2;
   return publicEntry;
 }
 function normalizeSearchToken(token) {
@@ -70044,31 +70959,36 @@ function matchesSearchTokens(haystack, query) {
   return tokens.some((token) => textMatchesSearchToken(haystack, token));
 }
 function queryMatchScore(entry2, query) {
-  if (!query) return 0;
+  if (!query) return { score: 0, direct: true };
   if (!matchesSearchTokens(entry2.searchText, query)) return null;
   const tokens = parseSearchTokens(query);
-  if (tokens.length === 0) return 0;
+  if (tokens.length === 0) return { score: 0, direct: true };
   const nameTitleText = [entry2.name, entry2.title].join(" ").toLowerCase();
+  const summaryText = entry2.rankText;
   const coreText = [
     entry2.name,
     entry2.title,
     entry2.category ?? "",
     entry2.provider,
-    entry2.summary
+    summaryText
   ].join(" ").toLowerCase();
   const nameTitleTokenSet = new Set(parseSearchTokens(nameTitleText));
   const coreTextTokenSet = new Set(parseSearchTokens(coreText));
+  const providerTokenSet = new Set(parseSearchTokens(entry2.provider));
+  let direct = false;
   const score = tokens.reduce((total, token) => {
     const exactToken = singularizeToken(normalizeSearchToken(token));
-    if (nameTitleTokenSet.has(exactToken)) return total + 24;
-    if (coreTextTokenSet.has(exactToken)) return total + 14;
-    if (textMatchesSearchToken(nameTitleText, token)) return total + 12;
-    if (textMatchesSearchToken(entry2.summary, token)) return total + 6;
-    if (textMatchesSearchToken(coreText, token)) return total + 4;
-    if (textMatchesSearchToken(entry2.searchText, token)) return total + 2;
+    const providerBonus = providerTokenSet.has(exactToken) ? 8 : 0;
+    const directScore = nameTitleTokenSet.has(exactToken) ? 24 : coreTextTokenSet.has(exactToken) ? 14 : nameTitleText.includes(exactToken) ? 12 : summaryText.includes(exactToken) ? 6 : coreText.includes(exactToken) ? 4 : 0;
+    if (directScore > 0) {
+      direct = true;
+      return total + directScore + providerBonus;
+    }
+    if (textMatchesSearchToken(coreText, token)) return total + 2;
+    if (textMatchesSearchToken(entry2.searchText, token)) return total + 1;
     return total;
   }, 0);
-  return score > 0 ? score : null;
+  return score > 0 ? { score, direct } : null;
 }
 function buildProviderByToolName(endpoints) {
   const providerByToolName = /* @__PURE__ */ new Map();
@@ -70147,6 +71067,26 @@ function selectToolsetRoutes(routes, query, routeId) {
   const positive = ranked.filter((item) => item.score > 0);
   return (positive.length > 0 ? positive : ranked).slice(0, 1).map((item) => item.route);
 }
+function promoteHealthyRouteFallbacks(route, availabilityForTool) {
+  let promoted = false;
+  const steps = route.steps.map((step2) => {
+    const primaryAvailability = availabilityForTool(step2.primaryTool);
+    const fallbackTool = step2.fallback.tool;
+    if (!isUnavailable(primaryAvailability) || !fallbackTool || isUnavailable(availabilityForTool(fallbackTool))) {
+      return step2;
+    }
+    promoted = true;
+    return {
+      ...step2,
+      primaryTool: fallbackTool,
+      fallback: {
+        tool: step2.primaryTool,
+        when: `Promoted fallback: ${step2.primaryTool} is ${primaryAvailability} right now and returns runtime_status, not data. Original fallback condition: ${step2.fallback.when}`
+      }
+    };
+  });
+  return promoted ? { ...route, steps } : route;
+}
 function publicRouteEntry(route) {
   return {
     id: route.id,
@@ -70160,9 +71100,11 @@ function publicRouteEntry(route) {
     stopCondition: route.stopCondition
   };
 }
-function publicToolsetEntry(entry2, detail, query, routeId) {
+function publicToolsetEntry(entry2, detail, query, routeId, availabilityForTool = () => "ok") {
   const routes = selectToolsetRoutes(entry2.routes, query, routeId).map(
-    publicRouteEntry
+    (route) => publicRouteEntry(
+      promoteHealthyRouteFallbacks(route, availabilityForTool)
+    )
   );
   const compact = {
     id: entry2.id,
@@ -70193,6 +71135,11 @@ function publicToolsetEntry(entry2, detail, query, routeId) {
 }
 function toolsetQueryMatchScore(entry2, query) {
   if (!query) return 0;
+  if (entry2.id === "solana_analysis" && /\b0x[0-9a-f]{40}\b|\b(ethereum|base|arbitrum|optimism|polygon|bsc|avalanche)\b/i.test(
+    query
+  ) && !/\b(solana|sol|spl|pump\.?fun|raydium|jupiter)\b/i.test(query)) {
+    return null;
+  }
   const haystack = [
     entry2.id,
     entry2.label,
@@ -70368,17 +71315,15 @@ function dynamicTools(endpoints, options = {}) {
       const filteredTools = catalogEntries.map((entry2, index) => ({
         entry: entry2,
         index,
-        score: routeId ? 100 : queryMatchScore(entry2, query)
-      })).filter((item) => item.score !== null).filter(
+        match: routeId ? { score: 100, direct: true } : queryMatchScore(entry2, query)
+      })).filter((item) => item.match !== null).filter(
         (item) => selectedRouteToolNames ? selectedRouteToolNames.has(item.entry.name) : true
       ).filter(
         (entry2) => provider ? entry2.entry.provider.toLowerCase() === provider : true
       ).filter(
         (entry2) => category ? entry2.entry.category?.toLowerCase() === category : true
       ).sort(
-        (a, b) => query ? b.score - a.score || a.index - b.index : a.index - b.index
-      ).sort(
-        (a, b) => Number(isUnavailable(availabilityFor(a.entry.provider))) - Number(isUnavailable(availabilityFor(b.entry.provider)))
+        (a, b) => Number(b.match.direct) - Number(a.match.direct) || Number(isUnavailable(availabilityFor(a.entry.provider))) - Number(isUnavailable(availabilityFor(b.entry.provider))) || (query ? b.match.score - a.match.score : 0) || a.index - b.index
       ).map((item) => item.entry);
       const filteredToolsets = taskToolsetCatalogEntries.map((entry2, index) => ({
         entry: entry2,
@@ -70432,7 +71377,8 @@ function dynamicTools(endpoints, options = {}) {
             entry2,
             parsed.detail ?? "compact",
             query,
-            routeId
+            routeId,
+            (toolName) => availabilityFor(providerByToolName.get(toolName) ?? "Hive")
           );
           const providerAvailability = Object.fromEntries(
             entry2.providers.map((name) => [
@@ -71306,7 +72252,7 @@ function getSharedClients() {
       );
     }
     sharedClients = {
-      coinGeckoClient: new Coingecko4(getCoinGeckoClientOptions()),
+      coinGeckoClient: new Coingecko5(getCoinGeckoClientOptions()),
       goplusClient,
       ccxtClient: new CCXTClient()
     };
@@ -71339,6 +72285,7 @@ function describeToolReference(toolName, endpointIndex) {
   };
 }
 function describeTaskToolset(toolset, endpointIndex) {
+  const availability = getProviderAvailabilitySnapshot().byProviderName;
   return {
     id: toolset.id,
     kind: toolset.kind,
@@ -71347,7 +72294,12 @@ function describeTaskToolset(toolset, endpointIndex) {
     outcome: toolset.outcome,
     requiredIdentifiers: toolset.requiredIdentifiers,
     optionalIdentifiers: toolset.optionalIdentifiers,
-    routes: toolset.routes,
+    routes: toolset.routes.map(
+      (route) => promoteHealthyRouteFallbacks(route, (toolName) => {
+        const endpoint = endpointIndex.get(toolName);
+        return endpoint ? availability[getProviderNameForTool(endpoint)] ?? "ok" : "ok";
+      })
+    ),
     coverageCatalog: {
       recommendedTools: toolset.recommendedTools.map(
         (toolName) => describeToolReference(toolName, endpointIndex)