@agether/agether 2.1.0 → 2.3.0

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "agether",
   "name": "Agether Credit",
   "description": "Onchain credit protocol for AI agents — Morpho-backed overcollateralized credit, ERC-8004 identity, x402 payments. Private key and RPC keys are read from OpenClaw secrets (env vars); no plaintext config needed.",
-  "version": "2.0.1",
+  "version": "2.3.0",
   "skills": ["skills/agether"],
   "configSchema": {
     "type": "object",
@@ -17,16 +17,16 @@
         "description": "Auto-borrow from Morpho credit line when USDC balance is low for x402 payments",
         "default": false
       },
+      "autoYield": {
+        "type": "boolean",
+        "description": "Auto-withdraw earned yield from supply positions before borrowing. Waterfall: balance → yield → borrow",
+        "default": false
+      },
       "dailySpendLimitUsdc": {
         "type": "number",
-        "description": "Daily USDC spending cap for x402 payments (0 = unlimited)",
+        "description": "Daily USDC spending cap for x402 auto-draw payments (0 = unlimited). Persisted to cache file so it survives restarts.",
         "default": 0
       },
-      "yieldLimitedSpending": {
-        "type": "boolean",
-        "description": "Limit auto-draw spending to theoretical yield on deposited collateral",
-        "default": false
-      },
       "autoDrawBuffer": {
         "type": "number",
         "description": "Extra USDC buffer when auto-drawing from Morpho (e.g. 0.5 = borrow $0.50 extra)",
@@ -43,8 +43,8 @@
   "uiHints": {
     "agentId": { "label": "Agent ID", "placeholder": "17676" },
     "autoDraw": { "label": "Auto-Draw Credit", "placeholder": "false" },
+    "autoYield": { "label": "Auto-Yield (use yield before borrowing)", "placeholder": "false" },
     "dailySpendLimitUsdc": { "label": "Daily Spend Limit (USDC)", "placeholder": "0" },
-    "yieldLimitedSpending": { "label": "Yield-Limited Spending", "placeholder": "false" },
     "autoDrawBuffer": { "label": "Auto-Draw Buffer (USDC)", "placeholder": "0" },
     "healthAlertThreshold": { "label": "Health Alert Threshold (%)", "placeholder": "70" }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agether/agether",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "OpenClaw plugin for Agether — onchain credit for AI agents",
   "main": "src/index.ts",
   "openclaw": {
@@ -9,7 +9,7 @@
     ]
   },
   "dependencies": {
-    "@agether/sdk": "^2.4.0",
+    "@agether/sdk": "^2.6.0",
     "axios": "^1.6.0",
     "ethers": "^6.9.0"
   },

package/src/index.ts

@@ -29,6 +29,44 @@ const BACKEND_URL = "http://95.179.189.214:3001";
 const DEFAULT_RPC = "https://base-rpc.publicnode.com";
 const BASESCAN = "https://basescan.org/tx";
 
+// ─── Spending Cache (persists dailySpendLimit tracker across restarts) ────
+
+const SPEND_CACHE_FILE = path.join(
+  process.env.HOME || process.env.USERPROFILE || "/root",
+  ".openclaw",
+  ".agether-spend-cache.json",
+);
+
+interface SpendCacheData {
+  date: string;           // YYYY-MM-DD
+  totalBorrowed: string;  // raw bigint string (6-decimal USDC units)
+}
+
+function loadSpendCache(): SpendCacheData | undefined {
+  try {
+    if (fs.existsSync(SPEND_CACHE_FILE)) {
+      const raw = fs.readFileSync(SPEND_CACHE_FILE, "utf-8");
+      const data: SpendCacheData = JSON.parse(raw);
+      // Only return if it's today's data
+      const today = new Date().toISOString().split("T")[0];
+      if (data.date === today && data.totalBorrowed) return data;
+    }
+  } catch (e) {
+    console.warn("[agether] failed to load spend cache:", e instanceof Error ? e.message : String(e));
+  }
+  return undefined;
+}
+
+function saveSpendCache(state: SpendCacheData): void {
+  try {
+    const dir = path.dirname(SPEND_CACHE_FILE);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(SPEND_CACHE_FILE, JSON.stringify(state, null, 2));
+  } catch (e) {
+    console.warn("[agether] failed to save spend cache:", e instanceof Error ? e.message : String(e));
+  }
+}
+
 // ─── Helpers ──────────────────────────────────────────────
 
 interface PluginConfig {
@@ -339,12 +377,12 @@ export default function register(api: any) {
   api.registerTool({
     name: "morpho_deposit",
     description:
-      "Deposit collateral (WETH, wstETH, or cbETH) into Morpho Blue via AgentAccount. Enables borrowing USDC.",
+      "Deposit collateral into Morpho Blue via AgentAccount. Enables borrowing USDC. Token is auto-discovered from available markets.",
     parameters: {
       type: "object",
       properties: {
         amount: { type: "string", description: "Amount of collateral tokens (e.g. '0.05')" },
-        token: { type: "string", enum: ["WETH", "wstETH", "cbETH"], description: "Collateral token" },
+        token: { type: "string", description: "Collateral token" },
       },
       required: ["amount", "token"],
     },
@@ -375,7 +413,7 @@ export default function register(api: any) {
       type: "object",
       properties: {
         collateralAmount: { type: "string", description: "Amount of collateral (e.g. '0.05')" },
-        token: { type: "string", enum: ["WETH", "wstETH", "cbETH"], description: "Collateral token" },
+        token: { type: "string", description: "Collateral token" },
         borrowAmount: { type: "string", description: "USDC amount to borrow (e.g. '50')" },
       },
       required: ["collateralAmount", "token", "borrowAmount"],
@@ -414,7 +452,7 @@ export default function register(api: any) {
         agentId: { type: "string", description: "Target agent's ERC-8004 ID (e.g. '17676')" },
         agentAddress: { type: "string", description: "Target AgentAccount address (alternative to agentId)" },
         amount: { type: "string", description: "Collateral amount (e.g. '0.05')" },
-        token: { type: "string", enum: ["WETH", "wstETH", "cbETH"], description: "Collateral token" },
+        token: { type: "string", description: "Collateral token" },
       },
       required: ["amount", "token"],
     },
@@ -452,7 +490,7 @@ export default function register(api: any) {
       type: "object",
       properties: {
         amount: { type: "string", description: "Amount in USD to borrow (e.g. '100')" },
-        token: { type: "string", enum: ["WETH", "wstETH", "cbETH"], description: "Collateral token (optional, auto-detected)" },
+        token: { type: "string", description: "Collateral token (optional, auto-detected)" },
       },
       required: ["amount"],
     },
@@ -484,7 +522,7 @@ export default function register(api: any) {
       type: "object",
       properties: {
         amount: { type: "string", description: "Amount in USD to repay (e.g. '50' or 'all' for full repayment)" },
-        token: { type: "string", enum: ["WETH", "wstETH", "cbETH"], description: "Collateral token (optional, auto-detected)" },
+        token: { type: "string", description: "Collateral token (optional, auto-detected)" },
       },
       required: ["amount"],
     },
@@ -509,21 +547,25 @@ export default function register(api: any) {
   api.registerTool({
     name: "morpho_withdraw",
     description:
-      "Withdraw collateral from Morpho Blue back to EOA wallet. " +
+      "Withdraw collateral from Morpho Blue. " +
+      "By default keeps collateral in AgentAccount. Set toEoa=true to send to EOA wallet. " +
       "Use amount 'all' to withdraw maximum. Must maintain collateral ratio if debt remains.",
     parameters: {
       type: "object",
       properties: {
         amount: { type: "string", description: "Amount to withdraw (e.g. '0.05' or 'all')" },
-        token: { type: "string", enum: ["WETH", "wstETH", "cbETH"], description: "Collateral token" },
+        token: { type: "string", description: "Collateral token" },
+        toEoa: { type: "boolean", description: "Send to EOA wallet instead of keeping in AgentAccount (default: false)" },
       },
       required: ["amount", "token"],
     },
-    async execute(_id: string, params: { amount: string; token: string }) {
+    async execute(_id: string, params: { amount: string; token: string; toEoa?: boolean }) {
       try {
         const cfg = getConfig(api);
         const client = createClient(cfg);
-        const result = await client.withdrawCollateral(params.token, params.amount);
+        // Default: keep in AgentAccount. toEoa=true → send to EOA.
+        const receiver = params.toEoa ? await client.getSignerAddress() : await client.getAccountAddress();
+        const result = await client.withdrawCollateral(params.token, params.amount, undefined, receiver);
         return ok(JSON.stringify({
           status: "withdrawn",
           amount: result.amount,
@@ -551,7 +593,7 @@ export default function register(api: any) {
         amount: { type: "string", description: "USDC amount to supply (e.g. '500')" },
         market: {
           type: "string",
-          enum: ["WETH", "wstETH", "cbETH"],
+         
           description: "Which market to supply to, identified by collateral token (optional — auto-picks highest APY)",
         },
       },
@@ -588,7 +630,7 @@ export default function register(api: any) {
       properties: {
         market: {
           type: "string",
-          enum: ["WETH", "wstETH", "cbETH"],
+         
           description: "Filter by market collateral token (optional)",
         },
       },
@@ -634,6 +676,7 @@ export default function register(api: any) {
     name: "morpho_withdraw_supply",
     description:
       "Withdraw supplied USDC (principal + earned interest) from a Morpho Blue lending position. " +
+      "By default keeps USDC in AgentAccount. Set toEoa=true to send to EOA wallet. " +
       "Use amount 'all' to withdraw the full position. Different from morpho_withdraw which withdraws collateral.",
     parameters: {
       type: "object",
@@ -641,17 +684,20 @@ export default function register(api: any) {
         amount: { type: "string", description: "USDC amount to withdraw (e.g. '100' or 'all')" },
         market: {
           type: "string",
-          enum: ["WETH", "wstETH", "cbETH"],
+         
           description: "Market collateral token (optional — auto-detects)",
         },
+        toEoa: { type: "boolean", description: "Send to EOA wallet instead of keeping in AgentAccount (default: false)" },
       },
       required: ["amount"],
     },
-    async execute(_id: string, params: { amount: string; market?: string }) {
+    async execute(_id: string, params: { amount: string; market?: string; toEoa?: boolean }) {
       try {
         const cfg = getConfig(api);
         const client = createClient(cfg);
-        const result = await client.withdrawSupply(params.amount, params.market);
+        // Default: keep in AgentAccount. toEoa=true → send to EOA.
+        const receiver = params.toEoa ? await client.getSignerAddress() : await client.getAccountAddress();
+        const result = await client.withdrawSupply(params.amount, params.market, receiver);
         return ok(JSON.stringify({
           status: "withdrawn",
           amount: params.amount === "all" ? "all (full position)" : `$${params.amount} USDC`,
@@ -664,70 +710,38 @@ export default function register(api: any) {
   });
 
   // ═══════════════════════════════════════════════════════
-  //  TOOL: morpho_pay_from_yield  (pay using only earned yield)
+  //  TOOL: morpho_markets  (Morpho GraphQL API — no backend)
   // ═══════════════════════════════════════════════════════
   api.registerTool({
-    name: "morpho_pay_from_yield",
+    name: "morpho_markets",
     description:
-      "Pay a recipient using ONLY earned yield from a supply position. " +
-      "Your principal stays untouched — only the interest earned gets withdrawn and sent. " +
-      "Fails if requested amount exceeds available yield.",
+      "List available Morpho Blue USDC markets on Base — liquidity, supply/borrow APY, utilization, LLTV. " +
+      "Optionally filter by collateral token.",
     parameters: {
       type: "object",
       properties: {
-        recipient: { type: "string", description: "Recipient address (0x...)" },
-        amount: { type: "string", description: "USDC amount to pay from yield (e.g. '2.50')" },
-        market: {
-          type: "string",
-          enum: ["WETH", "wstETH", "cbETH"],
-          description: "Which supply position to use (optional — auto-picks highest yield)",
-        },
+        token: { type: "string", description: "Filter by collateral token (optional)" },
       },
-      required: ["recipient", "amount"],
+      required: [],
     },
-    async execute(_id: string, params: { recipient: string; amount: string; market?: string }) {
+    async execute(_id: string, params: { token?: string }) {
       try {
         const cfg = getConfig(api);
         const client = createClient(cfg);
-        const result = await client.payFromYield(params.recipient, params.amount, params.market);
-        return ok(JSON.stringify({
-          status: "paid_from_yield",
-          amount: `$${params.amount} USDC`,
-          recipient: params.recipient,
-          remainingYield: `$${result.remainingYield} USDC`,
-          remainingSupply: `$${result.remainingSupply} USDC`,
-          note: "Paid from earned interest only — principal untouched",
-          tx: txLink(result.tx),
-        }));
-      } catch (e) { return fail(e); }
-    },
-  });
+        const rates = await client.getMarketRates(params.token);
 
-  // ═══════════════════════════════════════════════════════
-  //  TOOL: morpho_markets  (Morpho GraphQL API — no backend)
-  // ═══════════════════════════════════════════════════════
-  api.registerTool({
-    name: "morpho_markets",
-    description:
-      "List available Morpho Blue USDC borrow markets on Base with liquidity, APY, and collateral info.",
-    parameters: { type: "object", properties: {}, required: [] },
-    async execute() {
-      try {
-        const cfg = getConfig(api);
-        const client = createClient(cfg);
-        const markets = await client.getMarkets(true);
-
-        const formatted = markets
-          .filter((m) => m.collateralAsset.address !== "0x0000000000000000000000000000000000000000")
-          .map((m) => ({
-            collateral: m.collateralAsset.symbol,
-            loan: m.loanAsset.symbol,
-            lltv: `${(Number(m.lltv) / 1e16).toFixed(0)}%`,
-            totalSupply: `$${(Number(m.totalSupplyAssets) / 1e6).toFixed(0)}`,
-            totalBorrow: `$${(Number(m.totalBorrowAssets) / 1e6).toFixed(0)}`,
-            utilization: `${(m.utilization * 100).toFixed(1)}%`,
-            marketId: m.uniqueKey.slice(0, 18) + "…",
-          }));
+        if (rates.length === 0) return ok("No markets found.");
+
+        const formatted = rates.map((r: any) => ({
+          collateral: r.collateralToken,
+          loan: r.loanToken,
+          lltv: r.lltv,
+          supplyApy: `${(r.supplyApy * 100).toFixed(2)}%`,
+          borrowApy: `${(r.borrowApy * 100).toFixed(2)}%`,
+          utilization: `${(r.utilization * 100).toFixed(1)}%`,
+          totalSupply: `$${r.totalSupplyUsd.toFixed(0)}`,
+          totalBorrow: `$${r.totalBorrowUsd.toFixed(0)}`,
+        }));
 
         return ok(JSON.stringify(formatted, null, 2));
       } catch (e) { return fail(e); }
@@ -808,24 +822,88 @@ export default function register(api: any) {
   });
 
   // ═══════════════════════════════════════════════════════
-  //  TOOL: x402_pay (with auto-draw support)
+  //  TOOL: wallet_withdraw_token
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "wallet_withdraw_token",
+    description:
+      "Withdraw (transfer) a token from AgentAccount to EOA wallet. " +
+      "Works with any ERC-20 token (USDC, WETH, wstETH, cbBTC, etc.). " +
+      "Use amount 'all' to withdraw the full balance.",
+    parameters: {
+      type: "object",
+      properties: {
+        token: { type: "string", description: "Token to withdraw (e.g. 'USDC', 'WETH')" },
+        amount: { type: "string", description: "Amount to withdraw (e.g. '100' or 'all')" },
+      },
+      required: ["token", "amount"],
+    },
+    async execute(_id: string, params: { token: string; amount: string }) {
+      try {
+        const cfg = getConfig(api);
+        const client = createClient(cfg);
+        const result = await client.withdrawToken(params.token, params.amount);
+        return ok(JSON.stringify({
+          status: "withdrawn",
+          token: result.token,
+          amount: result.amount,
+          destination: result.destination,
+          tx: txLink(result.tx),
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: wallet_withdraw_eth
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "wallet_withdraw_eth",
+    description:
+      "Withdraw ETH from AgentAccount to EOA wallet. " +
+      "Use amount 'all' to withdraw the full ETH balance.",
+    parameters: {
+      type: "object",
+      properties: {
+        amount: { type: "string", description: "ETH amount to withdraw (e.g. '0.01' or 'all')" },
+      },
+      required: ["amount"],
+    },
+    async execute(_id: string, params: { amount: string }) {
+      try {
+        const cfg = getConfig(api);
+        const client = createClient(cfg);
+        const result = await client.withdrawEth(params.amount);
+        return ok(JSON.stringify({
+          status: "withdrawn",
+          token: "ETH",
+          amount: `${result.amount} ETH`,
+          destination: result.destination,
+          tx: txLink(result.tx),
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: x402_pay (with auto-yield + auto-draw waterfall)
   // ═══════════════════════════════════════════════════════
   api.registerTool({
     name: "x402_pay",
     description:
       "Make a paid API call using x402 protocol. Pays with USDC from AgentAccount via EIP-3009 signature. " +
-      "Set autoDraw=true to automatically borrow from Morpho Blue if USDC balance is insufficient (opt-in).",
+      "If USDC is insufficient, auto-sources funds: yield first (autoYield), then borrow (autoDraw). " +
+      "Both are configured in plugin settings.",
     parameters: {
       type: "object",
       properties: {
         url: { type: "string", description: "API endpoint URL" },
         method: { type: "string", enum: ["GET", "POST"], description: "HTTP method (default: GET)" },
         body: { type: "string", description: "JSON body for POST requests" },
-        autoDraw: { type: "boolean", description: "Auto-borrow from Morpho if USDC insufficient (default: false)" },
       },
       required: ["url"],
     },
-    async execute(_id: string, params: { url: string; method?: string; body?: string; autoDraw?: boolean }) {
+    async execute(_id: string, params: { url: string; method?: string; body?: string }) {
       try {
         const cfg = getConfig(api);
         const agetherCfg = api.config?.plugins?.entries?.agether?.config || {};
@@ -840,7 +918,8 @@ export default function register(api: any) {
           console.warn('[agether] x402_pay: getAccountAddress failed, paying from EOA:', e instanceof Error ? e.message : e);
         }
 
-        const autoDrawEnabled = params.autoDraw === true; // default false — opt-in only
+        const autoDrawEnabled = agetherCfg.autoDraw === true;
+        const autoYieldEnabled = agetherCfg.autoYield === true;
         const x402 = new X402Client({
           privateKey: cfg.privateKey,
           rpcUrl: cfg.rpcUrl,
@@ -848,16 +927,20 @@ export default function register(api: any) {
           agentId,
           accountAddress,
           autoDraw: autoDrawEnabled,
+          autoYield: autoYieldEnabled,
           dailySpendLimitUsdc: agetherCfg.dailySpendLimitUsdc,
-          yieldLimitedSpending: agetherCfg.yieldLimitedSpending,
           autoDrawBuffer: agetherCfg.autoDrawBuffer,
+          // Restore spending state from cache so limit survives restarts
+          initialSpendingState: loadSpendCache(),
+          // Persist every spending update to cache file
+          onSpendingUpdate: (state: any) => saveSpendCache(state),
           // Safe7579 needs validator prefix for ERC-1271 isValidSignature routing
           validatorModule: "0xde896C58163b5f6cAC5B16C1b0109843f26106F6",
         });
 
         let result;
-        if (autoDrawEnabled && agentId) {
-          // Use payWithAutoDraw which handles balance check + borrow
+        if ((autoDrawEnabled || autoYieldEnabled) && agentId) {
+          // Use payWithAutoDraw which handles waterfall: balance → yield → borrow
           const fetchOpts: any = {
             morphoClient: client,
           };
@@ -885,98 +968,22 @@ export default function register(api: any) {
           };
         }
         if (result.autoDrawInfo) {
-          response.autoDraw = {
-            ...result.autoDrawInfo,
-            borrowTx: result.autoDrawInfo.borrowTx ? txLink(result.autoDrawInfo.borrowTx) : undefined,
-          };
+          const info: any = { reason: result.autoDrawInfo.reason };
+          if (result.autoDrawInfo.yieldWithdrawn) {
+            info.yieldWithdrawn = `$${result.autoDrawInfo.yieldWithdrawn} USDC`;
+            if (result.autoDrawInfo.yieldTx) info.yieldTx = txLink(result.autoDrawInfo.yieldTx);
+          }
+          if (result.autoDrawInfo.borrowed) {
+            info.borrowed = `$${result.autoDrawInfo.borrowed} USDC`;
+            if (result.autoDrawInfo.borrowTx) info.borrowTx = txLink(result.autoDrawInfo.borrowTx);
+          }
+          response.autoFund = info;
         }
         return ok(JSON.stringify(response, null, 2));
       } catch (e) { return fail(e); }
     },
   });
 
-  // ═══════════════════════════════════════════════════════
-  //  TOOL: morpho_rates
-  // ═══════════════════════════════════════════════════════
-  api.registerTool({
-    name: "morpho_rates",
-    description:
-      "Show current Morpho Blue market rates — supply APY, borrow APY, utilization for USDC markets. " +
-      "Note: collateral does NOT earn yield on Morpho; supply APY is what lenders earn.",
-    parameters: {
-      type: "object",
-      properties: {
-        token: { type: "string", enum: ["WETH", "wstETH", "cbETH"], description: "Filter by collateral token (optional)" },
-      },
-      required: [],
-    },
-    async execute(_id: string, params: { token?: string }) {
-      try {
-        const cfg = getConfig(api);
-        const client = createClient(cfg);
-        const rates = await client.getMarketRates(params.token);
-
-        if (rates.length === 0) return ok("No markets found.");
-
-        const formatted = rates.map((r: any) => ({
-          collateral: r.collateralToken,
-          loan: r.loanToken,
-          supplyApy: `${(r.supplyApy * 100).toFixed(2)}%`,
-          borrowApy: `${(r.borrowApy * 100).toFixed(2)}%`,
-          utilization: `${(r.utilization * 100).toFixed(1)}%`,
-          totalSupply: `$${r.totalSupplyUsd.toFixed(0)}`,
-          totalBorrow: `$${r.totalBorrowUsd.toFixed(0)}`,
-          lltv: r.lltv,
-        }));
-
-        return ok(JSON.stringify(formatted, null, 2));
-      } catch (e) { return fail(e); }
-    },
-  });
-
-  // ═══════════════════════════════════════════════════════
-  //  TOOL: morpho_yield_estimate
-  // ═══════════════════════════════════════════════════════
-  api.registerTool({
-    name: "morpho_yield_estimate",
-    description:
-      "Estimate theoretical yield for collateral deposited in Morpho Blue. " +
-      "⚠️ Collateral does NOT actually earn yield on Morpho. This estimates " +
-      "what it WOULD earn if it were supplied as a lender instead. " +
-      "Useful for setting spending caps based on theoretical earnings.",
-    parameters: {
-      type: "object",
-      properties: {
-        token: { type: "string", enum: ["WETH", "wstETH", "cbETH"], description: "Collateral token" },
-        amount: { type: "string", description: "Collateral amount (e.g. '1.5')" },
-        periodDays: { type: "number", description: "Period in days (default: 1)" },
-        ethPriceUsd: { type: "number", description: "ETH price in USD (optional, uses oracle if not provided)" },
-      },
-      required: ["token", "amount"],
-    },
-    async execute(_id: string, params: { token: string; amount: string; periodDays?: number; ethPriceUsd?: number }) {
-      try {
-        const cfg = getConfig(api);
-        const client = createClient(cfg);
-        const result = await client.getYieldEstimate(
-          params.token,
-          params.amount,
-          params.periodDays || 1,
-          params.ethPriceUsd,
-        );
-
-        return ok(JSON.stringify({
-          collateral: `${result.amount} ${result.collateralToken}`,
-          collateralValueUsd: `$${result.collateralValueUsd.toFixed(2)}`,
-          theoreticalSupplyApy: `${(result.theoreticalSupplyApy * 100).toFixed(2)}%`,
-          estimatedYieldUsd: `$${result.estimatedYieldUsd.toFixed(4)}`,
-          period: `${result.periodDays} day(s)`,
-          disclaimer: result.disclaimer,
-        }, null, 2));
-      } catch (e) { return fail(e); }
-    },
-  });
-
   // ═══════════════════════════════════════════════════════
   //  TOOL: morpho_max_borrowable
   // ═══════════════════════════════════════════════════════
@@ -1177,13 +1184,32 @@ export default function register(api: any) {
         const client = createClient(cfg);
         const b = await client.getBalances();
 
+        const nz = (v: string) => parseFloat(v) > 0;
+
         let text = `💰 Agent #${b.agentId}\n`;
-        text += `Address: ${b.address}\n`;
-        text += `ETH: ${parseFloat(b.eth).toFixed(6)}\n`;
-        text += `USDC: $${b.usdc}`;
+        text += `Address: ${b.address}`;
+        if (nz(b.eth)) text += `\nETH: ${parseFloat(b.eth).toFixed(6)}`;
+        if (nz(b.usdc)) text += `\nUSDC: $${b.usdc}`;
+        for (const [sym, val] of Object.entries(b.collateral ?? {})) {
+          if (nz(val)) text += `\n${sym}: ${parseFloat(val).toFixed(6)}`;
+        }
+
         if (b.agentAccount) {
-          text += `\n\n🏦 AgentAccount: ${b.agentAccount.address}\nUSDC: $${b.agentAccount.usdc}`;
+          const a = b.agentAccount;
+          const hasAny = nz(a.eth) || nz(a.usdc) ||
+            Object.values(a.collateral ?? {}).some(nz);
+          if (hasAny) {
+            text += `\n\n🏦 AgentAccount: ${a.address}`;
+            if (nz(a.eth)) text += `\nETH: ${parseFloat(a.eth).toFixed(6)}`;
+            if (nz(a.usdc)) text += `\nUSDC: $${a.usdc}`;
+            for (const [sym, val] of Object.entries(a.collateral ?? {})) {
+              if (nz(val)) text += `\n${sym}: ${parseFloat(val).toFixed(6)}`;
+            }
+          } else {
+            text += `\n\n🏦 AgentAccount: ${a.address}\n(empty)`;
+          }
         }
+
         return { text };
       } catch (e: any) {
         return { text: `❌ ${e.message}` };