@t2000/engine 0.54.1 → 0.54.2

package/dist/index.js

@@ -537,6 +537,86 @@ var BLOCKVISION_BASE = "https://api.blockvision.org/v2/sui";
 var PORTFOLIO_TIMEOUT_MS = 4e3;
 var PRICES_TIMEOUT_MS = 3e3;
 var CACHE_TTL_MS = 6e4;
+var BV_RETRY_MAX_ATTEMPTS = 3;
+var BV_RETRY_BASE_DELAY_MS = 250;
+var BV_RETRY_BACKOFF_FACTOR = 3;
+var BV_RETRY_JITTER = 0.25;
+var BV_RETRY_AFTER_CAP_MS = 5e3;
+var CB_WINDOW_MS = 5e3;
+var CB_THRESHOLD = 10;
+var CB_COOLDOWN_MS = 3e4;
+var cb429Timestamps = [];
+var cbOpenUntil = 0;
+function cbIsOpen(now) {
+  return now < cbOpenUntil;
+}
+function cbRecord429(now) {
+  cb429Timestamps.push(now);
+  cb429Timestamps = cb429Timestamps.filter((t) => now - t < CB_WINDOW_MS);
+  if (cb429Timestamps.length >= CB_THRESHOLD && !cbIsOpen(now)) {
+    cbOpenUntil = now + CB_COOLDOWN_MS;
+    console.warn(
+      `[blockvision] circuit breaker OPEN \u2014 ${CB_THRESHOLD} 429s in ${CB_WINDOW_MS}ms, retries disabled for ${CB_COOLDOWN_MS / 1e3}s`
+    );
+    cb429Timestamps = [];
+  }
+}
+async function fetchBlockVisionWithRetry(url, init, opts = {}) {
+  const rng = opts.rng ?? Math.random;
+  const sleep2 = opts.sleep ?? ((ms) => new Promise((resolve, reject) => {
+    const timer = setTimeout(resolve, ms);
+    if (opts.signal) {
+      const onAbort = () => {
+        clearTimeout(timer);
+        reject(new DOMException("Aborted", "AbortError"));
+      };
+      if (opts.signal.aborted) onAbort();
+      else opts.signal.addEventListener("abort", onAbort, { once: true });
+    }
+  }));
+  let lastError = null;
+  let lastResponse = null;
+  for (let attempt = 0; attempt < BV_RETRY_MAX_ATTEMPTS; attempt++) {
+    if (attempt > 0) {
+      let waitMs = BV_RETRY_BASE_DELAY_MS * Math.pow(BV_RETRY_BACKOFF_FACTOR, attempt - 1);
+      const retryAfter = lastResponse?.headers.get("retry-after");
+      if (retryAfter) {
+        const secs = Number(retryAfter);
+        if (Number.isFinite(secs) && secs > 0) {
+          waitMs = Math.min(secs * 1e3, BV_RETRY_AFTER_CAP_MS);
+        }
+      }
+      const jitterPx = (rng() * 2 - 1) * BV_RETRY_JITTER * waitMs;
+      const delay = Math.max(0, waitMs + jitterPx);
+      try {
+        await sleep2(delay);
+      } catch (err) {
+        if (lastResponse) return lastResponse;
+        throw err;
+      }
+    }
+    try {
+      lastResponse = await fetch(url, init);
+    } catch (err) {
+      lastError = err;
+      if (err?.name === "AbortError") throw err;
+      continue;
+    }
+    if (lastResponse.ok) return lastResponse;
+    if (lastResponse.status !== 429 && lastResponse.status < 500) {
+      return lastResponse;
+    }
+    if (lastResponse.status === 429) {
+      const now = (opts.now ?? Date.now)();
+      cbRecord429(now);
+      if (cbIsOpen(now)) {
+        return lastResponse;
+      }
+    }
+  }
+  if (lastResponse) return lastResponse;
+  throw lastError ?? new Error("fetch failed after retries");
+}
 var DEGRADED_CACHE_TTL_MS = 15e3;
 var PRICE_LIST_CHUNK = 10;
 var STABLE_USD_PRICES = {
@@ -582,12 +662,17 @@ async function fetchAddressPortfolio(address, apiKey, fallbackRpcUrl) {
 }
 async function fetchPortfolioFromBlockVision(address, apiKey) {
   const url = `${BLOCKVISION_BASE}/account/coins?account=${encodeURIComponent(address)}`;
+  const signal = AbortSignal.timeout(PORTFOLIO_TIMEOUT_MS);
   let res;
   try {
-    res = await fetch(url, {
-      headers: { "x-api-key": apiKey, accept: "application/json" },
-      signal: AbortSignal.timeout(PORTFOLIO_TIMEOUT_MS)
-    });
+    res = await fetchBlockVisionWithRetry(
+      url,
+      {
+        headers: { "x-api-key": apiKey, accept: "application/json" },
+        signal
+      },
+      { signal }
+    );
   } catch (err) {
     console.warn("[blockvision-prices] portfolio fetch threw, degrading:", err);
     return null;
@@ -718,12 +803,17 @@ async function fetchPricesFromBlockVision(coinTypes, apiKey) {
     const chunk = longForms.slice(i, i + PRICE_LIST_CHUNK);
     const tokenIds = encodeURIComponent(chunk.join(","));
     const url = `${BLOCKVISION_BASE}/coin/price/list?tokenIds=${tokenIds}&show24hChange=true`;
+    const signal = AbortSignal.timeout(PRICES_TIMEOUT_MS);
     let res;
     try {
-      res = await fetch(url, {
-        headers: { "x-api-key": apiKey, accept: "application/json" },
-        signal: AbortSignal.timeout(PRICES_TIMEOUT_MS)
-      });
+      res = await fetchBlockVisionWithRetry(
+        url,
+        {
+          headers: { "x-api-key": apiKey, accept: "application/json" },
+          signal
+        },
+        { signal }
+      );
     } catch (err) {
       console.warn("[blockvision-prices] price chunk threw, skipping:", err);
       continue;
@@ -914,12 +1004,17 @@ async function fetchAddressDefiPortfolio(address, apiKey, priceHints = {}) {
 }
 async function fetchOneDefiProtocol(address, protocol, apiKey) {
   const url = `${BLOCKVISION_BASE}/account/defiPortfolio?address=${encodeURIComponent(address)}&protocol=${protocol}`;
+  const signal = AbortSignal.timeout(DEFI_PORTFOLIO_TIMEOUT_MS);
   let res;
   try {
-    res = await fetch(url, {
-      headers: { "x-api-key": apiKey, accept: "application/json" },
-      signal: AbortSignal.timeout(DEFI_PORTFOLIO_TIMEOUT_MS)
-    });
+    res = await fetchBlockVisionWithRetry(
+      url,
+      {
+        headers: { "x-api-key": apiKey, accept: "application/json" },
+        signal
+      },
+      { signal }
+    );
   } catch (err) {
     console.warn(`[defi] ${protocol} fetch threw:`, err);
     return null;
@@ -3329,12 +3424,31 @@ var portfolioAnalysisTool = buildTool({
         `${apiUrl}/api/analytics/portfolio-history?days=7`,
         { headers: { "x-sui-address": address }, signal: context.signal }
       ).then((res) => res.ok ? res.json() : null).catch(() => null) : Promise.resolve(null),
-      // DeFi fetch — prefer the audric snapshot's already-computed value
-      // (when present and not 'degraded'), otherwise call the engine's
-      // direct aggregator. The 'degraded' check prevents the audric
-      // path from masking a useful direct read when the audric route's
-      // own DeFi field came back empty.
-      audricSnapshot && audricSnapshot.defiSource !== "degraded" ? Promise.resolve({
+      // DeFi fetch — prefer the audric snapshot's already-computed
+      // value, but only when we can trust it. Two trust signals:
+      //   1. `source === 'blockvision'`  — fully successful fresh read
+      //      (even if value is 0, that's a confirmed empty position).
+      //   2. `defiValueUsd > 0`           — any positive value, regardless
+      //      of source. `partial-stale` with a positive total is fine,
+      //      `partial` with a positive total is the live equivalent.
+      //
+      // [Bug — 2026-04-28 round 2] Pre-fix the trust gate was
+      // `defiSource !== 'degraded'`, which let `partial + 0` through
+      // as authoritative. During a BlockVision 429 burst the audric
+      // host's `/api/portfolio` returns `partial + 0` (some protocols
+      // failed, the rest reported $0, no sticky-positive available
+      // *in that process*) — but the engine's direct fetcher in the
+      // chat route may have a sticky-positive in *this* Vercel
+      // instance's cache. Trusting audric's $0 silently dropped the
+      // DeFi line that `balance_check` (which always calls direct)
+      // showed correctly on the same turn — same SSOT-divergence bug
+      // class, manifested in a different layer.
+      //
+      // The new condition routes around audric's $0 in exactly that
+      // case. When the direct fetch ALSO returns $0 the answer is
+      // consistent across tools (both report degraded), which is the
+      // honest UX during a real outage.
+      audricSnapshot && (audricSnapshot.defiSource === "blockvision" || audricSnapshot.defiValueUsd > 0) ? Promise.resolve({
         totalUsd: audricSnapshot.defiValueUsd,
         perProtocol: {},
         pricedAt: Date.now(),