@agether/agether 1.0.0

package/README.md

@@ -0,0 +1,116 @@
+# @agether/openclaw-plugin
+
+OpenClaw plugin for **Agether** — on-chain credit protocol for AI agents on Base.
+
+## Prerequisites
+
+- [OpenClaw](https://docs.openclaw.ai) installed and running (`npm i -g openclaw`)
+- A Telegram bot connected (or any other OpenClaw channel)
+- A wallet private key with some ETH on **Base** (chain 8453) for gas
+
+## Install
+
+```bash
+openclaw plugins install @agether/openclaw-plugin
+```
+
+## Configure
+
+Edit `~/.openclaw/openclaw.json` and add the `agether` entry under `plugins.entries`:
+
+```jsonc
+// ~/.openclaw/openclaw.json
+{
+  "plugins": {
+    "entries": {
+      "agether": {
+        "enabled": true,
+        "config": {
+          "privateKey": "0x...",       // required — your wallet PK
+          "rpcUrl": "https://base-rpc.publicnode.com",  // optional (default)
+          "backendUrl": "http://95.179.189.214:3001",   // optional (default)
+          "autoDraw": false            // optional — auto-borrow for x402 payments
+        }
+      }
+    }
+  }
+}
+```
+
+Then restart the gateway:
+
+```bash
+openclaw gateway --force
+```
+
+> ⚠️ **Never share your private key.** The `privateKey` field is marked as sensitive in the plugin manifest.
+
+## Verify
+
+```bash
+openclaw plugins list
+```
+
+You should see `Agether Credit` with status `loaded`.
+
+## Tools
+
+Once installed, the following tools are available to your AI agent:
+
+| Tool | Description |
+|---|---|
+| `agether_balance` | Check ETH & USDC balances (EOA + AgentAccount) |
+| `agether_register` | Mint ERC-8004 identity & create AgentAccount |
+| `agether_score` | Get Bayesian credit score with 5-factor breakdown |
+| `morpho_status` | Show all Morpho credit positions |
+| `morpho_deposit` | Deposit collateral (WETH, wstETH, cbETH) |
+| `morpho_deposit_and_borrow` | Deposit collateral + borrow USDC in one step |
+| `morpho_sponsor` | Human deposits collateral for an agent (by ID or address) |
+| `morpho_borrow` | Borrow USDC against deposited collateral |
+| `morpho_repay` | Repay USDC debt |
+| `morpho_withdraw` | Withdraw collateral back to EOA |
+| `morpho_compare` | Compare collateral options with current prices |
+| `morpho_markets` | List supported Morpho Blue markets |
+| `wallet_fund` | Transfer USDC from EOA into AgentAccount |
+| `x402_pay` | Make paid API calls via x402 protocol (supports auto-draw) |
+
+## Commands
+
+Quick commands that run without AI:
+
+- `/balance` — wallet balances
+- `/morpho` — Morpho positions overview
+
+## Quick Start
+
+1. Install the plugin: `openclaw plugins install @agether/openclaw-plugin`
+2. Add config to `~/.openclaw/openclaw.json` (see above)
+3. Restart: `openclaw gateway --force`
+4. Open Telegram and send to your bot: *"What is my balance?"*
+5. Ask: *"Register me as an agent on Agether"*
+6. Fund your wallet with ETH (for gas) and WETH/wstETH/cbETH (for collateral)
+7. Ask: *"Deposit 0.05 WETH and borrow $50 USDC"*
+
+## Getting Collateral on Base
+
+- **ETH**: Bridge from Ethereum via [Base Bridge](https://bridge.base.org) or buy on any exchange that supports Base
+- **WETH**: Wrap ETH on [Uniswap](https://app.uniswap.org) (Base) or use `weth.deposit()` directly
+- **wstETH / cbETH**: Swap on [Uniswap](https://app.uniswap.org) or bridge from Ethereum
+
+## Config Options
+
+| Option | Required | Default | Description |
+|---|---|---|---|
+| `privateKey` | ✅ | — | Wallet private key for signing transactions |
+| `rpcUrl` | — | `https://base-rpc.publicnode.com` | Base RPC endpoint |
+| `backendUrl` | — | `http://95.179.189.214:3001` | Agether backend API |
+| `autoDraw` | — | `false` | Auto-borrow from credit line when USDC is insufficient for x402 payments |
+
+## Links
+
+- [Agether SDK](https://www.npmjs.com/package/@agether/sdk) — CLI + TypeScript clients
+- [ERC-8004 Standard](https://eips.ethereum.org/EIPS/eip-8004) — Agent Identity
+
+## License
+
+MIT

package/openclaw.plugin.json

@@ -0,0 +1,44 @@
+{
+  "id": "agether",
+  "name": "Agether Credit",
+  "description": "On-chain credit protocol for AI agents — Morpho-backed overcollateralized credit, ERC-8004 identity, x402 payments",
+  "version": "1.2.0",
+  "skills": ["skills/agether"],
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "privateKey": {
+        "type": "string",
+        "description": "Wallet private key for signing transactions"
+      },
+      "agentId": {
+        "type": "string",
+        "description": "ERC-8004 agent ID (set after registration)"
+      },
+      "rpcUrl": {
+        "type": "string",
+        "description": "Base RPC endpoint",
+        "default": "https://base-rpc.publicnode.com"
+      },
+      "backendUrl": {
+        "type": "string",
+        "description": "Agether backend URL",
+        "default": "http://95.179.189.214:3001"
+      },
+      "autoDraw": {
+        "type": "boolean",
+        "description": "Auto-borrow from Morpho credit line when USDC balance is low for x402 payments",
+        "default": false
+      }
+    },
+    "required": ["privateKey"]
+  },
+  "uiHints": {
+    "privateKey": { "label": "Private Key", "sensitive": true },
+    "agentId": { "label": "Agent ID", "placeholder": "17676" },
+    "rpcUrl": { "label": "RPC URL", "placeholder": "https://base-rpc.publicnode.com" },
+    "backendUrl": { "label": "Backend URL", "placeholder": "http://95.179.189.214:3001" },
+    "autoDraw": { "label": "Auto-Draw Credit", "placeholder": "false" }
+  }
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@agether/agether",
+  "version": "1.0.0",
+  "description": "OpenClaw plugin for Agether — on-chain credit for AI agents",
+  "main": "src/index.ts",
+  "openclaw": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  },
+  "dependencies": {
+    "@agether/sdk": "^1.6.5",
+    "axios": "^1.6.0",
+    "ethers": "^6.9.0"
+  },
+  "peerDependencies": {
+    "@sinclair/typebox": "*"
+  },
+  "keywords": [
+    "openclaw",
+    "agether",
+    "ai-agents",
+    "credit",
+    "defi"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  }
+}

package/skills/agether/SKILL.md

@@ -0,0 +1,241 @@
+---
+name: agether
+description: On-chain credit protocol for AI agents on Base. Morpho credit, x402 payments, ERC-8004 identity.
+---
+
+# Agether — On-Chain Credit for AI Agents
+
+You are an AI agent with on-chain financial capabilities on **Base mainnet**. You can earn credit, borrow USDC, and pay for APIs autonomously.
+
+---
+
+## 🚨 CRITICAL: THE USER CANNOT SEE TOOL RESULTS
+
+Tool results are invisible to the user. They ONLY see your text messages.
+After EVERY tool call, you MUST paste the important fields from the result into your reply:
+- tx links (always full URL)
+- agentId
+- balances
+- amounts
+- errors
+
+If you don't paste it, the user sees NOTHING. An empty colon ":" with no data after it is a bug.
+
+## ⚡ BEHAVIOR RULES
+
+1. **PASTE tool results into your reply.** Every tool returns JSON. Extract the key fields and write them in your message. The user cannot see tool output directly.
+2. **ALWAYS paste tx links.** Tools return `tx` field like `https://basescan.org/tx/0x...`. Copy it verbatim into your reply.
+3. **After on-chain actions, call `agether_balance` and paste the balances.**
+4. **On first message, call `agether_balance`.** If `agentId` is `"?"`, you need to set it up — see AGENT ID RESOLUTION below. If not registered at all, call `agether_register`.
+5. **Be proactive** — if the user asks to call a paid API, do the full flow without asking.
+6. **Never ask for private keys** — already configured.
+7. **Max LTV is 80%** (125% collateral ratio). To borrow $X, you need $X × 1.25 in collateral value.
+8. **When user says "register" → ALWAYS call `agether_register`.** A wallet CAN have multiple ERC-8004 identities. The tool handles everything. Never refuse to register because the wallet "already has an identity". Just call the tool.
+9. **Never guess about blockchain state.** If you're unsure, call the tool. Don't tell the user something is impossible — try it first.
+10. **Your EOA wallet IS the user's wallet.** Same private key, same address. If the user says "I have WETH", call `agether_balance` — you'll see it in the `collateral` field. You already have access to those tokens.
+11. **`morpho_deposit` and `morpho_deposit_and_borrow` transfer collateral from your EOA automatically.** You do NOT need anyone to "send you" tokens. If your EOA has WETH, just call the deposit tool directly. The SDK handles EOA→AgentAccount→Morpho in one flow.
+12. **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.
+
+---
+
+## 🆔 AGENT ID RESOLUTION (CRITICAL)
+
+If `agether_balance` returns `agentId: "?"`, ALL Morpho tools will fail. You MUST resolve this first:
+
+```
+1. Check your memory for a previously registered agentId
+2. IF you find an agentId in memory:
+     → Ask user: "I remember agent ID <X> from before. Should I use it, or register a new one?"
+     → IF user says yes → call `agether_set_agent(agentId: "<X>")`
+     → IF user says no  → call `agether_register(name: "<ask name>")`
+3. IF no agentId in memory:
+     → call `agether_register(name: "<ask name>")`
+4. After either path → call `agether_balance` to confirm agentId is set
+```
+
+Both `agether_set_agent` and `agether_register` save the agentId to config permanently (survives restarts).
+
+---
+
+## 🛠 YOUR TOOLS
+
+### Identity & Wallet
+| Tool | What it does |
+|------|-------------|
+| `agether_balance` | Show ETH + USDC + collateral (WETH/wstETH/cbETH) balances for both EOA wallet and AgentAccount |
+| `agether_register` | Register on-chain: mints ERC-8004 identity NFT + creates AgentAccount. Auto-saves agentId to config. |
+| `agether_set_agent` | Set a known agentId (e.g. from memory) and save to config. Use when agentId is "?" but you remember it. |
+| `agether_score` | Get credit score. `refresh: false` = free read. `refresh: true` = pays x402, computes fresh score on-chain. **Always call this when user asks about score.** |
+| `wallet_fund` | Transfer USDC from EOA wallet → AgentAccount |
+
+### Morpho Credit (Overcollateralized — instant, no approval)
+| Tool | Params | What it does |
+|------|--------|-------------|
+| `morpho_markets` | none | List supported Morpho markets and parameters |
+| `morpho_status` | none | Show all Morpho positions (collateral + debt) |
+| `morpho_deposit` | `amount`, `token` | Deposit collateral from EOA → Morpho (no borrow) |
+| `morpho_deposit_and_borrow` | `collateralAmount`, `token`, `borrowAmount` | Deposit + borrow in one flow. **Best for first-time setup** |
+| `morpho_borrow` | `amount` (USD) | Borrow USDC against existing collateral → lands in AgentAccount |
+| `morpho_repay` | `amount` (USD) | Repay USDC debt from AgentAccount → Morpho |
+| `morpho_withdraw` | `amount` (or "all"), `token` | Withdraw collateral back to EOA wallet |
+| `morpho_sponsor` | `agentId`/`agentAddress`, `amount`, `token`, `borrow?` | Deposit collateral for another agent |
+
+### x402 Payments
+| Tool | Params | What it does |
+|------|--------|-------------|
+| `x402_pay` | `url`, `method?`, `body?`, `autoDraw?` | Make a paid API call. Pays with USDC via EIP-3009 signature |
+
+### Slash Commands (user types these)
+| Command | What it does |
+|---------|-------------|
+| `/balance` | Quick balance check |
+| `/morpho` | Quick Morpho position summary |
+
+---
+
+## 📋 DECISION TREES
+
+### User asks to call a paid API (x402)
+```
+1. agether_balance → check USDC in AgentAccount AND collateral on EOA
+2. IF AgentAccount has USDC ≥ $0.01:
+     → x402_pay(url)
+3. IF no USDC but has collateral deposited in Morpho:
+     → morpho_borrow(amount: "1")    ← borrow $1
+     → x402_pay(url)
+4. IF no USDC AND no Morpho collateral BUT EOA has WETH/wstETH/cbETH:
+     → morpho_deposit_and_borrow(collateralAmount, token, borrowAmount: "1")
+     → x402_pay(url)
+5. IF no USDC AND no collateral anywhere:
+     → Tell user: "Need collateral (WETH/wstETH/cbETH) on Base to get credit. Send to <EOA address>"
+```
+
+### User wants to borrow USDC via Morpho
+```
+1. agether_balance               ← check collateral on EOA
+2. morpho_deposit_and_borrow(collateralAmount, token, borrowAmount)
+3. agether_balance               ← show the result with balance changes
+4. Show: tx hash, collateral deposited, USDC borrowed, new balances
+```
+
+### User wants to repay + withdraw
+```
+1. morpho_status                 ← check current debt and collateral
+2. morpho_repay(amount)          ← repay USDC
+3. morpho_withdraw("all", token) ← get collateral back
+4. agether_balance               ← show final balances
+```
+
+### User asks to check or refresh credit score
+```
+1. IF user says "refresh" / "update" / "get new score":
+     → agether_score(refresh: true)   ← pays via x402, computes fresh score, writes on-chain
+     → Paste the score and tx link
+2. IF user says "check" / "what's my score":
+     → agether_score(refresh: false)  ← free, reads current on-chain score
+     → Paste the score
+3. NEVER say "not registered" or "no score yet" without calling the tool first!
+```
+
+### User asks "what can I do?" or "what is agether?"
+```
+Explain: You're an AI agent with on-chain credit on Base.
+You can:
+- Deposit WETH/wstETH/cbETH as collateral
+- Borrow USDC instantly (125% collateral ratio)
+- Pay for APIs using x402 protocol
+- All on Base mainnet, all autonomous
+```
+
+---
+
+## 📊 RESPONSE FORMAT (MANDATORY)
+
+You MUST format every on-chain action reply like this. Do NOT skip any field.
+
+Example after repay:
+```
+✅ Repaid $1.50 USDC
+
+� Tx: https://basescan.org/tx/0xabc123def456...
+💰 Balances:
+  EOA: 0.05 ETH, 0 USDC
+  AgentAccount: 0 ETH, $3.50 USDC
+📊 Debt remaining: $0.00
+```
+
+Example after register:
+```
+✅ Registered!
+
+🆔 Agent ID: 18060
+📍 Wallet: 0x930C...
+📍 AgentAccount: 0x05d9...
+🔗 Tx: https://basescan.org/tx/0x177fdf...
+```
+
+If something **fails**:
+```
+❌ Borrow failed: ExceedsMaxLtv
+💡 Deposit more collateral. Need $X × 1.25 in value.
+```
+
+---
+
+## 🔢 KEY NUMBERS
+
+| Parameter | Value |
+|-----------|-------|
+| Chain | Base mainnet (8453) |
+| Currency | USDC (6 decimals) |
+| Max LTV | 80% (= 125% collateral ratio) |
+| Collateral tokens | WETH, wstETH, cbETH |
+| x402 cost | ~$0.001 per API call (WeatherXM) |
+| Gas cost | ~$0.001–$0.01 per tx |
+
+---
+
+## ⚠️ COMMON ERRORS
+
+| Error | Meaning | What to do |
+|-------|---------|-----------|
+| `ExceedsMaxLtv` | Collateral too low for borrow amount | Deposit more collateral or borrow less. LTV must be ≤ 80% |
+| `Payment rejected (402)` | No USDC for x402 payment | Borrow USDC first: `morpho_borrow` or `morpho_deposit_and_borrow` |
+| `No collateral deposited` | Trying to borrow without collateral | `morpho_deposit` first |
+| `Insufficient WETH/wstETH/cbETH` | EOA doesn't have enough collateral | Tell user to send collateral to EOA address |
+| `Insufficient USDC in AgentAccount` | Not enough USDC for repay | Need to fund AgentAccount or borrow more |
+| `ExecutionFailed` | Smart contract call reverted | Check inner error, usually LTV or approval issue |
+
+---
+
+## 🏗 ARCHITECTURE (for context)
+
+```
+EOA Wallet (private key)
+  ├── Owns ERC-8004 Identity NFT (agentId)  ← can own MULTIPLE
+  └── Owns AgentAccount (smart wallet, 1 per agentId)
+        ├── Holds USDC (from borrows)
+        └── Executes Morpho Blue operations via executeBatch()
+
+Morpho Blue (direct lending, overcollateralized 125%)
+  ├── supplyCollateral() → collateral into Morpho Blue market
+  ├── borrow()           → USDC from Morpho Blue → AgentAccount
+  ├── repay()            → USDC from AgentAccount → Morpho Blue
+  └── withdrawCollateral() → collateral back to EOA
+```
+
+---
+
+## 📍 CONTRACT ADDRESSES (Base Mainnet)
+
+| Contract | Address |
+|----------|---------|
+| AccountFactory | `0xb5b09213d0718f3FD56F1b111C8A83FDFcBdd5d8` |
+| ValidationRegistry | `0x867F4F6f749Dc422aeFEcF4273cD22015d2CBCc2` |
+| AgentReputation | `0x352883c396bc7e88891a7D343ba550A7638256c0` |
+| ERC-8004 Identity | `0x8004A169FB4a3325136EB29fA0ceB6D2e539a432` |
+| Morpho Blue | `0xBBBBBbbBBb9cC5e90e3b3Af64bdAF62C37EEFFCb` |
+| USDC | `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913` |
+| WETH | `0x4200000000000000000000000000000000000006` |
+| wstETH | `0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452` |
+| cbETH | `0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22` |

package/src/index.ts

@@ -0,0 +1,744 @@
+/**
+ * Agether OpenClaw Plugin — thin wrapper over @agether/sdk
+ *
+ * Each tool = MorphoClient / X402Client call → format result with txLink.
+ * Market discovery via Morpho GraphQL API (no backend dependency for markets).
+ */
+
+import axios from "axios";
+import * as fs from "fs";
+import * as path from "path";
+import {
+  MorphoClient,
+  X402Client,
+} from "@agether/sdk";
+
+// ─── Helpers ──────────────────────────────────────────────
+
+interface PluginConfig {
+  privateKey: string;
+  agentId?: string;
+  rpcUrl: string;
+  backendUrl: string;
+}
+
+const BASESCAN = "https://basescan.org/tx";
+function txLink(hash: string): string {
+  return hash ? `${BASESCAN}/${hash}` : "";
+}
+
+function ok(text: string) {
+  return { content: [{ type: "text" as const, text }] };
+}
+
+function fail(err: unknown) {
+  let msg = err instanceof Error ? err.message : String(err);
+  if (msg.includes("0xda04aecc")) {
+    msg = "ExceedsMaxLtv — collateral too low for this borrow amount";
+  } else if (msg.includes("0xfeca99cb")) {
+    msg = "ExecutionFailed — the inner contract call reverted. Likely ExceedsMaxLtv or insufficient collateral.";
+  } else if (msg.includes("0xa920ef9f")) {
+    msg = "PositionNotActive — no collateral deposited for this token";
+  }
+  if (msg.length > 300) msg = msg.slice(0, 250) + "…";
+  return { content: [{ type: "text" as const, text: `❌ ${msg}` }], isError: true };
+}
+
+function getConfig(api: any): PluginConfig {
+  const cfg = api.config?.plugins?.entries?.["agether"]?.config;
+  if (!cfg?.privateKey) {
+    throw new Error("Agether plugin not configured: missing privateKey in plugins.entries.agether.config");
+  }
+  return {
+    privateKey: cfg.privateKey,
+    agentId: cfg.agentId,
+    rpcUrl: cfg.rpcUrl || "https://base-rpc.publicnode.com",
+    backendUrl: cfg.backendUrl || "http://95.179.189.214:3001",
+  };
+}
+
+// Module-level cache
+let cachedAgentId: string | undefined;
+
+function createClient(cfg: PluginConfig): MorphoClient {
+  const agentId = cachedAgentId || cfg.agentId;
+  return new MorphoClient({
+    privateKey: cfg.privateKey,
+    rpcUrl: cfg.rpcUrl,
+    agentId,
+  });
+}
+
+/** Persist agentId to openclaw.json so it survives restarts. */
+function persistAgentId(agentId: string): string {
+  cachedAgentId = agentId;
+  try {
+    const home = process.env.HOME || process.env.USERPROFILE || "/root";
+    const cfgPath = path.join(home, ".openclaw", "openclaw.json");
+    const raw = fs.readFileSync(cfgPath, "utf-8");
+    const cfg = JSON.parse(raw);
+    if (cfg?.plugins?.entries?.agether?.config) {
+      cfg.plugins.entries.agether.config.agentId = agentId;
+      fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2));
+      return "saved";
+    }
+    return "config structure not found";
+  } catch (e) {
+    return `write failed: ${e instanceof Error ? e.message : String(e)}`;
+  }
+}
+
+// ─── Plugin Entry ─────────────────────────────────────────
+
+export default function register(api: any) {
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: agether_balance
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "agether_balance",
+    description:
+      "Check ETH and USDC balances for the agent's EOA wallet and AgentAccount on Base.",
+    parameters: { type: "object", properties: {}, required: [] },
+    async execute() {
+      try {
+        const cfg = getConfig(api);
+        const client = createClient(cfg);
+        const result = await client.getBalances();
+        return ok(JSON.stringify(result, null, 2));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: agether_register
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "agether_register",
+    description:
+      "Register a new ERC-8004 agent identity on Base and create an AgentAccount. Returns the new agentId.",
+    parameters: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: "Agent display name" },
+      },
+      required: ["name"],
+    },
+    async execute(_id: string, params: { name: string }) {
+      try {
+        const cfg = getConfig(api);
+        const client = createClient(cfg);
+        const result = await client.register(params.name);
+        const persistStatus = persistAgentId(result.agentId);
+        return ok(JSON.stringify({
+          status: result.alreadyRegistered ? "already_registered" : "registered",
+          agentId: result.agentId,
+          address: result.address,
+          agentAccount: result.agentAccount,
+          tx: result.tx ? txLink(result.tx) : undefined,
+          configSaved: persistStatus,
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: agether_set_agent
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "agether_set_agent",
+    description:
+      "Set the active agentId and save it to config. Use this when you know the agentId " +
+      "(e.g. from memory) but the tools return agentId '?'. This persists across restarts.",
+    parameters: {
+      type: "object",
+      properties: {
+        agentId: { type: "string", description: "The ERC-8004 agent ID (e.g. '18425')" },
+      },
+      required: ["agentId"],
+    },
+    async execute(_id: string, params: { agentId: string }) {
+      try {
+        const cfg = getConfig(api);
+        // Verify on-chain that this agentId exists and belongs to this wallet
+        const client = new MorphoClient({
+          privateKey: cfg.privateKey,
+          rpcUrl: cfg.rpcUrl,
+          agentId: params.agentId,
+        });
+        const acctAddr = await client.getAccountAddress();
+        const persistStatus = persistAgentId(params.agentId);
+        return ok(JSON.stringify({
+          status: "agent_set",
+          agentId: params.agentId,
+          agentAccount: acctAddr,
+          configSaved: persistStatus,
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: morpho_status
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "morpho_status",
+    description:
+      "Show all Morpho Blue positions — collateral deposited, USDC borrowed, debt, for each market.",
+    parameters: { type: "object", properties: {}, required: [] },
+    async execute() {
+      try {
+        const cfg = getConfig(api);
+        const client = createClient(cfg);
+        const result = await client.getStatus();
+        return ok(JSON.stringify(result, null, 2));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: morpho_deposit
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "morpho_deposit",
+    description:
+      "Deposit collateral (WETH, wstETH, or cbETH) into Morpho Blue via AgentAccount. Enables borrowing USDC.",
+    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" },
+      },
+      required: ["amount", "token"],
+    },
+    async execute(_id: string, params: { amount: string; token: string }) {
+      try {
+        const cfg = getConfig(api);
+        const client = createClient(cfg);
+        const result = await client.supplyCollateral(params.token, params.amount);
+        return ok(JSON.stringify({
+          status: "deposited",
+          amount: `${params.amount} ${params.token}`,
+          agentAccount: result.agentAccount,
+          tx: txLink(result.tx),
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: morpho_deposit_and_borrow
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "morpho_deposit_and_borrow",
+    description:
+      "Deposit collateral AND borrow USDC in one batched transaction via AgentAccount.executeBatch. " +
+      "Deposits collateral from EOA into Morpho, then borrows USDC. All in one tx.",
+    parameters: {
+      type: "object",
+      properties: {
+        collateralAmount: { type: "string", description: "Amount of collateral (e.g. '0.05')" },
+        token: { type: "string", enum: ["WETH", "wstETH", "cbETH"], description: "Collateral token" },
+        borrowAmount: { type: "string", description: "USDC amount to borrow (e.g. '50')" },
+      },
+      required: ["collateralAmount", "token", "borrowAmount"],
+    },
+    async execute(_id: string, params: { collateralAmount: string; token: string; borrowAmount: string }) {
+      try {
+        const cfg = getConfig(api);
+        const client = createClient(cfg);
+        const result = await client.depositAndBorrow(
+          params.token,
+          params.collateralAmount,
+          params.borrowAmount,
+        );
+        return ok(JSON.stringify({
+          status: "deposited_and_borrowed",
+          collateral: `${params.collateralAmount} ${params.token}`,
+          borrowed: `$${params.borrowAmount}`,
+          agentAccount: result.agentAccount,
+          tx: txLink(result.tx),
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: morpho_sponsor
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "morpho_sponsor",
+    description:
+      "Transfer collateral tokens to another agent's AgentAccount. " +
+      "The target agent can then supply the collateral to Morpho Blue themselves.",
+    parameters: {
+      type: "object",
+      properties: {
+        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" },
+      },
+      required: ["amount", "token"],
+    },
+    async execute(_id: string, params: { agentId?: string; agentAddress?: string; amount: string; token: string }) {
+      try {
+        if (!params.agentId && !params.agentAddress) return fail("Provide either agentId or agentAddress");
+        const cfg = getConfig(api);
+        const client = createClient(cfg);
+
+        const target = params.agentId
+          ? { agentId: params.agentId }
+          : { address: params.agentAddress! };
+
+        const result = await client.sponsor(target, params.token, params.amount);
+        return ok(JSON.stringify({
+          status: "sponsored",
+          target: result.targetAccount,
+          targetAgentId: result.targetAgentId || "by address",
+          collateral: `${params.amount} ${params.token}`,
+          tx: txLink(result.tx),
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: morpho_borrow
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "morpho_borrow",
+    description:
+      "Borrow USDC against deposited collateral via Morpho Blue. " +
+      "USDC lands in AgentAccount. Requires collateral deposited first.",
+    parameters: {
+      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)" },
+      },
+      required: ["amount"],
+    },
+    async execute(_id: string, params: { amount: string; token?: string }) {
+      try {
+        const cfg = getConfig(api);
+        const client = createClient(cfg);
+        const result = await client.borrow(params.amount, params.token);
+        return ok(JSON.stringify({
+          status: "borrowed",
+          amount: `$${params.amount}`,
+          collateral: result.collateralToken,
+          agentAccount: result.agentAccount,
+          tx: txLink(result.tx),
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: morpho_repay
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "morpho_repay",
+    description:
+      "Repay borrowed USDC back to Morpho Blue from AgentAccount. Reduces debt. " +
+      "Use amount 'all' to repay full debt and clear dust shares.",
+    parameters: {
+      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)" },
+      },
+      required: ["amount"],
+    },
+    async execute(_id: string, params: { amount: string; token?: string }) {
+      try {
+        const cfg = getConfig(api);
+        const client = createClient(cfg);
+        const result = await client.repay(params.amount, params.token);
+        return ok(JSON.stringify({
+          status: "repaid",
+          amount: `$${params.amount}`,
+          remainingDebt: result.remainingDebt,
+          tx: txLink(result.tx),
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: morpho_withdraw
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "morpho_withdraw",
+    description:
+      "Withdraw collateral from Morpho Blue back 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" },
+      },
+      required: ["amount", "token"],
+    },
+    async execute(_id: string, params: { amount: string; token: string }) {
+      try {
+        const cfg = getConfig(api);
+        const client = createClient(cfg);
+        const result = await client.withdrawCollateral(params.token, params.amount);
+        return ok(JSON.stringify({
+          status: "withdrawn",
+          amount: result.amount,
+          token: result.token,
+          remainingCollateral: result.remainingCollateral,
+          destination: result.destination,
+          tx: txLink(result.tx),
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  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) + "…",
+          }));
+
+        return ok(JSON.stringify(formatted, null, 2));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: agether_score  (backend API — x402 gated)
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "agether_score",
+    description:
+      "Get the agent's current on-chain credit score. " +
+      "Use 'refresh' param to request a fresh score computation (costs USDC via x402).",
+    parameters: {
+      type: "object",
+      properties: {
+        refresh: { type: "boolean", description: "Request fresh score via x402 payment (default: false)" },
+      },
+      required: [],
+    },
+    async execute(_id: string, params: { refresh?: boolean }) {
+      try {
+        const cfg = getConfig(api);
+        const client = createClient(cfg);
+        const agentId = client.getAgentId();
+
+        if (params.refresh) {
+          // x402-gated fresh score
+          const x402 = new X402Client({
+            privateKey: cfg.privateKey,
+            rpcUrl: cfg.rpcUrl,
+            backendUrl: cfg.backendUrl,
+            agentId,
+            accountAddress: await client.getAccountAddress().catch(() => undefined),
+          });
+          const result = await x402.get(`${cfg.backendUrl}/score/${agentId}`);
+          if (!result.success) return fail(result.error || "Score request failed");
+          return ok(JSON.stringify(result.data, null, 2));
+        }
+
+        // Free: read current on-chain score
+        const { data } = await axios.get(`${cfg.backendUrl}/score/${agentId}/current`);
+        return ok(JSON.stringify(data, null, 2));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: wallet_fund
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "wallet_fund",
+    description: "Transfer USDC from EOA wallet into AgentAccount.",
+    parameters: {
+      type: "object",
+      properties: {
+        amount: { type: "string", description: "USDC amount (e.g. '50')" },
+      },
+      required: ["amount"],
+    },
+    async execute(_id: string, params: { amount: string }) {
+      try {
+        const cfg = getConfig(api);
+        const client = createClient(cfg);
+        const result = await client.fundAccount(params.amount);
+        return ok(JSON.stringify({
+          status: "funded",
+          amount: `$${params.amount}`,
+          agentAccount: result.agentAccount,
+          tx: txLink(result.tx),
+        }));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  TOOL: x402_pay (with auto-draw support)
+  // ═══════════════════════════════════════════════════════
+  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).",
+    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 }) {
+      try {
+        const cfg = getConfig(api);
+        const agetherCfg = api.config?.plugins?.entries?.agether?.config || {};
+        const client = createClient(cfg);
+
+        let accountAddress: string | undefined;
+        let agentId: string | undefined;
+        try {
+          agentId = client.getAgentId();
+          accountAddress = await client.getAccountAddress();
+        } catch { /* no account, pay from EOA */ }
+
+        const autoDrawEnabled = params.autoDraw === true; // default false — opt-in only
+        const x402 = new X402Client({
+          privateKey: cfg.privateKey,
+          rpcUrl: cfg.rpcUrl,
+          backendUrl: cfg.backendUrl,
+          agentId,
+          accountAddress,
+          autoDraw: autoDrawEnabled,
+          dailySpendLimitUsdc: agetherCfg.dailySpendLimitUsdc,
+          yieldLimitedSpending: agetherCfg.yieldLimitedSpending,
+          autoDrawBuffer: agetherCfg.autoDrawBuffer,
+        });
+
+        let result;
+        if (autoDrawEnabled && agentId) {
+          // Use payWithAutoDraw which handles balance check + borrow
+          const fetchOpts: any = {
+            morphoClient: client,
+          };
+          if (params.method?.toUpperCase() === "POST" && params.body) {
+            fetchOpts.method = "POST";
+            fetchOpts.body = JSON.stringify(JSON.parse(params.body));
+            fetchOpts.headers = { "Content-Type": "application/json" };
+          }
+          result = await x402.payWithAutoDraw(params.url, fetchOpts);
+        } else {
+          if (params.method?.toUpperCase() === "POST" && params.body) {
+            result = await x402.post(params.url, JSON.parse(params.body));
+          } else {
+            result = await x402.get(params.url);
+          }
+        }
+
+        if (!result.success) return fail(result.error || "x402 payment failed");
+
+        const response: any = { status: "paid", data: result.data };
+        if (result.paymentInfo) {
+          response.payment = {
+            ...result.paymentInfo,
+            tx: result.paymentInfo.txHash ? txLink(result.paymentInfo.txHash) : undefined,
+          };
+        }
+        if (result.autoDrawInfo) {
+          response.autoDraw = {
+            ...result.autoDrawInfo,
+            borrowTx: result.autoDrawInfo.borrowTx ? txLink(result.autoDrawInfo.borrowTx) : undefined,
+          };
+        }
+        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
+  // ═══════════════════════════════════════════════════════
+  api.registerTool({
+    name: "morpho_max_borrowable",
+    description:
+      "Calculate maximum additional USDC that can be borrowed given current collateral and debt. " +
+      "Shows borrowing headroom per market based on LLTV and oracle prices.",
+    parameters: { type: "object", properties: {}, required: [] },
+    async execute() {
+      try {
+        const cfg = getConfig(api);
+        const client = createClient(cfg);
+        const result = await client.getMaxBorrowable();
+
+        const formatted = {
+          totalMaxBorrowable: `$${(Number(result.total) / 1e6).toFixed(2)}`,
+          markets: result.byMarket.map((m: any) => ({
+            collateral: m.collateralToken,
+            maxAdditionalBorrow: `$${(Number(m.maxAdditional) / 1e6).toFixed(2)}`,
+            currentDebt: `$${(Number(m.currentDebt) / 1e6).toFixed(2)}`,
+            collateralValueUsdc: `$${(Number(m.collateralValue) / 1e6).toFixed(2)}`,
+          })),
+        };
+
+        return ok(JSON.stringify(formatted, null, 2));
+      } catch (e) { return fail(e); }
+    },
+  });
+
+  // ═══════════════════════════════════════════════════════
+  //  SLASH COMMANDS (no AI needed)
+  // ═══════════════════════════════════════════════════════
+
+  api.registerCommand({
+    name: "balance",
+    description: "Show agent wallet balances (no AI)",
+    handler: async () => {
+      try {
+        const cfg = getConfig(api);
+        const client = createClient(cfg);
+        const b = await client.getBalances();
+
+        let text = `💰 Agent #${b.agentId}\n`;
+        text += `Address: ${b.address}\n`;
+        text += `ETH: ${parseFloat(b.eth).toFixed(6)}\n`;
+        text += `USDC: $${b.usdc}`;
+        if (b.agentAccount) {
+          text += `\n\n🏦 AgentAccount: ${b.agentAccount.address}\nUSDC: $${b.agentAccount.usdc}`;
+        }
+        return { text };
+      } catch (e: any) {
+        return { text: `❌ ${e.message}` };
+      }
+    },
+  });
+
+  api.registerCommand({
+    name: "morpho",
+    description: "Show Morpho positions (no AI)",
+    handler: async () => {
+      try {
+        const cfg = getConfig(api);
+        const client = createClient(cfg);
+        const s = await client.getStatus();
+
+        let text = `📊 Morpho\nAccount: ${s.agentAccount}\nTotal debt: $${s.totalDebt}\n`;
+        for (const p of s.positions) {
+          text += `\n${p.collateralToken}: ${p.collateral} collateral, $${p.debt} debt`;
+        }
+        return { text };
+      } catch (e: any) {
+        return { text: `❌ ${e.message}` };
+      }
+    },
+  });
+}