@t2000/engine 0.54.0 → 0.54.2

package/dist/index.d.ts

@@ -2274,6 +2274,20 @@ interface PortfolioResult {
     totalValue: number;
     walletValue: number;
     savingsValue: number;
+    /**
+     * [Bug — 2026-04-28] Aggregated DeFi value across non-NAVI protocols
+     * (Cetus LPs, Bluefin, Suilend, etc.) — same field that's been on
+     * `balance_check` since v0.50. Pre-fix this tool ignored DeFi entirely:
+     * a wallet with $1,569 in Cetus LPs reported a $228 totalValue
+     * (wallet only), under-counting net worth by 87% and prompting the LLM
+     * to misclassify the wallet as "concentrated in FAITH" when actually
+     * the bulk was in liquidity pools. Same SSOT-divergence class the v0.54
+     * cache work fixed for FullPortfolioCanvas, manifesting in a different
+     * tool that was written before DeFi support was bolted on.
+     */
+    defiValue: number;
+    /** Provenance of the DeFi read — used by the UI card to caveat partial/degraded. */
+    defiSource: DefiSummary['source'];
     debtValue: number;
     healthFactor: number | null;
     allocations: AssetAllocation[];
@@ -2508,12 +2522,21 @@ interface AudricPortfolioResult {
     portfolio: AddressPortfolio;
     /** NAVI lending positions, normalized to the engine's `ServerPositionData`. */
     positions: ServerPositionData;
-    /** Net worth derived audric-side (`wallet + savings - borrows`). */
+    /** Net worth derived audric-side (`wallet + savings + defi - borrows`). */
     netWorthUsd: number;
     /** `savings * savingsRate / 365`, capped at 0. */
     estimatedDailyYield: number;
     /** Per-symbol balance map — convenient for adapters that already used `WalletBalances`. */
     walletAllocations: Record<string, number>;
+    /**
+     * [Bug — 2026-04-28] Aggregated DeFi value (Cetus LPs, Bluefin, Suilend,
+     * etc.) when available. `defiSource === 'degraded'` when audric's wire
+     * didn't include the field — callers should treat that as "fall back to
+     * a direct fetchAddressDefiPortfolio call" (same convention used
+     * inside the audric web app's UI components).
+     */
+    defiValueUsd: number;
+    defiSource: DefiSummary['source'];
 }
 /**
  * Fetch the canonical portfolio snapshot from audric. Returns `null` if

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;
@@ -1243,7 +1338,14 @@ async function fetchAudricPortfolio(address, env, signal) {
       positions,
       netWorthUsd: json.netWorthUsd ?? portfolio.totalUsd + positions.savings - positions.borrows,
       estimatedDailyYield: json.estimatedDailyYield ?? 0,
-      walletAllocations: json.walletAllocations ?? {}
+      walletAllocations: json.walletAllocations ?? {},
+      // Default to 'degraded' (not 'partial') when the wire shape lacks
+      // DeFi: 'partial' implies "we tried and got partial data" which is
+      // misleading for a route that simply doesn't return the field.
+      // Callers that need DeFi must fall back to a direct fetch on
+      // 'degraded' — exactly the convention BalanceCard already uses.
+      defiValueUsd: typeof json.defiValueUsd === "number" ? json.defiValueUsd : 0,
+      defiSource: json.defiSource ?? "degraded"
     };
   } catch (err) {
     console.warn(`[audric-api] portfolio ${address.slice(0, 10)} fetch failed:`, err);
@@ -1932,10 +2034,25 @@ var STABLECOIN_SYMBOLS2 = /* @__PURE__ */ new Set([
 function isStable(symbol) {
   return STABLECOIN_SYMBOLS2.has(symbol.toLowerCase());
 }
+var TOKEN_ALIASES = {
+  usdt: ["usdt", "wusdt", "suiusdt"],
+  usdc: ["usdc", "wusdc"],
+  usde: ["usde", "suiusde", "sui_usde"],
+  usdsui: ["usdsui"]
+};
+function expandAliases(symbols) {
+  const out = /* @__PURE__ */ new Set();
+  for (const s of symbols) {
+    const norm = s.toLowerCase();
+    const aliases = TOKEN_ALIASES[norm] ?? [norm];
+    for (const a of aliases) out.add(a);
+  }
+  return out;
+}
 function applyFilters(rates, opts) {
   let entries = Object.entries(rates);
   if (opts.assets && opts.assets.length) {
-    const wanted = new Set(opts.assets.map((a) => a.toLowerCase()));
+    const wanted = expandAliases(opts.assets);
     entries = entries.filter(([sym]) => wanted.has(sym.toLowerCase()));
   } else if (opts.stableOnly) {
     entries = entries.filter(([sym]) => isStable(sym));
@@ -3277,7 +3394,7 @@ var portfolioAnalysisTool = buildTool({
       context.signal
     );
     const apiUrl = context.env?.AUDRIC_INTERNAL_API_URL;
-    const [portfolio, positions, weekHistResult] = await Promise.all([
+    const [portfolio, positions, weekHistResult, defiSummary] = await Promise.all([
       audricSnapshot ? Promise.resolve(audricSnapshot.portfolio) : (async () => {
         if (context.portfolioCache) {
           const hit = context.portfolioCache.get(address);
@@ -3306,7 +3423,42 @@ var portfolioAnalysisTool = buildTool({
       apiUrl ? fetch(
         `${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)
+      ).then((res) => res.ok ? res.json() : null).catch(() => null) : Promise.resolve(null),
+      // 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(),
+        source: audricSnapshot.defiSource
+      }) : fetchAddressDefiPortfolio(address, context.blockvisionApiKey).catch(
+        (err) => {
+          console.warn("[portfolio_analysis] defi fetch failed:", err);
+          return { totalUsd: 0, perProtocol: {}, pricedAt: Date.now(), source: "degraded" };
+        }
+      )
     ]);
     let walletValue = 0;
     const allAllocations = [];
@@ -3336,7 +3488,18 @@ var portfolioAnalysisTool = buildTool({
     if (weekHistResult?.change && weekHistResult.change.absoluteUsd !== 0) {
       weekChange = weekHistResult.change;
     }
-    const totalValue = walletValue + savingsValue;
+    const defiValue = defiSummary.totalUsd;
+    if (defiSummary.source !== "degraded") {
+      for (const [protocol, usdValue] of Object.entries(defiSummary.perProtocol)) {
+        if (typeof usdValue === "number" && usdValue >= DUST_USD) {
+          const label = protocol.charAt(0).toUpperCase() + protocol.slice(1) + " DeFi";
+          allocations.push({ symbol: label, amount: 0, usdValue, percentage: 0 });
+        }
+      }
+    } else if (defiValue > 0) {
+      allocations.push({ symbol: "DeFi (aggregate)", amount: 0, usdValue: defiValue, percentage: 0 });
+    }
+    const totalValue = walletValue + savingsValue + defiValue;
     for (const a of allocations) {
       a.percentage = totalValue > 0 ? a.usdValue / totalValue * 100 : 0;
     }
@@ -3374,10 +3537,23 @@ var portfolioAnalysisTool = buildTool({
         message: "Portfolio is concentrated in a single asset."
       });
     }
+    if (defiSummary.source === "degraded") {
+      insights.push({
+        type: "warning",
+        message: "DeFi positions could not be loaded \u2014 total may under-count any Cetus/Bluefin/Suilend value."
+      });
+    } else if (defiSummary.source === "partial") {
+      insights.push({
+        type: "warning",
+        message: "DeFi data is partial \u2014 at least one protocol failed; total may under-count."
+      });
+    }
     const result = {
       totalValue,
       walletValue,
       savingsValue,
+      defiValue,
+      defiSource: defiSummary.source,
       debtValue,
       healthFactor,
       allocations: allocations.slice(0, 10),
@@ -3388,7 +3564,8 @@ var portfolioAnalysisTool = buildTool({
       weekChange,
       priceSource: portfolio.source
     };
-    const topLine = `Total: $${totalValue.toFixed(2)} | Wallet: $${walletValue.toFixed(2)} | Savings: $${savingsValue.toFixed(2)}`;
+    const defiSegment = defiValue > 0 ? ` | DeFi: $${defiValue.toFixed(2)}${defiSummary.source === "partial" ? " (partial)" : ""}` : "";
+    const topLine = `Total: $${totalValue.toFixed(2)} | Wallet: $${walletValue.toFixed(2)} | Savings: $${savingsValue.toFixed(2)}${defiSegment}`;
     const insightLines = insights.map((i) => `${i.type === "warning" ? "\u26A0" : "\u2192"} ${i.message}`).join("\n");
     return {
       data: result,