@agether/agether 2.11.0 → 2.12.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agether/agether",
-  "version": "2.11.0",
+  "version": "2.12.1",
   "description": "OpenClaw plugin for Agether — onchain credit for AI agents on Ethereum & Base",
   "main": "src/index.ts",
   "openclaw": {
@@ -9,7 +9,7 @@
     ]
   },
   "dependencies": {
-    "@agether/sdk": "^2.13.0",
+    "@agether/sdk": "^2.14.0",
     "axios": "^1.6.0",
     "ethers": "^6.9.0"
   },

package/skills/agether/SKILL.md

@@ -38,7 +38,8 @@ If you don't paste it, the user sees NOTHING. An empty colon ":" with no data af
 13. **To get USDC for x402:** call `morpho_deposit_and_borrow` with collateral from your EOA. Do NOT ask the user to send tokens — check your balance first.
 14. **Check health before large actions.** Before borrowing, depositing, or withdrawing significant amounts, call `agether_health` to see current LTV and headroom. This prevents failed transactions.
 15. **Batch awareness:** `morpho_deposit_and_borrow` is a batched operation (deposit + borrow in one tx). Always prefer it over separate `morpho_deposit` then `morpho_borrow` when doing both — it saves gas and is atomic.
-16. **Collateral and loan tokens are dynamic.** Don't hardcode tokens. Call `morpho_markets` to discover which collateral/loan token pairs are available. The SDK auto-discovers from Morpho GraphQL API.
+16. **Collateral and loan tokens are dynamic.** Don't hardcode tokens. Use `morpho_search` to find any token by name, `morpho_borrowing_options` to discover what the user can borrow, and `morpho_markets` to list all markets. The SDK searches Morpho's full GraphQL registry — no token is "unsupported" unless it truly has no market.
+17. **Never say "token X is not supported" without searching first.** Always call `morpho_search(token: "X")` before telling the user a token isn't available. The registry has 500+ markets.
 17. **Withdrawals stay in AgentAccount by default.** `morpho_withdraw` and `morpho_withdraw_supply` keep funds in the Safe account unless `toEoa: true` is passed. Use `wallet_withdraw_token` / `wallet_withdraw_eth` to move any token or ETH from AgentAccount to EOA.
 18. **Always show Health Factor when reporting positions.** HF = LLTV / LTV. HF > 1.15 = safe 🟢, HF 1.0–1.15 = warning 🟡, HF ≤ 1.0 = liquidation 🔴. `morpho_status` returns HF per position. Always paste it so the user understands their risk.
 
@@ -135,6 +136,10 @@ Both `agether_set_agent` and `agether_register` save the agentId to config perma
 |------|--------|-------------|
 | `morpho_status` | none | Show all Morpho positions — collateral, debt, LTV, **Health Factor** (HF), headroom, risk level per market |
 | `morpho_markets` | `token?`, `loanToken?` | List all Morpho Blue markets — supply/borrow APY, utilization, LLTV, liquidity. Optional collateral or loan token filter. |
+| `morpho_search` | `token`, `asCollateral?`, `asLoanToken?` | **Search Morpho markets by token name** (fuzzy). Use when user asks about a specific token (ezETH, rETH, wstETH, etc.). No hardcoded list — searches full registry. |
+| `morpho_borrowing_options` | `collateral?` | **"What can I borrow?"** Without args: scans wallet for tokens with balance > 0, finds matching collateral markets. With `collateral`: finds all markets for that token. |
+| `morpho_supply_options` | `loanToken` | **"Where can I lend X?"** Shows all markets where the token is the loan asset (user supplies to earn yield). |
+| `morpho_wallet_tokens` | none | **Scan wallet** for all ERC-20 tokens that exist in Morpho markets. Shows every token with balance > 0. |
 | `morpho_max_borrowable` | none | Calculate max additional loan token borrowable given current collateral/debt across all markets |
 | `morpho_deposit` | `amount`, `token` | Deposit collateral from EOA → Morpho (no borrow). Token auto-discovered. |
 | `morpho_deposit_and_borrow` | `collateralAmount`, `token`, `borrowAmount`, `loanToken?` | **PREFERRED** — Deposit + borrow in one batched tx (ERC-7579 batch mode). Supports any loan token. Best for first-time setup. |
@@ -292,6 +297,49 @@ For supply positions (lent tokens):
 3. Suggest optimal strategy based on their holdings
 ```
 
+### User asks "what can I borrow?" or "what can I do with my tokens?"
+```
+IF user specifies a token (e.g. "what can I borrow with WETH?"):
+  → morpho_borrowing_options(collateral: "WETH")
+  → Shows all markets where WETH is collateral + available loan tokens
+
+IF user asks generally ("what can I borrow?"):
+  → morpho_borrowing_options()      ← no args = wallet scan mode
+  → Scans wallet for all tokens with balance > 0
+  → For each token, finds markets where it can be collateral
+  → Shows options grouped by collateral token with APYs
+
+IF no tokens found in wallet:
+  → Tell user: "Your wallet is empty. Send tokens to <EOA address>"
+  → morpho_markets to show which collateral tokens are accepted
+```
+
+### User asks "where can I put X as collateral?" or "are there ezETH markets?"
+```
+1. morpho_search(token: "ezETH", asCollateral: true)
+   → Searches Morpho's full registry (not just cached top markets)
+   → Shows all markets where ezETH is collateral
+2. IF no results → "No markets for ezETH on this chain."
+3. IF results → present the markets with APYs, LLTVs, liquidity
+```
+
+### User asks "what can I supply?" or "where can I lend USDC?"
+```
+1. morpho_supply_options(loanToken: "USDC")
+   → Shows all markets where USDC is the loan token
+   → User supplies USDC to earn yield from borrowers
+2. Present: sorted by supply APY (highest first)
+3. Suggest the most liquid market with best APY
+```
+
+### User asks "what tokens do I have?" or "what's in my wallet?"
+```
+1. morpho_wallet_tokens()        ← scans all ERC-20s from Morpho markets
+   → Returns every token with balance > 0 (symbol + amount + address)
+2. Present the list clearly
+3. Optionally follow up with morpho_borrowing_options() to show what they can do
+```
+
 ### User asks to check or refresh credit score
 ```
 1. IF user says "refresh" / "update" / "get new score":

package/src/index.ts

@@ -958,6 +958,176 @@ export default function register(api: any) {
     },
   });
 
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: morpho_search  (Morpho GraphQL search — find any token)
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "morpho_search",
+    description:
+      "Search Morpho markets by token name. Use this when the user asks about a specific token " +
+      "(e.g. 'ezETH', 'wstETH', 'rETH', 'cbBTC') to find all markets where it appears. " +
+      "No hardcoded list — searches Morpho's full market registry.",
+    parameters: {
+      type: "object",
+      properties: {
+        token: { type: "string", description: "Token name or symbol to search for (e.g. 'WETH', 'ezETH', 'wstETH')" },
+        asCollateral: { type: "boolean", description: "Only show markets where token is used as collateral (default: false)" },
+        asLoanToken: { type: "boolean", description: "Only show markets where token is the loan asset (default: false)" },
+      },
+      required: ["token"],
+    },
+    async execute(_id: string, params: { token: string; asCollateral?: boolean; asLoanToken?: boolean }) {
+      try {
+        const cfg = getConfig(api);
+        const client = createMorphoClient(cfg);
+        const results = await client.searchMarkets(params.token, {
+          asCollateral: params.asCollateral,
+          asLoanToken: params.asLoanToken,
+        });
+
+        if (results.length === 0) return ok(`No markets found for "${params.token}" on this chain.`);
+
+        const formatted = results.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); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: morpho_borrowing_options  (wallet scan → matching markets)
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "morpho_borrowing_options",
+    description:
+      "Find what the agent can borrow. " +
+      "Without arguments: scans wallet for all tokens with balance > 0, then finds Morpho markets " +
+      "where each token can be used as collateral. " +
+      "With 'collateral' argument: finds all markets for that specific collateral token. " +
+      "Use this when user asks 'what can I borrow?', 'where can I put X as collateral?', " +
+      "'what can I borrow with my WETH?'",
+    parameters: {
+      type: "object",
+      properties: {
+        collateral: {
+          type: "string",
+          description: "Specific collateral token to check (e.g. 'WETH', 'ezETH'). If omitted, scans wallet for all tokens.",
+        },
+      },
+      required: [],
+    },
+    async execute(_id: string, params: { collateral?: string }) {
+      try {
+        const cfg = getConfig(api);
+        const client = createMorphoClient(cfg);
+        const options = await client.findBorrowingOptions(params.collateral);
+
+        if (options.length === 0) {
+          if (params.collateral) {
+            return ok(`No borrowing markets found for ${params.collateral} as collateral on this chain.`);
+          }
+          return ok("No tokens with balance > 0 found in the agent wallet, or no matching Morpho markets exist.");
+        }
+
+        // Format for LLM readability
+        const formatted = options.map(opt => ({
+          collateralToken: opt.collateralToken,
+          walletBalance: opt.collateralBalance,
+          availableMarkets: opt.markets.map(m => ({
+            borrow: m.loanToken,
+            borrowApy: m.borrowApy,
+            lltv: m.lltv,
+            utilization: m.utilization,
+            availableLiquidity: m.availableLiquidity,
+          })),
+        }));
+
+        return ok(JSON.stringify(formatted, null, 2));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: morpho_supply_options  (find lending opportunities)
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "morpho_supply_options",
+    description:
+      "Find supply/lending opportunities for a specific loan token. " +
+      "Use when user asks 'what can I supply to earn WETH?', 'where can I lend USDC?', " +
+      "'what supply APY is available for USDC?'. " +
+      "Shows all markets where the specified token is the loan asset (user supplies it to earn yield).",
+    parameters: {
+      type: "object",
+      properties: {
+        loanToken: { type: "string", description: "The token to supply/lend (e.g. 'USDC', 'WETH')" },
+      },
+      required: ["loanToken"],
+    },
+    async execute(_id: string, params: { loanToken: string }) {
+      try {
+        const cfg = getConfig(api);
+        const client = createMorphoClient(cfg);
+        const options = await client.findSupplyOptions(params.loanToken);
+
+        if (options.length === 0) return ok(`No supply markets found for ${params.loanToken} on this chain.`);
+
+        const formatted = options.map((m: any) => ({
+          collateral: m.collateralToken,
+          loan: m.loanToken,
+          supplyApy: m.supplyApy,
+          lltv: m.lltv,
+          utilization: m.utilization,
+          totalSupply: m.totalSupply,
+        }));
+
+        return ok(JSON.stringify(formatted, null, 2));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: morpho_wallet_tokens  (scan wallet for all token balances)
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "morpho_wallet_tokens",
+    description:
+      "Scan the agent's wallet for all ERC-20 tokens that exist in Morpho markets. " +
+      "Shows every token with balance > 0. Use this when user asks 'what tokens do I have?', " +
+      "'what's in my wallet?', 'what can I use?'.",
+    parameters: {
+      type: "object",
+      properties: {},
+      required: [],
+    },
+    async execute(_id: string) {
+      try {
+        const cfg = getConfig(api);
+        const client = createMorphoClient(cfg);
+        const tokens = await client.getWalletTokenBalances();
+
+        if (tokens.length === 0) return ok("No tokens with balance > 0 found in the agent wallet.");
+
+        const formatted = tokens.map(t => ({
+          token: t.symbol,
+          balance: t.balanceFormatted,
+          address: t.address,
+        }));
+
+        return ok(JSON.stringify(formatted, null, 2));
+      } catch (e) { return fail(e); }
+    },
+  });
+
   // ═══════════════════════════════════════════════════════
   //  TOOL: agether_score  (backend API — x402 gated)
   // ═══════════════════════════════════════════════════════