@t2000/engine 0.54.2 → 0.56.0

package/dist/index.js

@@ -532,11 +532,139 @@ function resetDefiCacheStore() {
   activeStore = new InMemoryDefiCacheStore();
 }
 
+// src/wallet-cache.ts
+var InMemoryWalletCacheStore = class {
+  store = /* @__PURE__ */ new Map();
+  async get(address) {
+    const slot = this.store.get(address.toLowerCase());
+    if (!slot) return null;
+    if (Date.now() >= slot.expiresAt) {
+      this.store.delete(address.toLowerCase());
+      return null;
+    }
+    return slot.entry;
+  }
+  async set(address, entry, ttlSec) {
+    this.store.set(address.toLowerCase(), {
+      entry,
+      expiresAt: Date.now() + ttlSec * 1e3
+    });
+  }
+  async delete(address) {
+    this.store.delete(address.toLowerCase());
+  }
+  async clear() {
+    this.store.clear();
+  }
+};
+var activeStore2 = new InMemoryWalletCacheStore();
+function setWalletCacheStore(store) {
+  activeStore2 = store;
+}
+function getWalletCacheStore() {
+  return activeStore2;
+}
+function resetWalletCacheStore() {
+  activeStore2 = new InMemoryWalletCacheStore();
+}
+
+// src/cross-instance-lock.ts
+var InMemoryFetchLock = class {
+  held = /* @__PURE__ */ new Map();
+  async acquire(key, leaseSec) {
+    const now = Date.now();
+    const expiry = this.held.get(key);
+    if (expiry !== void 0 && expiry > now) return false;
+    this.held.set(key, now + leaseSec * 1e3);
+    return true;
+  }
+  async release(key) {
+    this.held.delete(key);
+  }
+};
+var activeLock = new InMemoryFetchLock();
+function setFetchLock(lock) {
+  activeLock = lock;
+}
+function getFetchLock() {
+  return activeLock;
+}
+function resetFetchLock() {
+  activeLock = new InMemoryFetchLock();
+}
+var DEFAULT_LEASE_SEC = 15;
+var DEFAULT_POLL_BUDGET_MS = 4500;
+var DEFAULT_POLL_INTERVAL_MS = 100;
+async function awaitOrFetch(key, fetcher, opts = {}) {
+  const lock = opts.lock ?? getFetchLock();
+  const leaseSec = opts.leaseSec ?? DEFAULT_LEASE_SEC;
+  const pollBudgetMs = opts.pollBudgetMs ?? DEFAULT_POLL_BUDGET_MS;
+  const pollIntervalMs = opts.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const rng = opts.rng ?? Math.random;
+  const now = opts.now ?? Date.now;
+  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 acquired = false;
+  try {
+    acquired = await lock.acquire(key, leaseSec);
+  } catch (err) {
+    console.warn(`[fetch-lock] acquire(${key}) threw; falling through to direct fetch:`, err);
+    return fetcher();
+  }
+  if (acquired) {
+    try {
+      return await fetcher();
+    } finally {
+      try {
+        await lock.release(key);
+      } catch (err) {
+        console.warn(`[fetch-lock] release(${key}) failed (non-fatal):`, err);
+      }
+    }
+  }
+  if (!opts.pollCache) {
+    return fetcher();
+  }
+  const deadline = now() + pollBudgetMs;
+  while (now() < deadline) {
+    const jitterPx = (rng() * 0.4 - 0.2) * pollIntervalMs;
+    const wait = Math.max(0, pollIntervalMs + jitterPx);
+    try {
+      await sleep2(wait);
+    } catch (err) {
+      if (err?.name === "AbortError") throw err;
+      return fetcher();
+    }
+    let cached = null;
+    try {
+      cached = await opts.pollCache();
+    } catch (err) {
+      console.warn(`[fetch-lock] pollCache(${key}) threw; continuing to poll:`, err);
+    }
+    if (cached !== null) return cached;
+  }
+  return fetcher();
+}
+
 // src/blockvision-prices.ts
 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 WALLET_FRESH_TTL_MS_BLOCKVISION = 6e4;
+var WALLET_FRESH_TTL_MS_DEGRADED = 15e3;
+var WALLET_STICKY_TTL_SEC = 30 * 60;
+var WALLET_LOCK_KEY = (address) => `bv-lock:wallet:${address.toLowerCase()}`;
+var DEFI_LOCK_KEY = (address) => `bv-lock:defi:${address.toLowerCase()}`;
 var BV_RETRY_MAX_ATTEMPTS = 3;
 var BV_RETRY_BASE_DELAY_MS = 250;
 var BV_RETRY_BACKOFF_FACTOR = 3;
@@ -617,7 +745,6 @@ async function fetchBlockVisionWithRetry(url, init, opts = {}) {
   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 = {
   "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC": 1,
@@ -627,38 +754,103 @@ var STABLE_USD_PRICES = {
   "0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN": 1,
   "0xc060006111016b8a020ad5b33834984a437aaa7d3c74c18e09a95d48aceab08c::coin::COIN": 1
 };
-var portfolioCache = /* @__PURE__ */ new Map();
 var portfolioInflight = /* @__PURE__ */ new Map();
 var priceMapCache = null;
+function walletFreshTtlMs(source) {
+  switch (source) {
+    case "blockvision":
+      return WALLET_FRESH_TTL_MS_BLOCKVISION;
+    case "sui-rpc-degraded":
+      return WALLET_FRESH_TTL_MS_DEGRADED;
+  }
+}
+async function safeWalletStoreSet(store, address, entry, ttlSec) {
+  try {
+    await store.set(address, entry, ttlSec);
+  } catch (err) {
+    console.warn("[wallet] cache set failed (non-fatal):", err);
+  }
+}
+async function safeWalletStoreGet(store, address) {
+  try {
+    return await store.get(address);
+  } catch (err) {
+    console.warn("[wallet] cache get failed (continuing as cache miss):", err);
+    return null;
+  }
+}
 async function fetchAddressPortfolio(address, apiKey, fallbackRpcUrl) {
-  const now = Date.now();
-  const cached = portfolioCache.get(address);
-  if (cached && now - cached.ts < CACHE_TTL_MS) {
-    return cached.data;
+  const store = getWalletCacheStore();
+  const cachedEntry = await safeWalletStoreGet(store, address);
+  if (cachedEntry) {
+    const ageMs = Date.now() - cachedEntry.pricedAt;
+    if (ageMs < walletFreshTtlMs(cachedEntry.data.source)) {
+      return cachedEntry.data;
+    }
   }
-  let inflight = portfolioInflight.get(address);
-  if (inflight) return inflight;
-  inflight = (async () => {
+  const existing = portfolioInflight.get(address);
+  if (existing) return existing;
+  const promise = (async () => {
     try {
-      if (apiKey && apiKey.trim().length > 0) {
-        const blockvision = await fetchPortfolioFromBlockVision(address, apiKey);
-        if (blockvision) {
-          portfolioCache.set(address, { data: blockvision, ts: Date.now() });
-          return blockvision;
+      return await awaitOrFetch(
+        WALLET_LOCK_KEY(address),
+        // ----------------------------------------------------------
+        // Leader path — runs after we've won the cross-instance lock.
+        // Re-checks the cache (small window where another leader on a
+        // different process just wrote) before paying for the BV call.
+        // ----------------------------------------------------------
+        async () => {
+          const recheck = await safeWalletStoreGet(store, address);
+          if (recheck) {
+            const ageMs = Date.now() - recheck.pricedAt;
+            if (ageMs < walletFreshTtlMs(recheck.data.source)) {
+              return recheck.data;
+            }
+          }
+          if (apiKey && apiKey.trim().length > 0) {
+            const blockvision = await fetchPortfolioFromBlockVision(address, apiKey);
+            if (blockvision) {
+              await safeWalletStoreSet(
+                store,
+                address,
+                { data: blockvision, pricedAt: Date.now() },
+                WALLET_STICKY_TTL_SEC
+              );
+              return blockvision;
+            }
+          }
+          const degraded = await fetchPortfolioFromSuiRpc(address, apiKey, fallbackRpcUrl);
+          const stickyCandidate = recheck && recheck.data.source === "blockvision" && recheck.data.totalUsd > 0 ? recheck : cachedEntry && cachedEntry.data.source === "blockvision" && cachedEntry.data.totalUsd > 0 ? cachedEntry : null;
+          const stickyFresh = stickyCandidate && Date.now() - stickyCandidate.pricedAt < WALLET_STICKY_TTL_SEC * 1e3;
+          if (stickyFresh) {
+            return stickyCandidate.data;
+          }
+          await safeWalletStoreSet(
+            store,
+            address,
+            { data: degraded, pricedAt: Date.now() },
+            Math.ceil(WALLET_FRESH_TTL_MS_DEGRADED / 1e3)
+          );
+          return degraded;
+        },
+        {
+          // Followers poll the wallet cache while the leader fetches.
+          // Returns non-null only when the leader has written a
+          // fresh-for-source entry — stale entries keep the poll going.
+          pollCache: async () => {
+            const e = await safeWalletStoreGet(store, address);
+            if (!e) return null;
+            const ageMs = Date.now() - e.pricedAt;
+            return ageMs < walletFreshTtlMs(e.data.source) ? e.data : null;
+          }
         }
-      }
-      const degraded = await fetchPortfolioFromSuiRpc(address, apiKey, fallbackRpcUrl);
-      portfolioCache.set(address, {
-        data: degraded,
-        ts: Date.now() - (CACHE_TTL_MS - DEGRADED_CACHE_TTL_MS)
-      });
-      return degraded;
+      );
     } finally {
       portfolioInflight.delete(address);
     }
   })();
-  portfolioInflight.set(address, inflight);
-  return inflight;
+  portfolioInflight.set(address, promise);
+  return promise;
 }
 async function fetchPortfolioFromBlockVision(address, apiKey) {
   const url = `${BLOCKVISION_BASE}/account/coins?account=${encodeURIComponent(address)}`;
@@ -889,6 +1081,14 @@ async function safeStoreSet(store, address, entry) {
     console.warn("[defi] cache set failed (non-fatal):", err);
   }
 }
+async function safeDefiStoreGet(store, address) {
+  try {
+    return await store.get(address);
+  } catch (err) {
+    console.warn("[defi] cache get failed (continuing as cache miss):", err);
+    return null;
+  }
+}
 var warnedMissingApiKey = false;
 async function fetchAddressDefiPortfolio(address, apiKey, priceHints = {}) {
   if (!apiKey || apiKey.trim().length === 0) {
@@ -901,15 +1101,9 @@ async function fetchAddressDefiPortfolio(address, apiKey, priceHints = {}) {
     return { totalUsd: 0, perProtocol: {}, pricedAt: Date.now(), source: "degraded" };
   }
   const store = getDefiCacheStore();
-  const now = Date.now();
-  let cachedEntry = null;
-  try {
-    cachedEntry = await store.get(address);
-  } catch (err) {
-    console.warn("[defi] cache get failed (continuing as cache miss):", err);
-  }
+  const cachedEntry = await safeDefiStoreGet(store, address);
   if (cachedEntry) {
-    const ageMs = now - cachedEntry.pricedAt;
+    const ageMs = Date.now() - cachedEntry.pricedAt;
     const freshTtlMs = freshTtlForSource(cachedEntry.data.source);
     if (ageMs < freshTtlMs) {
       return cachedEntry.data;
@@ -919,82 +1113,108 @@ async function fetchAddressDefiPortfolio(address, apiKey, priceHints = {}) {
   if (inflight) return inflight;
   inflight = (async () => {
     try {
-      const settled = await Promise.allSettled(
-        DEFI_PROTOCOLS.map((p) => fetchOneDefiProtocol(address, p, apiKey))
-      );
-      const seen = /* @__PURE__ */ new Set();
-      for (const s of settled) {
-        if (s.status === "fulfilled" && s.value) collectCoinTypes(s.value, seen);
-      }
-      const normalizedHints = {};
-      for (const [k, v] of Object.entries(priceHints)) {
-        normalizedHints[normalizeCoinType(k)] = v;
-      }
-      const missing = Array.from(seen).filter((ct) => {
-        const norm = normalizeCoinType(ct);
-        return !normalizedHints[norm] && !STABLE_USD_PRICES[norm];
-      });
-      let fetchedPrices = {};
-      if (missing.length > 0) {
-        try {
-          fetchedPrices = await fetchTokenPrices(missing, apiKey);
-        } catch (err) {
-          console.warn("[defi] fill-missing-prices failed:", err);
-        }
-      }
-      const prices = { ...normalizedHints };
-      for (const [ct, v] of Object.entries(fetchedPrices)) {
-        prices[normalizeCoinType(ct)] ??= v.price;
-      }
-      for (const [ct, p] of Object.entries(STABLE_USD_PRICES)) {
-        prices[normalizeCoinType(ct)] ??= p;
-      }
-      let totalUsd = 0;
-      let failures = 0;
-      const perProtocol = {};
-      for (let i = 0; i < DEFI_PROTOCOLS.length; i++) {
-        const proto = DEFI_PROTOCOLS[i];
-        const s = settled[i];
-        if (s.status !== "fulfilled" || !s.value) {
-          failures++;
-          continue;
-        }
-        try {
-          const usd = normalizeProtocol(proto, s.value, prices);
-          if (Number.isFinite(usd) && usd !== 0) {
-            perProtocol[proto] = usd;
-            totalUsd += usd;
+      return await awaitOrFetch(
+        DEFI_LOCK_KEY(address),
+        // Leader path — runs after acquiring the lock.
+        async () => {
+          const recheck = await safeDefiStoreGet(store, address);
+          if (recheck) {
+            const ageMs = Date.now() - recheck.pricedAt;
+            if (ageMs < freshTtlForSource(recheck.data.source)) {
+              return recheck.data;
+            }
+          }
+          const stickyBasis = recheck ?? cachedEntry;
+          const fanoutAt = Date.now();
+          const settled = await Promise.allSettled(
+            DEFI_PROTOCOLS.map((p) => fetchOneDefiProtocol(address, p, apiKey))
+          );
+          const seen = /* @__PURE__ */ new Set();
+          for (const s of settled) {
+            if (s.status === "fulfilled" && s.value) collectCoinTypes(s.value, seen);
+          }
+          const normalizedHints = {};
+          for (const [k, v] of Object.entries(priceHints)) {
+            normalizedHints[normalizeCoinType(k)] = v;
+          }
+          const missing = Array.from(seen).filter((ct) => {
+            const norm = normalizeCoinType(ct);
+            return !normalizedHints[norm] && !STABLE_USD_PRICES[norm];
+          });
+          let fetchedPrices = {};
+          if (missing.length > 0) {
+            try {
+              fetchedPrices = await fetchTokenPrices(missing, apiKey);
+            } catch (err) {
+              console.warn("[defi] fill-missing-prices failed:", err);
+            }
+          }
+          const prices = { ...normalizedHints };
+          for (const [ct, v] of Object.entries(fetchedPrices)) {
+            prices[normalizeCoinType(ct)] ??= v.price;
+          }
+          for (const [ct, p] of Object.entries(STABLE_USD_PRICES)) {
+            prices[normalizeCoinType(ct)] ??= p;
+          }
+          let totalUsd = 0;
+          let failures = 0;
+          const perProtocol = {};
+          for (let i = 0; i < DEFI_PROTOCOLS.length; i++) {
+            const proto = DEFI_PROTOCOLS[i];
+            const s = settled[i];
+            if (s.status !== "fulfilled" || !s.value) {
+              failures++;
+              continue;
+            }
+            try {
+              const usd = normalizeProtocol(proto, s.value, prices);
+              if (Number.isFinite(usd) && usd !== 0) {
+                perProtocol[proto] = usd;
+                totalUsd += usd;
+              }
+            } catch (err) {
+              console.warn(`[defi] ${proto} normaliser threw:`, err);
+              failures++;
+            }
+          }
+          if (totalUsd < 0) totalUsd = 0;
+          const fetchedAt = Date.now();
+          const summary = {
+            totalUsd,
+            perProtocol,
+            pricedAt: fetchedAt,
+            source: failures === DEFI_PROTOCOLS.length ? "degraded" : failures > 0 ? "partial" : "blockvision"
+          };
+          const cachedPositive = stickyBasis && stickyBasis.data.totalUsd > 0 && fanoutAt - stickyBasis.pricedAt < DEFI_STICKY_TTL_SEC * 1e3;
+          if (summary.source === "blockvision") {
+            await safeStoreSet(store, address, { data: summary, pricedAt: fetchedAt });
+            return summary;
+          }
+          if (summary.source === "partial" && summary.totalUsd > 0) {
+            await safeStoreSet(store, address, { data: summary, pricedAt: fetchedAt });
+            return summary;
+          }
+          if (cachedPositive) {
+            const stale = {
+              ...stickyBasis.data,
+              source: "partial-stale"
+            };
+            return stale;
+          }
+          return summary;
+        },
+        {
+          // Followers poll the DeFi cache while the leader fans out.
+          // Returns non-null only when the leader has written a
+          // fresh-for-source entry — stale entries keep the poll going.
+          pollCache: async () => {
+            const e = await safeDefiStoreGet(store, address);
+            if (!e) return null;
+            const ageMs = Date.now() - e.pricedAt;
+            return ageMs < freshTtlForSource(e.data.source) ? e.data : null;
           }
-        } catch (err) {
-          console.warn(`[defi] ${proto} normaliser threw:`, err);
-          failures++;
         }
-      }
-      if (totalUsd < 0) totalUsd = 0;
-      const fetchedAt = Date.now();
-      const summary = {
-        totalUsd,
-        perProtocol,
-        pricedAt: fetchedAt,
-        source: failures === DEFI_PROTOCOLS.length ? "degraded" : failures > 0 ? "partial" : "blockvision"
-      };
-      const cachedPositive = cachedEntry && cachedEntry.data.totalUsd > 0 && now - cachedEntry.pricedAt < DEFI_STICKY_TTL_SEC * 1e3;
-      if (summary.source === "blockvision") {
-        await safeStoreSet(store, address, { data: summary, pricedAt: fetchedAt });
-        return summary;
-      }
-      if (summary.source === "partial" && summary.totalUsd > 0) {
-        await safeStoreSet(store, address, { data: summary, pricedAt: fetchedAt });
-        return summary;
-      }
-      if (cachedPositive) {
-        const stale = {
-          ...cachedEntry.data,
-          source: "partial-stale"
-        };
-        return stale;
-      }
-      return summary;
+      );
     } finally {
       defiInflight.delete(address);
     }
@@ -1280,12 +1500,12 @@ function normalizeProtocol(protocol, result, prices) {
   if (bespoke) return bespoke(result, prices);
   return walkProtocolResponse(result, prices);
 }
-function clearPortfolioCache() {
-  portfolioCache.clear();
+async function clearPortfolioCache() {
+  await getWalletCacheStore().clear();
   portfolioInflight.clear();
 }
-function clearPortfolioCacheFor(address) {
-  portfolioCache.delete(address);
+async function clearPortfolioCacheFor(address) {
+  await getWalletCacheStore().delete(address);
   portfolioInflight.delete(address);
 }
 function clearPriceMapCache() {
@@ -4532,7 +4752,7 @@ function getModifiableFields(toolName) {
 }
 
 // src/prompt.ts
-var DEFAULT_SYSTEM_PROMPT = `You are Audric \u2014 a financial agent on Sui. Audric is exactly five products: Audric Passport (the trust layer \u2014 Google sign-in, non-custodial wallet, tap-to-confirm consent, sponsored gas \u2014 wraps every other product), Audric Intelligence (you \u2014 the 5-system brain: Agent Harness with 34 tools, Reasoning Engine with 9 guards and 7 skill recipes, Silent Profile, Chain Memory, AdviceLog), Audric Finance (manage money on Sui \u2014 Save via NAVI lending at 3-8% APY USDC, Credit via NAVI borrowing with health factor, Swap via Cetus aggregator across 20+ DEXs at 0.1% fee, Charts for yield/health/portfolio viz), Audric Pay (move money \u2014 send USDC, receive via payment links / invoices / QR; free, global, instant on Sui), and Audric Store (creator marketplace, ships Phase 5 \u2014 say "coming soon" if asked). Save, swap, borrow, repay, withdraw, charts \u2192 Audric Finance. Send, receive, payment-link, invoice, QR \u2192 Audric Pay. Your silent context (profile, memory, chain facts, advice log) shapes your replies but never surfaces as a notification \u2014 you act only when the user asks, and every write waits on their tap-to-confirm via Passport. You can also call 41 paid APIs (music, image, research, translation, weather, fulfilment) via MPP micropayments using the pay_api tool \u2014 this is an internal capability, not a promoted product, so only mention it when the user asks for something that needs it.
+var DEFAULT_SYSTEM_PROMPT = `You are Audric \u2014 a financial agent on Sui. Audric is exactly five products: Audric Passport (the trust layer \u2014 Google sign-in, non-custodial wallet, tap-to-confirm consent, sponsored gas \u2014 wraps every other product), Audric Intelligence (you \u2014 the 5-system brain: Agent Harness with 34 tools, Reasoning Engine with 14 guards and 6 skill recipes, Silent Profile, Chain Memory, AdviceLog), Audric Finance (manage money on Sui \u2014 Save via NAVI lending at 3-8% APY USDC, Credit via NAVI borrowing with health factor, Swap via Cetus aggregator across 20+ DEXs at 0.1% fee, Charts for yield/health/portfolio viz), Audric Pay (move money \u2014 send USDC, receive via payment links / invoices / QR; free, global, instant on Sui), and Audric Store (creator marketplace, ships Phase 5 \u2014 say "coming soon" if asked). Save, swap, borrow, repay, withdraw, charts \u2192 Audric Finance. Send, receive, payment-link, invoice, QR \u2192 Audric Pay. Your silent context (profile, memory, chain facts, advice log) shapes your replies but never surfaces as a notification \u2014 you act only when the user asks, and every write waits on their tap-to-confirm via Passport. You can also call 41 paid APIs (music, image, research, translation, weather, fulfilment) via MPP micropayments using the pay_api tool \u2014 this is an internal capability, not a promoted product, so only mention it when the user asks for something that needs it.
 
 ## Response rules
 - 1-2 sentences max. No bullet lists unless asked. No preambles.
@@ -5966,7 +6186,7 @@ var QueryEngine = class {
     };
     if (this.walletAddress) {
       this.portfolioCache?.delete(this.walletAddress);
-      clearPortfolioCacheFor(this.walletAddress);
+      await clearPortfolioCacheFor(this.walletAddress);
     }
     if (!signal.aborted) {
       await new Promise((resolve) => {
@@ -7866,6 +8086,6 @@ function sanitizeAnthropicMessages(messages) {
   return merged;
 }
 
-export { AnthropicProvider, BalanceTracker, CANVAS_TEMPLATES, ContextBudget, CostTracker, DEFAULT_GUARD_CONFIG, DEFAULT_PERMISSION_CONFIG, DEFAULT_SYSTEM_PROMPT, EarlyToolDispatcher, InMemoryDefiCacheStore, McpClientManager, McpResponseCache, MemorySessionStore, NAVI_MCP_CONFIG, NAVI_MCP_URL, NAVI_SERVER_NAME, NaviTools, PERMISSION_PRESETS, QueryEngine, READ_TOOLS, RecipeRegistry, RetryTracker, TOOL_FLAGS, TOOL_MODIFIABLE_FIELDS, TxMutex, WRITE_TOOLS, activitySummaryTool, adaptAllMcpTools, adaptAllServerTools, adaptMcpTool, applyToolFlags, balanceCheckTool, borrowTool, budgetToolResult, buildCachedSystemPrompt, buildMcpTools, buildProactivenessInstructions, buildProfileContext, buildSelfEvaluationInstruction, buildStateContext, buildTool, claimRewardsTool, classifyEffort, clearPortfolioCache, clearPortfolioCacheFor, clearPriceMapCache, compactMessages, createGuardRunnerState, engineToSSE, estimateTokens, explainTxTool, extractConversationText, extractMcpText, fetchAddressDefiPortfolio, fetchAddressPortfolio, fetchAudricHistory, fetchAudricPortfolio, fetchAvailableRewards, fetchBalance, fetchHealthFactor, fetchPositions, fetchProtocolStats, fetchRates, fetchSavings, fetchTokenPrices, fetchWalletCoins, findTool, getAudricApiBase, getDefaultTools, getDefiCacheStore, getMcpManager, getModifiableFields, getToolFlags, getWalletAddress, guardArtifactPreview, guardStaleData, hasNaviMcp, healthCheckTool, loadRecipes, microcompact, mppServicesTool, parseMcpJson, parseRecipe, parseSSE, payApiTool, portfolioAnalysisTool, protocolDeepDiveTool, ratesInfoTool, registerEngineTools, renderCanvasTool, repayDebtTool, requireAgent, resetDefiCacheStore, resolvePermissionTier, resolveUsdValue, runGuards, runTools, saveContactTool, saveDepositTool, savingsInfoTool, sendTransferTool, serializeSSE, setDefiCacheStore, spendingAnalyticsTool, swapExecuteTool, swapQuoteTool, tokenPricesTool, toolNameToOperation, toolsToDefinitions, transactionHistoryTool, transformBalance, transformHealthFactor, transformPositions, transformRates, transformRewards, transformSavings, updateGuardStateAfterToolResult, validateHistory, voloStakeTool, voloStatsTool, voloUnstakeTool, webSearchTool, withdrawTool, yieldSummaryTool };
+export { AnthropicProvider, BalanceTracker, CANVAS_TEMPLATES, ContextBudget, CostTracker, DEFAULT_GUARD_CONFIG, DEFAULT_LEASE_SEC, DEFAULT_PERMISSION_CONFIG, DEFAULT_POLL_BUDGET_MS, DEFAULT_POLL_INTERVAL_MS, DEFAULT_SYSTEM_PROMPT, EarlyToolDispatcher, InMemoryDefiCacheStore, InMemoryFetchLock, InMemoryWalletCacheStore, McpClientManager, McpResponseCache, MemorySessionStore, NAVI_MCP_CONFIG, NAVI_MCP_URL, NAVI_SERVER_NAME, NaviTools, PERMISSION_PRESETS, QueryEngine, READ_TOOLS, RecipeRegistry, RetryTracker, TOOL_FLAGS, TOOL_MODIFIABLE_FIELDS, TxMutex, WRITE_TOOLS, activitySummaryTool, adaptAllMcpTools, adaptAllServerTools, adaptMcpTool, applyToolFlags, awaitOrFetch, balanceCheckTool, borrowTool, budgetToolResult, buildCachedSystemPrompt, buildMcpTools, buildProactivenessInstructions, buildProfileContext, buildSelfEvaluationInstruction, buildStateContext, buildTool, claimRewardsTool, classifyEffort, clearPortfolioCache, clearPortfolioCacheFor, clearPriceMapCache, compactMessages, createGuardRunnerState, engineToSSE, estimateTokens, explainTxTool, extractConversationText, extractMcpText, fetchAddressDefiPortfolio, fetchAddressPortfolio, fetchAudricHistory, fetchAudricPortfolio, fetchAvailableRewards, fetchBalance, fetchHealthFactor, fetchPositions, fetchProtocolStats, fetchRates, fetchSavings, fetchTokenPrices, fetchWalletCoins, findTool, getAudricApiBase, getDefaultTools, getDefiCacheStore, getFetchLock, getMcpManager, getModifiableFields, getToolFlags, getWalletAddress, getWalletCacheStore, guardArtifactPreview, guardStaleData, hasNaviMcp, healthCheckTool, loadRecipes, microcompact, mppServicesTool, parseMcpJson, parseRecipe, parseSSE, payApiTool, portfolioAnalysisTool, protocolDeepDiveTool, ratesInfoTool, registerEngineTools, renderCanvasTool, repayDebtTool, requireAgent, resetDefiCacheStore, resetFetchLock, resetWalletCacheStore, resolvePermissionTier, resolveUsdValue, runGuards, runTools, saveContactTool, saveDepositTool, savingsInfoTool, sendTransferTool, serializeSSE, setDefiCacheStore, setFetchLock, setWalletCacheStore, spendingAnalyticsTool, swapExecuteTool, swapQuoteTool, tokenPricesTool, toolNameToOperation, toolsToDefinitions, transactionHistoryTool, transformBalance, transformHealthFactor, transformPositions, transformRates, transformRewards, transformSavings, updateGuardStateAfterToolResult, validateHistory, voloStakeTool, voloStatsTool, voloUnstakeTool, webSearchTool, withdrawTool, yieldSummaryTool };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map