@t2000/engine 0.31.1 → 0.32.0

package/dist/index.js

@@ -7,15 +7,18 @@ import Anthropic from '@anthropic-ai/sdk';
 
 // src/tool.ts
 function buildTool(opts) {
+  const isReadOnly = opts.isReadOnly ?? true;
   return {
     name: opts.name,
     description: opts.description,
     inputSchema: opts.inputSchema,
     jsonSchema: opts.jsonSchema,
     call: opts.call,
-    isReadOnly: opts.isReadOnly ?? true,
-    isConcurrencySafe: opts.isReadOnly ?? true,
-    permissionLevel: opts.permissionLevel ?? (opts.isReadOnly === false ? "confirm" : "auto")
+    isReadOnly,
+    isConcurrencySafe: isReadOnly,
+    permissionLevel: opts.permissionLevel ?? (isReadOnly ? "auto" : "confirm"),
+    flags: opts.flags ?? {},
+    preflight: opts.preflight
   };
 }
 function toolsToDefinitions(tools) {
@@ -152,6 +155,45 @@ async function executeSingleTool(tool, call, context) {
   const result = await tool.call(parsed.data, context);
   return { data: result.data, isError: false };
 }
+
+// src/tool-flags.ts
+var TOOL_FLAGS = {
+  // Write tools — financial
+  save_deposit: { mutating: true, requiresBalance: true },
+  withdraw: { mutating: true, affectsHealth: true },
+  send_transfer: { mutating: true, requiresBalance: true, irreversible: true },
+  swap_execute: { mutating: true, requiresBalance: true },
+  borrow: { mutating: true, affectsHealth: true },
+  repay_debt: { mutating: true, requiresBalance: true },
+  claim_rewards: { mutating: true },
+  volo_stake: { mutating: true, requiresBalance: true },
+  volo_unstake: { mutating: true },
+  // Write tools — pay / services
+  pay_api: { mutating: true, requiresBalance: true, costAware: true, producesArtifact: true, maxRetries: 1 },
+  // Write tools — lightweight (no financial guards)
+  save_contact: {},
+  create_schedule: { mutating: true },
+  cancel_schedule: { mutating: true },
+  // Allowance tools — API mutations disguised as reads
+  toggle_allowance: { mutating: true },
+  update_daily_limit: { mutating: true },
+  update_permissions: { mutating: true },
+  // Receive tools — create/cancel mutate server state
+  create_payment_link: { mutating: true },
+  cancel_payment_link: { mutating: true },
+  create_invoice: { mutating: true },
+  cancel_invoice: { mutating: true }
+};
+function applyToolFlags(tools) {
+  return tools.map((tool) => {
+    const flags = TOOL_FLAGS[tool.name];
+    if (!flags) return tool;
+    return { ...tool, flags: { ...tool.flags, ...flags } };
+  });
+}
+function getToolFlags(name) {
+  return TOOL_FLAGS[name] ?? {};
+}
 var SUI_MAINNET_URL = "https://fullnode.mainnet.sui.io:443";
 var EXTRA_COINS = {
   "0xc060006111016b8a020ad5b33834984a437aaa7d3c74c18e09a95d48aceab08c::coin::COIN": { symbol: "USDT", decimals: 6 }
@@ -992,7 +1034,7 @@ function parseRpcTx(tx, address) {
     gasCost
   };
 }
-async function queryHistoryRpc(rpcUrl, address, limit) {
+async function queryHistoryPage(rpcUrl, address, limit, cursor) {
   const res = await fetch(rpcUrl, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
@@ -1002,7 +1044,7 @@ async function queryHistoryRpc(rpcUrl, address, limit) {
       method: "suix_queryTransactionBlocks",
       params: [
         { filter: { FromAddress: address }, options: { showEffects: true, showInput: true, showBalanceChanges: true } },
-        null,
+        cursor,
         limit,
         true
       ]
@@ -1012,13 +1054,48 @@ async function queryHistoryRpc(rpcUrl, address, limit) {
   if (!res.ok) throw new Error(`Sui RPC error: ${res.status}`);
   const json = await res.json();
   if (json.error) throw new Error(`RPC error: ${json.error.message}`);
-  return (json.result?.data ?? []).map((tx) => parseRpcTx(tx, address));
+  return {
+    data: json.result?.data ?? [],
+    nextCursor: json.result?.nextCursor ?? null,
+    hasNextPage: json.result?.hasNextPage ?? false
+  };
+}
+async function queryHistoryRpc(rpcUrl, address, limit) {
+  const page = await queryHistoryPage(rpcUrl, address, limit, null);
+  return page.data.map((tx) => parseRpcTx(tx, address));
+}
+async function queryHistoryByDate(rpcUrl, address, targetDate, limit) {
+  const target = new Date(targetDate);
+  const dayStart = new Date(target.getFullYear(), target.getMonth(), target.getDate()).getTime();
+  const dayEnd = dayStart + 864e5;
+  const MAX_PAGES = 20;
+  const PAGE_SIZE = 50;
+  const results = [];
+  let cursor = null;
+  for (let page = 0; page < MAX_PAGES; page++) {
+    const res = await queryHistoryPage(rpcUrl, address, PAGE_SIZE, cursor);
+    if (res.data.length === 0) break;
+    for (const tx of res.data) {
+      const ts = Number(tx.timestampMs ?? 0);
+      if (ts === 0) continue;
+      if (ts < dayStart) {
+        return results.slice(0, limit);
+      }
+      if (ts >= dayStart && ts < dayEnd) {
+        results.push(parseRpcTx(tx, address));
+      }
+    }
+    if (!res.hasNextPage || !res.nextCursor) break;
+    cursor = res.nextCursor;
+  }
+  return results.slice(0, limit);
 }
 var transactionHistoryTool = buildTool({
   name: "transaction_history",
-  description: "Retrieve recent transaction history: past sends, saves, withdrawals, borrows, repayments, and rewards claims. Optionally limit the number of results.",
+  description: "Retrieve transaction history: past sends, saves, withdrawals, borrows, repayments, and rewards claims. Pass a date (YYYY-MM-DD) to find transactions from a specific day, or omit for the most recent.",
   inputSchema: z.object({
-    limit: z.number().int().min(1).max(50).optional()
+    limit: z.number().int().min(1).max(50).optional(),
+    date: z.string().optional().describe("Specific date to search for transactions (YYYY-MM-DD format). Paginates back to find that day.")
   }),
   jsonSchema: {
     type: "object",
@@ -1026,6 +1103,10 @@ var transactionHistoryTool = buildTool({
       limit: {
         type: "number",
         description: "Maximum number of transactions to return (1-50, default 10)"
+      },
+      date: {
+        type: "string",
+        description: "Specific date to search for transactions (YYYY-MM-DD format). Paginates back to find that day."
       }
     }
   },
@@ -1036,16 +1117,24 @@ var transactionHistoryTool = buildTool({
       const agent = requireAgent(context);
       const records2 = await agent.history({ limit });
       return {
-        data: { transactions: records2, count: records2.length },
+        data: { transactions: records2, count: records2.length, date: input.date ?? null },
         displayText: `${records2.length} recent transaction(s)`
       };
     }
     if (!context.walletAddress || !context.suiRpcUrl) {
       throw new Error("Transaction history requires a wallet address");
     }
+    if (input.date) {
+      const records2 = await queryHistoryByDate(context.suiRpcUrl, context.walletAddress, input.date, limit);
+      const dateLabel = new Date(input.date).toLocaleDateString("en-US", { month: "long", day: "numeric", year: "numeric" });
+      return {
+        data: { transactions: records2, count: records2.length, date: input.date },
+        displayText: records2.length > 0 ? `${records2.length} transaction(s) on ${dateLabel}` : `No transactions found on ${dateLabel}`
+      };
+    }
     const records = await queryHistoryRpc(context.suiRpcUrl, context.walletAddress, limit);
     return {
-      data: { transactions: records, count: records.length },
+      data: { transactions: records, count: records.length, date: null },
       displayText: `${records.length} recent transaction(s)`
     };
   }
@@ -1072,6 +1161,13 @@ var saveDepositTool = buildTool({
   },
   isReadOnly: false,
   permissionLevel: "confirm",
+  flags: { mutating: true, requiresBalance: true },
+  preflight: (input) => {
+    if (input.asset && input.asset.toUpperCase() !== "USDC") {
+      return { valid: false, error: `Only USDC deposits are supported. Got: "${input.asset}"` };
+    }
+    return { valid: true };
+  },
   async call(input, context) {
     assertAllowedAsset("save", input.asset);
     const agent = requireAgent(context);
@@ -1113,6 +1209,7 @@ var withdrawTool = buildTool({
   },
   isReadOnly: false,
   permissionLevel: "confirm",
+  flags: { mutating: true, affectsHealth: true },
   async call(input, context) {
     const agent = requireAgent(context);
     const result = await agent.withdraw({
@@ -1160,6 +1257,16 @@ var sendTransferTool = buildTool({
   },
   isReadOnly: false,
   permissionLevel: "confirm",
+  flags: { mutating: true, requiresBalance: true, irreversible: true },
+  preflight: (input) => {
+    if (input.to.startsWith("0x") && !/^0x[a-fA-F0-9]{64}$/.test(input.to)) {
+      return { valid: false, error: `Invalid Sui address format: "${input.to}". Must be 0x followed by 64 hex characters.` };
+    }
+    if (input.amount <= 0) {
+      return { valid: false, error: "Amount must be positive." };
+    }
+    return { valid: true };
+  },
   async call(input, context) {
     const agent = requireAgent(context);
     const result = await agent.send({ to: input.to, amount: input.amount });
@@ -1202,6 +1309,13 @@ var borrowTool = buildTool({
   },
   isReadOnly: false,
   permissionLevel: "confirm",
+  flags: { mutating: true, affectsHealth: true },
+  preflight: (input) => {
+    if (input.asset && input.asset.toUpperCase() !== "USDC") {
+      return { valid: false, error: `Only USDC borrows are supported. Got: "${input.asset}"` };
+    }
+    return { valid: true };
+  },
   async call(input, context) {
     assertAllowedAsset("borrow", input.asset);
     const agent = requireAgent(context);
@@ -1236,6 +1350,7 @@ var repayDebtTool = buildTool({
   },
   isReadOnly: false,
   permissionLevel: "confirm",
+  flags: { mutating: true, requiresBalance: true },
   async call(input, context) {
     const agent = requireAgent(context);
     const result = await agent.repay({ amount: input.amount });
@@ -1258,6 +1373,7 @@ var claimRewardsTool = buildTool({
   jsonSchema: { type: "object", properties: {}, required: [] },
   isReadOnly: false,
   permissionLevel: "confirm",
+  flags: { mutating: true },
   async call(_input, context) {
     const agent = requireAgent(context);
     const result = await agent.claimRewards();
@@ -1332,6 +1448,28 @@ Always use ISO-3166 country codes (GB not UK, US not USA). A return address ("fr
   },
   isReadOnly: false,
   permissionLevel: "confirm",
+  flags: { mutating: true, requiresBalance: true, costAware: true, producesArtifact: true, maxRetries: 1 },
+  preflight: (input) => {
+    if (!input.url.startsWith(MPP_GATEWAY)) {
+      return { valid: false, error: `URL must start with ${MPP_GATEWAY}. Got: "${input.url}"` };
+    }
+    if (input.body) {
+      try {
+        JSON.parse(input.body);
+      } catch {
+        return { valid: false, error: "body must be valid JSON." };
+      }
+      if (input.url.includes("lob/")) {
+        const body = JSON.parse(input.body);
+        const to = body.to;
+        const country = to?.address_country;
+        if (typeof country === "string" && country.length !== 2) {
+          return { valid: false, error: `Country must be ISO-3166 2-letter code (got "${country}")` };
+        }
+      }
+    }
+    return { valid: true };
+  },
   async call(input, context) {
     const agent = requireAgent(context);
     const result = await agent.pay({
@@ -1433,6 +1571,13 @@ var swapExecuteTool = buildTool({
   },
   isReadOnly: false,
   permissionLevel: "confirm",
+  flags: { mutating: true, requiresBalance: true },
+  preflight: (input) => {
+    if (input.from.toLowerCase() === input.to.toLowerCase()) {
+      return { valid: false, error: `Cannot swap ${input.from} to itself.` };
+    }
+    return { valid: true };
+  },
   async call(input, context) {
     const agent = requireAgent(context);
     const result = await agent.swap({
@@ -1507,6 +1652,7 @@ var voloStakeTool = buildTool({
   },
   isReadOnly: false,
   permissionLevel: "confirm",
+  flags: { mutating: true, requiresBalance: true },
   async call(input, context) {
     const agent = requireAgent(context);
     const result = await agent.stakeVSui({ amount: input.amount });
@@ -1537,6 +1683,7 @@ var voloUnstakeTool = buildTool({
   },
   isReadOnly: false,
   permissionLevel: "confirm",
+  flags: { mutating: true },
   async call(input, context) {
     const agent = requireAgent(context);
     const result = await agent.unstakeVSui({ amount: input.amount });
@@ -3369,7 +3516,7 @@ var WRITE_TOOLS = [
   cancelScheduleTool
 ];
 function getDefaultTools() {
-  return [...READ_TOOLS, ...WRITE_TOOLS];
+  return applyToolFlags([...READ_TOOLS, ...WRITE_TOOLS]);
 }
 
 // src/prompt.ts
@@ -3470,6 +3617,330 @@ var CostTracker = class {
   }
 };
 
+// src/guards.ts
+var DEFAULT_GUARD_CONFIG = {
+  balanceValidation: true,
+  healthFactor: { warnBelow: 2, blockBelow: 1.5 },
+  largeTransfer: { warnAbove: 50, strongWarnAbove: 500 },
+  slippage: true,
+  staleData: true,
+  irreversibility: true,
+  artifactPreview: true,
+  costWarning: true,
+  retryProtection: true,
+  inputValidation: true
+};
+var BalanceTracker = class {
+  lastBalanceAt = 0;
+  lastWriteAt = 0;
+  recordRead() {
+    this.lastBalanceAt = Date.now();
+  }
+  recordWrite() {
+    this.lastWriteAt = Date.now();
+  }
+  isStale() {
+    return this.lastWriteAt > this.lastBalanceAt;
+  }
+  hasEverRead() {
+    return this.lastBalanceAt > 0;
+  }
+};
+var BALANCE_READ_TOOLS = /* @__PURE__ */ new Set([
+  "balance_check",
+  "savings_info",
+  "health_check"
+]);
+var RetryTracker = class {
+  executed = /* @__PURE__ */ new Map();
+  key(toolName, input) {
+    const url = input?.url ?? "";
+    return `${toolName}:${url}`;
+  }
+  record(toolName, input, result) {
+    const r = result;
+    if (r?.paymentConfirmed || r?.doNotRetry) {
+      this.executed.set(this.key(toolName, input), { result, paidAt: Date.now() });
+    }
+  }
+  isBlocked(toolName, input) {
+    const prev = this.executed.get(this.key(toolName, input));
+    if (!prev) return { blocked: false };
+    return { blocked: true, previousResult: prev.result };
+  }
+};
+function guardRetryProtection(tool, call, retryTracker) {
+  const check = retryTracker.isBlocked(tool.name, call.input);
+  if (check.blocked) {
+    return {
+      verdict: "block",
+      gate: "retry_blocked",
+      tier: "safety",
+      message: `Blocked: ${tool.name} was already called and payment was confirmed. Do not retry.`
+    };
+  }
+  return { verdict: "pass", gate: "retry_blocked", tier: "safety" };
+}
+function guardIrreversibility(tool, _call, conversationText) {
+  if (!tool.flags.irreversible) {
+    return { verdict: "pass", gate: "irreversibility", tier: "safety" };
+  }
+  const hasPreview = /preview|here.s what|confirm.*send|looks? good/i.test(conversationText);
+  if (hasPreview) {
+    return { verdict: "pass", gate: "irreversibility", tier: "safety" };
+  }
+  return {
+    verdict: "hint",
+    gate: "irreversibility",
+    tier: "safety",
+    message: "This action is irreversible. Show a preview and ask the user to confirm before proceeding."
+  };
+}
+function guardBalanceValidation(tool, _call, balanceTracker) {
+  if (!tool.flags.requiresBalance) {
+    return { verdict: "pass", gate: "balance_required", tier: "financial" };
+  }
+  if (!balanceTracker.hasEverRead()) {
+    return {
+      verdict: "hint",
+      gate: "balance_required",
+      tier: "financial",
+      message: "Balance has not been checked this session. Call balance_check first to verify sufficient funds."
+    };
+  }
+  if (balanceTracker.isStale()) {
+    return {
+      verdict: "hint",
+      gate: "balance_required",
+      tier: "financial",
+      message: "Balance data is stale (a write action occurred since last check). Call balance_check first to verify sufficient funds."
+    };
+  }
+  return { verdict: "pass", gate: "balance_required", tier: "financial" };
+}
+function guardHealthFactor(tool, _call, lastHealthFactor, config) {
+  if (!tool.flags.affectsHealth) {
+    return { verdict: "pass", gate: "health_factor", tier: "financial" };
+  }
+  if (lastHealthFactor === null) {
+    return {
+      verdict: "hint",
+      gate: "health_factor",
+      tier: "financial",
+      message: "Health factor has not been checked this session. Call health_check before this action."
+    };
+  }
+  if (lastHealthFactor < config.blockBelow) {
+    return {
+      verdict: "block",
+      gate: "health_factor",
+      tier: "financial",
+      message: `Health factor is ${lastHealthFactor.toFixed(2)} \u2014 this action risks liquidation. Refusing.`
+    };
+  }
+  if (lastHealthFactor < config.warnBelow) {
+    return {
+      verdict: "warn",
+      gate: "health_factor",
+      tier: "financial",
+      message: `Health factor is ${lastHealthFactor.toFixed(2)} \u2014 this action may reduce it further.`
+    };
+  }
+  return { verdict: "pass", gate: "health_factor", tier: "financial" };
+}
+function guardLargeTransfer(tool, call, config) {
+  if (tool.name !== "send_transfer") {
+    return { verdict: "pass", gate: "large_transfer", tier: "financial" };
+  }
+  const input = call.input;
+  const amount = Number(input.amount ?? 0);
+  if (!amount || amount <= 0) {
+    return { verdict: "pass", gate: "large_transfer", tier: "financial" };
+  }
+  const recipient = String(input.recipient ?? input.to ?? "");
+  const shortAddr = recipient.length > 10 ? `${recipient.slice(0, 6)}...${recipient.slice(-4)}` : recipient;
+  if (amount > config.strongWarnAbove) {
+    return {
+      verdict: "warn",
+      gate: "large_transfer",
+      tier: "financial",
+      message: `High-value transfer ($${amount}). Double-check the address: ${shortAddr}`
+    };
+  }
+  if (amount > config.warnAbove) {
+    return {
+      verdict: "hint",
+      gate: "large_transfer",
+      tier: "financial",
+      message: `This is a large transfer ($${amount}). Verify the recipient address.`
+    };
+  }
+  return { verdict: "pass", gate: "large_transfer", tier: "financial" };
+}
+function guardSlippage(tool, _call, lastAssistantText) {
+  if (tool.name !== "swap_execute") {
+    return { verdict: "pass", gate: "slippage_warning", tier: "financial" };
+  }
+  const hasEstimate = /~?\$?[\d,]+\.?\d*\s*(SUI|USDC|USDT|WETH)/i.test(lastAssistantText) || /approximately|≈|about|expect|receive/i.test(lastAssistantText);
+  if (hasEstimate) {
+    return { verdict: "pass", gate: "slippage_warning", tier: "financial" };
+  }
+  return {
+    verdict: "hint",
+    gate: "slippage_warning",
+    tier: "financial",
+    message: "State the expected output amount to the user before executing the swap."
+  };
+}
+function guardCostWarning(tool, _call, conversationText) {
+  if (!tool.flags.costAware) {
+    return { verdict: "pass", gate: "cost_warning", tier: "ux" };
+  }
+  const hasCostMention = /\$\d+\.?\d*|cost|fee|charge|price|pay/i.test(conversationText);
+  if (hasCostMention) {
+    return { verdict: "pass", gate: "cost_warning", tier: "ux" };
+  }
+  return {
+    verdict: "hint",
+    gate: "cost_warning",
+    tier: "ux",
+    message: "This action has a monetary cost. Confirm the user is aware before proceeding."
+  };
+}
+function guardArtifactPreview(result) {
+  if (!result || typeof result !== "object") return null;
+  const r = result;
+  const hasImage = typeof r.url === "string" && /\.(png|jpg|jpeg|webp|gif|svg)(\?|$)/i.test(r.url) || Array.isArray(r.images) && r.images.length > 0 || typeof r.image_url === "string";
+  const hasPdf = typeof r.url === "string" && /\.pdf(\?|$)/i.test(r.url);
+  if (hasImage || hasPdf) {
+    return {
+      _gate: "artifact_preview",
+      _hint: "Show this to the user before proceeding. Output as ![description](url)."
+    };
+  }
+  return null;
+}
+function guardStaleData(toolFlags) {
+  if (!toolFlags.mutating) return null;
+  return {
+    _gate: "stale_data",
+    _hint: "A write action just completed. The balance snapshot is outdated. Do NOT calculate new balances from old data \u2014 call balance_check for fresh numbers, or use only the data returned by the write tool."
+  };
+}
+function createGuardRunnerState() {
+  return {
+    balanceTracker: new BalanceTracker(),
+    retryTracker: new RetryTracker(),
+    lastHealthFactor: null
+  };
+}
+function runGuards(tool, call, state, config, conversationContext) {
+  const results = [];
+  const now = Date.now();
+  if (config.inputValidation !== false && tool.preflight) {
+    const check = tool.preflight(call.input);
+    if (!check.valid) {
+      const event = {
+        timestamp: now,
+        toolName: tool.name,
+        toolUseId: call.id,
+        gate: "input_validation",
+        verdict: "block",
+        tier: "safety",
+        message: check.error
+      };
+      return {
+        blocked: true,
+        blockReason: check.error,
+        blockGate: "input_validation",
+        injections: [],
+        events: [event]
+      };
+    }
+  }
+  if (config.retryProtection !== false) {
+    results.push(guardRetryProtection(tool, call, state.retryTracker));
+  }
+  if (config.irreversibility !== false) {
+    results.push(guardIrreversibility(tool, call, conversationContext.fullText));
+  }
+  if (config.balanceValidation !== false) {
+    results.push(guardBalanceValidation(tool, call, state.balanceTracker));
+  }
+  if (config.healthFactor) {
+    results.push(guardHealthFactor(tool, call, state.lastHealthFactor, config.healthFactor));
+  }
+  if (config.largeTransfer) {
+    results.push(guardLargeTransfer(tool, call, config.largeTransfer));
+  }
+  if (config.slippage !== false) {
+    results.push(guardSlippage(tool, call, conversationContext.lastAssistantText));
+  }
+  if (config.costWarning !== false) {
+    results.push(guardCostWarning(tool, call, conversationContext.fullText));
+  }
+  const events = results.filter((r) => r.verdict !== "pass").map((r) => ({
+    timestamp: now,
+    toolName: tool.name,
+    toolUseId: call.id,
+    gate: r.gate,
+    verdict: r.verdict,
+    tier: r.tier,
+    message: r.message
+  }));
+  const block = results.find((r) => r.verdict === "block");
+  if (block) {
+    return {
+      blocked: true,
+      blockReason: block.message ?? `Blocked by ${block.gate}`,
+      blockGate: block.gate,
+      injections: [],
+      events
+    };
+  }
+  const injections = results.filter((r) => r.verdict === "hint" || r.verdict === "warn").map((r) => ({
+    _gate: r.gate,
+    ...r.verdict === "hint" ? { _hint: r.message } : { _warning: r.message }
+  }));
+  return { blocked: false, injections, events };
+}
+function updateGuardStateAfterToolResult(toolName, tool, input, result, isError, state) {
+  if (isError) return;
+  if (BALANCE_READ_TOOLS.has(toolName)) {
+    state.balanceTracker.recordRead();
+  }
+  if (tool?.flags.mutating) {
+    state.balanceTracker.recordWrite();
+  }
+  if (toolName === "health_check" && result && typeof result === "object") {
+    const r = result;
+    const hf = Number(r.healthFactor ?? r.health_factor ?? r.hf);
+    if (!isNaN(hf) && hf > 0) {
+      state.lastHealthFactor = hf;
+    }
+  }
+  state.retryTracker.record(toolName, input, result);
+}
+function extractConversationText(messages) {
+  const textParts = [];
+  let lastAssistantText = "";
+  for (const msg of messages) {
+    if (!Array.isArray(msg.content)) continue;
+    for (const block of msg.content) {
+      if (block.type === "text" && typeof block.text === "string") {
+        textParts.push(block.text);
+        if (msg.role === "assistant") {
+          lastAssistantText = block.text;
+        }
+      }
+    }
+  }
+  return {
+    fullText: textParts.join("\n"),
+    lastAssistantText
+  };
+}
+
 // src/engine.ts
 var DEFAULT_MAX_TURNS = 10;
 var DEFAULT_MAX_TOKENS = 4096;
@@ -3482,6 +3953,8 @@ var QueryEngine = class {
   maxTokens;
   temperature;
   toolChoice;
+  thinking;
+  outputConfig;
   agent;
   mcpManager;
   walletAddress;
@@ -3491,8 +3964,11 @@ var QueryEngine = class {
   env;
   txMutex = new TxMutex();
   costTracker;
+  guardConfig;
+  guardState;
   messages = [];
   abortController = null;
+  guardEvents = [];
   constructor(config) {
     this.provider = config.provider;
     this.agent = config.agent;
@@ -3507,8 +3983,12 @@ var QueryEngine = class {
     this.maxTokens = config.maxTokens ?? DEFAULT_MAX_TOKENS;
     this.temperature = config.temperature;
     this.toolChoice = config.toolChoice;
+    this.thinking = config.thinking;
+    this.outputConfig = config.outputConfig;
     this.systemPrompt = config.systemPrompt ?? DEFAULT_SYSTEM_PROMPT;
     this.costTracker = new CostTracker(config.costTracker);
+    this.guardConfig = config.guards;
+    this.guardState = createGuardRunnerState();
     this.tools = config.tools ?? (config.agent ? getDefaultTools() : []);
   }
   /**
@@ -3587,6 +4067,10 @@ var QueryEngine = class {
   reset() {
     this.messages = [];
     this.costTracker.reset();
+    this.guardEvents = [];
+  }
+  getGuardEvents() {
+    return this.guardEvents;
   }
   loadMessages(messages) {
     this.messages = [...messages];
@@ -3638,6 +4122,8 @@ var QueryEngine = class {
           const summary = this.messages.map((m, idx) => {
             const blocks = m.content.map((b) => {
               if (b.type === "text") return `text(${b.text.slice(0, 40)}\u2026)`;
+              if (b.type === "thinking") return `thinking(${b.thinking.length}ch)`;
+              if (b.type === "redacted_thinking") return `redacted_thinking`;
               if (b.type === "tool_use") return `tool_use:${b.id.slice(-8)}/${b.name}`;
               return `tool_result:${b.toolUseId.slice(-8)}`;
             });
@@ -3646,6 +4132,8 @@ var QueryEngine = class {
           console.log(`[engine] provider.chat turn=${turns} msgs=${this.messages.length}
 ${summary.join("\n")}`);
         }
+        const thinkingEnabled = this.thinking && this.thinking.type !== "disabled";
+        const effectiveToolChoice = thinkingEnabled ? applyToolChoice && turns === 1 ? "auto" : void 0 : applyToolChoice && turns === 1 ? this.toolChoice : void 0;
         const stream = this.provider.chat({
           messages: this.messages,
           systemPrompt: this.systemPrompt,
@@ -3653,7 +4141,9 @@ ${summary.join("\n")}`);
           model: this.model,
           maxTokens: this.maxTokens,
           temperature: this.temperature,
-          toolChoice: applyToolChoice && turns === 1 ? this.toolChoice : void 0,
+          toolChoice: effectiveToolChoice,
+          thinking: this.thinking,
+          outputConfig: this.outputConfig,
           signal
         });
         for await (const event of stream) {
@@ -3699,7 +4189,42 @@ ${summary.join("\n")}`);
         pendingWrite = { call, tool };
         break;
       }
-      for await (const toolEvent of runTools(approved, this.tools, context, this.txMutex)) {
+      const guardedApproved = [];
+      if (this.guardConfig) {
+        const convCtx = extractConversationText(this.messages);
+        for (const call of approved) {
+          const tool = findTool(this.tools, call.name);
+          if (!tool) {
+            guardedApproved.push(call);
+            continue;
+          }
+          const check = runGuards(tool, call, this.guardState, this.guardConfig, convCtx);
+          this.guardEvents.push(...check.events);
+          if (check.blocked) {
+            yield {
+              type: "tool_result",
+              toolName: call.name,
+              toolUseId: call.id,
+              result: { error: check.blockReason, _gate: check.blockGate },
+              isError: true
+            };
+            toolResultBlocks.push({
+              type: "tool_result",
+              toolUseId: call.id,
+              content: JSON.stringify({ error: check.blockReason, _gate: check.blockGate }),
+              isError: true
+            });
+            continue;
+          }
+          if (check.injections.length > 0) {
+            call._guardInjections = check.injections;
+          }
+          guardedApproved.push(call);
+        }
+      } else {
+        guardedApproved.push(...approved);
+      }
+      for await (const toolEvent of runTools(guardedApproved, this.tools, context, this.txMutex)) {
         if (toolEvent.type === "tool_result" && !toolEvent.isError) {
           const warning = flagSuspiciousResult(toolEvent.toolName, toolEvent.result);
           if (warning) {
@@ -3717,29 +4242,89 @@ ${summary.join("\n")}`);
             continue;
           }
         }
-        yield toolEvent;
-        if (toolEvent.type === "tool_result" && !toolEvent.isError) {
-          const r = toolEvent.result;
-          if (r && r.__canvas === true) {
-            yield {
-              type: "canvas",
-              template: String(r.template ?? ""),
-              title: String(r.title ?? ""),
-              data: r.templateData ?? null,
-              toolUseId: toolEvent.toolUseId
-            };
+        if (toolEvent.type === "tool_result") {
+          const tool = findTool(this.tools, toolEvent.toolName);
+          const originalCall = guardedApproved.find((c) => c.id === toolEvent.toolUseId);
+          updateGuardStateAfterToolResult(
+            toolEvent.toolName,
+            tool,
+            originalCall?.input ?? null,
+            toolEvent.result,
+            toolEvent.isError,
+            this.guardState
+          );
+          let enrichedResult = toolEvent.result;
+          if (this.guardConfig && !toolEvent.isError && tool) {
+            const artifactInj = this.guardConfig.artifactPreview !== false ? guardArtifactPreview(toolEvent.result) : null;
+            const staleInj = this.guardConfig.staleData !== false ? guardStaleData(tool.flags) : null;
+            const preInjections = guardedApproved.find((c) => c.id === toolEvent.toolUseId)?._guardInjections ?? [];
+            const allInjections = [
+              ...preInjections,
+              ...artifactInj ? [artifactInj] : [],
+              ...staleInj ? [staleInj] : []
+            ];
+            if (allInjections.length > 0 && typeof enrichedResult === "object" && enrichedResult) {
+              enrichedResult = { ...enrichedResult, _guards: allInjections };
+            }
+          }
+          const finalEvent = enrichedResult !== toolEvent.result ? { ...toolEvent, result: enrichedResult } : toolEvent;
+          yield finalEvent;
+          if (finalEvent.type === "tool_result" && !finalEvent.isError) {
+            const r = finalEvent.result;
+            if (r && r.__canvas === true) {
+              yield {
+                type: "canvas",
+                template: String(r.template ?? ""),
+                title: String(r.title ?? ""),
+                data: r.templateData ?? null,
+                toolUseId: finalEvent.toolUseId
+              };
+            }
           }
+          toolResultBlocks.push({
+            type: "tool_result",
+            toolUseId: finalEvent.toolUseId,
+            content: JSON.stringify(finalEvent.result),
+            isError: finalEvent.isError
+          });
+          continue;
         }
-        if (toolEvent.type === "tool_result") {
+        yield toolEvent;
+      }
+      if (pendingWrite && this.guardConfig) {
+        const convCtx = extractConversationText(this.messages);
+        const check = runGuards(
+          pendingWrite.tool,
+          pendingWrite.call,
+          this.guardState,
+          this.guardConfig,
+          convCtx
+        );
+        this.guardEvents.push(...check.events);
+        if (check.blocked) {
+          yield {
+            type: "tool_result",
+            toolName: pendingWrite.call.name,
+            toolUseId: pendingWrite.call.id,
+            result: { error: check.blockReason, _gate: check.blockGate },
+            isError: true
+          };
           toolResultBlocks.push({
             type: "tool_result",
-            toolUseId: toolEvent.toolUseId,
-            content: JSON.stringify(toolEvent.result),
-            isError: toolEvent.isError
+            toolUseId: pendingWrite.call.id,
+            content: JSON.stringify({ error: check.blockReason, _gate: check.blockGate }),
+            isError: true
           });
+          this.messages.push({ role: "assistant", content: acc.assistantBlocks });
+          this.messages.push({ role: "user", content: toolResultBlocks });
+          continue;
+        }
+        if (check.injections.length > 0) {
+          pendingWrite.call._guardInjections = check.injections;
         }
       }
       if (pendingWrite) {
+        const writeGuardInjections = pendingWrite.call._guardInjections;
         yield {
           type: "pending_action",
           action: {
@@ -3752,7 +4337,8 @@ ${summary.join("\n")}`);
               toolUseId: b.toolUseId,
               content: b.content,
               isError: b.isError ?? false
-            }))
+            })),
+            ...writeGuardInjections?.length ? { guardInjections: writeGuardInjections } : {}
           }
         };
         return;
@@ -3782,6 +4368,26 @@ ${summary.join("\n")}`);
   }
   *handleProviderEvent(event, acc) {
     switch (event.type) {
+      case "thinking_delta": {
+        yield { type: "thinking_delta", text: event.text };
+        break;
+      }
+      case "thinking_done": {
+        acc.assistantBlocks.push({
+          type: "thinking",
+          thinking: event.thinking,
+          signature: event.signature
+        });
+        yield { type: "thinking_done", signature: event.signature };
+        break;
+      }
+      case "redacted_thinking": {
+        acc.assistantBlocks.push({
+          type: "redacted_thinking",
+          data: event.data
+        });
+        break;
+      }
       case "text_delta": {
         acc.text += event.text;
         yield { type: "text_delta", text: event.text };
@@ -4029,6 +4635,165 @@ var MemorySessionStore = class {
   }
 };
 
+// src/classify-effort.ts
+function classifyEffort(model, userMessage, matchedRecipe, sessionWriteCount) {
+  const supportsMax = model.includes("opus-4-6");
+  const msg = userMessage.toLowerCase();
+  if (supportsMax) {
+    if (matchedRecipe?.name === "portfolio_rebalance") return "max";
+    if (matchedRecipe?.name === "emergency_withdraw") return "max";
+    if (/rebalance|reallocate|dca setup|close.*position/i.test(msg)) return "max";
+  }
+  if (matchedRecipe && matchedRecipe.steps.length >= 3) return "high";
+  if (matchedRecipe?.name === "safe_borrow" || matchedRecipe?.name === "bulk_mail") return "high";
+  if (sessionWriteCount > 0 && /borrow|withdraw|send|swap/i.test(msg)) return "high";
+  if (/balance|rate|how much|what is|check|history|show|price/i.test(msg)) return "low";
+  if (!matchedRecipe && !/deposit|send|swap|borrow|withdraw|save|pay/i.test(msg)) return "low";
+  return "medium";
+}
+
+// src/prompt-cache.ts
+function buildCachedSystemPrompt(staticParts, dynamicPart) {
+  const blocks = staticParts.map((text, i) => ({
+    type: "text",
+    text,
+    ...i === staticParts.length - 1 && { cache_control: { type: "ephemeral" } }
+  }));
+  if (dynamicPart) {
+    blocks.push({ type: "text", text: dynamicPart });
+  }
+  return blocks;
+}
+
+// src/intelligence.ts
+function buildProfileContext(profile) {
+  if (!profile || profile.riskConfidence < 0.3) return "";
+  const lines = ["User financial profile (inferred from conversation history):"];
+  if (profile.riskConfidence >= 0.5) {
+    lines.push(`- Risk appetite: ${profile.riskAppetite}`);
+  }
+  if (profile.literacyConfidence >= 0.5) {
+    lines.push(`- Financial literacy: ${profile.financialLiteracy}`);
+    if (profile.financialLiteracy === "advanced") {
+      lines.push("  \u2192 Skip basic DeFi explanations (health factor, APY, etc). User knows these.");
+    }
+    if (profile.financialLiteracy === "novice") {
+      lines.push("  \u2192 Always explain DeFi concepts in plain language.");
+    }
+  }
+  if (profile.currencyFraming === "fiat") {
+    lines.push('- Frame amounts as dollars (e.g. "$50" not "50 USDC")');
+  }
+  if (profile.prefersBriefResponses) {
+    lines.push("- Prefers brief responses \u2014 be concise");
+  }
+  if (profile.primaryGoals.length > 0) {
+    lines.push(`- Stated goals: ${profile.primaryGoals.join(", ")}`);
+  }
+  if (profile.knownPatterns.length > 0) {
+    lines.push(`- Behavioural patterns: ${profile.knownPatterns.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+function buildProactivenessInstructions(profile) {
+  const brevityGuidance = profile?.prefersBriefResponses ? "This user prefers brevity \u2014 only surface context if urgent or directly actionable." : "Surface relevant context when criteria are met.";
+  const styleGuidance = profile?.financialLiteracy === "novice" ? "Frame observations in plain English, no DeFi jargon." : "Technical framing is fine.";
+  return `Proactive awareness:
+After completing the user's request, consider whether ONE additional piece of financial
+context is worth mentioning. ${brevityGuidance}
+
+\u2713 Mention if:
+- Their savings goal is materially off-track (>20% behind pace)
+- Yield rate changed significantly since last session (>0.5%)
+- They have idle USDC >$50 sitting for >48h
+- An action they just took interacts with an active goal or debt position
+- A pattern would materially benefit from their attention
+
+\u2717 Do NOT mention if:
+- Tangentially related but not actionable
+- Already surfaced this session
+- Requires more explanation than the original answer
+- Would seem pushy or sales-y
+
+${styleGuidance}
+Format: One sentence maximum, after main response, separated by a line break.
+Frame as observation, not advice: "Your Tokyo goal is $80 behind pace." \u2014 not "You should deposit more."`;
+}
+function buildSelfEvaluationInstruction() {
+  return `Self-evaluation (apply silently before composing your response):
+
+1. ACCURACY \u2014 Quote exact values from tool results, not estimates or rounded figures.
+   Never combine post-action tool results with pre-action snapshot numbers.
+   If the tool returned an error, label it as an error \u2014 do not paraphrase it as success.
+
+2. STATE CONSISTENCY \u2014 Describe the actual outcome of all steps.
+   Partial success (swap ok, deposit failed): describe both clearly.
+   Never describe a failed action as if it succeeded.
+
+3. COMPLETENESS \u2014 If the user asked multiple things, answer all of them.
+   If you couldn't complete something, explain why and what the current state is.
+
+4. TONE \u2014 Match tone to outcome.
+   Success: confirming and forward-looking.
+   Failure: clear about what failed, unchanged, and what to do next.
+   Warning: specific risk, not generic caution.
+
+If any check fails, rewrite before outputting.`;
+}
+
+// src/state/conversation-state.ts
+function buildStateContext(state) {
+  switch (state.type) {
+    case "idle":
+      return "";
+    case "mid_recipe": {
+      const elapsed = Math.round((Date.now() - state.startedAt) / 6e4);
+      const outputs = JSON.stringify(state.completedStepOutputs);
+      return [
+        `Conversation state: MID-RECIPE`,
+        `Active recipe: ${state.recipeName} (step ${state.currentStep + 1} of ${state.totalSteps})`,
+        `Started: ${elapsed} minutes ago`,
+        `Completed step key outputs: ${outputs}`,
+        `If the user asks an unrelated question: answer briefly, then offer to continue the ${state.recipeName} flow.`,
+        `If the user says "cancel" or "stop": confirm you have abandoned the recipe and return to idle.`
+      ].join("\n");
+    }
+    case "awaiting_confirmation": {
+      const expiryMins = Math.max(0, Math.round((state.expiresAt - Date.now()) / 6e4));
+      const expired = state.expiresAt < Date.now();
+      return [
+        `Conversation state: AWAITING CONFIRMATION`,
+        `Proposed action: ${state.action}${state.amount ? ` for $${state.amount}` : ""}${state.recipient ? ` to ${state.recipient}` : ""}`,
+        expired ? `Status: EXPIRED \u2014 ask if user still wants to proceed` : `Expires in: ${expiryMins} minutes`,
+        `"yes/confirm/do it" \u2192 execute. "no/cancel/wait" \u2192 abort, reset to idle.`
+      ].join("\n");
+    }
+    case "post_error":
+      return [
+        `Conversation state: POST-ERROR`,
+        `Failed action: ${state.failedAction}`,
+        `Error: ${state.errorMessage}`,
+        state.partialState ? `Partial state: ${state.partialState}` : "",
+        `Acknowledge failure clearly. Offer a specific recovery path if one exists.`,
+        `This state clears automatically on the next successful action.`
+      ].filter(Boolean).join("\n");
+    case "post_liquidation_warning":
+      return [
+        `Conversation state: LIQUIDATION WARNING ACTIVE`,
+        `Health factor: ${state.healthFactor.toFixed(2)} \u2014 below safe threshold`,
+        `Prioritise debt repayment or collateral deposit.`,
+        `Do not proceed with any action that would further reduce health factor.`
+      ].join("\n");
+    case "onboarding":
+      return [
+        `Conversation state: ONBOARDING (session ${state.sessionNumber})`,
+        state.sessionNumber === 1 ? "First session \u2014 introduce capabilities through context, not a feature list." : `Returning user \u2014 ${state.hasSavedBefore ? "has saved before" : "has not saved yet"}.`
+      ].join("\n");
+    default:
+      return "";
+  }
+}
+
 // src/context.ts
 var CHARS_PER_TOKEN = 4;
 function estimateTokens(messages) {
@@ -4044,6 +4809,10 @@ function blockCharCount(block) {
   switch (block.type) {
     case "text":
       return block.text.length;
+    case "thinking":
+      return block.thinking.length;
+    case "redacted_thinking":
+      return block.data.length;
     case "tool_use":
       return block.name.length + JSON.stringify(block.input).length;
     case "tool_result":
@@ -4372,6 +5141,7 @@ function adaptMcpTool(mcpTool, config) {
     isReadOnly,
     isConcurrencySafe: isReadOnly,
     permissionLevel,
+    flags: {},
     async call(input, _context) {
       const result = await config.manager.callTool(
         config.serverName,
@@ -4437,17 +5207,26 @@ var AnthropicProvider = class {
         toolChoice = { type: "tool", name: params.toolChoice.name };
       }
     }
-    const streamParams = {
+    const thinkingParam = toAnthropicThinking(params.thinking);
+    const systemParam = toAnthropicSystem(params.systemPrompt);
+    const baseParams = {
       model: params.model ?? this.defaultModel,
       max_tokens: params.maxTokens ?? this.defaultMaxTokens,
-      system: params.systemPrompt,
+      system: systemParam,
       messages,
+      stream: true,
       tools: tools.length > 0 ? tools : void 0,
-      ...params.temperature !== void 0 && { temperature: params.temperature },
+      ...!thinkingParam && params.temperature !== void 0 && { temperature: params.temperature },
       ...toolChoice && { tool_choice: toolChoice }
     };
+    const streamParams = {
+      ...baseParams,
+      ...thinkingParam && { thinking: thinkingParam },
+      ...params.outputConfig?.effort && { output_config: { effort: params.outputConfig.effort } }
+    };
     const stream = params.signal ? this.client.messages.stream(streamParams, { signal: params.signal }) : this.client.messages.stream(streamParams);
     const toolInputBuffers = /* @__PURE__ */ new Map();
+    const thinkingBuffers = /* @__PURE__ */ new Map();
     let outputTokensFromStart = 0;
     try {
       for await (const event of stream) {
@@ -4485,6 +5264,10 @@ var AnthropicProvider = class {
                 id: block.id,
                 name: block.name
               };
+            } else if (block.type === "thinking") {
+              thinkingBuffers.set(event.index, { type: "thinking", text: "", signature: "" });
+            } else if (block.type === "redacted_thinking") {
+              thinkingBuffers.set(event.index, { type: "redacted_thinking", data: block.data ?? "" });
             }
             break;
           }
@@ -4502,26 +5285,41 @@ var AnthropicProvider = class {
                   partialJson: delta.partial_json
                 };
               }
+            } else if (delta.type === "thinking_delta") {
+              const buf = thinkingBuffers.get(event.index);
+              if (buf?.type === "thinking") buf.text += delta.thinking ?? "";
+              yield { type: "thinking_delta", text: delta.thinking ?? "" };
+            } else if (delta.type === "signature_delta") {
+              const buf = thinkingBuffers.get(event.index);
+              if (buf?.type === "thinking") buf.signature = delta.signature ?? "";
             }
             break;
           }
           case "content_block_stop": {
-            const buf = toolInputBuffers.get(event.index);
-            if (buf) {
+            const toolBuf = toolInputBuffers.get(event.index);
+            if (toolBuf) {
               let input = {};
               try {
-                input = JSON.parse(buf.json || "{}");
+                input = JSON.parse(toolBuf.json || "{}");
               } catch {
                 input = {};
               }
               yield {
                 type: "tool_use_done",
-                id: buf.id,
-                name: buf.name,
+                id: toolBuf.id,
+                name: toolBuf.name,
                 input
               };
               toolInputBuffers.delete(event.index);
             }
+            const thinkBuf = thinkingBuffers.get(event.index);
+            if (thinkBuf?.type === "thinking") {
+              yield { type: "thinking_done", thinking: thinkBuf.text, signature: thinkBuf.signature };
+              thinkingBuffers.delete(event.index);
+            } else if (thinkBuf?.type === "redacted_thinking") {
+              yield { type: "redacted_thinking", data: thinkBuf.data };
+              thinkingBuffers.delete(event.index);
+            }
             break;
           }
           case "message_delta": {
@@ -4551,11 +5349,28 @@ var AnthropicProvider = class {
     }
   }
 };
+function toAnthropicSystem(prompt) {
+  if (typeof prompt === "string") return prompt;
+  return prompt.map((block) => ({
+    type: "text",
+    text: block.text,
+    ...block.cache_control && { cache_control: block.cache_control }
+  }));
+}
+function toAnthropicThinking(config) {
+  if (!config || config.type === "disabled") return void 0;
+  if (config.type === "adaptive") return { type: "adaptive" };
+  return { type: "enabled", budget_tokens: config.budgetTokens };
+}
 function toAnthropicMessage(msg) {
   const content = msg.content.map((block) => {
     switch (block.type) {
       case "text":
         return { type: "text", text: block.text };
+      case "thinking":
+        return { type: "thinking", thinking: block.thinking, signature: block.signature };
+      case "redacted_thinking":
+        return { type: "redacted_thinking", data: block.data };
       case "tool_use":
         return {
           type: "tool_use",
@@ -4571,7 +5386,7 @@ function toAnthropicMessage(msg) {
           is_error: block.isError
         };
     }
-  });
+  }).filter((b) => b !== null);
   return { role: msg.role, content };
 }
 function toAnthropicTool(def) {
@@ -4660,6 +5475,6 @@ function sanitizeAnthropicMessages(messages) {
   return merged;
 }
 
-export { AnthropicProvider, CANVAS_TEMPLATES, CostTracker, DEFAULT_SYSTEM_PROMPT, McpClientManager, McpResponseCache, MemorySessionStore, NAVI_MCP_CONFIG, NAVI_MCP_URL, NAVI_SERVER_NAME, NaviTools, QueryEngine, READ_TOOLS, TxMutex, WRITE_TOOLS, activitySummaryTool, adaptAllMcpTools, adaptAllServerTools, adaptMcpTool, balanceCheckTool, borrowTool, buildMcpTools, buildTool, claimRewardsTool, clearPriceCache, compactMessages, defillamaChainTvlTool, defillamaPriceChangeTool, defillamaProtocolFeesTool, defillamaProtocolInfoTool, defillamaSuiProtocolsTool, defillamaTokenPricesTool, defillamaYieldPoolsTool, engineToSSE, estimateTokens, explainTxTool, extractMcpText, fetchAvailableRewards, fetchBalance, fetchHealthFactor, fetchPositions, fetchProtocolStats, fetchRates, fetchSavings, fetchTokenPrices, fetchWalletCoins, findTool, getDefaultTools, getMcpManager, getWalletAddress, hasNaviMcp, healthCheckTool, mppServicesTool, parseMcpJson, parseSSE, payApiTool, portfolioAnalysisTool, protocolDeepDiveTool, ratesInfoTool, registerEngineTools, renderCanvasTool, repayDebtTool, requireAgent, runTools, saveContactTool, saveDepositTool, savingsInfoTool, sendTransferTool, serializeSSE, spendingAnalyticsTool, swapExecuteTool, swapQuoteTool, toolsToDefinitions, transactionHistoryTool, transformBalance, transformHealthFactor, transformPositions, transformRates, transformRewards, transformSavings, validateHistory, voloStakeTool, voloStatsTool, voloUnstakeTool, webSearchTool, withdrawTool, yieldSummaryTool };
+export { AnthropicProvider, BalanceTracker, CANVAS_TEMPLATES, CostTracker, DEFAULT_GUARD_CONFIG, DEFAULT_SYSTEM_PROMPT, McpClientManager, McpResponseCache, MemorySessionStore, NAVI_MCP_CONFIG, NAVI_MCP_URL, NAVI_SERVER_NAME, NaviTools, QueryEngine, READ_TOOLS, RetryTracker, TOOL_FLAGS, TxMutex, WRITE_TOOLS, activitySummaryTool, adaptAllMcpTools, adaptAllServerTools, adaptMcpTool, applyToolFlags, balanceCheckTool, borrowTool, buildCachedSystemPrompt, buildMcpTools, buildProactivenessInstructions, buildProfileContext, buildSelfEvaluationInstruction, buildStateContext, buildTool, claimRewardsTool, classifyEffort, clearPriceCache, compactMessages, createGuardRunnerState, defillamaChainTvlTool, defillamaPriceChangeTool, defillamaProtocolFeesTool, defillamaProtocolInfoTool, defillamaSuiProtocolsTool, defillamaTokenPricesTool, defillamaYieldPoolsTool, engineToSSE, estimateTokens, explainTxTool, extractConversationText, extractMcpText, fetchAvailableRewards, fetchBalance, fetchHealthFactor, fetchPositions, fetchProtocolStats, fetchRates, fetchSavings, fetchTokenPrices, fetchWalletCoins, findTool, getDefaultTools, getMcpManager, getToolFlags, getWalletAddress, guardArtifactPreview, guardStaleData, hasNaviMcp, healthCheckTool, mppServicesTool, parseMcpJson, parseSSE, payApiTool, portfolioAnalysisTool, protocolDeepDiveTool, ratesInfoTool, registerEngineTools, renderCanvasTool, repayDebtTool, requireAgent, runGuards, runTools, saveContactTool, saveDepositTool, savingsInfoTool, sendTransferTool, serializeSSE, spendingAnalyticsTool, swapExecuteTool, swapQuoteTool, toolsToDefinitions, transactionHistoryTool, transformBalance, transformHealthFactor, transformPositions, transformRates, transformRewards, transformSavings, updateGuardStateAfterToolResult, validateHistory, voloStakeTool, voloStatsTool, voloUnstakeTool, webSearchTool, withdrawTool, yieldSummaryTool };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map