hive-intelligence 1.16.1 → 1.17.1

package/build/{chunk-757ZNB6W.js → chunk-UP47NKED.js}

@@ -14579,7 +14579,7 @@ var handlers = {
   getApprovalSecurity: createHandler("getApprovalSecurity", {
     suggestion: "Verify the chain ID and spender contract address. Use this before approving tokens to a contract.",
     alternatives: [
-      "get_user_approvals - List existing approvals",
+      "get_wallet_approvals - List existing approvals",
       "get_token_security - Analyze token contract"
     ],
     example: {
@@ -14601,7 +14601,7 @@ var handlers = {
   getDappSecurity: createHandler("getDappSecurity", {
     suggestion: "Provide a complete URL including https://. For comprehensive dApp analysis use this tool.",
     alternatives: [
-      "detect_phishing_site - Quick phishing check",
+      "check_phishing_site - Quick phishing check",
       "check_malicious_address - Check associated addresses"
     ],
     example: { url: "https://app.uniswap.org" }
@@ -14630,7 +14630,7 @@ var handlers = {
     suggestion: "Provide chain_id, from, to, and data fields. Use hex-encoded calldata starting with 0x.",
     alternatives: [
       "get_solana_token_security - For Solana token analysis",
-      "decode_abi_data - To decode transaction data"
+      "decode_abi - To decode transaction data"
     ],
     example: {
       chain_id: "1",
@@ -18594,10 +18594,10 @@ var wrapper = {
 // src/utils/fetchClient.ts
 var HttpError = class extends Error {
   config;
-  constructor(message, config2, code, response) {
+  constructor(message, config, code, response) {
     super(message);
     this.name = "HttpError";
-    this.config = config2;
+    this.config = config;
     if (code) this.code = code;
     if (response) this.response = response;
   }
@@ -18634,16 +18634,16 @@ var UNDICI_CODES = {
   UND_ERR_BODY_TIMEOUT: "ETIMEDOUT",
   UND_ERR_SOCKET: "ECONNRESET"
 };
-function networkError(error, timedOut, timeout, config2) {
+function networkError(error, timedOut, timeout, config) {
   if (timedOut) {
-    return new HttpError(`timeout of ${timeout}ms exceeded`, config2, "ECONNABORTED");
+    return new HttpError(`timeout of ${timeout}ms exceeded`, config, "ECONNABORTED");
   }
   const cause = error?.cause;
   const rawCode = cause?.code;
   const code = (rawCode && UNDICI_CODES[rawCode]) ?? rawCode ?? "ERR_NETWORK";
-  return new HttpError(cause?.message || rawCode || "Network Error", config2, code);
+  return new HttpError(cause?.message || rawCode || "Network Error", config, code);
 }
-async function readBody(response, maxContentLength, config2, onChunk) {
+async function readBody(response, maxContentLength, config, onChunk) {
   if (!response.body) return "";
   const reader = response.body.getReader();
   const chunks = [];
@@ -18657,7 +18657,7 @@ async function readBody(response, maxContentLength, config2, onChunk) {
       await reader.cancel();
       throw new HttpError(
         `maxContentLength size of ${maxContentLength} exceeded`,
-        config2,
+        config,
         "ERR_BAD_RESPONSE"
       );
     }
@@ -18674,9 +18674,9 @@ function parseBody(text) {
   }
 }
 function createFetchClient(options = {}) {
-  async function request(method, url, data, config2 = {}) {
+  async function request(method, url, data, config = {}) {
     const info = { method, url };
-    const timeout = config2.timeout ?? options.timeout ?? 0;
+    const timeout = config.timeout ?? options.timeout ?? 0;
     const controller = new AbortController();
     let timedOut = false;
     let timer;
@@ -18694,7 +18694,7 @@ function createFetchClient(options = {}) {
       const headers = {
         Accept: "application/json, text/plain, */*",
         ...options.headers,
-        ...config2.headers
+        ...config.headers
       };
       let body;
       if (data !== void 0) {
@@ -18707,7 +18707,7 @@ function createFetchClient(options = {}) {
       let text;
       let res;
       try {
-        res = await fetch(buildUrl(options.baseURL, url, config2.params), {
+        res = await fetch(buildUrl(options.baseURL, url, config.params), {
           method: method.toUpperCase(),
           headers,
           body,
@@ -18741,10 +18741,10 @@ function createFetchClient(options = {}) {
     }
   }
   return {
-    get: (url, config2) => request("get", url, void 0, config2),
-    post: (url, data, config2) => request("post", url, data, config2),
-    put: (url, data, config2) => request("put", url, data, config2),
-    delete: (url, config2) => request("delete", url, void 0, config2)
+    get: (url, config) => request("get", url, void 0, config),
+    post: (url, data, config) => request("post", url, data, config),
+    put: (url, data, config) => request("put", url, data, config),
+    delete: (url, config) => request("delete", url, void 0, config)
   };
 }
 
@@ -31592,8 +31592,7 @@ function isRetryableError(error) {
       "ECONNRESET",
       "ETIMEDOUT",
       "ECONNREFUSED",
-      "ENOTFOUND",
-      "ECONNABORTED"
+      "ENOTFOUND"
     ];
     return retryableCodes.includes(error.code || "");
   }
@@ -31612,23 +31611,23 @@ var ResilientHttpClient = class {
   http;
   config;
   circuitBreaker;
-  constructor(config2) {
+  constructor(config) {
     this.config = {
-      baseURL: config2.baseURL,
-      timeout: config2.timeout ?? 3e4,
+      baseURL: config.baseURL,
+      timeout: config.timeout ?? 3e4,
       // 30 seconds default
-      headers: config2.headers,
-      serviceName: config2.serviceName,
-      maxRetries: config2.maxRetries ?? 3,
-      retryBaseDelay: config2.retryBaseDelay ?? 1e3,
-      enableCircuitBreaker: config2.enableCircuitBreaker ?? true,
-      circuitBreakerThreshold: config2.circuitBreakerThreshold ?? 5,
-      circuitBreakerResetTimeout: config2.circuitBreakerResetTimeout ?? 3e4
+      headers: config.headers,
+      serviceName: config.serviceName,
+      maxRetries: config.maxRetries ?? 3,
+      retryBaseDelay: config.retryBaseDelay ?? 1e3,
+      enableCircuitBreaker: config.enableCircuitBreaker ?? true,
+      circuitBreakerThreshold: config.circuitBreakerThreshold ?? 5,
+      circuitBreakerResetTimeout: config.circuitBreakerResetTimeout ?? 3e4
     };
     this.http = createFetchClient({
       baseURL: this.config.baseURL,
       timeout: this.config.timeout,
-      maxContentLength: config2.maxContentLength,
+      maxContentLength: config.maxContentLength,
       headers: {
         "Content-Type": "application/json",
         Accept: "application/json",
@@ -31647,12 +31646,12 @@ var ResilientHttpClient = class {
       url: endpoint,
       params: options.params
     });
-    const config2 = {
+    const config = {
       params: options.params,
       timeout: options.timeout ?? this.config.timeout,
       headers: options.headers
     };
-    const response = method === "get" || method === "delete" ? await this.http[method](endpoint, config2) : await this.http[method](endpoint, options.body, config2);
+    const response = method === "get" || method === "delete" ? await this.http[method](endpoint, config) : await this.http[method](endpoint, options.body, config);
     secureLogger.debug(`[${this.config.serviceName}] Response`, {
       status: response.status,
       url: endpoint
@@ -31844,8 +31843,8 @@ var ResilientHttpClient = class {
     );
   }
 };
-function createHttpClient(config2) {
-  return new ResilientHttpClient(config2);
+function createHttpClient(config) {
+  return new ResilientHttpClient(config);
 }
 
 // src/tools/tenderly/tenderlyClient.ts
@@ -35981,15 +35980,15 @@ var getTransactionHandler = makeHandler(
   },
   (client2, args) => {
     const signature = String(args.signature ?? "");
-    const config2 = {};
+    const config = {};
     for (const key of [
       "encoding",
       "commitment",
       "maxSupportedTransactionVersion"
     ]) {
-      if (args[key] !== void 0) config2[key] = args[key];
+      if (args[key] !== void 0) config[key] = args[key];
     }
-    return client2.request("getTransaction", [signature, config2]);
+    return client2.request("getTransaction", [signature, config]);
   }
 );
 var getTransactionsForAddressHandler = makeHandler(
@@ -36004,7 +36003,7 @@ var getTransactionsForAddressHandler = makeHandler(
       1,
       Math.min(transactionDetails === "full" ? 100 : 1e3, requestedLimit)
     );
-    const config2 = { transactionDetails, limit };
+    const config = { transactionDetails, limit };
     for (const key of [
       "sortOrder",
       "commitment",
@@ -36014,11 +36013,11 @@ var getTransactionsForAddressHandler = makeHandler(
       "maxSupportedTransactionVersion",
       "filters"
     ]) {
-      if (args[key] !== void 0) config2[key] = args[key];
+      if (args[key] !== void 0) config[key] = args[key];
     }
     return client2.request("getTransactionsForAddress", [
       String(args.address ?? ""),
-      config2
+      config
     ]);
   }
 );
@@ -36029,7 +36028,7 @@ var getTransfersByAddressHandler = makeHandler(
   { address: EX_OWNER, limit: 50 },
   (client2, args) => {
     const requestedLimit = Number(args.limit ?? 100);
-    const config2 = {
+    const config = {
       limit: Math.max(1, Math.min(100, requestedLimit))
     };
     for (const key of [
@@ -36043,11 +36042,11 @@ var getTransfersByAddressHandler = makeHandler(
       "minContextSlot",
       "sortOrder"
     ]) {
-      if (args[key] !== void 0) config2[key] = args[key];
+      if (args[key] !== void 0) config[key] = args[key];
     }
     return client2.request("getTransfersByAddress", [
       String(args.address ?? ""),
-      config2
+      config
     ]);
   }
 );
@@ -36332,7 +36331,7 @@ var getTokenAccountsByOwnerV2Handler = makeHandler(
   (client2, args) => {
     const owner = String(args.owner ?? "");
     const filter = args.mint !== void 0 ? { mint: String(args.mint) } : { programId: String(args.programId ?? TOKEN_PROGRAM_ID) };
-    const config2 = {
+    const config = {
       encoding: args.encoding ?? "jsonParsed",
       limit: args.limit ?? 1e3
     };
@@ -36344,9 +36343,9 @@ var getTokenAccountsByOwnerV2Handler = makeHandler(
       "withContext",
       "commitment"
     ]) {
-      if (args[key] !== void 0) config2[key] = args[key];
+      if (args[key] !== void 0) config[key] = args[key];
     }
-    return client2.request("getTokenAccountsByOwnerV2", [owner, filter, config2]);
+    return client2.request("getTokenAccountsByOwnerV2", [owner, filter, config]);
   }
 );
 var getProgramAccountsV2Handler = makeHandler(
@@ -36355,7 +36354,7 @@ var getProgramAccountsV2Handler = makeHandler(
   ["helius_get_token_accounts_by_owner_v2"],
   { programId: TOKEN_PROGRAM_ID, encoding: "base64", limit: 10 },
   (client2, args) => {
-    const config2 = {
+    const config = {
       encoding: args.encoding ?? "base64",
       limit: args.limit ?? 100
     };
@@ -36368,11 +36367,11 @@ var getProgramAccountsV2Handler = makeHandler(
       "withContext",
       "commitment"
     ]) {
-      if (args[key] !== void 0) config2[key] = args[key];
+      if (args[key] !== void 0) config[key] = args[key];
     }
     return client2.request("getProgramAccountsV2", [
       String(args.programId ?? ""),
-      config2
+      config
     ]);
   }
 );
@@ -36522,8 +36521,8 @@ var AlchemyClient = class {
     secureLogger.info("Alchemy client initialized");
   }
   getHttpClient(baseURL, serviceName) {
-    const cacheKey2 = `${serviceName}:${baseURL}`;
-    const existing = this.clients.get(cacheKey2);
+    const cacheKey = `${serviceName}:${baseURL}`;
+    const existing = this.clients.get(cacheKey);
     if (existing) return existing;
     const client2 = createHttpClient({
       baseURL,
@@ -36539,7 +36538,7 @@ var AlchemyClient = class {
       circuitBreakerThreshold: 5,
       circuitBreakerResetTimeout: 3e4
     });
-    this.clients.set(cacheKey2, client2);
+    this.clients.set(cacheKey, client2);
     return client2;
   }
   apiPath(path) {
@@ -47582,7 +47581,7 @@ async function fetchWithTimeout(url, options, timeout) {
 }
 async function resilientFetch(url, fetchOptions = {}, resilientOptions = {}) {
   const startTime = Date.now();
-  const config2 = {
+  const config = {
     timeout: resilientOptions.timeout ?? 3e4,
     maxRetries: resilientOptions.maxRetries ?? 3,
     retryBaseDelay: resilientOptions.retryBaseDelay ?? 1e3,
@@ -47591,21 +47590,21 @@ async function resilientFetch(url, fetchOptions = {}, resilientOptions = {}) {
     circuitBreakerThreshold: resilientOptions.circuitBreakerThreshold ?? 5,
     circuitBreakerResetTimeout: resilientOptions.circuitBreakerResetTimeout ?? 3e4
   };
-  const circuitBreaker = getCircuitBreaker2(config2.serviceName);
-  if (config2.enableCircuitBreaker) {
-    checkCircuitBreaker(circuitBreaker, config2);
+  const circuitBreaker = getCircuitBreaker2(config.serviceName);
+  if (config.enableCircuitBreaker) {
+    checkCircuitBreaker(circuitBreaker, config);
   }
   let lastError = null;
-  for (let attempt = 0; attempt <= config2.maxRetries; attempt++) {
+  for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
     try {
-      const response = await fetchWithTimeout(url, fetchOptions, config2.timeout);
+      const response = await fetchWithTimeout(url, fetchOptions, config.timeout);
       if (!response.ok && isRetryableStatus(response.status)) {
         throw new Error(`HTTP ${response.status}: ${response.statusText}`);
       }
-      if (config2.enableCircuitBreaker) {
+      if (config.enableCircuitBreaker) {
         recordSuccess(circuitBreaker);
       }
-      secureLogger.debug(`[${config2.serviceName}] Request succeeded`, {
+      secureLogger.debug(`[${config.serviceName}] Request succeeded`, {
         url: sanitizeUrl(url),
         status: response.status,
         duration: Date.now() - startTime
@@ -47613,15 +47612,15 @@ async function resilientFetch(url, fetchOptions = {}, resilientOptions = {}) {
       return response;
     } catch (error) {
       lastError = error instanceof Error ? error : new Error(String(error));
-      if (config2.enableCircuitBreaker) {
-        recordFailure(circuitBreaker, config2);
+      if (config.enableCircuitBreaker) {
+        recordFailure(circuitBreaker, config);
       }
-      if (attempt < config2.maxRetries) {
-        const delay2 = calculateBackoffDelay2(attempt, config2.retryBaseDelay);
-        secureLogger.warn(`[${config2.serviceName}] Request failed, retrying`, {
+      if (attempt < config.maxRetries) {
+        const delay2 = calculateBackoffDelay2(attempt, config.retryBaseDelay);
+        secureLogger.warn(`[${config.serviceName}] Request failed, retrying`, {
           url: sanitizeUrl(url),
           attempt: attempt + 1,
-          maxRetries: config2.maxRetries,
+          maxRetries: config.maxRetries,
           delayMs: Math.round(delay2),
           error: lastError.message
         });
@@ -47630,28 +47629,28 @@ async function resilientFetch(url, fetchOptions = {}, resilientOptions = {}) {
       }
     }
   }
-  secureLogger.error(`[${config2.serviceName}] Request failed after all retries`, lastError, {
+  secureLogger.error(`[${config.serviceName}] Request failed after all retries`, lastError, {
     url: sanitizeUrl(url),
-    attempts: config2.maxRetries + 1,
+    attempts: config.maxRetries + 1,
     duration: Date.now() - startTime
   });
   throw lastError;
 }
-function checkCircuitBreaker(breaker, config2) {
+function checkCircuitBreaker(breaker, config) {
   const now = Date.now();
   switch (breaker.state) {
     case "OPEN" /* OPEN */:
-      if (now - breaker.lastFailureTime > config2.circuitBreakerResetTimeout) {
+      if (now - breaker.lastFailureTime > config.circuitBreakerResetTimeout) {
         breaker.state = "HALF_OPEN" /* HALF_OPEN */;
-        secureLogger.info(`[${config2.serviceName}] Circuit breaker HALF_OPEN, testing recovery`);
+        secureLogger.info(`[${config.serviceName}] Circuit breaker HALF_OPEN, testing recovery`);
       } else {
         throw new Error(
-          `Circuit breaker OPEN for ${config2.serviceName}. Will retry in ${Math.ceil((config2.circuitBreakerResetTimeout - (now - breaker.lastFailureTime)) / 1e3)}s`
+          `Circuit breaker OPEN for ${config.serviceName}. Will retry in ${Math.ceil((config.circuitBreakerResetTimeout - (now - breaker.lastFailureTime)) / 1e3)}s`
         );
       }
       break;
     case "HALF_OPEN" /* HALF_OPEN */:
-      secureLogger.debug(`[${config2.serviceName}] Testing recovery (HALF_OPEN)`);
+      secureLogger.debug(`[${config.serviceName}] Testing recovery (HALF_OPEN)`);
       break;
     case "CLOSED" /* CLOSED */:
       break;
@@ -47664,15 +47663,15 @@ function recordSuccess(breaker) {
   breaker.state = "CLOSED" /* CLOSED */;
   breaker.failures = 0;
 }
-function recordFailure(breaker, config2) {
+function recordFailure(breaker, config) {
   breaker.failures++;
   breaker.lastFailureTime = Date.now();
   if (breaker.state === "HALF_OPEN" /* HALF_OPEN */) {
     breaker.state = "OPEN" /* OPEN */;
-    secureLogger.warn(`[${config2.serviceName}] Recovery failed, circuit OPEN`);
-  } else if (breaker.failures >= config2.circuitBreakerThreshold) {
+    secureLogger.warn(`[${config.serviceName}] Recovery failed, circuit OPEN`);
+  } else if (breaker.failures >= config.circuitBreakerThreshold) {
     breaker.state = "OPEN" /* OPEN */;
-    secureLogger.warn(`[${config2.serviceName}] Circuit OPEN after ${breaker.failures} failures`);
+    secureLogger.warn(`[${config.serviceName}] Circuit OPEN after ${breaker.failures} failures`);
   }
 }
 function extractServiceName(url) {
@@ -48917,243 +48916,6 @@ async function trackOAuthFirstMaterialReceipt(params) {
   ]);
 }
 
-// src/wrapper/cache.ts
-import crypto from "crypto";
-
-// src/utils/redis.ts
-import Redis from "ioredis";
-var client = null;
-var available = false;
-function logRedisInfo(message) {
-  process.stderr.write(`${(/* @__PURE__ */ new Date()).toISOString()} [INFO]: ${message}
-`);
-}
-function getRedisClient() {
-  return client;
-}
-function isRedisAvailable() {
-  return available;
-}
-async function waitForRedisAvailability(timeoutMs = 1e4) {
-  if (!client) return false;
-  if (available) return true;
-  const boundedTimeoutMs = Math.max(1, Math.min(timeoutMs, 3e4));
-  const current = client;
-  return new Promise((resolve) => {
-    let settled = false;
-    const finish = (ready) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      current.off("ready", onReady);
-      current.off("end", onEnd);
-      resolve(ready);
-    };
-    const onReady = () => finish(true);
-    const onEnd = () => finish(false);
-    const timer = setTimeout(() => finish(available), boundedTimeoutMs);
-    current.once("ready", onReady);
-    current.once("end", onEnd);
-    if (available) finish(true);
-  });
-}
-async function closeRedisClient() {
-  if (!client) return;
-  const current = client;
-  client = null;
-  available = false;
-  try {
-    await Promise.race([
-      current.quit(),
-      new Promise(
-        (_, reject) => setTimeout(() => reject(new Error("Redis quit timed out")), 5e3)
-      )
-    ]);
-    logRedisInfo("[redis] Connection closed gracefully");
-  } catch (err) {
-    secureLogger.error(
-      "[redis] Error closing connection, forcing disconnect",
-      err,
-      {}
-    );
-    current.disconnect();
-  }
-}
-var DEGRADED_AFTER_ATTEMPTS = 3;
-var MAX_RECONNECT_DELAY_MS = 3e3;
-function redisRetryStrategy(times) {
-  if (times === DEGRADED_AFTER_ATTEMPTS) {
-    secureLogger.warn(
-      `[redis] Connection failed after ${DEGRADED_AFTER_ATTEMPTS} retries, falling back to in-memory while reconnection continues`,
-      {}
-    );
-    available = false;
-  }
-  return Math.min(times * 100, MAX_RECONNECT_DELAY_MS);
-}
-function redisClientOptions() {
-  return {
-    maxRetriesPerRequest: 3,
-    retryStrategy: redisRetryStrategy,
-    lazyConnect: true
-  };
-}
-var redisUrl = getEnvVar("REDIS_URL");
-function isRedisConfigured() {
-  return Boolean(redisUrl);
-}
-if (redisUrl) {
-  try {
-    client = new Redis(redisUrl, redisClientOptions());
-    client.connect().then(() => {
-      available = true;
-      logRedisInfo("[redis] Connected successfully");
-    }).catch((err) => {
-      secureLogger.warn("[redis] Connection failed", {
-        error: err.message
-      });
-      available = false;
-    });
-    client.on("error", (err) => {
-      secureLogger.warn("[redis] Error", { error: err.message });
-      available = false;
-    });
-    client.on("ready", () => {
-      available = true;
-    });
-    const gracefulShutdown = async (signal) => {
-      logRedisInfo(`[redis] Received ${signal}, closing connection...`);
-      await closeRedisClient();
-    };
-    process.on("SIGINT", () => gracefulShutdown("SIGINT"));
-    process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
-  } catch (err) {
-    secureLogger.warn("[redis] Failed to initialise", {
-      error: String(err)
-    });
-    client = null;
-  }
-} else {
-  logRedisInfo("[redis] No REDIS_URL provided, using in-memory fallbacks");
-}
-
-// src/wrapper/cache.ts
-var PREFIX = "mcp-cache:";
-var CACHE_ENVELOPE_VERSION = 1;
-var TTL_MARKET_S = 30;
-var TTL_METADATA_S = 5 * 60;
-var TTL_STATIC_S = 60 * 60;
-var BUCKETS = [
-  {
-    // Static reference data — list of chains, supported currencies, asset
-    // platforms. Changes on the order of weeks/months.
-    patterns: [
-      /_get_(asset_platforms|networks|supported_currencies|categories_list|coins_list|new_coins_list|exchanges_list|exchange_rates)\b/,
-      /\bdefillama_get_chains\b/
-    ],
-    ttlS: TTL_STATIC_S
-  },
-  {
-    // Live market data — prices, volume, OHLC, market caps. Refreshes on
-    // 30s-1m boundaries upstream.
-    patterns: [
-      /_get_(price|prices|coins_market_data_browser|coins_markets|simple_price|token_price|historical_token_prices|ohlc|funding_rate|open_interest|ticker|tickers)\b/,
-      /\bmarket_data\b/,
-      /\bvolume\b/,
-      /\bderivatives\b/
-    ],
-    ttlS: TTL_MARKET_S
-  },
-  {
-    // Token / coin metadata — descriptions, contract addresses, holder
-    // breakdowns, top-N rankings. Refreshes slowly.
-    patterns: [
-      /_get_(coin_by_id|token_holders|top_holders|onchain_token_top_holders|token_data|protocol_tvl|protocols|categories|trending|nft_collection)\b/
-    ],
-    ttlS: TTL_METADATA_S
-  }
-];
-function ttlForTool(toolName) {
-  for (const b of BUCKETS) {
-    if (b.patterns.some((rx) => rx.test(toolName))) return b.ttlS;
-  }
-  return 0;
-}
-function hashArgs(args) {
-  return crypto.createHash("sha256").update(stableStringify(args)).digest("hex").slice(0, 32);
-}
-function stableStringify(value) {
-  if (value === null || typeof value !== "object") {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map(stableStringify).join(",")}]`;
-  }
-  const obj = value;
-  const keys = Object.keys(obj).sort();
-  return `{${keys.map((k) => `${JSON.stringify(k)}:${stableStringify(obj[k])}`).join(",")}}`;
-}
-function cacheKey(toolName, args) {
-  return `${PREFIX}${toolName}:${hashArgs(args)}`;
-}
-async function getCached(toolName, args) {
-  const redis = getRedisClient();
-  if (!redis || !isRedisAvailable()) return null;
-  if (ttlForTool(toolName) === 0) return null;
-  try {
-    const raw = await redis.get(cacheKey(toolName, args));
-    if (!raw) return null;
-    try {
-      const parsed = JSON.parse(raw);
-      if (parsed._hive_cache_version === CACHE_ENVELOPE_VERSION && typeof parsed.observed_at === "string" && typeof parsed.payload === "string") {
-        const observedMs = Date.parse(parsed.observed_at);
-        return {
-          payload: parsed.payload,
-          observedAt: parsed.observed_at,
-          ageMs: Number.isFinite(observedMs) ? Math.max(0, Date.now() - observedMs) : null,
-          originSource: parsed.origin_source === "live" || parsed.origin_source === "fallback" ? parsed.origin_source : null
-        };
-      }
-    } catch {
-    }
-    return {
-      payload: raw,
-      observedAt: null,
-      ageMs: null,
-      originSource: null
-    };
-  } catch (err) {
-    secureLogger.warn("[mcp-cache] get failed", {
-      error: err instanceof Error ? err.message : String(err)
-    });
-    return null;
-  }
-}
-async function setCached(toolName, args, payload, originSource = "live") {
-  const redis = getRedisClient();
-  if (!redis || !isRedisAvailable()) return;
-  const ttlS = ttlForTool(toolName);
-  if (ttlS === 0) return;
-  try {
-    const envelope = {
-      _hive_cache_version: CACHE_ENVELOPE_VERSION,
-      observed_at: (/* @__PURE__ */ new Date()).toISOString(),
-      origin_source: originSource,
-      payload
-    };
-    await redis.set(
-      cacheKey(toolName, args),
-      JSON.stringify(envelope),
-      "EX",
-      ttlS
-    );
-  } catch (err) {
-    secureLogger.warn("[mcp-cache] set failed", {
-      error: err instanceof Error ? err.message : String(err)
-    });
-  }
-}
-
 // src/providers/catalog.ts
 var UNKNOWN_PROVIDER_DESCRIPTOR = {
   id: "unknown",
@@ -50412,31 +50174,6 @@ function createSafeHandler(handler100, metadata103, toolName, inputSchema) {
       }
       const { response_format: responseFormat, ...safeArgs } = args ?? {};
       const wantsMarkdown = responseFormat === "markdown";
-      const cacheableTtlS = ttlForTool(toolName);
-      if (cacheableTtlS > 0 && !wantsMarkdown) {
-        const cached = await getCached(toolName, safeArgs);
-        if (cached) {
-          trackToolCall({
-            toolName,
-            success: true,
-            durationMs: Date.now() - t0,
-            category: "cache_hit"
-          });
-          return withContentAnnotations(
-            withExecMarker(
-              { content: [{ type: "text", text: cached.payload }] },
-              {
-                source: "cached",
-                originSource: cached.originSource,
-                cacheStatus: "hit",
-                observedAt: cached.observedAt,
-                cacheAgeMs: cached.ageMs
-              }
-            ),
-            false
-          );
-        }
-      }
       let result2 = await handler100(effectiveClient, safeArgs);
       const observedAt = (/* @__PURE__ */ new Date()).toISOString();
       if (result2._hiveExec?.source === "fallback") usedFallback = true;
@@ -50562,23 +50299,14 @@ function createSafeHandler(handler100, metadata103, toolName, inputSchema) {
           true
         );
       }
-      if (cacheableTtlS > 0 && !wantsMarkdown) {
-        setCached(
-          toolName,
-          safeArgs,
-          text,
-          usedFallback ? "fallback" : "live"
-        ).catch(() => {
-        });
-      }
       trackToolCall({
         toolName,
         success: !result2.isError,
         durationMs: Date.now() - t0,
-        category: cacheableTtlS > 0 ? "live_cacheable" : "live_uncached"
+        category: "live_uncached"
       });
       const successMarker = {
-        cacheStatus: cacheableTtlS > 0 && !wantsMarkdown ? "miss" : "bypass",
+        cacheStatus: "bypass",
         observedAt,
         cacheAgeMs: 0,
         originSource: usedFallback ? "fallback" : "live",
@@ -51922,290 +51650,6 @@ function buildToolCatalogEntry(endpoint) {
   };
 }
 
-// src/config/toolNameMappings.ts
-var TOOL_NAME_MAPPINGS = {
-  // ============================================
-  // Category 1: Market Data and Price (43 tools)
-  // ============================================
-  // CoinGecko endpoints
-  coins_index: "get_coins_index",
-  coins_market_data_browser: "get_coins_market_data",
-  coins_history_browser: "get_coin_history",
-  range_coins_market_chart_browser: "get_coin_market_chart_range",
-  range_coins_ohlc_browser: "get_coin_ohlc_range",
-  simple_price_browser: "get_price",
-  gainers_losers_browser: "get_gainers_losers",
-  contract_coins_browser: "get_contract_coin",
-  range_contract_coins_market_chart_browser: "get_contract_market_chart_range",
-  id_simple_token_price_browser: "get_token_price_by_contract",
-  global_browser: "get_global_stats",
-  simple_supported_vs_currencies_browser: "get_supported_currencies",
-  // Codex endpoints
-  retrieve_token_pricing: "codex_get_token_price",
-  fetch_price_chart_data: "get_token_chart_data",
-  fetch_token_mini_charts: "get_token_sparklines",
-  fetch_token_chart_urls: "get_token_chart_urls",
-  // CoinGecko additional
-  coin_tickers_data: "get_coin_tickers",
-  coin_historical_chart: "get_coin_historical_chart",
-  btc_exchange_rates: "get_btc_exchange_rates",
-  global_market_cap_chart: "get_global_market_cap_chart",
-  companies_crypto_treasury: "get_companies_treasury",
-  // Stablecoins (DeFiLlama)
-  stablecoins_list: "get_stablecoins",
-  stablecoin_chains_list: "get_stablecoin_chains",
-  stablecoin_charts_global: "get_stablecoin_charts_global",
-  stablecoin_charts_by_chain: "get_stablecoin_charts_by_chain",
-  stablecoin_prices_current: "get_stablecoin_prices",
-  // CCXT
-  trading_pair_ticker_data: "get_ticker",
-  multiple_tickers_data: "get_tickers",
-  trading_pair_orderbook_data: "get_orderbook",
-  trading_pair_recent_trades: "get_recent_trades",
-  trading_pair_candlestick_data: "get_ohlcv",
-  multiple_pairs_best_prices: "get_best_bid_ask",
-  level2_orderbook_data: "get_l2_orderbook",
-  derivatives_index_candlestick: "get_index_ohlcv",
-  derivatives_mark_candlestick: "get_mark_ohlcv",
-  perpetual_premium_index_data: "get_premium_index_ohlcv",
-  perpetual_funding_rate_current: "get_funding_rate",
-  perpetual_funding_rate_history: "get_funding_rate_history",
-  perpetual_funding_rates_all: "get_funding_rates",
-  // ============================================
-  // Category 2: On-Chain DEX & Pool Analytics (50 tools)
-  // ============================================
-  // GeckoTerminal (CoinGecko OnChain)
-  onchain_categories_browser: "get_onchain_categories",
-  pools_onchain_categories_browser: "get_pools_by_category",
-  networks_onchain_new_pools_browser: "get_new_pools",
-  network_networks_onchain_new_pools_browser: "get_new_pools_by_network",
-  networks_onchain_trending_pools_browser: "get_trending_pools",
-  network_networks_onchain_trending_pools_browser: "get_trending_pools_by_network",
-  networks_onchain_dexes_browser: "get_dexes",
-  pools_networks_onchain_dexes_browser: "get_pools_by_dex",
-  networks_onchain_pools_browser: "get_pools",
-  address_networks_onchain_pools_browser: "get_pools_by_address",
-  pools_networks_onchain_info_browser: "get_pool_info",
-  timeframe_pools_networks_onchain_ohlcv_browser: "get_pool_ohlcv",
-  pools_networks_onchain_trades_browser: "get_pool_trades",
-  timeframe_tokens_networks_onchain_ohlcv_browser: "get_token_ohlcv",
-  tokens_networks_onchain_pools_browser: "get_token_pools",
-  tokens_networks_onchain_trades_browser: "get_token_trades",
-  pools_onchain_megafilter_browser: "filter_pools",
-  pools_onchain_trending_search_browser: "search_trending_pools",
-  search_onchain_pools_browser: "search_pools",
-  addresses_networks_simple_onchain_token_price_browser: "get_onchain_token_price",
-  // Codex
-  retrieve_token_transactions: "get_token_transactions",
-  fetch_trading_pair_metrics: "get_pair_stats",
-  fetch_multiple_pairs_metrics: "get_pairs_stats",
-  search_filter_pairs: "filter_pairs",
-  fetch_pair_information: "get_pair_info",
-  list_token_pairs: "get_token_pairs",
-  fetch_token_pairs_details: "get_token_pairs_metadata",
-  retrieve_liquidity_information: "get_liquidity_info",
-  fetch_liquidity_lock_details: "get_liquidity_locks",
-  search_exchange_platforms: "filter_exchanges",
-  describe_onchain_transaction: "explain_transaction",
-  // CoinGecko Exchanges
-  exchanges_data: "get_exchanges",
-  exchange_details: "get_exchange",
-  exchange_tickers_data: "get_exchange_tickers",
-  exchange_volume_chart: "get_exchange_volume_chart",
-  exchange_volume_chart_range: "get_exchange_volume_chart_range",
-  derivatives_tickers_data: "get_derivatives_tickers",
-  derivatives_exchanges_data: "get_derivatives_exchanges",
-  derivative_exchange_details: "get_derivatives_exchange",
-  // Additional
-  network_trending_pools: "get_network_trending_pools",
-  multi_pools_data: "get_multi_pools",
-  network_exchanges_list: "get_network_dexes",
-  pair_chart_metadata: "get_pair_chart_metadata",
-  token_liquidity_metadata: "get_token_liquidity_metadata",
-  // DeFiLlama DEX
-  dex_volumes_overview: "get_dex_volumes",
-  dex_volume_specific: "get_dex_volume",
-  dex_volumes_chain_specific: "get_dex_volumes_by_chain",
-  options_trading_overview: "get_options_overview",
-  options_trading_by_chain: "get_options_by_chain",
-  options_protocol_summary: "get_options_protocol",
-  // ============================================
-  // Category 3: Portfolio & Wallet (14 tools)
-  // ============================================
-  // Codex
-  fetch_wallet_balances: "get_wallet_balances",
-  fetch_wallet_token_activity: "get_wallet_token_events",
-  wallets_search_filter: "filter_wallets",
-  token_wallets_filter: "filter_token_wallets",
-  wallet_detailed_stats: "get_wallet_stats",
-  wallet_chart_data: "get_wallet_chart",
-  // ============================================
-  // Category 4: Token & Contract Data (15 tools)
-  // ============================================
-  // GeckoTerminal
-  address_networks_onchain_tokens_browser: "get_tokens_by_address",
-  tokens_networks_onchain_info_browser: "get_token_info",
-  tokens_networks_onchain_top_holders_browser: "get_token_top_holders",
-  tokens_networks_onchain_holders_chart_browser: "get_token_holders_chart",
-  // Codex
-  retrieve_token_details: "get_token_details",
-  fetch_multiple_tokens: "get_tokens",
-  search_tokens_by_criteria: "filter_tokens",
-  list_token_holders: "get_token_holders",
-  calculate_top_holders_percentage: "get_top_holders_percentage",
-  list_newest_token_contracts: "get_new_tokens",
-  multi_tokens_data: "get_multi_tokens",
-  tokens_recent_updates: "get_recently_updated_tokens",
-  token_top_traders_stats: "get_token_top_traders",
-  fetch_coin_metadata: "get_coin_metadata",
-  // ============================================
-  // Category 5: DeFi Protocol Analytics
-  // ============================================
-  // CoinGecko
-  global_defi_data: "get_global_defi",
-  // DeFiLlama
-  defi_protocols_list: "get_defi_protocols",
-  defi_protocol_details: "get_defi_protocol",
-  protocol_tvl_current: "get_protocol_tvl",
-  protocol_fees_data: "get_protocol_fees",
-  blockchain_chains_list: "get_chains",
-  chain_tvl_history: "get_chain_tvl_history",
-  chains_tvl_historical_all: "get_chains_tvl_history",
-  yield_pools_list: "get_yield_pools",
-  yield_pool_details: "get_yield_pool_chart",
-  yield_pool_chart_history: "get_yield_pool_chart",
-  protocol_fees_overview: "get_fees_overview",
-  chain_fees_overview: "get_chain_fees",
-  // ============================================
-  // Category 6: NFT Analytics (30 tools)
-  // ============================================
-  // CoinGecko NFTs
-  id_nfts_browser: "get_nft",
-  list_nfts_browser: "get_nfts",
-  nfts_market_chart_browser: "get_nft_market_chart",
-  // ============================================
-  // Category 7: Security & Risk Analysis (8 tools)
-  // ============================================
-  // GoPlus (mostly compliant)
-  get_token_security: "get_token_security",
-  // Already compliant
-  get_nft_security: "get_nft_security",
-  // Already compliant
-  check_malicious_address: "check_malicious_address",
-  // Already compliant
-  check_approval_security: "check_approval_security",
-  // Already compliant
-  get_user_approvals: "get_wallet_approvals",
-  check_dapp_security: "check_dapp_security",
-  // Already compliant
-  detect_phishing_site: "check_phishing_site",
-  decode_abi_data: "decode_abi",
-  // ============================================
-  // Category 8: Network & Infrastructure (12 tools)
-  // ============================================
-  // GeckoTerminal
-  onchain_networks_browser: "get_networks",
-  // Codex
-  list_blockchain_networks: "get_networks_list",
-  check_network_health: "get_network_status",
-  fetch_network_metrics: "get_network_stats",
-  // CoinGecko
-  asset_platforms_browser: "get_asset_platforms",
-  // Codex
-  community_notes_data: "get_community_notes",
-  monitor_system_updates: "get_system_changes",
-  // CCXT
-  exchange_system_status: "get_exchange_status",
-  exchange_server_time: "get_exchange_time",
-  exchange_markets_browser: "get_exchange_markets",
-  exchange_currencies_browser: "get_exchange_currencies",
-  // ============================================
-  // Category 9: Search & Discovery (9 tools)
-  // ============================================
-  // CoinGecko
-  search_browser: "search_all",
-  search_trending_browser: "get_trending",
-  coins_categories_browser: "get_categories",
-  coins_list_browser: "get_coins_list",
-  new_coins_list_browser: "get_new_coins",
-  coins_categories_market_data: "get_categories_market_data",
-  exchanges_list_simple: "get_exchanges_list",
-  derivatives_exchanges_list: "get_derivatives_exchanges_list",
-  // Codex
-  event_labels_list: "get_event_labels"
-};
-var REVERSE_TOOL_NAME_MAPPINGS = Object.entries(TOOL_NAME_MAPPINGS).reduce(
-  (acc, [legacy, standard]) => {
-    acc[standard] = legacy;
-    return acc;
-  },
-  {}
-);
-var COMPLIANT_TOOLS = [
-  "get_token_security",
-  "get_nft_security",
-  "check_malicious_address",
-  "check_approval_security",
-  "check_dapp_security"
-];
-function getStandardName(legacyName) {
-  return TOOL_NAME_MAPPINGS[legacyName] || legacyName;
-}
-function isLegacyName(name) {
-  return name in TOOL_NAME_MAPPINGS && TOOL_NAME_MAPPINGS[name] !== name;
-}
-
-// src/config/toolAliasSystem.ts
-var defaultConfig = {
-  enableWarnings: true,
-  enableTracking: true,
-  strictMode: false
-};
-var config = { ...defaultConfig };
-var usageStats = {
-  legacyUsage: {},
-  standardUsage: {},
-  lastUpdated: /* @__PURE__ */ new Date()
-};
-function logDeprecationWarning(legacyName, standardName) {
-  if (!config.enableWarnings) return;
-  const message = `[DEPRECATED] Tool "${legacyName}" is deprecated. Use "${standardName}" instead.`;
-  if (config.warningHandler) {
-    config.warningHandler(message, legacyName, standardName);
-  } else {
-    console.warn(`\x1B[33m${message}\x1B[0m`);
-  }
-}
-function trackUsage(toolName, isLegacy) {
-  if (!config.enableTracking) return;
-  usageStats.lastUpdated = /* @__PURE__ */ new Date();
-  if (isLegacy) {
-    usageStats.legacyUsage[toolName] = (usageStats.legacyUsage[toolName] || 0) + 1;
-  } else {
-    usageStats.standardUsage[toolName] = (usageStats.standardUsage[toolName] || 0) + 1;
-  }
-}
-function resolveToolName(requestedName) {
-  if (isLegacyName(requestedName)) {
-    const standardName = getStandardName(requestedName);
-    logDeprecationWarning(requestedName, standardName);
-    trackUsage(requestedName, true);
-    return standardName;
-  }
-  if (requestedName in REVERSE_TOOL_NAME_MAPPINGS) {
-    trackUsage(requestedName, false);
-    return requestedName;
-  }
-  if (COMPLIANT_TOOLS.includes(requestedName)) {
-    trackUsage(requestedName, false);
-    return requestedName;
-  }
-  if (config.strictMode) {
-    throw new Error(`Unknown tool: "${requestedName}"`);
-  }
-  return requestedName;
-}
-
 // src/utils/errorCodes.ts
 var ERROR_DOC_BASE = "https://www.hiveintelligence.xyz/errors";
 function entry(code, transports, meaning, nextAction, retryable = false) {
@@ -53018,7 +52462,7 @@ function isRecord2(value) {
 }
 function resolveEndpoint(endpoints, toolName) {
   const requestedToolName = toolName ?? "";
-  const resolvedToolName = requestedToolName ? resolveToolName(requestedToolName) : "";
+  const resolvedToolName = requestedToolName;
   const endpoint = endpoints.find(
     (item) => item.tool.name === resolvedToolName
   );
@@ -53035,7 +52479,7 @@ function normalizeInvokeArgs(args) {
       message: "No endpoint provided. Pass 'endpoint_name' (or 'endpoint') and optionally 'args'."
     };
   }
-  const resolvedToolName = resolveToolName(requestedToolName);
+  const resolvedToolName = requestedToolName;
   let nestedArgs = args?.args;
   if (typeof nestedArgs === "string") {
     try {
@@ -53151,9 +52595,9 @@ function createHiveExecutionMetadata(endpoint, durationMs, runtimeStatus, source
     observed_at: observedAt,
     cache_age_ms: cacheAgeMs,
     duration_ms: durationMs,
-    // Markers from createSafeHandler (cache hit, fallback client, truncation)
-    // take precedence over the caller-supplied defaults so the agent sees
-    // whether data is live, cached, or fallback-tier.
+    // Markers from createSafeHandler (fallback client, truncation) take
+    // precedence over the caller-supplied defaults so the agent sees whether
+    // data is live or fallback-tier.
     cache_status: exec?.cacheStatus ?? "unknown",
     source: effectiveSource,
     origin_source: originSource,
@@ -54426,7 +53870,7 @@ function heroTools(endpoints, options = {}) {
       'Chain name, for example "eth", "base", "arbitrum", or "solana". Defaults to eth for 0x addresses; Solana is auto-detected.'
     ),
     include_spam: z.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."
+      "Show likely spam airdrops (tokens with a URL or claim lure in the name, and on EVM chains tokens with no market price or not listed on CoinGecko). Default false; the response says how many were hidden."
     ),
     response_format: RESPONSE_FORMAT
   });
@@ -54512,15 +53956,21 @@ function heroTools(endpoints, options = {}) {
         address: tokenAddress,
         balance,
         usd_value: token.totalValueUsd ?? token.valueUsd ?? token.usd_value ?? (typeof token.totalValueUsdCents === "number" ? token.totalValueUsdCents / 100 : usdFromPrices(token, balance)),
-        ...token.h24_change_pct != null ? { h24_change_pct: token.h24_change_pct } : {}
+        ...token.h24_change_pct != null ? { h24_change_pct: token.h24_change_pct } : {},
+        ...token.coingecko_listed === false ? { coingecko_listed: false } : {}
       };
     });
     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 isSpam = (token) => isRecord3(token) && token.address != null && (SPAM_LURE.test(`${token.name ?? ""} ${token.symbol ?? ""}`) || priced && token.usd_value == null || token.coingecko_listed === false);
     const held = includeSpam ? nonZero : nonZero.filter((t) => !isSpam(t));
     const hidden = nonZero.length - held.length;
+    const total = payload.total_value_usd;
+    const hiddenUsd = nonZero.filter((t) => !held.includes(t)).reduce(
+      (sum, t) => sum + (isRecord3(t) && typeof t.usd_value === "number" ? t.usd_value : 0),
+      0
+    );
     return {
       address,
       chain: chainLabel,
@@ -54528,7 +53978,7 @@ function heroTools(endpoints, options = {}) {
       ...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",
+          reason: priced ? "no market price, not listed on CoinGecko, 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."
         }
       } : {},
@@ -54537,7 +53987,8 @@ function heroTools(endpoints, options = {}) {
         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 > nonZero.length ? {
         note: `${summarized.length - nonZero.length} zero-balance tokens omitted. Use response_format=detailed for the full provider payload.`
-      } : {}
+      } : {},
+      ...typeof total === "number" ? { total_value_usd: Math.round((total - hiddenUsd) * 100) / 100 } : {}
     };
   };
   const coingeckoBalances = (payload) => {
@@ -54553,7 +54004,9 @@ function heroTools(endpoints, options = {}) {
         balance: row.balance ?? null,
         decimals: 0,
         usd_value: toNumber(row.value_usd),
-        h24_change_pct: toNumber(row.h24_price_change_percentage)
+        h24_change_pct: toNumber(row.h24_price_change_percentage),
+        // Only an explicit null means unlisted; a missing field fails open.
+        coingecko_listed: row.coingecko_coin_id !== null
       }))
     };
   };
@@ -54606,13 +54059,13 @@ function heroTools(endpoints, options = {}) {
           per_page: 100
         }, "get_wallet_portfolio");
         if (!network || "hive" in result3 && result3.ok) {
-          return respond(result3, format, (payload) => {
-            const balances = coingeckoBalances(payload);
-            return {
-              ...trimWalletPortfolio(address, normalized, includeSpam, true)(balances),
-              total_value_usd: balances.total_value_usd
-            };
-          });
+          return respond(
+            result3,
+            format,
+            (payload) => trimWalletPortfolio(address, normalized, includeSpam, true)(
+              coingeckoBalances(payload)
+            )
+          );
         }
         fallbackNote = "CoinGecko wallet balances failed for this call; served from Alchemy.";
       }
@@ -57301,6 +56754,123 @@ async function executeEndpointWithRouteFallback(endpoints, endpoint, args, conte
 // src/health/scheduledCanaries.ts
 import { randomUUID as randomUUID5 } from "crypto";
 
+// src/utils/redis.ts
+import Redis from "ioredis";
+var client = null;
+var available = false;
+function logRedisInfo(message) {
+  process.stderr.write(`${(/* @__PURE__ */ new Date()).toISOString()} [INFO]: ${message}
+`);
+}
+function getRedisClient() {
+  return client;
+}
+function isRedisAvailable() {
+  return available;
+}
+async function waitForRedisAvailability(timeoutMs = 1e4) {
+  if (!client) return false;
+  if (available) return true;
+  const boundedTimeoutMs = Math.max(1, Math.min(timeoutMs, 3e4));
+  const current = client;
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (ready) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      current.off("ready", onReady);
+      current.off("end", onEnd);
+      resolve(ready);
+    };
+    const onReady = () => finish(true);
+    const onEnd = () => finish(false);
+    const timer = setTimeout(() => finish(available), boundedTimeoutMs);
+    current.once("ready", onReady);
+    current.once("end", onEnd);
+    if (available) finish(true);
+  });
+}
+async function closeRedisClient() {
+  if (!client) return;
+  const current = client;
+  client = null;
+  available = false;
+  try {
+    await Promise.race([
+      current.quit(),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("Redis quit timed out")), 5e3)
+      )
+    ]);
+    logRedisInfo("[redis] Connection closed gracefully");
+  } catch (err) {
+    secureLogger.error(
+      "[redis] Error closing connection, forcing disconnect",
+      err,
+      {}
+    );
+    current.disconnect();
+  }
+}
+var DEGRADED_AFTER_ATTEMPTS = 3;
+var MAX_RECONNECT_DELAY_MS = 3e3;
+function redisRetryStrategy(times) {
+  if (times === DEGRADED_AFTER_ATTEMPTS) {
+    secureLogger.warn(
+      `[redis] Connection failed after ${DEGRADED_AFTER_ATTEMPTS} retries, falling back to in-memory while reconnection continues`,
+      {}
+    );
+    available = false;
+  }
+  return Math.min(times * 100, MAX_RECONNECT_DELAY_MS);
+}
+function redisClientOptions() {
+  return {
+    maxRetriesPerRequest: 3,
+    retryStrategy: redisRetryStrategy,
+    lazyConnect: true
+  };
+}
+var redisUrl = getEnvVar("REDIS_URL");
+function isRedisConfigured() {
+  return Boolean(redisUrl);
+}
+if (redisUrl) {
+  try {
+    client = new Redis(redisUrl, redisClientOptions());
+    client.connect().then(() => {
+      available = true;
+      logRedisInfo("[redis] Connected successfully");
+    }).catch((err) => {
+      secureLogger.warn("[redis] Connection failed", {
+        error: err.message
+      });
+      available = false;
+    });
+    client.on("error", (err) => {
+      secureLogger.warn("[redis] Error", { error: err.message });
+      available = false;
+    });
+    client.on("ready", () => {
+      available = true;
+    });
+    const gracefulShutdown = async (signal) => {
+      logRedisInfo(`[redis] Received ${signal}, closing connection...`);
+      await closeRedisClient();
+    };
+    process.on("SIGINT", () => gracefulShutdown("SIGINT"));
+    process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
+  } catch (err) {
+    secureLogger.warn("[redis] Failed to initialise", {
+      error: String(err)
+    });
+    client = null;
+  }
+} else {
+  logRedisInfo("[redis] No REDIS_URL provided, using in-memory fallbacks");
+}
+
 // src/health/canaryHistory.ts
 var HEALTH_EVIDENCE_STATUSES = [
   "unknown",
@@ -58987,16 +58557,16 @@ function sameScopes(left, right) {
   return left.length === right.length && right.every((scope) => left.includes(scope));
 }
 var HiveOAuthProvider = class {
-  constructor(config2, storage2, options = {}) {
-    this.config = config2;
+  constructor(config, storage2, options = {}) {
+    this.config = config;
     this.storage = storage2;
-    if (!config2.configured || !config2.issuerUrl || !config2.resourceUrl || !config2.consentUrl) {
+    if (!config.configured || !config.issuerUrl || !config.resourceUrl || !config.consentUrl) {
       throw new Error("Cannot construct OAuth provider from incomplete configuration.");
     }
     this.clientsStore = new HiveOAuthClientsStore({
       storage: storage2,
-      dcrClientTtlSeconds: config2.dcrClientTtlSeconds,
-      cimdAllowedHosts: config2.cimdAllowedHosts,
+      dcrClientTtlSeconds: config.dcrClientTtlSeconds,
+      cimdAllowedHosts: config.cimdAllowedHosts,
       fetcher: options.fetcher
     });
   }
@@ -59745,11 +59315,11 @@ function elapsed(started) {
 function check(name, status, started, detail) {
   return { name, status, duration: elapsed(started), detail };
 }
-function healthResult(started, status, config2, persistentStorage, checks) {
+function healthResult(started, status, config, persistentStorage, checks) {
   return {
     status,
-    enabled: config2.enabled,
-    configured: config2.configured,
+    enabled: config.enabled,
+    configured: config.configured,
     persistentStorage,
     checks,
     passed: checks.filter((entry2) => entry2.status === "passed").length,
@@ -60101,6 +59671,7 @@ function parsePositiveInteger(value, fallback) {
 function sleep4(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+var GOPLUS_CALL_BUDGET_MS = 45e3;
 function chainIdPathSegment(value) {
   return assertDecimalPathSegment(value, "chainId");
 }
@@ -60247,6 +59818,27 @@ var GoPlusClient = class {
    * @internal
    */
   async request(endpoint, params, method = "GET") {
+    let timer;
+    const budget = new Promise((_, reject) => {
+      timer = setTimeout(
+        () => reject(
+          new Error(
+            `GoPlus ${endpoint} timed out after ${GOPLUS_CALL_BUDGET_MS / 1e3}s; nothing was returned.`
+          )
+        ),
+        GOPLUS_CALL_BUDGET_MS
+      );
+    });
+    try {
+      return await Promise.race([
+        this.send(endpoint, params, method),
+        budget
+      ]);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async send(endpoint, params, method) {
     const startTime = Date.now();
     try {
       let url = endpoint;
@@ -60851,9 +60443,9 @@ var CCXTClient = class {
       throw new Error("Exchange ID is required");
     }
     const ccxt = await loadCcxt();
-    const cacheKey2 = `${exchangeId}`;
-    if (this.exchanges.has(cacheKey2)) {
-      return this.exchanges.get(cacheKey2);
+    const cacheKey = `${exchangeId}`;
+    if (this.exchanges.has(cacheKey)) {
+      return this.exchanges.get(cacheKey);
     }
     if (REMOVED_CCXT_EXCHANGES.has(exchangeId.toLowerCase())) {
       throw new Error(removedVenueMessage(exchangeId));
@@ -60869,7 +60461,7 @@ var CCXTClient = class {
       // Prevent API rate limit violations
       ...options
     });
-    this.exchanges.set(cacheKey2, exchange);
+    this.exchanges.set(cacheKey, exchange);
     secureLogger.debug("Exchange initialized", {
       exchangeId,
       hasRateLimit: true
@@ -63053,14 +62645,14 @@ function firstString(value, keys) {
   }
   return void 0;
 }
-function getCachedDynamicArgs(cacheKey2, resolver) {
-  const cached = dynamicProbeArgCache.get(cacheKey2);
+function getCachedDynamicArgs(cacheKey, resolver) {
+  const cached = dynamicProbeArgCache.get(cacheKey);
   if (cached) return cached;
   const promise = resolver().catch((err) => {
-    dynamicProbeArgCache.delete(cacheKey2);
+    dynamicProbeArgCache.delete(cacheKey);
     throw err;
   });
-  dynamicProbeArgCache.set(cacheKey2, promise);
+  dynamicProbeArgCache.set(cacheKey, promise);
   return promise;
 }
 var hiveCanarySubjectContextPromise;
@@ -64996,7 +64588,7 @@ var refreshing = null;
 var testOverrides = null;
 async function refreshWithCanary() {
   const now = Date.now();
-  const config2 = buildConfigSnapshot(now);
+  const config = buildConfigSnapshot(now);
   try {
     const history = await getProviderCanaryHistory(1);
     const latest = history.evidence.state === "present" ? history.latest : null;
@@ -65009,20 +64601,20 @@ async function refreshWithCanary() {
         const observed = availabilityFromRuntimeStatus(
           api.runtimeStatus ?? (api.status === "passed" ? "ok" : api.status === "inactive" ? "degraded" : "failing")
         );
-        config2.byProviderName[descriptor.name] = worseOf(
-          config2.byProviderName[descriptor.name] ?? "ok",
+        config.byProviderName[descriptor.name] = worseOf(
+          config.byProviderName[descriptor.name] ?? "ok",
           observed
         );
       }
-      config2.source = "config+canary";
-      config2.canaryObservedAt = latest.observedAt ?? latest.timestamp ?? null;
+      config.source = "config+canary";
+      config.canaryObservedAt = latest.observedAt ?? latest.timestamp ?? null;
     }
   } catch (error) {
     secureLogger.warn("Provider availability canary overlay failed", {
       error: error instanceof Error ? error.message : String(error)
     });
   }
-  cachedSnapshot = config2;
+  cachedSnapshot = config;
 }
 function kickRefresh() {
   if (refreshing) return;
@@ -67867,11 +67459,6 @@ export {
   trackServerEvent,
   trackCliCommand,
   trackOAuthFirstMaterialReceipt,
-  getRedisClient,
-  isRedisAvailable,
-  waitForRedisAvailability,
-  closeRedisClient,
-  isRedisConfigured,
   PROVIDER_CATALOG,
   getProviderRuntimeStatus,
   READ_ENDPOINT_INVOKER,
@@ -67896,6 +67483,11 @@ export {
   HERO_TOOL_NAMES,
   heroTools,
   TASK_TOOLSETS,
+  getRedisClient,
+  isRedisAvailable,
+  waitForRedisAvailability,
+  closeRedisClient,
+  isRedisConfigured,
   OAUTH_SCOPES,
   MCP_BASIC_SCOPES,
   MCP_RESOURCE_SCOPES,