@agether/agether 2.11.0 → 2.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agether/agether",
-  "version": "2.11.0",
+  "version": "2.12.0",
   "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/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)
   // ═══════════════════════════════════════════════════════