cornerstone-autonomous-agent 1.0.1

package/src/lib/wallet.js

@@ -0,0 +1,255 @@
+/**
+ * Wallet state management
+ * Handles wallet generation, loading, saving, and client creation.
+ * Supports EVM_PRIVATE_KEY env (single wallet) or multi-wallet file with optional network (testnet/mainnet).
+ */
+
+import { existsSync, readFileSync, writeFileSync, chmodSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { createWalletClient, http } from 'viem';
+import { privateKeyToAccount, generatePrivateKey } from 'viem/accounts';
+import { getChain } from './chains.js';
+
+const LEGACY_PATH = join(homedir(), '.evm-wallet.json');
+
+function getWalletPath() {
+  const envPath = process.env.EVM_WALLET_PATH;
+  if (envPath) {
+    return envPath.startsWith('~') ? join(homedir(), envPath.slice(1)) : envPath;
+  }
+  return join(homedir(), '.evm-wallet.json');
+}
+
+function getWalletsPath() {
+  const base = process.env.EVM_WALLET_PATH
+    ? (process.env.EVM_WALLET_PATH.startsWith('~')
+        ? join(homedir(), process.env.EVM_WALLET_PATH.slice(1))
+        : process.env.EVM_WALLET_PATH)
+    : join(homedir(), '.evm-wallets.json');
+  return base.endsWith('.json') && base.includes('evm-wallet')
+    ? base.replace('.evm-wallet.json', '.evm-wallets.json').replace('.evm-wallet', '.evm-wallets')
+    : join(homedir(), '.evm-wallets.json');
+}
+
+/**
+ * Generate a new wallet
+ * @returns {Object} Wallet object with address and private key
+ */
+export function generate() {
+  const privateKey = generatePrivateKey();
+  const account = privateKeyToAccount(privateKey);
+  return {
+    address: account.address,
+    privateKey,
+    createdAt: new Date().toISOString(),
+  };
+}
+
+/**
+ * Load default wallet from EVM_PRIVATE_KEY env or state file(s)
+ * @returns {Object|null} Wallet object or null if no wallet exists
+ */
+export function load() {
+  try {
+    const pk = (process.env.EVM_PRIVATE_KEY || '').trim();
+    if (pk) {
+      const normalizedPk = pk.startsWith('0x') ? pk : `0x${pk}`;
+      const account = privateKeyToAccount(normalizedPk);
+      return {
+        address: account.address,
+        privateKey: normalizedPk,
+        createdAt: new Date().toISOString(),
+      };
+    }
+    const multi = loadAll();
+    if (!multi.wallets.length) return null;
+    const idx = Math.min(multi.defaultIndex ?? 0, multi.wallets.length - 1);
+    return multi.wallets[idx];
+  } catch (error) {
+    throw new Error(`Failed to load wallet: ${error.message}`);
+  }
+}
+
+/**
+ * @returns {{ wallets: Array<{ address: string, privateKey: string, network?: string, createdAt?: string }>, defaultIndex: number }}
+ */
+export function loadAll() {
+  try {
+    const pk = (process.env.EVM_PRIVATE_KEY || '').trim();
+    if (pk) {
+      const normalizedPk = pk.startsWith('0x') ? pk : `0x${pk}`;
+      const account = privateKeyToAccount(normalizedPk);
+      return {
+        wallets: [{ address: account.address, privateKey: normalizedPk, createdAt: new Date().toISOString() }],
+        defaultIndex: 0,
+      };
+    }
+    const walletsPath = getWalletsPath();
+    if (existsSync(walletsPath)) {
+      const data = readFileSync(walletsPath, 'utf8');
+      const parsed = JSON.parse(data);
+      const wallets = Array.isArray(parsed.wallets) ? parsed.wallets : [];
+      const defaultIndex = typeof parsed.defaultIndex === 'number' ? parsed.defaultIndex : 0;
+      return { wallets, defaultIndex };
+    }
+    const legacyPath = getWalletPath();
+    if (existsSync(legacyPath)) {
+      const data = readFileSync(legacyPath, 'utf8');
+      const wallet = JSON.parse(data);
+      if (wallet.privateKey && wallet.address) {
+        const migrated = {
+          wallets: [{ ...wallet, createdAt: wallet.createdAt || new Date().toISOString() }],
+          defaultIndex: 0,
+        };
+        saveAll(migrated);
+        return migrated;
+      }
+    }
+    return { wallets: [], defaultIndex: 0 };
+  } catch (e) {
+    throw new Error(`Failed to load EVM wallets: ${e.message}`);
+  }
+}
+
+/**
+ * @param {{ wallets: Array, defaultIndex: number }} data
+ */
+export function saveAll(data) {
+  try {
+    if ((process.env.EVM_PRIVATE_KEY || '').trim()) return;
+    const out = {
+      wallets: (data.wallets || []).map((w) => ({
+        ...w,
+        createdAt: w.createdAt || new Date().toISOString(),
+      })),
+      defaultIndex: data.defaultIndex ?? 0,
+    };
+    const path = getWalletsPath();
+    writeFileSync(path, JSON.stringify(out, null, 2), 'utf8');
+    chmodSync(path, 0o600);
+  } catch (e) {
+    throw new Error(`Failed to save EVM wallets: ${e.message}`);
+  }
+}
+
+/**
+ * Save wallet: add or update. When EVM_PRIVATE_KEY is set, no-op.
+ * @param {Object} wallet - Wallet object to save
+ * @param {{ setDefault?: boolean }} options
+ */
+export function save(wallet, options = {}) {
+  if ((process.env.EVM_PRIVATE_KEY || '').trim()) return;
+  const data = loadAll();
+  const normalized = { ...wallet, createdAt: wallet.createdAt || new Date().toISOString() };
+  const idx = data.wallets.findIndex(
+    (w) => (w.address || '').toLowerCase() === (wallet.address || '').toLowerCase()
+  );
+  if (idx >= 0) {
+    data.wallets[idx] = normalized;
+  } else {
+    data.wallets.push(normalized);
+  }
+  if (options.setDefault !== false && (data.wallets.length === 1 || options.setDefault === true)) {
+    const i = data.wallets.findIndex((w) => w.address === wallet.address);
+    data.defaultIndex = i >= 0 ? i : data.wallets.length - 1;
+  }
+  saveAll(data);
+}
+
+/**
+ * Get viem account from stored wallet (default or by index/address)
+ * @param {number|string} [indexOrAddress]
+ */
+export function getAccount(indexOrAddress) {
+  const wallet = indexOrAddress !== undefined ? getWalletAt(indexOrAddress) : load();
+  if (!wallet) {
+    throw new Error('No wallet found. Run setup.js or create_evm_wallet first.');
+  }
+  return privateKeyToAccount(wallet.privateKey);
+}
+
+/**
+ * Get wallet address (default)
+ * @returns {string} Wallet address
+ */
+export function getAddress() {
+  const wallet = load();
+  if (!wallet) {
+    throw new Error('No wallet found. Run setup.js or create_evm_wallet first.');
+  }
+  return wallet.address;
+}
+
+/**
+ * Get wallet by index or by address. Returns default if no arg.
+ * @param {number|string} [indexOrAddress]
+ * @returns {Object|null}
+ */
+export function getWalletAt(indexOrAddress) {
+  const data = loadAll();
+  if (data.wallets.length === 0) return null;
+  if (typeof indexOrAddress === 'number') {
+    return data.wallets[indexOrAddress] ?? null;
+  }
+  if (typeof indexOrAddress === 'string' && indexOrAddress.trim()) {
+    const addr = indexOrAddress.trim().toLowerCase();
+    return data.wallets.find((w) => (w.address || '').toLowerCase() === addr) ?? null;
+  }
+  const idx = Math.min(data.defaultIndex ?? 0, data.wallets.length - 1);
+  return data.wallets[idx] ?? null;
+}
+
+/**
+ * Create viem wallet client for a specific chain (uses default wallet)
+ * @param {string} chainName - Chain name
+ * @returns {Object} Viem wallet client
+ */
+export function getWalletClient(chainName) {
+  const chain = getChain(chainName);
+  const account = getAccount();
+  const viemChain = {
+    id: chain.chainId,
+    name: chain.name,
+    nativeCurrency: {
+      name: chain.nativeToken.symbol,
+      symbol: chain.nativeToken.symbol,
+      decimals: chain.nativeToken.decimals,
+    },
+    rpcUrls: { default: { http: chain.rpcs }, public: { http: chain.rpcs } },
+    blockExplorers: { default: { name: chain.explorer.name, url: chain.explorer.url } },
+  };
+  return createWalletClient({
+    account,
+    chain: viemChain,
+    transport: http(chain.rpcs[0], { retryCount: 3, timeout: 30_000 }),
+  });
+}
+
+/**
+ * Check if wallet exists (EVM_PRIVATE_KEY or wallet file(s))
+ * @returns {boolean}
+ */
+export function exists() {
+  if ((process.env.EVM_PRIVATE_KEY || '').trim()) return true;
+  return existsSync(getWalletsPath()) || existsSync(getWalletPath());
+}
+
+/**
+ * Get default wallet info (safe - no private key)
+ * @returns {Object|null}
+ */
+export function getWalletInfo() {
+  const wallet = load();
+  if (!wallet) return null;
+  return { address: wallet.address, network: wallet.network || null, createdAt: wallet.createdAt };
+}
+
+/**
+ * Get all wallet infos (no private keys)
+ * @returns {Array<{ address: string, network?: string }>}
+ */
+export function getAllWalletInfos() {
+  const data = loadAll();
+  return data.wallets.map((w) => ({ address: w.address, network: w.network || null }));
+}

package/src/lib/x402/client.js

@@ -0,0 +1,195 @@
+/**
+ * x402 client: fetch with retry on 402 Payment Required.
+ * On 402: parse requirements → build payment (Aptos/EVM) → verify → settle → retry with PAYMENT-SIGNATURE.
+ */
+
+import { getFirstPaymentRequirements, isAptosNetwork, isEvmNetwork } from './types.js';
+
+const DEFAULT_MAX_RETRIES = 2;
+const PAYMENT_SIGNATURE_HEADER = 'PAYMENT-SIGNATURE';
+
+/**
+ * Normalize facilitator base URL for /verify and /settle.
+ * @param {string} url - Base URL (may end with /facilitator or /)
+ * @returns {{ verifyUrl: string, settleUrl: string }}
+ */
+function normalizeFacilitatorUrl(url) {
+  const base = url.replace(/\/+$/, '');
+  const hasFacilitator = base.endsWith('/facilitator');
+  const prefix = hasFacilitator ? base : base;
+  return {
+    verifyUrl: `${prefix}/verify`,
+    settleUrl: `${prefix}/settle`,
+  };
+}
+
+/** Timeout for verify (ms); slightly above server/facilitator 30s */
+const VERIFY_TIMEOUT_MS = 35_000;
+/** Timeout for settle (ms); slightly above server/facilitator 60s */
+const SETTLE_TIMEOUT_MS = 65_000;
+
+/**
+ * Verify payment with facilitator.
+ * @param {string} facilitatorUrl - Facilitator base URL
+ * @param {Object} paymentPayload - Payment payload from wallet
+ * @param {import('./types.js').PaymentRequirements} paymentRequirements - Payment requirements
+ * @returns {Promise<Object>} Verification result
+ */
+export async function verifyPayment(facilitatorUrl, paymentPayload, paymentRequirements) {
+  const { verifyUrl } = normalizeFacilitatorUrl(facilitatorUrl);
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), VERIFY_TIMEOUT_MS);
+  try {
+    const res = await fetch(verifyUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        x402Version: 2,
+        paymentPayload: {
+          x402Version: 2,
+          ...paymentPayload,
+          network: paymentRequirements.network,
+          scheme: paymentRequirements.scheme
+        },
+        paymentRequirements,
+      }),
+      signal: controller.signal,
+    });
+    const body = await res.json().catch(() => ({ isValid: false, invalidReason: 'invalid_response' }));
+    if (body && body.isValid === false && body.invalidReason) {
+      const extra = [body.message, body.detail, body.error].filter(Boolean).join(' ');
+      if (extra) {
+        body.invalidReason = body.invalidReason + ` (${extra})`;
+        console.warn('Facilitator verify failed:', body.invalidReason, body);
+      }
+    }
+    return body;
+  } catch (e) {
+    if (e.name === 'AbortError') {
+      return { isValid: false, invalidReason: 'facilitator_timeout: Request timed out' };
+    }
+    throw e;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+/**
+ * Settle payment with facilitator.
+ * @param {string} facilitatorUrl - Facilitator base URL
+ * @param {Object} paymentPayload - Payment payload from wallet
+ * @param {import('./types.js').PaymentRequirements} paymentRequirements - Payment requirements
+ * @param {Object} [verification] - Verification result (optional)
+ * @returns {Promise<Object>} Settlement result
+ */
+export async function settlePayment(facilitatorUrl, paymentPayload, paymentRequirements, verification = {}) {
+  const { settleUrl } = normalizeFacilitatorUrl(facilitatorUrl);
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), SETTLE_TIMEOUT_MS);
+  try {
+    const res = await fetch(settleUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        x402Version: 2,
+        paymentPayload: {
+          x402Version: 2,
+          ...paymentPayload,
+          network: paymentRequirements.network,
+          scheme: paymentRequirements.scheme
+        },
+        paymentRequirements,
+        verification,
+      }),
+      signal: controller.signal,
+    });
+    return await res.json().catch(() => ({ success: false, errorReason: 'invalid_response' }));
+  } catch (e) {
+    if (e.name === 'AbortError') {
+      return { success: false, errorReason: 'settlement_timeout: Request timed out' };
+    }
+    throw e;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+/**
+ * Fetch with x402 retry: on 402, pay via facilitator then retry with PAYMENT-SIGNATURE.
+ * @param {string} url - Request URL
+ * @param {RequestInit} [options] - Fetch options (method, headers, body, etc.)
+ * @param {Object} context - x402 context
+ * @param {string} context.facilitatorUrl - Facilitator base URL (e.g. https://x402-navy.vercel.app/facilitator)
+ * @param {(req: import('./types.js').PaymentRequirements) => Promise<Object>} [context.getAptosPaymentPayload]
+ * @param {(req: import('./types.js').PaymentRequirements) => Promise<Object>} [context.getEvmPaymentPayload]
+ * @param {number} [context.maxRetries]
+ * @returns {Promise<Object>} Parsed JSON response body (after retry if 402)
+ */
+export async function fetchWithX402Retry(url, options = {}, context = {}) {
+  const maxRetries = context.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const { verifyUrl, settleUrl } = normalizeFacilitatorUrl(context.facilitatorUrl || '');
+
+  const doRequest = async (extraHeaders = {}) => {
+    const headers = { ...(options.headers || {}), ...extraHeaders };
+    const res = await fetch(url, { ...options, headers });
+    const contentType = res.headers.get('content-type') || '';
+    const isJson = contentType.includes('application/json');
+    const body = isJson ? await res.json().catch(() => ({})) : await res.text().catch(() => '');
+
+    if (res.status !== 402) {
+      if (typeof body === 'object') return body;
+      return { raw: body, status: res.status };
+    }
+
+    const requirements = getFirstPaymentRequirements(body);
+    if (!requirements) {
+      const reason = body?.invalidReason || 'missing_payment_requirements';
+      throw new Error(`402: ${reason}`);
+    }
+
+    const network = requirements.network || '';
+    let paymentPayload;
+    if (isAptosNetwork(network) && context.getAptosPaymentPayload) {
+      paymentPayload = await context.getAptosPaymentPayload(requirements);
+    } else if (isEvmNetwork(network) && context.getEvmPaymentPayload) {
+      paymentPayload = await context.getEvmPaymentPayload(requirements);
+    } else {
+      throw new Error(`402: unsupported network ${network}`);
+    }
+
+    const verifyRes = await fetch(verifyUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        paymentPayload: { ...paymentPayload, network, scheme: requirements.scheme },
+        paymentRequirements: requirements,
+      }),
+    });
+    const verifyResult = await verifyRes.json().catch(() => ({}));
+    if (!verifyResult?.isValid) {
+      throw new Error(`402 verify failed: ${verifyResult?.invalidReason || 'invalid'}`);
+    }
+
+    const settleRes = await fetch(settleUrl, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        paymentPayload: { ...paymentPayload, network, scheme: requirements.scheme },
+        paymentRequirements: requirements,
+        verification: verifyResult,
+      }),
+    });
+    const settleResult = await settleRes.json().catch(() => ({}));
+    if (!settleResult?.success) {
+      throw new Error(`402 settle failed: ${settleResult?.errorReason || 'unknown'}`);
+    }
+
+    const signatureValue = typeof paymentPayload === 'string'
+      ? paymentPayload
+      : (Buffer.isBuffer(paymentPayload) ? paymentPayload.toString('base64') : JSON.stringify(paymentPayload));
+    const retryHeaders = { [PAYMENT_SIGNATURE_HEADER]: signatureValue };
+    return doRequest(retryHeaders);
+  };
+
+  return doRequest();
+}

package/src/lib/x402/index.js

@@ -0,0 +1,7 @@
+export { fetchWithX402Retry, verifyPayment, settlePayment } from './client.js';
+export {
+  NETWORKS,
+  isAptosNetwork,
+  isEvmNetwork,
+  getFirstPaymentRequirements,
+} from './types.js';

package/src/lib/x402/types.js

@@ -0,0 +1,50 @@
+/**
+ * x402 payment requirement and 402 response types.
+ * Used for parsing 402 Payment Required and building payment payloads.
+ */
+
+/** @typedef {Object} PaymentRequirements
+ * @property {string} scheme - e.g. "exact"
+ * @property {string} network - e.g. "aptos:2", "eip155:84532"
+ * @property {string|number} amount - atomic units
+ * @property {string} asset - asset type or contract address
+ * @property {string} payTo - recipient address
+ * @property {string} [resource] - resource path
+ * @property {string} [description] - human-readable description
+ */
+
+/** @typedef {Object} Payment402Body
+ * @property {PaymentRequirements|PaymentRequirements[]} paymentRequirements
+ * @property {string} [invalidReason] - e.g. "insufficient_funds"
+ * @property {string} [onramp_url]
+ */
+
+/** Network constants: which tool uses which.
+ * - aptos:2, aptos:1: prediction, backtest (Aptos testnet/mainnet)
+ * - eip155:8453, eip155:84532: open_bank_account (Base, Base Sepolia)
+ */
+export const NETWORKS = {
+  APTOS_TESTNET: 'aptos:2',
+  APTOS_MAINNET: 'aptos:1',
+  BASE: 'eip155:8453',
+  BASE_SEPOLIA: 'eip155:84532',
+};
+
+export function isAptosNetwork(network) {
+  return typeof network === 'string' && network.startsWith('aptos:');
+}
+
+export function isEvmNetwork(network) {
+  return typeof network === 'string' && network.startsWith('eip155:');
+}
+
+/**
+ * Normalize 402 body to a single PaymentRequirements object.
+ * @param {Payment402Body} body - Parsed 402 response body
+ * @returns {PaymentRequirements|null}
+ */
+export function getFirstPaymentRequirements(body) {
+  if (!body || !body.paymentRequirements) return null;
+  const pr = body.paymentRequirements;
+  return Array.isArray(pr) ? pr[0] ?? null : pr;
+}

package/src/register-aptos-agent.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+/**
+ * Register an Aptos agent address on-chain so it can receive tokens.
+ * On Aptos, an account must exist before it can receive; the first transfer
+ * (or a zero/minimal transfer) creates it. Use this when tokens are "sent"
+ * (e.g. from the testnet faucet) but don't arrive at the agent address.
+ *
+ * Requires a sender with APT on the same network (testnet by default).
+ * Set REGISTER_SENDER_PRIVATE_KEY in env (hex, with or without 0x).
+ * Or omit to use the agent's own wallet (it must already have some APT).
+ *
+ * Usage: node src/register-aptos-agent.js [agent_address]
+ *   agent_address: Aptos address to register (default: default agent wallet)
+ * Env: REGISTER_SENDER_PRIVATE_KEY (optional), APTOS_NETWORK=testnet|mainnet|devnet
+ */
+
+import { getAptosConfig } from './lib/aptos/config.js';
+import { getWalletInfo, load } from './lib/aptos/wallet.js';
+
+const MIN_OCTAS = 1; // minimal amount so account is created and receives something
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const address = args[0]?.trim();
+  return { address };
+}
+
+async function main() {
+  const { address: argAddress } = parseArgs();
+  const network = (process.env.APTOS_NETWORK || 'testnet').toLowerCase();
+  const cfg = getAptosConfig(network);
+
+  let recipientAddress = argAddress;
+  if (!recipientAddress) {
+    const info = getWalletInfo();
+    if (!info?.address) {
+      console.error('No agent address provided and no Aptos wallet found. Run: node src/setup-aptos.js');
+      process.exit(1);
+    }
+    recipientAddress = info.address;
+    console.log('Using default agent address from wallet:', recipientAddress);
+  }
+
+  const senderKey = (process.env.REGISTER_SENDER_PRIVATE_KEY || '').trim();
+  let senderWallet = null;
+  if (senderKey && senderKey.length >= 64) {
+    const { Account, Ed25519PrivateKey } = await import('@aptos-labs/ts-sdk');
+    const pk = new Ed25519PrivateKey(senderKey.startsWith('0x') ? senderKey : '0x' + senderKey);
+    const account = Account.fromPrivateKey({ privateKey: pk, legacy: false });
+    senderWallet = { address: account.accountAddress.toString(), privateKey: senderKey.startsWith('0x') ? senderKey : '0x' + senderKey };
+  } else {
+    const w = load();
+    if (!w?.privateKey) {
+      console.error('Set REGISTER_SENDER_PRIVATE_KEY (hex key with APT on ' + network + ') or ensure agent wallet has APT.');
+      process.exit(1);
+    }
+    senderWallet = w;
+  }
+
+  const { Aptos, AptosConfig, Network, Ed25519PrivateKey } = await import('@aptos-labs/ts-sdk');
+  const net = network === 'mainnet' ? Network.MAINNET : network === 'devnet' ? Network.DEVNET : Network.TESTNET;
+  const aptosConfig = new AptosConfig({ fullnode: cfg.nodeUrl, network: net });
+  const aptos = new Aptos(aptosConfig);
+  const privateKey = new Ed25519PrivateKey(senderWallet.privateKey);
+  const account = Account.fromPrivateKey({ privateKey, legacy: false });
+
+  console.log('Registering agent address on', network + ':', recipientAddress);
+  console.log('Sender:', senderWallet.address);
+  try {
+    const builder = await aptos.transaction.build.simple({
+      sender: account.accountAddress,
+      withFeePayer: false,
+      data: {
+        function: '0x1::aptos_account::transfer',
+        functionArguments: [recipientAddress, BigInt(MIN_OCTAS)],
+      },
+    });
+    const signed = await aptos.transaction.sign({ signer: account, transaction: builder });
+    const pending = await aptos.transaction.submit.simple({ transaction: signed });
+    await aptos.waitForTransaction({ transactionHash: pending.hash });
+    console.log('Done. Agent account is registered. Tx:', pending.hash);
+    console.log('You can now fund this address via the faucet or other transfers.');
+  } catch (e) {
+    console.error('Registration failed:', e.message);
+    process.exit(1);
+  }
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});

package/src/run-agent.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+/**
+ * Entrypoint for the autonomous agent (x402 MCP + LangChain.js).
+ * Usage: node src/run-agent.js [message]
+ * If no message, runs demo prompt.
+ */
+
+import 'dotenv/config';
+import { createMcpClient } from './lib/mcp/index.js';
+import { buildAptosPaymentPayload } from './lib/aptos/index.js';
+import { getEvmPaymentPayload } from './lib/evm/index.js';
+import { createAgent } from './agent/index.js';
+
+const DEMO_PROMPT =
+  'Check my Aptos balance, then run a prediction for AAPL for 30 days and summarize the result.';
+
+async function main() {
+  const message = process.argv.slice(2).join(' ').trim() || DEMO_PROMPT;
+
+  const mcpServerUrl = process.env.MCP_SERVER_URL || 'http://localhost:4023';
+  const defaultFacilitator = 'https://x402-navy.vercel.app/facilitator';
+  let facilitatorUrl = process.env.X402_FACILITATOR_URL || defaultFacilitator;
+  if (facilitatorUrl.includes('facilitator.x402.org')) {
+    facilitatorUrl = defaultFacilitator;
+  }
+  const evmFacilitatorUrl = process.env.X402_EVM_FACILITATOR_URL || facilitatorUrl;
+
+  let getAptosPaymentPayloadFn = null;
+  let getEvmPaymentPayloadFn = null;
+  try {
+    getAptosPaymentPayloadFn = (req) => buildAptosPaymentPayload(req);
+  } catch (e) {
+    console.warn('Aptos payment not available:', e.message);
+  }
+  try {
+    getEvmPaymentPayloadFn = (req) => getEvmPaymentPayload(req);
+  } catch (e) {
+    console.warn('EVM payment not available:', e.message);
+  }
+
+  const mcpClient = createMcpClient({
+    baseUrl: mcpServerUrl,
+    facilitatorUrl,
+    evmFacilitatorUrl,
+    getAptosPaymentPayload: getAptosPaymentPayloadFn,
+    getEvmPaymentPayload: getEvmPaymentPayloadFn,
+  });
+
+  const { runAgent } = await createAgent({ mcpClient });
+
+  console.log('Running agent with message:', message);
+  const result = await runAgent(message);
+  const messages = result?.messages ?? [];
+  const last = messages[messages.length - 1];
+  if (last?.content) {
+    console.log('Agent response:', typeof last.content === 'string' ? last.content : JSON.stringify(last.content));
+  } else {
+    console.log('Result:', JSON.stringify(result, null, 2));
+  }
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});