@fidesbuild/mcp-server 0.8.1 → 0.9.0

package/dist/server.js

@@ -21,6 +21,7 @@ import { createX402, decodePaymentRequired, exactEip3009 } from '@fidesbuild/x40
 import { netObligations, settle, netRoots, PUBLISH_SELECTOR, NetError } from '@fidesbuild/net';
 import { createSubClient, SubFidesKit, SubAgent, SubFidesError, subDeployments } from '@fidesbuild/sub';
 import { quoteUniswap, checkMandate, swapActions, verifySwap, describeRoute, mandateOf, uniswap, NATIVE, SwapError } from '@fidesbuild/swap';
+import { route } from '@fidesbuild/router';
 export function configFromEnv(env = process.env) {
     const home = env.FIDES_HOME ?? path.join(os.homedir(), '.fides');
     return {
@@ -822,7 +823,7 @@ export function createFidesMcpServer(cfg) {
     const tokenArg = (t) => (/^eth$/i.test(t) ? 'ETH' : /^weth$/i.test(t) ? uniswap[cfg.chainId]?.weth : isAddress(t) ? getAddress(t) : null);
     server.registerTool('fides_swap', {
         title: 'Swap on Uniswap inside the FIDES',
-        description: 'Gets the best route from Uniswap on Robinhood Chain (v2, v3 and v4 pools, including v4 pools with hooks such as the aggregator hooks) for the FIDES Account, checks it against the trading mandate the owner signed (tokens it may buy, worst price, most per swap), and simulates it to measure what would actually arrive. Sends nothing. Returns a plan_id for fides_execute, which sends an exact approval and the swap as one transaction; gas is paid by the relayer. Show the route, the quoted amount and the worst accepted amount to the user before executing. Needs a FIDES that allows swaps: fides_setup with swap.',
+        description: 'Swaps on Uniswap on Robinhood Chain with FIDES ROUTER: gets a route through each kind of pool (v2, v3 and v4, including v4 pools with hooks), checks each against the FIDES and the trading mandate the owner signed (tokens it may buy, worst price, most per swap), simulates them, ranks them by output, and offers only the best valid one. Show the user routes_compared (the ranking, how far behind each route is, and why any are out) with the chosen route, before executing. Sends nothing. Returns a plan_id for fides_execute, which sends an exact approval and the swap as one transaction; gas is paid by the relayer. Show the route, the quoted amount and the worst accepted amount to the user before executing. Needs a FIDES that allows swaps: fides_setup with swap.',
         inputSchema: {
             token_out: z.string().describe('What to buy: "ETH", "WETH" or a token address'),
             amount: z.string().describe('How much of the budget token to spend, e.g. "1"'),
@@ -850,28 +851,51 @@ export function createFidesMcpServer(cfg) {
                 return fail(`"amount" must be a number of ${tIn.symbol}, like "1".`);
             }
             const slippageBps = max_slippage_percent ? Math.round(max_slippage_percent * 100) : m.maxSlippageBps;
-            let q, blocked;
-            if (cfg.api) {
-                const r = await post('/v1/swap/quote', { fides, tokenOut: out, amount: value, slippageBps });
-                q = r.quote;
-                blocked = r.mandate?.allowed ? null : { code: r.mandate.code, message: r.mandate.message };
-            }
-            else {
-                if (!process.env.UNISWAP_API_KEY)
-                    return fail('Swaps need the FIDES API, or UNISWAP_API_KEY when running without it.');
-                q = await quoteUniswap({ apiKey: process.env.UNISWAP_API_KEY, fides, tokenOut: out, amount: value, slippageBps });
-                blocked = checkMandate(fides, q);
+            if (!cfg.api && !process.env.UNISWAP_API_KEY)
+                return fail('Swaps need the FIDES API, or UNISWAP_API_KEY when running without it.');
+            // FIDES ROUTER: a route through each kind of Uniswap pool, each checked against the trading mandate and the
+            // FIDES, simulated and ranked by output. Only the best valid one is offered to execute.
+            const POOLS = [['uniswap v2', ['V2']], ['uniswap v3', ['V3']], ['uniswap v4', ['V4']]];
+            const quotes = new Map(), excluded = [];
+            await Promise.all(POOLS.map(async ([name, protocols]) => {
+                try {
+                    let q, blocked;
+                    if (cfg.api) {
+                        const r = await post('/v1/swap/quote', { fides, tokenOut: out, amount: value, slippageBps, protocols });
+                        q = r.quote;
+                        blocked = r.mandate?.allowed ? null : { code: r.mandate.code, message: r.mandate.message };
+                    }
+                    else {
+                        q = await quoteUniswap({ apiKey: process.env.UNISWAP_API_KEY, fides, tokenOut: out, amount: value, slippageBps, protocols });
+                        blocked = checkMandate(fides, q);
+                    }
+                    if (blocked)
+                        excluded.push({ route: name, why: `trading mandate: ${blocked.message}` });
+                    else
+                        quotes.set(name, q);
+                }
+                catch (err) {
+                    excluded.push({ route: name, why: `no route: ${err?.message ?? err}` });
+                }
+            }));
+            if (!quotes.size) {
+                const mandate = excluded.find((x) => x.why.startsWith('trading mandate'));
+                return fail(mandate ? `Blocked by the ${mandate.why} Nothing was sent.` : `Uniswap has no route for this swap: ${excluded.map((x) => `${x.route} (${x.why})`).join('; ')}. Nothing was sent.`);
             }
-            const outInfo = q.tokenOut === NATIVE ? { symbol: 'ETH', decimals: 18 } : await token(q.tokenOut);
+            const first = [...quotes.values()][0];
+            const outInfo = first.tokenOut === NATIVE ? { symbol: 'ETH', decimals: 18 } : await token(first.tokenOut);
             const fmt = (v) => `${formatUnits(v, outInfo.decimals)} ${outInfo.symbol}`;
-            if (blocked)
-                return fail(`Blocked by the trading mandate: ${blocked.message} Nothing was sent.`);
-            const actions = swapActions(q, `swap ${amount} ${tIn.symbol} to ${outInfo.symbol} on Uniswap`);
-            const plan = await new FidesBuilder({ client, fides, agent }).add(actions).build();
-            if (plan.rejected().length) {
-                const r = plan.rejected()[0];
-                return fail(`Blocked by the FIDES: ${REASONS[r.reason ?? ''] ?? r.reason}. Nothing was sent.`);
-            }
+            const label = `swap ${amount} ${tIn.symbol} to ${outInfo.symbol} on Uniswap`;
+            const routed = await route({ client, fides, agent }, [...quotes].map(([name, q]) => ({ name, actions: swapActions(q, label), expectedOut: q.quotedOut, minOut: q.minOut })));
+            const ranking = [
+                ...routed.ranked.map((x) => x.valid
+                    ? { route: x.name, verdict: x === routed.best ? 'best, chosen' : 'valid', quoted: fmt(x.expectedOut ?? 0n), behind_best: `${(x.slippageBps ?? 0) / 100}%`, gas: String(x.gas), pools: describeRoute(quotes.get(x.name)) }
+                    : { route: x.name, verdict: 'out', why: REASONS[x.reasons[0]?.split(': ')[1] ?? ''] ?? x.reasons[0] }),
+                ...excluded.map((x) => ({ route: x.route, verdict: 'out', why: x.why })),
+            ];
+            if (!routed.best)
+                return fail(`No route is inside the FIDES, so nothing can run: ${ranking.map((x) => `${x.route} (${x.why})`).join('; ')}. Nothing was sent.`);
+            const q = quotes.get(routed.best.name), plan = routed.plan(routed.best.name), actions = swapActions(q, label);
             const v = await verifySwap(client, fides, plan, q);
             const id = plan.planHash.slice(0, 18);
             if (v.ok)
@@ -879,6 +903,9 @@ export function createFidesMcpServer(cfg) {
             return ok({
                 plan_id: v.ok ? id : null,
                 ready_to_execute: v.ok,
+                router: `FIDES ROUTER compared ${ranking.length} routes, one per kind of Uniswap pool: each checked against the FIDES and the trading mandate, simulated, and ranked by output. Only the chosen route runs.`,
+                routes_compared: ranking,
+                chosen: routed.best.name,
                 route: describeRoute(q),
                 spend: `${amount} ${tIn.symbol}`,
                 quoted: fmt(q.quotedOut),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fidesbuild/mcp-server",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "FIDES as tools for Claude and any MCP client: plan and execute actions inside a signed FIDES, gas paid by the hosted relayer.",
   "keywords": [
     "fides",
@@ -14,9 +14,14 @@
   "homepage": "https://fidesbuilder.xyz/docs",
   "license": "MIT",
   "type": "module",
-  "exports": "./src/server.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/server.d.ts",
+      "default": "./dist/server.js"
+    }
+  },
   "bin": {
-    "fides-mcp": "./src/server.ts"
+    "fides-mcp": "./dist/server.js"
   },
   "files": [
     "dist",
@@ -27,16 +32,7 @@
     "node": ">=20.10"
   },
   "publishConfig": {
-    "access": "public",
-    "exports": {
-      ".": {
-        "types": "./dist/server.d.ts",
-        "default": "./dist/server.js"
-      }
-    },
-    "bin": {
-      "fides-mcp": "./dist/server.js"
-    }
+    "access": "public"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.32.1",
@@ -46,6 +42,7 @@
     "@fidesbuild/x402": "0.2.0",
     "@fidesbuild/net": "0.2.1",
     "@fidesbuild/sub": "0.2.0",
-    "@fidesbuild/swap": "0.2.0"
+    "@fidesbuild/swap": "0.2.1",
+    "@fidesbuild/router": "0.2.0"
   }
-}
+}

package/src/server.ts

@@ -1,968 +0,0 @@
-#!/usr/bin/env node
-// fides-mcp — FIDES as tools for Claude and any other MCP client.
-//
-//   npx -y @fidesbuild/mcp-server setup     make this computer's agent key and print what to do next
-//   npx -y @fidesbuild/mcp-server           run the MCP server over stdio (what Claude starts)
-//
-// The agent key lives in ~/.fides/agent.json and holds no funds. It can only sign actions inside the
-// FIDES the owner signed for it. Bundles are relayed by the hosted FIDES API, which pays the gas,
-// unless FIDES_RELAY=self, in which case the agent key pays.
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { z } from 'zod';
-import { encodeFunctionData, decodeFunctionResult, erc20Abi, formatUnits, parseUnits, isAddress, getAddress, type Address, type Hex, type AbiFunction, type AbiParameter } from 'viem';
-import { generatePrivateKey, privateKeyToAccount, type PrivateKeyAccount } from 'viem/accounts';
-import { Fides, FidesBuilder, Policy, Receipts, accountOf, createFidesClient, fromJson, toJson, type SignedFides, type ActionInput, type ExecutionPlan, type FidesClient, type FidesAddresses } from '@fidesbuild/sdk';
-import { createX402, decodePaymentRequired, exactEip3009 } from '@fidesbuild/x402';
-import { netObligations, settle, netRoots, PUBLISH_SELECTOR, NetError, type Obligation } from '@fidesbuild/net';
-import { createSubClient, SubFidesKit, SubAgent, SubFidesError, subDeployments, type SignedSubFides, type SubAddresses, type SubPlan } from '@fidesbuild/sub';
-import { quoteUniswap, checkMandate, swapActions, verifySwap, describeRoute, mandateOf, uniswap, NATIVE, SwapError, type SwapQuote } from '@fidesbuild/swap';
-
-export type Config = {
-  /** Folder for agent.json and the default fides.json. */
-  home: string;
-  rpc: string;
-  chainId: number;
-  /** The relaying API, or null to have the agent key pay gas itself. */
-  api: string | null;
-  /** The FIDES API, asked for the FIDES signed for this agent. Null to only use fidesFile. */
-  directory: string | null;
-  /** The FIDES app, for the setup link. */
-  app: string;
-  fidesFile: string;
-  addresses?: FidesAddresses;
-  /** SUB-FIDES contracts, when not the published ones for the chain. */
-  sub?: SubAddresses;
-  agentKey?: Hex;
-};
-
-export function configFromEnv(env: NodeJS.ProcessEnv = process.env): Config {
-  const home = env.FIDES_HOME ?? path.join(os.homedir(), '.fides');
-  return {
-    home,
-    rpc: env.FIDES_RPC ?? 'https://rpc.mainnet.chain.robinhood.com',
-    chainId: Number(env.FIDES_CHAIN_ID ?? 4663),
-    api: env.FIDES_RELAY === 'self' ? null : (env.FIDES_API ?? 'https://api.fidesbuilder.xyz').replace(/\/$/, ''),
-    directory: env.FIDES_LOOKUP === 'off' ? null : (env.FIDES_API ?? 'https://api.fidesbuilder.xyz').replace(/\/$/, ''),
-    app: (env.FIDES_APP ?? 'https://fidesbuilder.xyz/app').replace(/\/$/, ''),
-    fidesFile: env.FIDES_FILE ?? path.join(home, 'fides.json'),
-    addresses: env.FIDES_ADDRESSES ? JSON.parse(fs.readFileSync(env.FIDES_ADDRESSES, 'utf8')) : undefined,
-    sub: env.FIDES_SUB_ADDRESSES ? JSON.parse(fs.readFileSync(env.FIDES_SUB_ADDRESSES, 'utf8')) : undefined,
-    agentKey: env.FIDES_AGENT_KEY as Hex | undefined,
-  };
-}
-
-/** This computer's agent key: from FIDES_AGENT_KEY, or ~/.fides/agent.json, made on first use. */
-export function agentKey(cfg: Config): { account: PrivateKeyAccount; file: string | null; created: boolean } {
-  if (cfg.agentKey) return { account: privateKeyToAccount(cfg.agentKey), file: null, created: false };
-  const file = path.join(cfg.home, 'agent.json');
-  if (fs.existsSync(file)) return { account: privateKeyToAccount(JSON.parse(fs.readFileSync(file, 'utf8')).privateKey), file, created: false };
-  fs.mkdirSync(cfg.home, { recursive: true, mode: 0o700 });
-  const privateKey = generatePrivateKey();
-  const account = privateKeyToAccount(privateKey);
-  fs.writeFileSync(file, JSON.stringify({ address: account.address, privateKey, note: 'FIDES agent key. It holds no funds and can only act inside the FIDES signed for it. Keep this file private.' }, null, 2) + '\n', { mode: 0o600 });
-  return { account, file, created: true };
-}
-
-const EXPLORER: Record<number, string> = { 4663: 'https://robinhoodchain.blockscout.com' };
-const SELECTORS: Record<string, string> = { '0xa9059cbb': 'transfer', '0x095ea7b3': 'approve', '0x23b872dd': 'transferFrom' };
-const REASONS: Record<string, string> = {
-  SPEND_LIMIT_EXCEEDED: 'over the FIDES’s budget', ASSET_NOT_ALLOWED: 'token not allowed by the FIDES', TARGET_NOT_ALLOWED: 'contract not allowed by the FIDES',
-  SELECTOR_NOT_ALLOWED: 'function not allowed by the FIDES', NATIVE_VALUE_EXCEEDED: 'sends more ETH than the FIDES allows', ACTION_LIMIT_EXCEEDED: 'over the FIDES’s action limit',
-  FIDES_EXPIRED: 'the FIDES has expired', FIDES_REVOKED: 'the FIDES has been revoked', DEPENDENCY_REJECTED: 'depends on a blocked action',
-};
-
-/** Simulation and relay failures, in words. */
-function failure(reason: unknown): string {
-  const r = String(reason ?? '');
-  if (/InsufficientBalance|InsufficientFunds|0x356680b7|exceeds balance/i.test(r)) return 'The FIDES Account does not hold enough of the token. The owner needs to fund it.';
-  if (/SpendLimitExceeded|AssetOutflowExceeded/.test(r)) return 'This would go over the FIDES’s budget, counting what it has already spent.';
-  if (/TargetNotAllowed|SelectorNotAllowed/.test(r)) return 'This calls a contract or function the FIDES does not allow.';
-  if (/FidesRevoked/.test(r)) return 'The FIDES has been revoked.';
-  if (/FidesExpired|FidesNotYetValid/.test(r)) return 'The FIDES is outside its valid time window.';
-  if (/NonceAlreadyUsed/.test(r)) return 'This plan was already executed. Make a new plan.';
-  if (/RELAYER_BUDGET_EXHAUSTED|RELAYER_OUT_OF_GAS_MONEY|NO_RELAYER/.test(r)) return 'The hosted relayer cannot pay for gas right now. Try later, or set FIDES_RELAY=self and give the agent address a little ETH.';
-  return r;
-}
-
-// Paid APIs that have been bought through FIDES with real payments on mainnet (the docs list the same ones).
-const KNOWN_SERVICES = [
-  { id: 'fides-demo', name: 'FIDES demo', url: 'https://api.fidesbuilder.xyz/v1/demo/chain-stats', price: '0.01 USDG', returns: 'Robinhood Chain\'s latest block, gas price and USDG supply', run_by: 'FIDES' },
-  { id: 'spraay', name: 'Spraay', url: 'https://gateway.spraay.app/api/v1/models', price: '0.001 USDG', returns: 'The AI models the Spraay gateway offers, with providers and prices', run_by: 'Spraay, not FIDES' },
-  { id: 'madeonsol', name: 'MadeOnSol', url: 'https://madeonsol.com/api/x402/rhc/kol/feed?limit=5', price: '0.04 USDG', returns: 'Recent trades on Robinhood Chain by tracked wallets', run_by: 'MadeOnSol, not FIDES' },
-];
-
-/** Turns plain JSON values into what viem encodes for each ABI type. "me" is the FIDES Account. */
-export function coerce(p: AbiParameter, v: unknown, me: Address | null, at: string): unknown {
-  const arr = p.type.match(/^(.*)\[(\d*)\]$/);
-  if (arr) {
-    if (!Array.isArray(v)) throw new Error(`${at} must be a list`);
-    return v.map((x, i) => coerce({ ...p, type: arr[1] } as AbiParameter, x, me, `${at}[${i}]`));
-  }
-  if (p.type === 'tuple') {
-    const parts = (p as any).components as AbiParameter[];
-    const get = (c: AbiParameter, i: number) => (Array.isArray(v) ? v[i] : (v as any)?.[c.name ?? '']);
-    if (v === null || typeof v !== 'object') throw new Error(`${at} must be an object with ${parts.map((c) => c.name).join(', ')}`);
-    const out = parts.map((c, i) => coerce(c, get(c, i), me, `${at}.${c.name ?? i}`));
-    return Array.isArray(v) || parts.some((c) => !c.name) ? out : Object.fromEntries(parts.map((c, i) => [c.name, out[i]]));
-  }
-  if (/^u?int\d*$/.test(p.type)) {
-    if (!/^-?\d+$/.test(String(v ?? '').trim())) throw new Error(`${at} must be a whole number in the token's smallest unit, as a string (got ${JSON.stringify(v)})`);
-    return BigInt(String(v).trim());
-  }
-  if (p.type === 'address') {
-    if (typeof v === 'string' && /^me$/i.test(v)) { if (!me) throw new Error(`${at}: "me" needs a signed FIDES`); return me; }
-    if (typeof v !== 'string' || !isAddress(v)) throw new Error(`${at} must be an address`);
-    return getAddress(v);
-  }
-  if (p.type === 'bool') return v === true || v === 'true';
-  if (/^bytes\d*$/.test(p.type)) {
-    const h = v === '' || v == null ? '0x' : String(v);
-    if (!/^0x([0-9a-fA-F]{2})*$/.test(h)) throw new Error(`${at} must be hex bytes, like "0x"`);
-    return h;
-  }
-  return v;
-}
-
-/** Encodes a call from one ABI function and plain JSON args. */
-export function encodeCall(abi: AbiFunction, args: unknown[], me: Address | null): Hex {
-  const values = abi.inputs.map((p, i) => coerce(p, args[i], me, p.name || `arg ${i + 1}`));
-  return encodeFunctionData({ abi: [abi], functionName: abi.name, args: values as any });
-}
-
-const ok = (value: unknown) =>({ content: [{ type: 'text' as const, text: typeof value === 'string' ? value : JSON.stringify(value, null, 2) }] });
-const fail = (message: string) => ({ content: [{ type: 'text' as const, text: message }], isError: true });
-
-export function createFidesMcpServer(cfg: Config) {
-  const agent = agentKey(cfg).account;
-  const client: FidesClient = createFidesClient({ chainId: cfg.chainId, rpc: cfg.rpc, addresses: cfg.addresses });
-  const explorer = EXPLORER[cfg.chainId];
-  const txLink = (h?: string) => (h && explorer ? `${explorer}/tx/${h}` : h);
-  const plans = new Map<string, { plan: ExecutionPlan; actions: ActionInput[]; fides: SignedFides; net?: { epoch: bigint; obligationsRoot: Hex; settlementRoot: Hex }; swap?: { quote: SwapQuote; outDecimals: number; outSymbol: string } }>();
-  const tokens = new Map<string, { symbol: string; decimals: number }>();
-  // SUB-FIDES: a FIDES on a V2 account can hand slices of itself to other agents.
-  const subAddrs = cfg.sub ?? subDeployments[cfg.chainId];
-  const subClient = subAddrs ? createSubClient({ chainId: cfg.chainId, rpc: cfg.rpc, base: cfg.addresses, addresses: subAddrs }) : null;
-  const subPlans = new Map<string, { agent: SubAgent; plan: SubPlan; parent: SignedFides; sub: SignedSubFides }>();
-  const subsDir = path.join(cfg.home, 'subs');
-
-  const token = async (asset: Address) => {
-    const key = asset.toLowerCase();
-    if (!tokens.has(key)) {
-      const [symbol, decimals] = await Promise.all([
-        client.public.readContract({ address: asset, abi: erc20Abi, functionName: 'symbol' }).catch(() => 'TOKEN'),
-        client.public.readContract({ address: asset, abi: erc20Abi, functionName: 'decimals' }).catch(() => 18),
-      ]);
-      tokens.set(key, { symbol: String(symbol), decimals: Number(decimals) });
-    }
-    return tokens.get(key)!;
-  };
-
-  const setupLink = `${cfg.app}/#/create?agent=${agent.address}&via=claude`;
-  const notLoaded = () => `No FIDES is signed for this agent yet. This computer's agent address is ${agent.address}.\n\n` +
-    `To set one up, the user opens this link: ${setupLink}\n` +
-    'It opens the FIDES app with this agent filled in. They set the budget, contracts and expiry, sign with their wallet, then create and fund their FIDES Account. ' +
-    'Then they come back here: the signed FIDES is picked up automatically, with nothing to download.';
-
-  function readFides(): SignedFides | null {
-    if (!fs.existsSync(cfg.fidesFile)) return null;
-    return fromJson(fs.readFileSync(cfg.fidesFile, 'utf8')) as SignedFides;
-  }
-  const keep = (fides: SignedFides) => { fs.mkdirSync(path.dirname(cfg.fidesFile), { recursive: true }); fs.writeFileSync(cfg.fidesFile, toJson(fides, 2) + '\n'); };
-
-  // The FIDES to act under: the newest valid one signed for this agent, from the copy kept here or from
-  // the FIDES API, where the app registers a FIDES when the owner signs it. Each is verified onchain here.
-  async function currentFides(): Promise<SignedFides | null> {
-    const mine = (o: SignedFides | null) => Boolean(o && String(o.agent).toLowerCase() === agent.address.toLowerCase() && Number(o.chainId) === cfg.chainId);
-    const local = readFides();
-    const candidates: SignedFides[] = mine(local) ? [local!] : [];
-    if (cfg.directory) {
-      try {
-        const res = await fetch(`${cfg.directory}/v1/agents/${agent.address}/fides`);
-        if (res.ok) for (const x of (fromJson(await res.text()) as any).fidesList ?? []) if (mine(x.fides) && x.status?.valid) candidates.push(x.fides);
-      } catch { /* the API is optional: the copy kept here still works */ }
-    }
-    const valid: SignedFides[] = [];
-    for (const o of candidates) if ((await Fides.verify(client, o).catch(() => null))?.valid) valid.push(o);
-    valid.sort((a, b) => Number(BigInt(b.validAfter) - BigInt(a.validAfter)));
-    const best = valid[0];
-    if (best && (!local || local.id !== best.id)) { keep(best); plans.clear(); }
-    return best ?? local;
-  }
-
-  async function summary(fides: SignedFides) {
-    const t = await token(fides.spendLimits[0].asset);
-    const [check, [spend], balance, code] = await Promise.all([
-      Fides.verify(client, fides),
-      Policy.remainingSpend(client, fides),
-      client.public.readContract({ address: fides.spendLimits[0].asset, abi: erc20Abi, functionName: 'balanceOf', args: [fides.account] }),
-      client.public.getCode({ address: fides.account }),
-    ]);
-    const amount = (v: bigint) => `${formatUnits(v, t.decimals)} ${t.symbol}`;
-    const outside = await stray(fides.spendLimits[0].asset);
-    const status = check.revoked ? 'revoked' : check.expired ? 'expired' : check.notYetValid ? 'not valid yet' : !check.validSignature || !check.idMatches ? 'signature does not verify' : 'active';
-    return {
-      status,
-      fides: fides.id,
-      owner: fides.owner,
-      agent: fides.agent,
-      fides_account: fides.account,
-      fides_account_created: Boolean(code),
-      fides_account_balance: amount(balance as bigint),
-      budget: amount(spend.limit),
-      spent: amount(spend.spent),
-      remaining: amount(spend.remaining),
-      budget_token: fides.spendLimits[0].asset,
-      expires: new Date(Number(fides.validUntil) * 1000).toISOString(),
-      allowed_contracts: fides.targets.map((r) => ({ contract: r.target, functions: r.selectors.map((s) => SELECTORS[s.toLowerCase()] ? `${SELECTORS[s.toLowerCase()]} (${s})` : s) })),
-      allowed_services: fides.services.map((s) => s.serviceId),
-      max_actions: fides.maxActions.toString(),
-      relay: cfg.api ? `hosted relayer at ${cfg.api} pays the gas` : `the agent key ${agent.address} pays the gas`,
-      ...(outside > 0n ? { warning: `${amount(outside)} sits on the agent key ${agent.address} outside the FIDES: it was sent to the agent address directly instead of to the FIDES Account. FIDES never spends it. To get it back, the owner can import the agent key from ${path.join(cfg.home, 'agent.json')} into a wallet on this computer, add a little ETH for gas, and send it to themselves. Funds for the agent always go to the FIDES Account address.` } : {}),
-    };
-  }
-
-  const server = new McpServer({ name: 'fides', version: '0.8.0' }, {
-    instructions: 'FIDES lets you act with the owner\'s funds only inside limits the owner signed (a FIDES): a budget, allowed contracts and functions, paid services, and an expiry. ' +
-      'Funds move from the owner\'s FIDES Account, never from the owner\'s wallet. If no FIDES is set up yet, call fides_setup and give the user the link. Always call fides_plan first and show the user what is inside the FIDES, what is blocked and why, ' +
-      'and ask before calling fides_execute. Actions outside the FIDES are blocked before anything is sent. Amounts are in whole token units, like "1.5". ' +
-      'When the user asks what you can do with FIDES, which paid APIs or services there are, or how to start, call fides_help and answer from it: give the paid APIs by name with their price and suggest a next step. ' +
-      'A paid service\'s id is a name the user chooses when signing, like "spraay"; nobody issues it. Any API that charges USDG on Robinhood Chain over x402 (exact, EIP-3009) works, not only the ones fides_help lists. ' +
-      'When the user has many payments owed between their agent and services (or other parties), fides_net nets them to final positions and builds the FIDES Account\'s side of the settlement, plus the publication of the round\'s roots onchain, into one plan for fides_execute.',
-  });
-
-  server.registerTool('fides_help', {
-    title: 'What FIDES can do',
-    description: 'Use when the user asks what you can do with FIDES, what paid APIs or services are available, what to try, or how to get started. Returns what FIDES can do, paid APIs known to work with their URL and price, example requests, and the next step for this user.',
-    inputSchema: {},
-  }, async () => {
-    let fides: SignedFides | null = null;
-    try { fides = await currentFides(); } catch { /* answer without it */ }
-    const allowed = fides?.services.map((s) => s.serviceId) ?? [];
-    return ok({
-      can_do: [
-        'Send USDG from the FIDES Account, to one address or many, inside the budget. Several transfers go out as one transaction.',
-        'Use any verified contract on Robinhood Chain: read what it lets an agent do, risky functions flagged (fides_inspect_contract), allow the functions you choose (fides_setup with contracts), read values from it for free (fides_read_contract), and call it by function name and plain values (fides_plan with function and args). Example: supply USDG to a Morpho market and withdraw it, never borrow.',
-        'Use any paid API that charges on Robinhood Chain: read its price without paying (fides_check_api), allow it with a cap (fides_setup with services), then pay per request (fides_pay_request).',
-        'Buy from paid APIs that charge per request over x402, paying from the FIDES budget, each capped per service.',
-        'Swap on Uniswap inside a trading mandate the owner signed: tokens it may buy, worst price, most per swap; best route across Robinhood Chain including v4 hook pools, approval and swap as one transaction (fides_swap). The FIDES must allow swaps: fides_setup with swap.',
-        'Hand another agent a slice of the FIDES with its own budget and expiry (fides_delegate, SUB-FIDES); or, as the child, act inside a slice handed to you (fides_sub_plan). The FIDES must allow delegation: fides_setup with delegate: true.',
-        'Settle with FIDES NET: give the payments owed to and from the FIDES Account, and they are netted to final positions and settled in one transaction, with the round published onchain (fides_net). The FIDES must allow NET: fides_setup with net: true.',
-        'Show the budget spent and left, what is allowed, the expiry, and every transaction executed, with explorer links.',
-        'Everything is planned and simulated first, and shown to the user before anything is sent. Anything outside the FIDES is blocked. The hosted relayer pays the gas.',
-      ],
-      paid_apis: KNOWN_SERVICES.map((s) => ({ ...s, in_this_fides: allowed.includes(s.id) })),
-      other_paid_apis: 'Any API that charges USDG on Robinhood Chain over x402 (exact scheme, EIP-3009) works the same way. The user adds it as a service with a cap when signing (the id is any name they choose), then gives you its URL.',
-      try_saying: [
-        'Set up FIDES with these paid services: fides-demo up to 0.1 USDG, spraay up to 0.01 USDG, madeonsol up to 0.1 USDG',
-        'Pay 0.5 USDG to 0x... and 0.5 USDG to 0x...',
-        'Buy the chain stats from the FIDES demo',
-        'What\'s left in my FIDES?',
-        'Show what you\'ve executed',
-      ],
-      next_step: !fides ? 'No FIDES is set up yet. Offer to call fides_setup, with any paid services the user wants and a cap for each.'
-        : !allowed.length ? 'This FIDES has no paid services. To use a paid API, call fides_setup with the services and caps, and the user signs the new FIDES.'
-        : `This FIDES allows these paid services: ${allowed.join(', ')}. Make sure the FIDES Account holds USDG (fides_status shows the balance).`,
-      docs: 'https://fidesbuilder.xyz/docs#/claude',
-    });
-  });
-
-  server.registerTool('fides_status', {
-    title: 'FIDES status',
-    description: 'The loaded FIDES: whether it is active, the budget spent and remaining, the FIDES Account balance, the allowed contracts and the expiry. Also gives this computer\'s agent address: use it when the user asks for their FIDES agent address. With no FIDES loaded, explains how to set one up.',
-    inputSchema: {},
-  }, async () => {
-    try {
-      const fides = await currentFides();
-      if (!fides) return ok(notLoaded());
-      if (fides.agent.toLowerCase() !== agent.address.toLowerCase()) return fail(`The loaded FIDES is for agent ${fides.agent}, but this computer's agent key is ${agent.address}. Create a FIDES for ${agent.address}.`);
-      return ok(await summary(fides));
-    } catch (err: any) { return fail('Could not read the FIDES: ' + (err?.shortMessage ?? err?.message ?? err)); }
-  });
-
-  server.registerTool('fides_setup', {
-    title: 'Set up FIDES',
-    description: 'Use when the user wants to set up FIDES, connect their wallet or sign a new FIDES. Returns this computer\'s agent address and a link to the FIDES app with it filled in, where the user sets the limits and signs. The signed FIDES is then picked up automatically. To let the user buy from paid APIs (fides_pay_request), pass the services with a spending cap each. Paid APIs known to work use the ids "fides-demo", "spraay" and "madeonsol" (fides_help has their URLs and prices); for any other paid API, call fides_check_api with its URL and use the service_id it returns. To let the agent call any contract on the chain, pass contracts with the functions it may call by name (fides_inspect_contract lists them and flags the risky ones). When a function pulls tokens from the account (such as Morpho supply, or a vault deposit), also allow approve on that token, so the agent can approve exactly the amount in the same transaction.',
-    inputSchema: {
-      services: z.array(z.object({ id: z.string().describe('The service id: "fides-demo", "spraay", "madeonsol", or for any other paid API the service_id fides_check_api returns (its host)'), max: z.string().describe('Most the agent may spend on it, in USDG, e.g. "0.1"') })).optional(),
-      contracts: z.array(z.object({
-        address: z.string().describe('The contract address'),
-        functions: z.array(z.string()).min(1).describe('Function names (e.g. "supply", "withdraw") or 4-byte selectors. fides_inspect_contract lists them'),
-      })).optional().describe('Any contracts on the chain the agent may call, and exactly which functions; everything else on them stays blocked'),
-      net: z.boolean().optional().describe('true to allow FIDES NET: lets the FIDES publish netting roots on FidesNetRoots, which fides_net needs'),
-      delegate: z.boolean().optional().describe('true to let this agent hand slices of the FIDES to other agents (SUB-FIDES), which fides_delegate needs'),
-      swap: z.object({
-        buy: z.array(z.string()).min(1).describe('Tokens the agent may buy: "ETH", "WETH" or addresses'),
-        max_slippage_percent: z.number().positive().max(50).optional().describe('The worst price it may accept against the quote, in percent. Default 1'),
-        max_per_swap: z.string().optional().describe('The most one swap may spend, in the budget token. Default "1"'),
-      }).optional().describe('Let the agent swap on Uniswap inside a trading mandate the owner signs; fides_swap needs it'),
-    },
-  }, async ({ services, net, delegate, swap, contracts }) => {
-    let targets = '';
-    const added: string[] = [];
-    for (const c of contracts ?? []) {
-      if (!isAddress(c.address)) return fail(`"${c.address}" is not a contract address.`);
-      const sels = c.functions.filter((x) => /^0x[0-9a-fA-F]{8}$/.test(x)).map((x) => x.toLowerCase());
-      const names = c.functions.filter((x) => !/^0x[0-9a-fA-F]{8}$/.test(x));
-      let label = c.address;
-      if (names.length) {
-        let info: any;
-        try { info = await inspect(c.address); } catch (err: any) { return fail(`Could not read ${c.address}: ${err?.message ?? err}`); }
-        if (!info.verified) return fail(`${c.address} is not verified, so its functions cannot be found by name. Give their 4-byte selectors instead.`);
-        label = info.name ?? c.address;
-        for (const n of names) {
-          const fn = info.functions.find((x: any) => x.name === n || x.signature.replace(/ \w+(?=[,)])/g, '') === n);
-          if (!fn) return fail(`${label} has no function "${n}" that changes anything. It has: ${info.functions.map((x: any) => x.name).join(', ')}.`);
-          sels.push(fn.selector);
-        }
-      }
-      targets += `&target=${getAddress(c.address)}:${[...new Set(sels)].join(',')}`;
-      added.push(`${label}: ${c.functions.join(', ')}`);
-    }
-    return ok({
-    agent_address: agent.address,
-    link: setupLink + targets + (services ?? []).map((x) => `&service=${encodeURIComponent(x.id)}:${encodeURIComponent(x.max)}`).join('') + (net && netRoots[cfg.chainId] ? `&target=${netRoots[cfg.chainId]}:${PUBLISH_SELECTOR}` : '') + (delegate ? '&delegate=1' : '') + (swap ? `&swap=${encodeURIComponent(swap.buy.map((t) => (/^weth$/i.test(t) ? uniswap[cfg.chainId]?.weth ?? t : t)).join('|'))}:${Math.round((swap.max_slippage_percent ?? 1) * 100)}:${encodeURIComponent(swap.max_per_swap ?? '1')}` : ''),
-    services: services?.length ? services.map((x) => `${x.id}: up to ${x.max} USDG`) : undefined,
-    contracts: added.length ? added : undefined,
-    steps: [
-      'Open the link. It opens the FIDES app with this agent already filled in.',
-      'Connect your wallet. Set the budget, the contracts allowed and the expiry. Start small.',
-      'Sign (free), click Create FIDES Account (a little gas), and send the budget to the FIDES Account address shown.',
-      'Come back and ask me for what you want. I pick up the signed FIDES by myself.',
-    ],
-  });
-  });
-
-  server.registerTool('fides_use_file', {
-    title: 'Use a FIDES file',
-    description: 'Only needed if the user has a fides.json file: loads a signed FIDES from a path on this computer, checks that it is for this computer\'s agent key, and keeps a copy. FIDES signed in the app are picked up without this.',
-    inputSchema: { path: z.string().describe('Full path to the fides.json file, e.g. C:\\Users\\me\\Downloads\\fides.json') },
-  }, async ({ path: file }) => {
-    try {
-      const full = file.replace(/^~(?=$|[\\/])/, os.homedir());
-      if (!fs.existsSync(full)) return fail(`No file at ${full}.`);
-      let fides: SignedFides;
-      try { fides = fromJson(fs.readFileSync(full, 'utf8')) as SignedFides; } catch { return fail(`${full} is not valid JSON.`); }
-      if (!fides || !fides.id || !fides.signature || !fides.agent || !Array.isArray(fides.spendLimits)) return fail('That file is not a signed FIDES. In the FIDES app, open the FIDES and click "Download signed FIDES".');
-      if (fides.agent.toLowerCase() !== agent.address.toLowerCase()) return fail(`That FIDES is for agent ${fides.agent}, but this computer's agent key is ${agent.address}. Create a new FIDES in the app with "An external agent" and paste ${agent.address}.`);
-      if (Number(fides.chainId) !== cfg.chainId) return fail(`That FIDES is for chain ${fides.chainId}; this server is set up for chain ${cfg.chainId}.`);
-      keep(fides);
-      plans.clear();
-      return ok({ loaded: cfg.fidesFile, ...(await summary(fides)) });
-    } catch (err: any) { return fail('Could not load the FIDES: ' + (err?.shortMessage ?? err?.message ?? err)); }
-  });
-
-  const actionSchema = z.object({
-    kind: z.enum(['transfer', 'call']).describe('"transfer" sends a token from the FIDES Account. "call" calls an allowed contract, by function name and args (encoded from its verified source), or with raw calldata.'),
-    to: z.string().optional().describe('transfer: the recipient address'),
-    amount: z.string().optional().describe('transfer: how much, in whole token units, e.g. "1.5". call: how much of the budget token the call spends, if any, in whole units'),
-    token: z.string().optional().describe('transfer: the token address. Defaults to the FIDES\'s budget token'),
-    target: z.string().optional().describe('call: the contract address'),
-    function: z.string().optional().describe('call: the function name, e.g. "supply", or its signature when the name is overloaded. FIDES encodes the call from the contract\'s verified source'),
-    args: z.array(z.any()).optional().describe('call with function: the arguments in order. Integers as strings in the token\'s smallest unit (USDG has 6 decimals: 0.05 USDG is "50000"). Structs as objects keyed by field name. "me" for an address means this FIDES Account. Empty bytes as "0x"'),
-    data: z.string().optional().describe('call: hex calldata, starting with the 4-byte function selector. Use function and args instead when you can'),
-    label: z.string().optional().describe('A short description shown in the plan'),
-  });
-
-  /** The tool's actions as Builder actions, in the budget token unless a transfer names another. */
-  async function buildActions(actions: z.infer<typeof actionSchema>[], budget: Address): Promise<{ built: ActionInput[] } | { error: string }> {
-    const built: ActionInput[] = [];
-    for (let [i, a] of actions.entries()) {
-      const n = i + 1;
-      if (a.kind === 'transfer') {
-        if (!a.to || !isAddress(a.to)) return { error: `Action ${n}: "to" must be an address.` };
-        const asset = a.token ? (isAddress(a.token) ? getAddress(a.token) : null) : budget;
-        if (!asset) return { error: `Action ${n}: "token" must be an address.` };
-        const t = await token(asset);
-        let amount: bigint;
-        try { amount = parseUnits(String(a.amount ?? ''), t.decimals); } catch { return { error: `Action ${n}: "amount" must be a number of ${t.symbol}, like "1.5".` }; }
-        if (amount <= 0n) return { error: `Action ${n}: "amount" must be more than zero.` };
-        built.push({ id: `a${n}`, type: 'TOKEN_TRANSFER', label: a.label ?? `send ${formatUnits(amount, t.decimals)} ${t.symbol} to ${getAddress(a.to)}`, target: asset, spend: { asset, amount },
-          payload: encodeFunctionData({ abi: erc20Abi, functionName: 'transfer', args: [getAddress(a.to), amount] }) } as ActionInput);
-      } else {
-        if (!a.target || !isAddress(a.target)) return { error: `Action ${n}: "target" must be a contract address.` };
-        if (a.function && !a.data) {
-          const enc = await encodeByName(getAddress(a.target), a.function, a.args ?? [], 'write');
-          if ('error' in enc) return { error: `Action ${n}: ${enc.error}` };
-          a = { ...a, data: enc.data, label: a.label ?? enc.label };
-        }
-        if (!a.data || !/^0x([0-9a-fA-F]{2}){4,}$/.test(a.data)) return { error: `Action ${n}: give "function" and "args", or "data" as hex calldata starting with the 4-byte selector.` };
-        const t = await token(budget);
-        let spend: bigint = 0n;
-        if (a.amount) { try { spend = parseUnits(a.amount, t.decimals); } catch { return { error: `Action ${n}: "amount" must be a number of ${t.symbol}.` }; } }
-        built.push({ id: `a${n}`, type: 'CONTRACT_WRITE', label: a.label ?? `call ${a.data!.slice(0, 10)} on ${getAddress(a.target!)}`, target: getAddress(a.target!), payload: a.data as Hex,
-          ...(spend > 0n ? { spend: { asset: budget, amount: spend } } : {}) } as ActionInput);
-      }
-    }
-    return { built };
-  }
-
-  server.registerTool('fides_plan', {
-    title: 'Plan actions under the FIDES',
-    description: 'Builds the actions into one execution plan: checks every action against the FIDES, groups what can go out together, and simulates it against the chain. Sends nothing. Returns a plan_id for fides_execute. Show the result to the user before executing. Call contracts by function name and args; FIDES encodes them from the verified source. When a contract pulls tokens (e.g. Morpho supply), put an approve of exactly that amount first in the same plan, so nothing stays approved, and set amount on the call so it counts against the budget. Use "me" for addresses that should be the FIDES Account.',
-    inputSchema: { actions: z.array(actionSchema).min(1).max(50) },
-  }, async ({ actions }) => {
-    try {
-      const fides = await currentFides();
-      if (!fides) return fail(notLoaded());
-      if (fides.agent.toLowerCase() !== agent.address.toLowerCase()) return fail(`The loaded FIDES is for agent ${fides.agent}, not this computer's agent key ${agent.address}.`);
-      const made = await buildActions(actions, fides.spendLimits[0].asset);
-      if ('error' in made) return fail(made.error);
-      const built = made.built;
-      const plan = await new FidesBuilder({ client, fides, agent }).add(built).build();
-      const savings = plan.estimatedSavings();
-      const simulations = savings.estimatedTransactions ? await plan.simulate() : [];
-      const failed = simulations.filter((s) => !s.success);
-      const id = plan.planHash.slice(0, 18);
-      if (savings.estimatedTransactions && !failed.length) plans.set(id, { plan, actions: built, fides });
-      return ok({
-        plan_id: savings.estimatedTransactions && !failed.length ? id : null,
-        ready_to_execute: Boolean(savings.estimatedTransactions && !failed.length),
-        actions: plan.actions().map((a) => ({ action: a.label, decision: a.decision === 'AUTHORIZED' ? 'inside the FIDES' : a.decision === 'REJECTED' ? `blocked: ${REASONS[a.reason ?? ''] ?? a.reason} (${a.reason})` : 'duplicate, sent once' })),
-        transactions: `${savings.baselineTransactions} onchain write(s) go out as ${savings.estimatedTransactions} transaction(s)`,
-        simulation: !simulations.length ? 'nothing to execute: no action is inside the FIDES' : failed.length ? `would fail: ${failure(failed[0].revertReason)}` : 'simulated against the chain: it would succeed',
-        sent: 'nothing has been sent',
-      });
-    } catch (err: any) { return fail('Could not build the plan: ' + (err?.shortMessage ?? err?.message ?? err)); }
-  });
-
-  const obligationSchema = z.object({
-    from: z.string().describe('Who owes: an address, or "me" for this FIDES Account'),
-    to: z.string().describe('Who is owed: an address, or "me" for this FIDES Account'),
-    amount: z.string().describe('How much, in whole token units, e.g. "1.5"'),
-    ref: z.string().optional().describe('What it was for, e.g. a job or invoice id. Goes into the obligations root'),
-  });
-
-  server.registerTool('fides_net', {
-    title: 'Net and settle what is owed (FIDES NET)',
-    description: 'Takes the payments owed between this FIDES Account ("me") and other parties, nets them to one final position per party, and builds the FIDES Account\'s side of the settlement into one plan: its net transfers plus the publication of the round\'s two roots (every obligation, every settling transfer) on FidesNetRoots, so payments and the public record go out in the same transaction. Checks every action against the FIDES and simulates. Sends nothing: returns a plan_id for fides_execute. Transfers owed by other parties are listed, not sent. Show the result to the user before executing.',
-    inputSchema: { obligations: z.array(obligationSchema).min(1).max(200), token: z.string().optional().describe('The token address. Defaults to the FIDES\'s budget token') },
-  }, async ({ obligations, token: tokenArg }) => {
-    try {
-      const fides = await currentFides();
-      if (!fides) return fail(notLoaded());
-      if (fides.agent.toLowerCase() !== agent.address.toLowerCase()) return fail(`The loaded FIDES is for agent ${fides.agent}, not this computer's agent key ${agent.address}.`);
-      const roots = netRoots[cfg.chainId];
-      if (!roots) return fail(`FIDES NET is not deployed on chain ${cfg.chainId}.`);
-      const allowsRoots = fides.targets.some((t) => t.target.toLowerCase() === roots.toLowerCase() && t.selectors.some((x) => x.toLowerCase() === PUBLISH_SELECTOR));
-      if (!allowsRoots) return fail(`This FIDES does not allow FIDES NET to publish its roots on ${roots}. The user signs a new FIDES that does: call fides_setup with net: true (and the same services, if any) and give them the link.`);
-      const asset = tokenArg ? (isAddress(tokenArg) ? getAddress(tokenArg) : null) : fides.spendLimits[0].asset;
-      if (!asset) return fail('"token" must be an address.');
-      const t = await token(asset);
-      const party = (x: string, n: number, side: string) => {
-        if (x.trim().toLowerCase() === 'me') return fides.account;
-        if (!isAddress(x)) throw new NetError(`Obligation ${n}: "${side}" must be an address or "me".`);
-        return getAddress(x);
-      };
-      const list: Obligation[] = obligations.map((o, i) => {
-        let amount: bigint;
-        try { amount = parseUnits(o.amount, t.decimals); } catch { throw new NetError(`Obligation ${i + 1}: "amount" must be a number of ${t.symbol}, like "1.5".`); }
-        return { from: party(o.from, i + 1, 'from'), to: party(o.to, i + 1, 'to'), asset, amount, fidesId: fides.id, ref: o.ref ?? `${i + 1}` };
-      });
-      const s = netObligations(list);
-      const p = settle(s, { account: fides.account, chainId: cfg.chainId, decimals: t.decimals, symbol: t.symbol });
-      const plan = await new FidesBuilder({ client, fides, agent }).add(p.actions).build();
-      const savings = plan.estimatedSavings();
-      const simulations = savings.estimatedTransactions ? await plan.simulate() : [];
-      const failed = simulations.filter((x) => !x.success);
-      const ready = Boolean(savings.estimatedTransactions && !failed.length && !plan.rejected().length);
-      const id = plan.planHash.slice(0, 18);
-      if (ready) plans.set(id, { plan, actions: p.actions, fides, net: { epoch: p.epoch, obligationsRoot: s.obligationsRoot, settlementRoot: s.settlementRoot } });
-      const amt = (v: bigint) => `${formatUnits(v < 0n ? -v : v, t.decimals)} ${t.symbol}`;
-      const name = (a: string) => (a.toLowerCase() === fides.account.toLowerCase() ? 'me' : getAddress(a));
-      const book = s.positions[asset.toLowerCase()] ?? {};
-      return ok({
-        plan_id: ready ? id : null,
-        ready_to_execute: ready,
-        gross: `${s.gross.obligations} obligations, ${amt(s.gross.volume[asset.toLowerCase()] ?? 0n)} moving`,
-        net: `${s.net.transfers} transfer(s), ${amt(s.net.volume[asset.toLowerCase()] ?? 0n)} moving`,
-        positions: Object.entries(book).map(([who, v]) => `${name(who)}: ${v < 0n ? 'pays' : 'receives'} ${amt(v)}`),
-        my_transfers: p.own.map((x) => `pay ${amt(x.amount)} to ${getAddress(x.to)}`),
-        settled_by_others: p.others.map((x) => `${name(x.from)} pays ${amt(x.amount)} to ${name(x.to)} (not sent by this FIDES)`),
-        actions: plan.actions().map((a) => ({ action: a.label, decision: a.decision === 'AUTHORIZED' ? 'inside the FIDES' : a.decision === 'REJECTED' ? `blocked: ${REASONS[a.reason ?? ''] ?? a.reason} (${a.reason})` : 'duplicate, sent once' })),
-        transactions: `${savings.baselineTransactions} onchain write(s) go out as ${savings.estimatedTransactions} transaction(s)`,
-        record: { contract: roots, epoch: p.epoch.toString(), obligations_root: s.obligationsRoot, settlement_root: s.settlementRoot },
-        simulation: !simulations.length ? 'nothing to execute' : failed.length ? `would fail: ${failure(failed[0].revertReason)}` : 'simulated against the chain: it would succeed',
-        sent: 'nothing has been sent',
-      });
-    } catch (err: any) { return fail(err instanceof NetError ? err.message : 'Could not net these: ' + (err?.shortMessage ?? err?.message ?? err)); }
-  });
-
-  async function post(route: string, body: unknown) {
-    const res = await fetch(cfg.api + route, { method: 'POST', headers: { 'content-type': 'application/json' }, body: toJson(body) });
-    const json = fromJson(await res.text()) as any;
-    if (!res.ok || json?.error) throw new Error(json?.error?.code ? `${json.error.code}: ${json.error.message}` : `HTTP ${res.status}`);
-    return json;
-  }
-
-  /** Sends a plan's bundles: through the hosted relayer, or paid by the agent key with FIDES_RELAY=self. */
-  async function send(plan: ExecutionPlan, actions: ActionInput[], fides: SignedFides) {
-    if (!cfg.api) return (await plan.execute()).bundles as { group: string; status: string; txHash?: string; error?: string }[];
-    const stored = await post('/v1/plans/build', { fides, actions });
-    if (stored.planHash !== plan.planHash) throw new Error('The relayer built a different plan from the same actions, so nothing was sent.');
-    return (await post(`/v1/plans/${plan.planHash}/execute`, { bundles: await plan.signedBundles() })).bundles as { group: string; status: string; txHash?: string; error?: string }[];
-  }
-
-  // What each paid service has cost so far, while this server runs. The onchain limit is the budget;
-  // the per-service caps are checked here, before anything is signed.
-  const servicePaid = new Map<string, bigint>();
-
-  // The float: what this tool moved to the agent key through a FIDES and has not spent yet, by FIDES and
-  // token. Kept on disk so a restart does not forget it. Only this is ever used to pay; anything else on
-  // the agent key (someone sent it there directly) did not pass through the FIDES, so it is left alone.
-  const floatFile = path.join(cfg.home, 'float.json');
-  const floats = (): Record<string, string> => { try { return JSON.parse(fs.readFileSync(floatFile, 'utf8')); } catch { return {}; } };
-  const floatKey = (fides: SignedFides, asset: string) => `${fides.id}:${asset.toLowerCase()}`;
-  const floatOf = (fides: SignedFides, asset: string) => BigInt(floats()[floatKey(fides, asset)] ?? '0');
-  const setFloat = (fides: SignedFides, asset: string, v: bigint) => { const m = floats(); m[floatKey(fides, asset)] = (v > 0n ? v : 0n).toString(); fs.mkdirSync(cfg.home, { recursive: true }); fs.writeFileSync(floatFile, JSON.stringify(m, null, 2)); };
-  /** What sits on the agent key that did not come through any FIDES by this tool. */
-  const stray = async (asset: Address) => {
-    const held = await client.public.readContract({ address: asset, abi: erc20Abi, functionName: 'balanceOf', args: [agent.address] }) as bigint;
-    const ours = Object.entries(floats()).filter(([k]) => k.endsWith(':' + asset.toLowerCase())).reduce((n, [, v]) => n + BigInt(v), 0n);
-    return held > ours ? held - ours : 0n;
-  };
-
-  server.registerTool('fides_pay_request', {
-    title: 'Buy from a paid API',
-    description: `Fetches a URL from a paid API that charges per request over x402, paying from the FIDES budget. Reads the price first and refuses if it is over the service\'s cap in the FIDES or over max_price. Moves exactly the price from the FIDES Account to the agent key, pays, and returns the response. The service must be in the FIDES (its services list). Known URLs: ${KNOWN_SERVICES.map((s) => `"${s.id}" ${s.url}`).join(', ')}. Tell the user the price and get their OK before paying unless they already asked you to buy it.`,
-    inputSchema: {
-      url: z.string().describe('The paid API URL'),
-      service: z.string().optional().describe('The service id in the FIDES. Can be left out if the FIDES has exactly one service'),
-      max_price: z.string().optional().describe('Refuse if the price is above this, in USDG'),
-    },
-  }, async ({ url, service, max_price }) => {
-    try {
-      const fides = await currentFides();
-      if (!fides) return fail(notLoaded());
-      if (!fides.services.length) return fail(`This FIDES allows no paid services. To buy from a paid API, the user signs a new FIDES that includes one: call fides_setup with services, for example [{ id: "fides-demo", max: "0.1" }].`);
-      const host = (() => { try { return new URL(url).host.toLowerCase().replace(/^www\./, ''); } catch { return ''; } })();
-      const id = service ?? (fides.services.some((x) => x.serviceId === host) ? host : fides.services.length === 1 ? fides.services[0].serviceId : undefined);
-      if (!id) return fail(`Say which service this is. The FIDES allows: ${fides.services.map((x) => x.serviceId).join(', ')}.`);
-      const rule = fides.services.find((x) => x.serviceId === id);
-      if (!rule) return fail(`"${id}" is not a service in this FIDES. It allows: ${fides.services.map((x) => x.serviceId).join(', ')}. Anything else is blocked.`);
-
-      // 1. the price
-      let first: Response;
-      try { first = await fetch(url); } catch (err: any) { return fail('Could not reach ' + url + ': ' + (err?.message ?? err)); }
-      const header = first.headers.get('PAYMENT-REQUIRED');
-      if (first.status !== 402 || !header) {
-        const text = await first.text();
-        return ok({ paid: 'nothing: this URL did not ask for payment', status: first.status, response: text.slice(0, 4000) });
-      }
-      const required = decodePaymentRequired(header);
-      const offer = required.accepts.find((r) => exactEip3009.supports(r, { fides, payer: agent }) && fides.spendLimits.some((l) => l.asset.toLowerCase() === r.asset.toLowerCase()));
-      if (!offer) return fail('This service asks for a payment FIDES cannot make from this FIDES: it needs the budget token, paid with EIP-3009 on this chain. Nothing was paid.');
-      const t = await token(offer.asset as Address);
-      const price = BigInt(offer.amount);
-      const shown = `${formatUnits(price, t.decimals)} ${t.symbol}`;
-      if (max_price) { let cap: bigint; try { cap = parseUnits(max_price, t.decimals); } catch { return fail('max_price must be a number, like "0.05".'); } if (price > cap) return fail(`Blocked: the price is ${shown}, over your max of ${max_price}. Nothing was paid.`); }
-      const paidSoFar = servicePaid.get(id) ?? 0n;
-      if (paidSoFar + price > BigInt(rule.maxSpend)) return fail(`Blocked: ${shown} would take "${id}" past its cap of ${formatUnits(BigInt(rule.maxSpend), t.decimals)} ${t.symbol} in this FIDES (${formatUnits(paidSoFar, t.decimals)} spent). Nothing was paid.`);
-
-      // 2. fund the agent key through the FIDES: reuse only float this tool moved there under this FIDES
-      const held = await client.public.readContract({ address: offer.asset as Address, abi: erc20Abi, functionName: 'balanceOf', args: [agent.address] }) as bigint;
-      let float = floatOf(fides, offer.asset);
-      if (float > held) float = held;
-      const x402 = createX402({ fides, payer: agent, serviceId: () => id });
-      let funded: string | undefined;
-      if (float < price) {
-        const actions = [x402.float(offer.asset as Address, price - float, 'pay-float')];
-        const plan = await new FidesBuilder({ client, fides, agent }).add(actions).build();
-        if (plan.rejected().length) { const r = plan.rejected()[0]; return fail(`Blocked by the FIDES: ${REASONS[r.reason ?? ''] ?? r.reason}. Nothing was paid.`); }
-        const [sim] = await plan.simulate();
-        if (sim && !sim.success) return fail('Blocked: ' + failure(sim.revertReason) + ' Nothing was paid.');
-        const bundles = await send(plan, actions, fides);
-        if (!bundles.length || bundles.some((b) => b.status !== 'EXECUTED')) return fail('Could not move the price to the agent key: ' + failure(bundles.find((b) => b.error)?.error) + ' Nothing was paid.');
-        funded = txLink(bundles[0].txHash);
-        float = price;
-        setFloat(fides, offer.asset, float);
-      }
-
-      // 3. pay and fetch
-      const res = await x402.fetch(url);
-      const body = await res.text();
-      const p = x402.payments[0];
-      // No confirmed payment (a 402, or an error before the service settled): the price moved to the agent
-      // key is still there, recorded as float, and pays for the next request instead of moving it again.
-      if (!p) return fail(`The service did not take the payment (it answered ${res.status}${body ? ': ' + body.slice(0, 200) : ''}), so nothing was paid. ${funded ? 'The price already moved to the agent key stays there and pays for the next attempt, so a retry does not move it again.' : ''}`);
-      if (p) { servicePaid.set(id, paidSoFar + p.amount); setFloat(fides, offer.asset, float - p.amount); }
-      let response: unknown = body.slice(0, 4000);
-      try { response = JSON.parse(body); } catch {}
-      const [spend] = await Policy.remainingSpend(client, fides);
-      return ok({
-        paid: p ? shown : 'nothing',
-        service: id,
-        settlement: txLink((p?.settlement as any)?.transaction),
-        moved_to_agent_key: funded,
-        status: res.status,
-        response,
-        budget_remaining: `${formatUnits(spend.remaining, t.decimals)} of ${formatUnits(spend.limit, t.decimals)} ${t.symbol}`,
-      });
-    } catch (err: any) { return fail('Paid request stopped: ' + failure(err?.shortMessage ?? err?.message ?? err)); }
-  });
-
-  // ---- SUB-FIDES ----
-
-  // ---- Connect anything ----
-
-  const lookupBase = () => cfg.api ?? cfg.directory ?? 'https://api.fidesbuilder.xyz';
-  async function inspect(address: string) {
-    const res = await fetch(`${lookupBase()}/v1/contracts/${address}`);
-    const json = fromJson(await res.text()) as any;
-    if (!res.ok || json?.error) throw new Error(json?.error?.message ?? `HTTP ${res.status}`);
-    return json;
-  }
-
-  /** Encodes a call to `fn` on `target` from the contract's verified ABI (standard ERC-20 functions work without one). */
-  async function encodeByName(target: Address, fn: string, args: unknown[], kind: 'write' | 'read'): Promise<{ data: Hex; label: string; abi: AbiFunction; name: string } | { error: string }> {
-    let info: any = null;
-    try { info = await inspect(target); } catch { /* fall back to ERC-20 below */ }
-    const list: { abi: AbiFunction }[] = (kind === 'write' ? info?.functions : info?.reads) ?? [];
-    const byName = (x: { abi: AbiFunction }) => x.abi.name === fn || `${x.abi.name}(${x.abi.inputs.map((i) => i.type).join(',')})` === fn.replace(/\s/g, '') || (x as any).signature === fn;
-    let matches = list.filter((x) => x.abi && byName(x));
-    if (!matches.length) {
-      const std = (erc20Abi as readonly any[]).filter((x) => x.type === 'function' && x.name === fn && (kind === 'read') === (x.stateMutability === 'view'));
-      matches = std.map((abi) => ({ abi }));
-    }
-    if (matches.length > 1) matches = matches.filter((x) => x.abi.inputs.length === args.length);
-    if (!matches.length) {
-      if (info && !info.verified) return { error: `${target} is not verified on Sourcify, so "${fn}" cannot be encoded by name. Pass "data" as hex calldata instead.` };
-      const names = list.map((x: any) => x.name).filter(Boolean);
-      return { error: `${info?.name ?? target} has no ${kind === 'write' ? 'write' : 'read'} function "${fn}"${names.length ? `. It has: ${[...new Set(names)].join(', ')}` : ''}.` };
-    }
-    if (matches.length > 1) return { error: `"${fn}" is overloaded; give its signature, one of: ${matches.map((x) => `${x.abi.name}(${x.abi.inputs.map((i) => i.type).join(',')})`).join(', ')}.` };
-    const abi = matches[0].abi;
-    if (args.length !== abi.inputs.length) return { error: `${abi.name} takes ${abi.inputs.length} argument(s): ${abi.inputs.map((i) => `${i.type} ${i.name ?? ''}`.trim()).join(', ')}. Got ${args.length}.` };
-    const me = (await currentFides().catch(() => null))?.account ?? null;
-    try {
-      const data = encodeCall(abi, args, me);
-      return { data, label: `${info?.name ?? 'contract'}.${abi.name} on ${target}`, abi, name: info?.name ?? null };
-    } catch (err: any) { return { error: err?.shortMessage ?? err?.message ?? String(err) }; }
-  }
-
-  server.registerTool('fides_inspect_contract', {
-    title: 'What a contract lets an agent do',
-    description: 'Reads any contract on the chain from its verified source (proxies followed) and lists the functions that change something, in plain words, with risks flagged: "danger" (lasting approvals, handing control to another address, upgrades, debt), "warn" (the agent picks where funds go, or it sends ETH) and "admin" (operator-only; will fail for an agent). Use it before fides_setup with contracts, and recommend only the functions the user needs. Sends nothing.',
-    inputSchema: { address: z.string().describe('The contract address') },
-  }, async ({ address }) => {
-    try {
-      if (!isAddress(address)) return fail('That is not a contract address.');
-      const info = await inspect(address);
-      if (!info.verified) return ok({ address: info.address, verified: false, note: 'Not verified on Sourcify, so its functions cannot be read. The user can still allow it by 4-byte selector.' });
-      return ok({
-        name: info.name, address: info.address, verified: true, proxy: info.proxy ?? undefined,
-        functions: info.functions.map((fn: any) => ({ name: fn.name, does: fn.about || undefined, signature: fn.signature, selector: fn.selector, risks: fn.risks.length ? fn.risks.map((r: any) => `${r.level}: ${r.why}`) : undefined })),
-        reads: info.reads?.length ? info.reads.map((fn: any) => fn.signature) : undefined,
-        next: 'To allow some of these, call fides_setup with contracts: [{ address, functions: [names] }] and give the user the link. Once signed, call them with fides_plan: { kind: "call", target, function, args }. Read functions are free: fides_read_contract.',
-      });
-    } catch (err: any) { return fail('Could not read the contract: ' + (err?.message ?? err)); }
-  });
-
-  server.registerTool('fides_read_contract', {
-    title: 'Read from a contract',
-    description: 'Calls a read-only (view) function on any verified contract on the chain, by name, and returns the result. Free: nothing is signed or sent, and it needs no permission in the FIDES. Use it to look up what a write needs, such as a market\'s parameters or a balance. Integers come back as strings in the smallest unit.',
-    inputSchema: {
-      address: z.string().describe('The contract address'),
-      function: z.string().describe('The view function name, or its signature when overloaded'),
-      args: z.array(z.any()).optional().describe('The arguments in order. Integers as strings. "me" for an address means this FIDES Account'),
-    },
-  }, async ({ address, function: fn, args }) => {
-    try {
-      if (!isAddress(address)) return fail('That is not a contract address.');
-      const enc = await encodeByName(getAddress(address), fn, args ?? [], 'read');
-      if ('error' in enc) return fail(enc.error);
-      const { data } = await client.public.call({ to: getAddress(address), data: enc.data });
-      const result = decodeFunctionResult({ abi: [enc.abi], functionName: enc.abi.name, data: data ?? '0x' });
-      const named = enc.abi.outputs.length > 1 && enc.abi.outputs.every((o) => o.name) && Array.isArray(result) ? Object.fromEntries(enc.abi.outputs.map((o, i) => [o.name, (result as unknown[])[i]])) : result;
-      return ok({ contract: enc.name ?? address, function: enc.abi.name, result: JSON.parse(JSON.stringify(named, (_k, x) => (typeof x === 'bigint' ? x.toString() : x))) });
-    } catch (err: any) { return fail('Could not read: ' + failure(err?.shortMessage ?? err?.message ?? err)); }
-  });
-
-  server.registerTool('fides_check_api', {
-    title: 'Can FIDES pay this API?',
-    description: 'Calls a paid API\'s URL once, without paying, and reads its x402 price: whether a FIDES on Robinhood Chain can pay it, the price, who is paid, and the service id and a suggested cap to use with fides_setup. Use it when the user wants the agent to use a paid API that is not one of the known ones. Pays nothing.',
-    inputSchema: { url: z.string().describe('The API URL, https') },
-  }, async ({ url }) => {
-    try {
-      const res = await fetch(`${lookupBase()}/v1/services/probe`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: toJson({ url, budgetToken: (await currentFides().catch(() => null))?.spendLimits[0].asset ?? '0x5fc5360D0400a0Fd4f2af552ADD042D716F1d168' }) });
-      const p = fromJson(await res.text()) as any;
-      if (!res.ok || p?.error) return fail(p?.error?.message ?? `HTTP ${res.status}`);
-      if (!p.payable) return ok({ url: p.url, payable: false, why: p.reason, charges_on: p.networks?.length ? p.networks : undefined });
-      const dec = p.offer.decimals ?? 6, sym = p.offer.symbol ?? 'USDG';
-      return ok({
-        url: p.url, payable: true, price: `${formatUnits(BigInt(p.offer.amount), dec)} ${sym} a request`, paid_to: p.offer.payTo, what_it_is: p.description,
-        service_id: p.serviceId, suggested_cap: `${formatUnits(BigInt(p.suggestedCap), dec)} ${sym} (10 requests)`,
-        next: `To allow it, call fides_setup with services: [{ id: "${p.serviceId}", max: "${formatUnits(BigInt(p.suggestedCap), dec)}" }]. Then fides_pay_request with this URL.`,
-      });
-    } catch (err: any) { return fail('Could not check the API: ' + (err?.message ?? err)); }
-  });
-
-  // ---- Uniswap ----
-
-  const tokenArg = (t: string) => (/^eth$/i.test(t) ? 'ETH' as const : /^weth$/i.test(t) ? uniswap[cfg.chainId]?.weth : isAddress(t) ? getAddress(t) : null);
-
-  server.registerTool('fides_swap', {
-    title: 'Swap on Uniswap inside the FIDES',
-    description: 'Gets the best route from Uniswap on Robinhood Chain (v2, v3 and v4 pools, including v4 pools with hooks such as the aggregator hooks) for the FIDES Account, checks it against the trading mandate the owner signed (tokens it may buy, worst price, most per swap), and simulates it to measure what would actually arrive. Sends nothing. Returns a plan_id for fides_execute, which sends an exact approval and the swap as one transaction; gas is paid by the relayer. Show the route, the quoted amount and the worst accepted amount to the user before executing. Needs a FIDES that allows swaps: fides_setup with swap.',
-    inputSchema: {
-      token_out: z.string().describe('What to buy: "ETH", "WETH" or a token address'),
-      amount: z.string().describe('How much of the budget token to spend, e.g. "1"'),
-      max_slippage_percent: z.number().positive().optional().describe('Worst price against the quote, in percent. Defaults to the most the FIDES allows'),
-    },
-  }, async ({ token_out, amount, max_slippage_percent }) => {
-    try {
-      const fides = await currentFides();
-      if (!fides) return fail(notLoaded());
-      if (fides.agent.toLowerCase() !== agent.address.toLowerCase()) return fail(`The loaded FIDES is for agent ${fides.agent}, not this computer's agent key ${agent.address}.`);
-      const m = mandateOf(fides);
-      if (!m) return fail('This FIDES does not allow swaps. The user signs one that does: call fides_setup with swap, for example { buy: ["ETH"], max_slippage_percent: 1, max_per_swap: "1" }, and give them the link.');
-      const out = tokenArg(token_out);
-      if (!out) return fail('"token_out" must be "ETH", "WETH" or a token address.');
-      const budgetToken = fides.spendLimits[0].asset, tIn = await token(budgetToken);
-      let value: bigint;
-      try { value = parseUnits(amount, tIn.decimals); } catch { return fail(`"amount" must be a number of ${tIn.symbol}, like "1".`); }
-      const slippageBps = max_slippage_percent ? Math.round(max_slippage_percent * 100) : m.maxSlippageBps;
-      let q: SwapQuote, blocked: { code: string; message: string } | null;
-      if (cfg.api) {
-        const r = await post('/v1/swap/quote', { fides, tokenOut: out, amount: value, slippageBps });
-        q = r.quote as SwapQuote; blocked = r.mandate?.allowed ? null : { code: r.mandate.code, message: r.mandate.message };
-      } else {
-        if (!process.env.UNISWAP_API_KEY) return fail('Swaps need the FIDES API, or UNISWAP_API_KEY when running without it.');
-        q = await quoteUniswap({ apiKey: process.env.UNISWAP_API_KEY, fides, tokenOut: out, amount: value, slippageBps });
-        blocked = checkMandate(fides, q);
-      }
-      const outInfo = q.tokenOut === NATIVE ? { symbol: 'ETH', decimals: 18 } : await token(q.tokenOut);
-      const fmt = (v: bigint) => `${formatUnits(v, outInfo.decimals)} ${outInfo.symbol}`;
-      if (blocked) return fail(`Blocked by the trading mandate: ${blocked.message} Nothing was sent.`);
-      const actions = swapActions(q, `swap ${amount} ${tIn.symbol} to ${outInfo.symbol} on Uniswap`);
-      const plan = await new FidesBuilder({ client, fides, agent }).add(actions).build();
-      if (plan.rejected().length) { const r = plan.rejected()[0]; return fail(`Blocked by the FIDES: ${REASONS[r.reason ?? ''] ?? r.reason}. Nothing was sent.`); }
-      const v = await verifySwap(client as any, fides, plan as any, q);
-      const id = plan.planHash.slice(0, 18);
-      if (v.ok) plans.set(id, { plan, actions, fides, swap: { quote: q, outDecimals: outInfo.decimals, outSymbol: outInfo.symbol } });
-      return ok({
-        plan_id: v.ok ? id : null,
-        ready_to_execute: v.ok,
-        route: describeRoute(q),
-        spend: `${amount} ${tIn.symbol}`,
-        quoted: fmt(q.quotedOut),
-        worst_accepted: `${fmt(q.minOut)} (${q.slippageBps / 100}% below the quote)`,
-        simulated: v.ok ? `would receive ${fmt(v.received)}` : `refused: ${v.reason}`,
-        transactions: `${plan.estimatedSavings().baselineTransactions} onchain write(s) go out as ${plan.estimatedSavings().estimatedTransactions} transaction(s): an exact approval and the swap, nothing left approved`,
-        mandate: `may buy ${m.buy.join(', ')}; worst price ${m.maxSlippageBps / 100}%; most per swap ${formatUnits(m.maxPerSwap, tIn.decimals)} ${tIn.symbol}`,
-        sent: 'nothing has been sent',
-      });
-    } catch (err: any) { return fail(err instanceof SwapError ? `Uniswap: ${err.message}` : 'Could not get a swap: ' + (err?.shortMessage ?? err?.message ?? err)); }
-  });
-
-  server.registerTool('fides_delegate', {
-    title: 'Hand another agent a slice of the FIDES (SUB-FIDES)',
-    description: 'This agent hands another agent a SUB-FIDES: its own budget, contracts and expiry, inside this FIDES. The child can never exceed it, and everything it spends also counts against this FIDES. This agent signs it; nothing is sent onchain and it costs nothing. The child agent (Claude or an SDK agent running FIDES) finds it by itself, or the user can hand it the file. Needs a FIDES that allows delegation: fides_setup with delegate: true. Confirm the amount and the agent with the user first.',
-    inputSchema: {
-      agent: z.string().describe('The child agent\'s address'),
-      amount: z.string().describe('The most the child may spend, in the budget token, e.g. "0.1"'),
-      minutes: z.number().int().positive().optional().describe('How long the slice lasts. Defaults to as long as this FIDES; never longer'),
-    },
-  }, async ({ agent: child, amount, minutes }) => {
-    try {
-      if (!subClient || !subAddrs) return fail(`SUB-FIDES is not deployed on chain ${cfg.chainId}.`);
-      const parent = await currentFides();
-      if (!parent) return fail(notLoaded());
-      if (parent.agent.toLowerCase() !== agent.address.toLowerCase()) return fail(`The loaded FIDES is for agent ${parent.agent}, not this computer's agent key ${agent.address}.`);
-      if (!isAddress(child)) return fail('"agent" must be an address.');
-      if (child.toLowerCase() === agent.address.toLowerCase()) return fail('An agent cannot delegate to itself.');
-      const v2 = await accountOf(subClient, parent.owner);
-      if (v2.toLowerCase() !== parent.account.toLowerCase()) return fail('This FIDES cannot delegate: its FIDES Account is not one that supports SUB-FIDES. The user signs a new FIDES that allows delegation: call fides_setup with delegate: true and give them the link.');
-      const asset = parent.spendLimits[0].asset, t = await token(asset);
-      let value: bigint;
-      try { value = parseUnits(amount, t.decimals); } catch { return fail(`"amount" must be a number of ${t.symbol}, like "0.1".`); }
-      const expiry = minutes ? BigInt(Math.min(Number(parent.validUntil), Math.floor(Date.now() / 1000) + minutes * 60)) : parent.validUntil;
-      const unsigned = SubFidesKit.create(parent, { agent: getAddress(child), spend: [{ asset, amount: value }], expiry });
-      const sub = await SubFidesKit.sign(unsigned, agent, subClient, parent);
-      if (cfg.api) await SubFidesKit.register(cfg.api, parent, sub);
-      fs.mkdirSync(subsDir, { recursive: true });
-      const file = path.join(subsDir, `${sub.id.slice(0, 18)}.json`);
-      fs.writeFileSync(file, toJson({ parent, sub }, 2) + '\n');
-      return ok({
-        sub_fides: sub.id,
-        child_agent: sub.agent,
-        budget: `${formatUnits(value, t.decimals)} ${t.symbol}`,
-        expires: new Date(Number(sub.validUntil) * 1000).toISOString(),
-        contracts: sub.targets.map((r) => r.target),
-        file,
-        how_the_child_gets_it: cfg.api ? 'Shared with the FIDES API: a child running FIDES (Claude or the SDK) finds it by its agent address. The file is a copy to hand over directly.' : 'Hand the child the file.',
-        revoke: 'The owner can revoke it any time in the FIDES app, on this FIDES\'s page.',
-      });
-    } catch (err: any) { return fail(err instanceof SubFidesError ? err.message : 'Could not delegate: ' + (err?.shortMessage ?? err?.message ?? err)); }
-  });
-
-  /** The SUB-FIDES handed to this agent that can still act: from a file, or found through the FIDES API. */
-  async function receivedSubs(file?: string): Promise<{ parent: SignedFides; sub: SignedSubFides }[]> {
-    const found: { parent: SignedFides; sub: SignedSubFides }[] = [];
-    if (file) { const full = file.replace(/^~(?=$|[\\/])/, os.homedir()); found.push(fromJson(fs.readFileSync(full, 'utf8'))); }
-    if (cfg.directory) {
-      try {
-        const res = await fetch(`${cfg.directory}/v1/agents/${agent.address}/subs`);
-        if (res.ok) for (const x of (fromJson(await res.text()) as any).subs ?? []) if (x.parentStatus?.valid) found.push({ parent: x.parent, sub: x.sub });
-      } catch { /* the API is optional when a file is given */ }
-    }
-    const now = BigInt(Math.floor(Date.now() / 1000));
-    const live: { parent: SignedFides; sub: SignedSubFides }[] = [];
-    for (const x of found) {
-      if (x.sub.agent.toLowerCase() !== agent.address.toLowerCase() || now >= x.sub.validUntil) continue;
-      if (subClient && await SubFidesKit.isRevoked(subClient, x.parent, x.sub).catch(() => true)) continue;
-      live.push(x);
-    }
-    return live.sort((a, b) => Number(b.sub.validAfter - a.sub.validAfter));
-  }
-
-  server.registerTool('fides_sub_plan', {
-    title: 'Plan actions under a SUB-FIDES handed to this agent',
-    description: 'For when another agent handed this agent a SUB-FIDES (a slice of its FIDES). Builds the actions into one plan, checks every action against the slice, and simulates it. Sends nothing. Returns a plan_id for fides_execute, which sends it through the relayer (no gas needed). Show the result to the user before executing.',
-    inputSchema: { actions: z.array(actionSchema).min(1).max(50), file: z.string().optional().describe('Path to a SUB-FIDES file, if the user has one. Otherwise it is found by this agent\'s address') },
-  }, async ({ actions, file }) => {
-    try {
-      if (!subClient) return fail(`SUB-FIDES is not deployed on chain ${cfg.chainId}.`);
-      const [x] = await receivedSubs(file);
-      if (!x) return fail(`No active SUB-FIDES has been handed to this agent (${agent.address}). The delegating agent creates one with this address, or the user gives you its file.`);
-      const made = await buildActions(actions, x.sub.spendLimits[0]?.asset ?? x.parent.spendLimits[0].asset);
-      if ('error' in made) return fail(made.error);
-      const child = new SubAgent({ client: subClient, parent: x.parent, sub: x.sub, agent, ...(cfg.api ? { api: cfg.api } : { relayer: agent }) });
-      const p = await child.plan(made.built);
-      const sim = p.bundle ? await child.simulate(p) : { success: false, reason: 'NOTHING_TO_SEND' };
-      const id = (p.bundleHash ?? '0x').slice(0, 18);
-      if (sim.success) subPlans.set(id, { agent: child, plan: p, parent: x.parent, sub: x.sub });
-      const t = await token(x.sub.spendLimits[0]?.asset ?? x.parent.spendLimits[0].asset);
-      return ok({
-        plan_id: sim.success ? id : null,
-        ready_to_execute: sim.success,
-        sub_fides: x.sub.id,
-        slice: `${x.sub.spendLimits.map((l) => formatUnits(l.amount, t.decimals) + ' ' + t.symbol).join(', ')} until ${new Date(Number(x.sub.validUntil) * 1000).toISOString()}`,
-        delegated_by: x.parent.agent,
-        actions: p.plan.actions.map((a) => ({ action: a.label, decision: a.decision === 'AUTHORIZED' ? 'inside the SUB-FIDES' : a.decision === 'REJECTED' ? `blocked: ${REASONS[a.reason ?? ''] ?? a.reason} (${a.reason})` : 'duplicate, sent once' })),
-        transactions: p.bundle ? `${p.bundle.calls.length} onchain write(s) go out as 1 transaction` : 'nothing to execute',
-        simulation: !p.bundle ? 'nothing to execute: no action is inside the SUB-FIDES' : sim.success ? 'simulated against the chain: it would succeed' : `would fail: ${failure(sim.reason)}`,
-        sent: 'nothing has been sent',
-      });
-    } catch (err: any) { return fail('Could not build the plan: ' + (err?.shortMessage ?? err?.message ?? err)); }
-  });
-
-  server.registerTool('fides_subs', {
-    title: 'SUB-FIDES handed out and received',
-    description: 'The SUB-FIDES this agent has handed to other agents, and the ones handed to it that can still act.',
-    inputSchema: {},
-  }, async () => {
-    try {
-      const given = fs.existsSync(subsDir) ? fs.readdirSync(subsDir).filter((n) => n.endsWith('.json')).map((n) => (fromJson(fs.readFileSync(path.join(subsDir, n), 'utf8')) as any).sub as SignedSubFides) : [];
-      const now = BigInt(Math.floor(Date.now() / 1000));
-      return ok({
-        handed_out: await Promise.all(given.map(async (s) => ({ sub_fides: s.id, child_agent: s.agent, budget: (await Promise.all(s.spendLimits.map(async (l) => { const t = await token(l.asset); return `${formatUnits(l.amount, t.decimals)} ${t.symbol}`; }))).join(', '), expires: new Date(Number(s.validUntil) * 1000).toISOString(), expired: now >= s.validUntil }))),
-        received: (await receivedSubs()).map((x) => ({ sub_fides: x.sub.id, delegated_by: x.parent.agent, expires: new Date(Number(x.sub.validUntil) * 1000).toISOString() })),
-      });
-    } catch (err: any) { return fail('Could not list SUB-FIDES: ' + (err?.shortMessage ?? err?.message ?? err)); }
-  });
-
-  server.registerTool('fides_execute', {
-    title: 'Execute a plan',
-    description: 'Executes a plan made by fides_plan, by its plan_id. Only the actions inside the FIDES are sent; blocked ones never are. Moves real funds from the FIDES Account: confirm with the user first.',
-    inputSchema: { plan_id: z.string() },
-  }, async ({ plan_id }) => {
-    const subEntry = subPlans.get(plan_id);
-    if (subEntry) {
-      subPlans.delete(plan_id);
-      try {
-        const r = await subEntry.agent.execute(subEntry.plan);
-        return ok({
-          result: r.status === 'EXECUTED' ? 'executed' : 'not executed',
-          transactions: r.txHash || r.error ? [{ status: r.status.toLowerCase(), transaction: txLink(r.txHash), ...(r.error ? { reason: failure(r.error) } : {}) }] : [],
-          under: `SUB-FIDES ${subEntry.sub.id} from ${subEntry.parent.agent}`,
-          blocked_and_not_sent: subEntry.plan.plan.rejected.map((a) => `${a.label}: ${REASONS[a.reason ?? ''] ?? a.reason}`),
-        });
-      } catch (err: any) { return fail('Execution stopped: ' + failure(err?.shortMessage ?? err?.message ?? err)); }
-    }
-    const entry = plans.get(plan_id);
-    if (!entry) return fail('No plan with that id. Make one with fides_plan first (plans are kept until they are executed or the server restarts).');
-    plans.delete(plan_id); // a plan's bundles can be sent once
-    const { plan, actions, fides, net, swap } = entry;
-    try {
-      const outBalance = () => !swap ? Promise.resolve(0n) : swap.quote.tokenOut === NATIVE ? client.public.getBalance({ address: fides.account }) : client.public.readContract({ address: swap.quote.tokenOut, abi: erc20Abi, functionName: 'balanceOf', args: [fides.account] }) as Promise<bigint>;
-      const before = await outBalance();
-      const bundles = await send(plan, actions, fides);
-      const received = swap ? (await outBalance()) - before : 0n;
-      const [spend] = await Policy.remainingSpend(client, fides);
-      const t = await token(fides.spendLimits[0].asset);
-      const executed = bundles.filter((b) => b.status === 'EXECUTED').length;
-      return ok({
-        result: executed === bundles.length ? 'executed' : executed ? 'partly executed' : 'not executed',
-        transactions: bundles.map((b) => ({ status: b.status.toLowerCase(), transaction: txLink(b.txHash), ...(b.error ? { reason: failure(b.error) } : {}) })),
-        blocked_and_not_sent: plan.rejected().map((a) => `${a.label}: ${REASONS[a.reason ?? ''] ?? a.reason}`),
-        ...(swap && executed === bundles.length ? { best_execution: {
-          quoted: `${formatUnits(swap.quote.quotedOut, swap.outDecimals)} ${swap.outSymbol}`,
-          received: `${formatUnits(received, swap.outDecimals)} ${swap.outSymbol}`,
-          versus_quote: received >= swap.quote.quotedOut ? 'at or better than the quote' : `${(Number(((swap.quote.quotedOut - received) * 10000n) / swap.quote.quotedOut) / 100).toFixed(2)}% below the quote, inside the ${swap.quote.slippageBps / 100}% allowed`,
-          route: describeRoute(swap.quote),
-        } } : {}),
-        ...(net && executed === bundles.length ? { netting_record: { contract: netRoots[cfg.chainId], operator: fides.account, epoch: net.epoch.toString(), obligations_root: net.obligationsRoot, settlement_root: net.settlementRoot, contract_link: explorer ? `${explorer}/address/${netRoots[cfg.chainId]}` : undefined } } : {}),
-        budget_remaining: `${formatUnits(spend.remaining, t.decimals)} of ${formatUnits(spend.limit, t.decimals)} ${t.symbol}`,
-      });
-    } catch (err: any) { return fail('Execution stopped: ' + failure(err?.shortMessage ?? err?.message ?? err)); }
-  });
-
-  server.registerTool('fides_receipts', {
-    title: 'Executed transactions',
-    description: 'Every bundle executed onchain under the loaded FIDES, with transaction links, and the budget spent.',
-    inputSchema: {},
-  }, async () => {
-    try {
-      const fides = await currentFides();
-      if (!fides) return fail(notLoaded());
-      const [list, [spend], t] = await Promise.all([Receipts.get(client, fides), Policy.remainingSpend(client, fides), token(fides.spendLimits[0].asset)]);
-      return ok({
-        executed: list.map((r) => ({ transaction: txLink(r.txHash), calls_succeeded: r.succeeded, calls_failed: r.failed, block: r.blockNumber.toString() })),
-        spent: `${formatUnits(spend.spent, t.decimals)} of ${formatUnits(spend.limit, t.decimals)} ${t.symbol}`,
-      });
-    } catch (err: any) { return fail('Could not read receipts: ' + (err?.shortMessage ?? err?.message ?? err)); }
-  });
-
-  return Object.assign(server, { agent: agent.address });
-}
-
-function setup(cfg: Config) {
-  const { account, file, created } = agentKey(cfg);
-  const win = process.platform === 'win32';
-  const desktop = JSON.stringify({ mcpServers: { fides: win ? { command: 'cmd', args: ['/c', 'npx', '-y', '@fidesbuild/mcp-server@latest'] } : { command: 'npx', args: ['-y', '@fidesbuild/mcp-server@latest'] } } }, null, 2);
-  console.log(`FIDES for Claude
-
-Agent address: ${account.address}
-${file ? `${created ? 'New key saved' : 'Key'} in ${file}. Keep that file private. It holds no funds and can only act inside the FIDES you sign for it.` : 'Key from FIDES_AGENT_KEY.'}
-
-Next:
-1. Open this link. It opens the FIDES app with this agent filled in:
-   ${cfg.app}/#/create?agent=${account.address}&via=claude
-2. Set the budget, contracts and expiry, then sign. Create your FIDES Account and fund it.
-3. Add FIDES to Claude, if you have not yet.
-   Claude Code, in a terminal:
-     claude mcp add fides -- ${win ? 'cmd /c ' : ''}npx -y @fidesbuild/mcp-server@latest
-   Claude Desktop: Settings, Developer, Edit Config, and add:
-${desktop.split('\n').map((l) => '     ' + l).join('\n')}
-   Then restart Claude Desktop.
-4. Ask Claude for what you want. It picks up the signed FIDES by itself.
-`);
-}
-
-// Run directly, or through the npm bin link (which may be a symlink to this file).
-const entry = (() => { try { return pathToFileURL(fs.realpathSync(process.argv[1] ?? '')).href; } catch { return ''; } })();
-if (import.meta.url === entry) {
-  const cfg = configFromEnv();
-  if (process.argv[2] === 'setup') setup(cfg);
-  else if (process.argv[2] === '--help' || process.argv[2] === '-h') console.log('npx -y @fidesbuild/mcp-server setup   make the agent key and print the next steps\nnpx -y @fidesbuild/mcp-server         run the MCP server over stdio\n\nEnvironment: FIDES_HOME, FIDES_FILE, FIDES_RPC, FIDES_CHAIN_ID, FIDES_API, FIDES_APP, FIDES_RELAY=self, FIDES_LOOKUP=off, FIDES_AGENT_KEY, FIDES_ADDRESSES');
-  else {
-    const server = createFidesMcpServer(cfg);
-    await server.connect(new StdioServerTransport());
-    console.error(`fides-mcp running. Agent address ${server.agent}.`);
-  }
-}