x402-proxy 0.9.4 → 0.10.1

package/dist/openclaw/plugin.js

@@ -1,12 +1,11 @@
 import os, { homedir } from "node:os";
 import path, { dirname, join } from "node:path";
-import { SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR, address, appendTransactionMessageInstructions, createDefaultRpcTransport, createKeyPairSignerFromBytes, createSolanaRpc, createSolanaRpcFromTransport, createTransactionMessage, getAddressEncoder, getBase64EncodedWireTransaction, getProgramDerivedAddress, isSolanaError, mainnet, partiallySignTransactionMessageWithSigners, pipe, prependTransactionMessageInstruction, setTransactionMessageFeePayer, setTransactionMessageLifetimeUsingBlockhash } from "@solana/kit";
+import { SOLANA_ERROR__RPC__TRANSPORT_HTTP_ERROR, address, appendTransactionMessageInstructions, createDefaultRpcTransport, createKeyPairSignerFromBytes, createSolanaRpc, createSolanaRpcFromTransport, createTransactionMessage, getAddressEncoder, getBase64EncodedWireTransaction, getProgramDerivedAddress, isSolanaError, mainnet, partiallySignTransactionMessageWithSigners, pipe, setTransactionMessageComputeUnitLimit, setTransactionMessageComputeUnitPrice, setTransactionMessageFeePayer, setTransactionMessageLifetimeUsingBlockhash } from "@solana/kit";
 import { decodePaymentResponseHeader, wrapFetchWithPayment, x402Client } from "@x402/fetch";
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
 import fs, { appendFileSync, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import "yaml";
-import { getSetComputeUnitLimitInstruction, setTransactionMessageComputeUnitPrice } from "@solana-program/compute-budget";
-import { TOKEN_PROGRAM_ADDRESS } from "@solana-program/token";
-import { TOKEN_2022_PROGRAM_ADDRESS, fetchMint, findAssociatedTokenPda, getTransferCheckedInstruction } from "@solana-program/token-2022";
+import { TOKEN_PROGRAM_ADDRESS, findAssociatedTokenPda, getTransferCheckedInstruction } from "@solana-program/token";
 import { ed25519 } from "@noble/curves/ed25519.js";
 import { base58 } from "@scure/base";
 import "@x402/evm";
@@ -22,6 +21,8 @@ import { HDKey } from "@scure/bip32";
 import { mnemonicToSeedSync } from "@scure/bip39";
 import "@scure/bip39/wordlists/english.js";
 import { Type } from "@sinclair/typebox";
+import { buildCommand } from "@stricli/core";
+import pc from "picocolors";
 //#region src/handler.ts
 /**
 * Extract the on-chain transaction signature from an x402 payment response header.
@@ -59,6 +60,94 @@ function createX402ProxyHandler(opts) {
 		shiftPayment: () => paymentQueue.shift()
 	};
 }
+const TEMPO_NETWORK = "eip155:4217";
+/**
+* Create an MPP proxy handler using mppx client.
+* Dynamically imports mppx/client to keep startup fast.
+*/
+async function createMppProxyHandler(opts) {
+	const { Mppx, tempo } = await import("mppx/client");
+	const { privateKeyToAccount } = await import("viem/accounts");
+	const account = privateKeyToAccount(opts.evmKey);
+	const maxDeposit = opts.maxDeposit ?? "1";
+	const paymentQueue = [];
+	let lastChallengeAmount;
+	const mppx = Mppx.create({
+		methods: [tempo({
+			account,
+			maxDeposit
+		})],
+		polyfill: false,
+		onChallenge: async (challenge) => {
+			const req = challenge.request;
+			if (req.amount) lastChallengeAmount = (Number(req.amount) / 10 ** (req.decimals ?? 6)).toString();
+		}
+	});
+	let session;
+	return {
+		async fetch(input, init) {
+			const response = await mppx.fetch(typeof input === "string" ? input : input.toString(), init);
+			const receiptHeader = response.headers.get("Payment-Receipt");
+			if (receiptHeader) {
+				try {
+					const receipt = JSON.parse(Buffer.from(receiptHeader, "base64url").toString());
+					paymentQueue.push({
+						protocol: "mpp",
+						network: TEMPO_NETWORK,
+						amount: lastChallengeAmount,
+						receipt
+					});
+				} catch {
+					paymentQueue.push({
+						protocol: "mpp",
+						network: TEMPO_NETWORK,
+						amount: lastChallengeAmount
+					});
+				}
+				lastChallengeAmount = void 0;
+			}
+			return response;
+		},
+		async sse(input, init) {
+			session ??= tempo.session({
+				account,
+				maxDeposit
+			});
+			const url = typeof input === "string" ? input : input.toString();
+			const iterable = await session.sse(url, init);
+			paymentQueue.push({
+				protocol: "mpp",
+				network: TEMPO_NETWORK,
+				intent: "session"
+			});
+			return iterable;
+		},
+		shiftPayment: () => paymentQueue.shift(),
+		async close() {
+			if (session?.opened) {
+				const receipt = await session.close();
+				if (receipt) {
+					const spentUsdc = receipt.spent ? (Number(receipt.spent) / 1e6).toString() : void 0;
+					paymentQueue.push({
+						protocol: "mpp",
+						network: TEMPO_NETWORK,
+						intent: "session",
+						amount: spentUsdc,
+						channelId: session.channelId ?? void 0,
+						receipt: {
+							method: receipt.method,
+							reference: receipt.reference,
+							status: receipt.status,
+							timestamp: receipt.timestamp,
+							acceptedCumulative: receipt.acceptedCumulative,
+							txHash: receipt.txHash
+						}
+					});
+				}
+			}
+		}
+	};
+}
 //#endregion
 //#region src/lib/config.ts
 const APP_NAME = "x402-proxy";
@@ -87,7 +176,7 @@ function loadWalletFile() {
 //#region src/lib/optimized-svm-scheme.ts
 const MEMO_PROGRAM_ADDRESS = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
 const COMPUTE_UNIT_LIMIT = 2e4;
-const COMPUTE_UNIT_PRICE_MICROLAMPORTS = 1;
+const COMPUTE_UNIT_PRICE_MICROLAMPORTS = 1n;
 const USDC_MINT$1 = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
 const USDC_DECIMALS$1 = 6;
 const MAINNET_RPC_URLS = ["https://api.mainnet.solana.com", "https://public.rpc.solanavibestation.com"];
@@ -133,35 +222,24 @@ var OptimizedSvmScheme = class {
 	async createPaymentPayload(x402Version, paymentRequirements) {
 		const rpc = this.rpc;
 		const asset = paymentRequirements.asset;
-		let tokenProgramAddress;
-		let decimals;
-		if (asset === USDC_MINT$1) {
-			tokenProgramAddress = TOKEN_PROGRAM_ADDRESS;
-			decimals = USDC_DECIMALS$1;
-		} else {
-			const tokenMint = await fetchMint(rpc, asset);
-			tokenProgramAddress = tokenMint.programAddress;
-			if (tokenProgramAddress !== TOKEN_PROGRAM_ADDRESS && tokenProgramAddress !== TOKEN_2022_PROGRAM_ADDRESS) throw new Error("Asset was not created by a known token program");
-			decimals = tokenMint.data.decimals;
-		}
-		const [sourceATA] = await findAssociatedTokenPda({
+		if (asset !== USDC_MINT$1) throw new Error(`Unsupported asset: ${asset}. Only USDC is supported.`);
+		const [[sourceATA], [destinationATA]] = await Promise.all([findAssociatedTokenPda({
 			mint: asset,
 			owner: this.signer.address,
-			tokenProgram: tokenProgramAddress
-		});
-		const [destinationATA] = await findAssociatedTokenPda({
+			tokenProgram: TOKEN_PROGRAM_ADDRESS
+		}), findAssociatedTokenPda({
 			mint: asset,
 			owner: paymentRequirements.payTo,
-			tokenProgram: tokenProgramAddress
-		});
+			tokenProgram: TOKEN_PROGRAM_ADDRESS
+		})]);
 		const transferIx = getTransferCheckedInstruction({
 			source: sourceATA,
 			mint: asset,
 			destination: destinationATA,
 			authority: this.signer,
 			amount: BigInt(paymentRequirements.amount),
-			decimals
-		}, { programAddress: tokenProgramAddress });
+			decimals: USDC_DECIMALS$1
+		});
 		const feePayer = paymentRequirements.extra?.feePayer;
 		if (!feePayer) throw new Error("feePayer is required in paymentRequirements.extra for SVM transactions");
 		const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
@@ -173,7 +251,7 @@ var OptimizedSvmScheme = class {
 		};
 		return {
 			x402Version,
-			payload: { transaction: getBase64EncodedWireTransaction(await partiallySignTransactionMessageWithSigners(pipe(createTransactionMessage({ version: 0 }), (tx) => setTransactionMessageComputeUnitPrice(COMPUTE_UNIT_PRICE_MICROLAMPORTS, tx), (tx) => setTransactionMessageFeePayer(feePayer, tx), (tx) => prependTransactionMessageInstruction(getSetComputeUnitLimitInstruction({ units: COMPUTE_UNIT_LIMIT }), tx), (tx) => appendTransactionMessageInstructions([transferIx, memoIx], tx), (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx)))) }
+			payload: { transaction: getBase64EncodedWireTransaction(await partiallySignTransactionMessageWithSigners(pipe(createTransactionMessage({ version: 0 }), (tx) => setTransactionMessageComputeUnitPrice(COMPUTE_UNIT_PRICE_MICROLAMPORTS, tx), (tx) => setTransactionMessageComputeUnitLimit(COMPUTE_UNIT_LIMIT, tx), (tx) => setTransactionMessageFeePayer(feePayer, tx), (tx) => appendTransactionMessageInstructions([transferIx, memoIx], tx), (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx)))) }
 		};
 	}
 };
@@ -441,7 +519,7 @@ async function loadSvmWallet(keypairPath) {
 //#endregion
 //#region src/openclaw/solana.ts
 const USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
-const TOKEN_PROGRAM = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+const TOKEN_PROGRAM$1 = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
 const ASSOCIATED_TOKEN_PROGRAM = address("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
 async function findAta(mint, owner) {
 	const encoder = getAddressEncoder();
@@ -449,7 +527,7 @@ async function findAta(mint, owner) {
 		programAddress: ASSOCIATED_TOKEN_PROGRAM,
 		seeds: [
 			encoder.encode(owner),
-			encoder.encode(TOKEN_PROGRAM),
+			encoder.encode(TOKEN_PROGRAM$1),
 			encoder.encode(mint)
 		]
 	});
@@ -461,7 +539,7 @@ function transferCheckedIx(source, mint, destination, authority, amount, decimal
 	new DataView(data.buffer).setBigUint64(1, amount, true);
 	data[9] = decimals;
 	return {
-		programAddress: TOKEN_PROGRAM,
+		programAddress: TOKEN_PROGRAM$1,
 		accounts: [
 			{
 				address: source,
@@ -484,7 +562,7 @@ function transferCheckedIx(source, mint, destination, authority, amount, decimal
 	};
 }
 async function getTokenAccounts(rpcUrl, owner) {
-	const { value } = await createSolanaRpc(rpcUrl).getTokenAccountsByOwner(address(owner), { programId: TOKEN_PROGRAM }, { encoding: "jsonParsed" }).send();
+	const { value } = await createSolanaRpc(rpcUrl).getTokenAccountsByOwner(address(owner), { programId: TOKEN_PROGRAM$1 }, { encoding: "jsonParsed" }).send();
 	return value.map((v) => {
 		const info = v.account.data.parsed.info;
 		return {
@@ -530,6 +608,158 @@ async function transferUsdc(signer, rpcUrl, dest, amountRaw) {
 	return await rpc.sendTransaction(encoded, { encoding: "base64" }).send();
 }
 //#endregion
+//#region src/lib/output.ts
+function isTTY() {
+	return !!process.stderr.isTTY;
+}
+function info(msg) {
+	process.stderr.write(`${isTTY() ? pc.cyan(msg) : msg}\n`);
+}
+function dim(msg) {
+	process.stderr.write(`${isTTY() ? pc.dim(msg) : msg}\n`);
+}
+//#endregion
+//#region src/commands/wallet.ts
+const BASE_RPC = "https://mainnet.base.org";
+const SOLANA_RPC = "https://api.mainnet-beta.solana.com";
+const TEMPO_RPC = "https://rpc.presto.tempo.xyz";
+const USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+const USDC_TEMPO = "0x20C000000000000000000000b9537d11c60E8b50";
+const USDC_SOLANA_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+const TOKEN_PROGRAM = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+const ATA_PROGRAM = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+async function rpcCall(url, method, params) {
+	const res = await fetch(url, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			jsonrpc: "2.0",
+			method,
+			params,
+			id: 1
+		})
+	});
+	if (!res.ok) throw new Error(`RPC ${method} failed: ${res.status} ${res.statusText}`);
+	return res.json();
+}
+async function fetchEvmBalances(address) {
+	const usdcData = `0x70a08231${address.slice(2).padStart(64, "0")}`;
+	const [ethRes, usdcRes] = await Promise.all([rpcCall(BASE_RPC, "eth_getBalance", [address, "latest"]), rpcCall(BASE_RPC, "eth_call", [{
+		to: USDC_BASE,
+		data: usdcData
+	}, "latest"])]);
+	return {
+		eth: ethRes.result ? (Number(BigInt(ethRes.result)) / 0xde0b6b3a7640000).toFixed(6) : "?",
+		usdc: usdcRes.result ? formatUsdcValue(Number(BigInt(usdcRes.result)) / 1e6) : "?"
+	};
+}
+async function fetchTempoBalances(address) {
+	const res = await rpcCall(TEMPO_RPC, "eth_call", [{
+		to: USDC_TEMPO,
+		data: `0x70a08231${address.slice(2).padStart(64, "0")}`
+	}, "latest"]);
+	return { usdc: res.result ? formatUsdcValue(Number(BigInt(res.result)) / 1e6) : "?" };
+}
+async function getUsdcAta(owner) {
+	const encoder = getAddressEncoder();
+	const [ata] = await getProgramDerivedAddress({
+		programAddress: address(ATA_PROGRAM),
+		seeds: [
+			encoder.encode(address(owner)),
+			encoder.encode(address(TOKEN_PROGRAM)),
+			encoder.encode(address(USDC_SOLANA_MINT))
+		]
+	});
+	return ata;
+}
+async function fetchSolanaBalances(ownerAddress) {
+	const ata = await getUsdcAta(ownerAddress);
+	const [solRes, usdcRes] = await Promise.all([rpcCall(SOLANA_RPC, "getBalance", [ownerAddress]), rpcCall(SOLANA_RPC, "getTokenAccountBalance", [ata])]);
+	const sol = solRes.result?.value != null ? (solRes.result.value / 1e9).toFixed(6) : "?";
+	const usdcVal = usdcRes.result?.value;
+	return {
+		sol,
+		usdc: usdcVal ? formatUsdcValue(Number(usdcVal.uiAmountString)) : "0"
+	};
+}
+function balanceLine(usdc, native, nativeSymbol) {
+	return pc.dim(` (${usdc} USDC, ${native} ${nativeSymbol})`);
+}
+async function fetchAllBalances(evmAddress, solanaAddress) {
+	const [evmResult, solResult, tempoResult] = await Promise.allSettled([
+		evmAddress ? fetchEvmBalances(evmAddress) : Promise.resolve(null),
+		solanaAddress ? fetchSolanaBalances(solanaAddress) : Promise.resolve(null),
+		evmAddress ? fetchTempoBalances(evmAddress) : Promise.resolve(null)
+	]);
+	return {
+		evm: evmResult.status === "fulfilled" ? evmResult.value : null,
+		sol: solResult.status === "fulfilled" ? solResult.value : null,
+		tempo: tempoResult.status === "fulfilled" ? tempoResult.value : null
+	};
+}
+buildCommand({
+	docs: { brief: "Show wallet addresses and balances" },
+	parameters: {
+		flags: { verbose: {
+			kind: "boolean",
+			brief: "Show transaction IDs",
+			default: false
+		} },
+		positional: {
+			kind: "tuple",
+			parameters: []
+		}
+	},
+	async func(flags) {
+		const wallet = resolveWallet();
+		if (wallet.source === "none") {
+			console.log(pc.yellow("No wallet configured."));
+			console.log(pc.dim(`\nRun:\n  ${pc.cyan("$ npx x402-proxy setup")}\n\nOr set ${pc.cyan("X402_PROXY_WALLET_MNEMONIC")} environment variable.`));
+			process.exit(1);
+		}
+		console.log();
+		info("Wallet");
+		console.log();
+		console.log(pc.dim(`  Source: ${wallet.source}`));
+		const { evm, sol, tempo } = await fetchAllBalances(wallet.evmAddress, wallet.solanaAddress);
+		if (wallet.evmAddress) {
+			const bal = evm ? balanceLine(evm.usdc, evm.eth, "ETH") : pc.dim(" (network error)");
+			console.log(`  Base:   ${pc.green(wallet.evmAddress)}${bal}`);
+		}
+		if (wallet.evmAddress) {
+			const bal = tempo ? pc.dim(` (${tempo.usdc} USDC)`) : pc.dim(" (network error)");
+			console.log(`  Tempo:  ${pc.green(wallet.evmAddress)}${bal}`);
+		}
+		if (wallet.solanaAddress) {
+			const bal = sol ? balanceLine(sol.usdc, sol.sol, "SOL") : pc.dim(" (network error)");
+			console.log(`  Solana: ${pc.green(wallet.solanaAddress)}${bal}`);
+		}
+		const evmEmpty = !evm || Number(evm.usdc) === 0;
+		const solEmpty = !sol || Number(sol.usdc) === 0;
+		const tempoEmpty = !tempo || Number(tempo.usdc) === 0;
+		if (evmEmpty && solEmpty && tempoEmpty) {
+			console.log();
+			dim("  Send USDC to any address above to start using paid APIs.");
+		}
+		console.log();
+		const records = readHistory(getHistoryPath());
+		if (records.length > 0) {
+			const spend = calcSpend(records);
+			const recent = records.slice(-10);
+			dim("  Recent transactions:");
+			for (const r of recent) {
+				const line = formatTxLine(r, { verbose: flags.verbose }).replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+				console.log(line);
+			}
+			console.log();
+			console.log(pc.dim(`  Today: ${formatAmount(spend.today, "USDC")} | Total: ${formatAmount(spend.total, "USDC")} | ${spend.count} tx`));
+		} else dim("  No transactions yet.");
+		console.log();
+		console.log(pc.dim("  See also: wallet history, wallet export-key"));
+		console.log();
+	}
+});
+//#endregion
 //#region src/openclaw/tools.ts
 const SOL_MAINNET = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
 const USDC_DECIMALS = 6;
@@ -540,6 +770,11 @@ function paymentAmount(payment) {
 	const parsed = Number.parseFloat(payment.amount);
 	return Number.isNaN(parsed) ? void 0 : parsed / 10 ** USDC_DECIMALS;
 }
+function parseMppAmount(value) {
+	if (!value) return void 0;
+	const parsed = Number(value);
+	return Number.isFinite(parsed) ? parsed : void 0;
+}
 function toolResult(text) {
 	return {
 		content: [{
@@ -549,11 +784,23 @@ function toolResult(text) {
 		details: {}
 	};
 }
-async function getWalletSnapshot(rpcUrl, wallet, historyPath) {
-	const [{ ui, raw }, sol, tokens] = await Promise.all([
-		getUsdcBalance(rpcUrl, wallet),
-		getSolBalance(rpcUrl, wallet),
-		getTokenAccounts(rpcUrl, wallet).catch(() => [])
+function addressForNetwork(evmAddress, solanaAddress, network) {
+	if (network?.startsWith("eip155:")) return evmAddress ?? solanaAddress;
+	if (network?.startsWith("solana:")) return solanaAddress ?? evmAddress;
+	return solanaAddress ?? evmAddress;
+}
+function walletAddressForNetwork(ctx, network) {
+	return addressForNetwork(ctx.getEvmWalletAddress(), ctx.getSolanaWalletAddress(), network) ?? "unknown";
+}
+async function getWalletSnapshot(rpcUrl, solanaWallet, evmWallet, historyPath) {
+	const [{ ui, raw }, sol, tokens, balances] = await Promise.all([
+		solanaWallet ? getUsdcBalance(rpcUrl, solanaWallet) : Promise.resolve({
+			ui: "0",
+			raw: 0n
+		}),
+		solanaWallet ? getSolBalance(rpcUrl, solanaWallet) : Promise.resolve("0"),
+		solanaWallet ? getTokenAccounts(rpcUrl, solanaWallet).catch(() => []) : Promise.resolve([]),
+		fetchAllBalances(evmWallet ?? void 0, solanaWallet ?? void 0)
 	]);
 	const records = readHistory(historyPath);
 	return {
@@ -561,61 +808,80 @@ async function getWalletSnapshot(rpcUrl, wallet, historyPath) {
 		raw,
 		sol,
 		tokens,
+		balances,
 		records,
 		spend: calcSpend(records)
 	};
 }
-function createBalanceTool(ctx) {
+function createWalletTool(ctx) {
 	return {
-		name: "x_balance",
-		label: "Wallet Balance",
-		description: "Check wallet SOL and USDC balances. Use before making payments to verify sufficient funds.",
+		name: "x_wallet",
+		label: "Wallet Status",
+		description: "Check wallet readiness, balances, and spend history for x402 and MPP payments before making paid requests.",
 		parameters: Type.Object({}),
 		async execute() {
-			const walletAddress = ctx.getWalletAddress();
-			if (!walletAddress) return toolResult("Wallet not loaded yet. Wait for gateway startup.");
+			await ctx.ensureReady();
+			const solanaWallet = ctx.getSolanaWalletAddress();
+			const evmWallet = ctx.getEvmWalletAddress();
+			if (!solanaWallet && !evmWallet) return toolResult("Wallet not configured yet. Run `x402-proxy setup` or set X402_PROXY_WALLET_MNEMONIC.");
 			try {
-				const snap = await getWalletSnapshot(ctx.rpcUrl, walletAddress, ctx.historyPath);
+				const snap = await getWalletSnapshot(ctx.rpcUrl, solanaWallet, evmWallet, ctx.historyPath);
 				const total = Number.parseFloat(snap.ui);
 				const available = Math.max(0, total - INFERENCE_RESERVE);
 				const tokenLines = snap.tokens.slice(0, 5).map((t) => {
 					const short = `${t.mint.slice(0, 4)}...${t.mint.slice(-4)}`;
 					return `${Number.parseFloat(t.amount).toLocaleString("en-US", { maximumFractionDigits: 0 })} (${short})`;
 				});
-				return toolResult([
-					`Wallet: ${walletAddress}`,
-					`SOL: ${snap.sol} SOL`,
-					`USDC: ${snap.ui} USDC`,
-					`Available for tools: ${available.toFixed(2)} USDC`,
-					`Reserved for inference: ${INFERENCE_RESERVE.toFixed(2)} USDC`,
-					`Spent today: ${formatAmount(snap.spend.today, "USDC")}`,
-					`Total spent: ${formatAmount(snap.spend.total, "USDC")} (${snap.spend.count} txs)`,
-					...tokenLines.length > 0 ? [`Tokens held: ${tokenLines.join(", ")}`] : []
-				].join("\n"));
+				const lines = [
+					`Default protocol: ${ctx.getDefaultRequestProtocol()}`,
+					`MPP budget: ${ctx.getDefaultMppSessionBudget()} USDC`,
+					`MPP ready: ${evmWallet ? "yes" : "no"}`,
+					`x402 ready: ${solanaWallet ? "yes" : "no"}`
+				];
+				if (evmWallet) {
+					lines.push(`Base wallet: ${evmWallet}`);
+					lines.push(`Base balance: ${snap.balances.evm?.usdc ?? "?"} USDC`);
+					lines.push(`Tempo balance: ${snap.balances.tempo?.usdc ?? "?"} USDC`);
+				}
+				if (solanaWallet) {
+					lines.push(`Solana wallet: ${solanaWallet}`);
+					lines.push(`Solana: ${snap.sol} SOL`);
+					lines.push(`Solana USDC: ${snap.ui} USDC`);
+					lines.push(`Available for x402 tools: ${available.toFixed(2)} USDC`);
+					lines.push(`Reserved for inference: ${INFERENCE_RESERVE.toFixed(2)} USDC`);
+				}
+				lines.push(`Spent today: ${formatAmount(snap.spend.today, "USDC")}`);
+				lines.push(`Total spent: ${formatAmount(snap.spend.total, "USDC")} (${snap.spend.count} txs)`);
+				if (tokenLines.length > 0) lines.push(`Tokens held: ${tokenLines.join(", ")}`);
+				if (!evmWallet) lines.push("MPP setup hint: set X402_PROXY_WALLET_MNEMONIC or X402_PROXY_WALLET_EVM_KEY, or run x402-proxy setup.");
+				if (!solanaWallet) lines.push("x402 setup hint: add a Solana wallet or mnemonic if you want to pay Solana x402 endpoints.");
+				return toolResult(lines.join("\n"));
 			} catch (err) {
-				return toolResult(`Failed to check balance: ${String(err)}`);
+				return toolResult(`Failed to check wallet status: ${String(err)}`);
 			}
 		}
 	};
 }
-function createPaymentTool(ctx) {
+function createRequestTool(ctx) {
 	return {
-		name: "x_payment",
-		label: "x402 Payment",
-		description: `Call an x402-enabled paid API endpoint with automatic USDC payment on Solana. Use this when you need to call a paid service given by the user. Note: ${INFERENCE_RESERVE.toFixed(2)} USDC is reserved for LLM inference and cannot be spent by this tool.`,
+		name: "x_request",
+		label: "Paid Request",
+		description: "Call a paid HTTP endpoint with automatic x402 or MPP settlement. Defaults to the plugin protocol and supports explicit protocol override.",
 		parameters: Type.Object({
-			url: Type.String({ description: "The x402-enabled endpoint URL" }),
+			url: Type.String({ description: "The paid endpoint URL" }),
 			method: Type.Optional(Type.String({ description: "HTTP method (default: GET)" })),
 			params: Type.Optional(Type.String({ description: "For GET: query params as JSON object. For POST/PUT/PATCH: JSON request body." })),
-			headers: Type.Optional(Type.String({ description: "Custom HTTP headers as JSON object" }))
+			headers: Type.Optional(Type.String({ description: "Custom HTTP headers as JSON object" })),
+			protocol: Type.Optional(Type.Union([
+				Type.Literal("x402"),
+				Type.Literal("mpp"),
+				Type.Literal("auto")
+			], { description: "Override the default payment protocol for this request." }))
 		}),
 		async execute(_id, params) {
-			const walletAddress = ctx.getWalletAddress();
-			if (!walletAddress) return toolResult("Wallet not loaded yet. Wait for gateway startup.");
-			try {
-				const { ui } = await getUsdcBalance(ctx.rpcUrl, walletAddress);
-				if (Number.parseFloat(ui) <= INFERENCE_RESERVE) return toolResult(`Insufficient funds. Balance: ${ui} USDC, reserved for inference: ${INFERENCE_RESERVE.toFixed(2)} USDC. Top up wallet: ${walletAddress}`);
-			} catch {}
+			await ctx.ensureReady();
+			const solanaWallet = ctx.getSolanaWalletAddress();
+			const evmWallet = ctx.getEvmWalletAddress();
 			const method = (params.method || "GET").toUpperCase();
 			let url = params.url;
 			const reqInit = { method };
@@ -638,35 +904,101 @@ function createPaymentTool(ctx) {
 					...reqInit.headers
 				};
 			}
+			const protocol = params.protocol && [
+				"x402",
+				"mpp",
+				"auto"
+			].includes(params.protocol) ? params.protocol : ctx.getDefaultRequestProtocol();
 			const toolStartMs = Date.now();
+			if ((protocol === "mpp" || protocol === "auto") && !ctx.getEvmKey()) return toolResult("MPP request failed: no EVM wallet configured. Run x402-proxy setup or set X402_PROXY_WALLET_EVM_KEY.");
+			if (protocol === "x402") {
+				if (!solanaWallet) return toolResult("x402 request failed: no Solana wallet configured. Add a mnemonic or Solana key first.");
+				try {
+					const { ui } = await getUsdcBalance(ctx.rpcUrl, solanaWallet);
+					if (Number.parseFloat(ui) <= INFERENCE_RESERVE) return toolResult(`Insufficient funds. Balance: ${ui} USDC, reserved for inference: ${INFERENCE_RESERVE.toFixed(2)} USDC. Top up wallet: ${solanaWallet}`);
+				} catch {}
+				const proxy = ctx.getX402Proxy();
+				if (!proxy) return toolResult("x402 wallet is not ready yet. Try again in a moment.");
+				try {
+					const response = await proxy.x402Fetch(url, reqInit);
+					const body = await response.text();
+					if (response.status === 402) {
+						const payment = proxy.shiftPayment();
+						appendHistory(ctx.historyPath, {
+							t: Date.now(),
+							ok: false,
+							kind: "x402_payment",
+							net: payment?.network ?? "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+							from: walletAddressForNetwork(ctx, payment?.network),
+							label: url,
+							ms: Date.now() - toolStartMs,
+							error: "payment_required"
+						});
+						return toolResult(`Payment failed (402): ${body.substring(0, 500)}. Wallet: ${walletAddressForNetwork(ctx, payment?.network)}`);
+					}
+					const payment = proxy.shiftPayment();
+					const amount = paymentAmount(payment);
+					appendHistory(ctx.historyPath, {
+						t: Date.now(),
+						ok: true,
+						kind: "x402_payment",
+						net: payment?.network ?? "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+						from: walletAddressForNetwork(ctx, payment?.network),
+						to: payment?.payTo,
+						tx: extractTxSignature(response),
+						amount,
+						token: "USDC",
+						label: url,
+						ms: Date.now() - toolStartMs
+					});
+					const truncated = body.length > MAX_RESPONSE_CHARS ? `${body.substring(0, MAX_RESPONSE_CHARS)}\n\n[Truncated - response was ${body.length} chars]` : body;
+					return toolResult(`HTTP ${response.status}\n\n${truncated}`);
+				} catch (err) {
+					ctx.getX402Proxy()?.shiftPayment();
+					appendHistory(ctx.historyPath, {
+						t: Date.now(),
+						ok: false,
+						kind: "x402_payment",
+						net: SOL_MAINNET,
+						from: solanaWallet,
+						label: params.url,
+						error: String(err).substring(0, 200)
+					});
+					const msg = String(err);
+					return toolResult(msg.includes("Simulation failed") || msg.includes("insufficient") ? `Payment failed - insufficient funds. Wallet: ${solanaWallet}. Error: ${msg}` : `Request failed: ${msg}`);
+				}
+			}
+			const evmKey = ctx.getEvmKey();
+			if (!evmKey) return toolResult("MPP request failed: no EVM wallet configured. Run x402-proxy setup or set X402_PROXY_WALLET_EVM_KEY.");
+			const mpp = await createMppProxyHandler({
+				evmKey,
+				maxDeposit: ctx.getDefaultMppSessionBudget()
+			});
 			try {
-				const response = await ctx.proxy.x402Fetch(url, reqInit);
+				const response = await mpp.fetch(url, reqInit);
 				const body = await response.text();
+				const payment = mpp.shiftPayment();
 				if (response.status === 402) {
-					ctx.proxy.shiftPayment();
 					appendHistory(ctx.historyPath, {
 						t: Date.now(),
 						ok: false,
-						kind: "x402_payment",
-						net: SOL_MAINNET,
-						from: walletAddress,
+						kind: "mpp_payment",
+						net: payment?.network ?? "eip155:4217",
+						from: evmWallet ?? "unknown",
 						label: url,
 						ms: Date.now() - toolStartMs,
 						error: "payment_required"
 					});
-					return toolResult(`Payment failed (402): ${body.substring(0, 500)}. Wallet: ${walletAddress}`);
+					return toolResult(`MPP payment failed (402): ${body.substring(0, 500)}`);
 				}
-				const payment = ctx.proxy.shiftPayment();
-				const amount = paymentAmount(payment);
 				appendHistory(ctx.historyPath, {
 					t: Date.now(),
 					ok: true,
-					kind: "x402_payment",
-					net: SOL_MAINNET,
-					from: walletAddress,
-					to: payment?.payTo,
-					tx: extractTxSignature(response),
-					amount,
+					kind: "mpp_payment",
+					net: payment?.network ?? "eip155:4217",
+					from: evmWallet ?? "unknown",
+					tx: extractTxSignature(response) ?? payment?.receipt?.reference,
+					amount: parseMppAmount(payment?.amount),
 					token: "USDC",
 					label: url,
 					ms: Date.now() - toolStartMs
@@ -674,18 +1006,18 @@ function createPaymentTool(ctx) {
 				const truncated = body.length > MAX_RESPONSE_CHARS ? `${body.substring(0, MAX_RESPONSE_CHARS)}\n\n[Truncated - response was ${body.length} chars]` : body;
 				return toolResult(`HTTP ${response.status}\n\n${truncated}`);
 			} catch (err) {
-				ctx.proxy.shiftPayment();
 				appendHistory(ctx.historyPath, {
 					t: Date.now(),
 					ok: false,
-					kind: "x402_payment",
-					net: SOL_MAINNET,
-					from: walletAddress,
+					kind: "mpp_payment",
+					net: TEMPO_NETWORK,
+					from: evmWallet ?? "unknown",
 					label: params.url,
 					error: String(err).substring(0, 200)
 				});
-				const msg = String(err);
-				return toolResult(msg.includes("Simulation failed") || msg.includes("insufficient") ? `Payment failed - insufficient funds. Wallet: ${walletAddress}. Error: ${msg}` : `Request failed: ${msg}`);
+				return toolResult(`MPP request failed: ${String(err)}`);
+			} finally {
+				await mpp.close().catch(() => {});
 			}
 		}
 	};
@@ -695,8 +1027,10 @@ function createPaymentTool(ctx) {
 const HISTORY_PAGE_SIZE = 5;
 const STATUS_HISTORY_COUNT = 3;
 const INLINE_HISTORY_TOKEN_THRESHOLD = 3;
+const SEND_CONFIRM_TTL_MS = 300 * 1e3;
 const TOKEN_SYMBOL_CACHE_MAX = 200;
 const tokenSymbolCache = /* @__PURE__ */ new Map();
+const pendingSends = /* @__PURE__ */ new Map();
 async function resolveTokenSymbols(mints) {
 	const result = /* @__PURE__ */ new Map();
 	const toResolve = [];
@@ -725,13 +1059,18 @@ async function resolveTokenSymbols(mints) {
 	} catch {}
 	return result;
 }
-async function handleSend(parts, wallet, signer, rpc, histPath) {
+function senderKey(cmdCtx) {
+	return [
+		cmdCtx.channel,
+		cmdCtx.accountId ?? "",
+		cmdCtx.senderId ?? cmdCtx.from ?? "",
+		String(cmdCtx.messageThreadId ?? "")
+	].join(":");
+}
+async function executeSend(amountStr, destination, wallet, signer, rpc, histPath) {
 	if (!signer) return { text: "Wallet not loaded yet. Please wait for the gateway to finish starting." };
-	if (parts.length !== 2) return { text: "Usage: `/x_wallet send <amount|all> <address>`\n\n  `/x_wallet send 0.5 7xKXtg...`\n  `/x_wallet send all 7xKXtg...`" };
-	const [amountStr, destAddr] = parts;
-	if (destAddr.length < 32 || destAddr.length > 44) return { text: `Invalid Solana address: ${destAddr}` };
 	try {
-		if (!await checkAtaExists(rpc, destAddr)) return { text: "Recipient does not have a USDC token account.\nThey need to receive USDC at least once to create one." };
+		if (!await checkAtaExists(rpc, destination)) return { text: "Recipient does not have a USDC token account.\nThey need to receive USDC at least once to create one." };
 		let amountRaw;
 		let amountUi;
 		if (amountStr.toLowerCase() === "all") {
@@ -745,20 +1084,20 @@ async function handleSend(parts, wallet, signer, rpc, histPath) {
 			amountRaw = BigInt(Math.round(amount * 1e6));
 			amountUi = amount.toString();
 		}
-		const sig = await transferUsdc(signer, rpc, destAddr, amountRaw);
+		const sig = await transferUsdc(signer, rpc, destination, amountRaw);
 		appendHistory(histPath, {
 			t: Date.now(),
 			ok: true,
 			kind: "transfer",
 			net: SOL_MAINNET,
 			from: wallet,
-			to: destAddr,
+			to: destination,
 			tx: sig,
 			amount: Number.parseFloat(amountUi),
 			token: "USDC",
-			label: `${destAddr.slice(0, 4)}...${destAddr.slice(-4)}`
+			label: `${destination.slice(0, 4)}...${destination.slice(-4)}`
 		});
-		return { text: `Sent ${amountUi} USDC to \`${destAddr}\`\n[View transaction](https://solscan.io/tx/${sig})` };
+		return { text: `Sent ${amountUi} USDC to \`${destination}\`\n[View transaction](https://solscan.io/tx/${sig})` };
 	} catch (err) {
 		appendHistory(histPath, {
 			t: Date.now(),
@@ -766,7 +1105,7 @@ async function handleSend(parts, wallet, signer, rpc, histPath) {
 			kind: "transfer",
 			net: SOL_MAINNET,
 			from: wallet,
-			to: destAddr,
+			to: destination,
 			token: "USDC",
 			error: String(err).substring(0, 200)
 		});
@@ -794,31 +1133,46 @@ function handleHistory(histPath, page) {
 function createWalletCommand(ctx) {
 	return {
 		name: "x_wallet",
-		description: "Wallet status, balance, send USDC, transaction history",
+		description: "Wallet status, balances, payment readiness, and transaction history",
 		acceptsArgs: true,
+		requireAuth: true,
 		handler: async (cmdCtx) => {
-			const walletAddress = ctx.getWalletAddress();
-			if (!walletAddress) return { text: "Wallet not loaded yet. Please wait for the gateway to finish starting." };
+			await ctx.ensureReady();
+			const solanaWallet = ctx.getSolanaWalletAddress();
+			const evmWallet = ctx.getEvmWalletAddress();
+			if (!solanaWallet && !evmWallet) return { text: "Wallet not configured yet.\nRun `x402-proxy setup` or set `X402_PROXY_WALLET_MNEMONIC` on the gateway host." };
 			const parts = (cmdCtx.args?.trim() ?? "").split(/\s+/).filter(Boolean);
-			if (parts[0]?.toLowerCase() === "send") return handleSend(parts.slice(1), walletAddress, ctx.getSigner(), ctx.rpcUrl, ctx.historyPath);
 			if (parts[0]?.toLowerCase() === "history") {
 				const pageArg = parts[1];
 				const page = pageArg ? Math.max(1, Number.parseInt(pageArg, 10) || 1) : 1;
 				return handleHistory(ctx.historyPath, page);
 			}
+			if (parts[0]?.toLowerCase() === "send") return { text: "Use `/x_send <amount|all> <address>` for transfers." };
 			try {
-				const snap = await getWalletSnapshot(ctx.rpcUrl, walletAddress, ctx.historyPath);
-				const solscanUrl = `https://solscan.io/account/${walletAddress}`;
-				const lines = [`x402-proxy v0.9.4`];
+				const snap = await getWalletSnapshot(ctx.rpcUrl, solanaWallet, evmWallet, ctx.historyPath);
+				const lines = [`x402-proxy v0.10.1`];
 				const defaultModel = ctx.allModels[0];
 				if (defaultModel) lines.push("", `**Model** - ${defaultModel.name} (${defaultModel.provider})`);
-				lines.push("", `**[Wallet](${solscanUrl})**`, `\`${walletAddress}\``);
-				lines.push("", `  ${snap.sol} SOL`, `  ${snap.ui} USDC`);
-				if (snap.spend.today > 0) lines.push(`  -${snap.spend.today.toFixed(2)} USDC today`);
+				lines.push("", `**Protocol** - ${ctx.getDefaultRequestProtocol()}`);
+				lines.push(`MPP session budget: ${ctx.getDefaultMppSessionBudget()} USDC`);
+				lines.push(`MPP ready: ${evmWallet ? "yes" : "no"}`);
+				lines.push(`x402 ready: ${solanaWallet ? "yes" : "no"}`);
+				if (evmWallet) {
+					lines.push("", "**EVM / Tempo**");
+					lines.push(`\`${evmWallet}\``);
+					lines.push(`  Base: ${snap.balances.evm?.usdc ?? "?"} USDC`);
+					lines.push(`  Tempo: ${snap.balances.tempo?.usdc ?? "?"} USDC`);
+				}
+				if (solanaWallet) {
+					const solscanUrl = `https://solscan.io/account/${solanaWallet}`;
+					lines.push("", `**[Solana Wallet](${solscanUrl})**`, `\`${solanaWallet}\``);
+					lines.push(`  ${snap.sol} SOL`, `  ${snap.ui} USDC`);
+					if (snap.spend.today > 0) lines.push(`  -${snap.spend.today.toFixed(2)} USDC today`);
+				}
 				if (snap.tokens.length > 0) {
 					const displayTokens = snap.tokens.slice(0, 10);
 					const symbols = await resolveTokenSymbols(displayTokens.map((t) => t.mint));
-					lines.push("", "**Tokens**");
+					lines.push("", "**Solana Tokens**");
 					for (const t of displayTokens) {
 						const label = symbols.get(t.mint) ?? `${t.mint.slice(0, 4)}...${t.mint.slice(-4)}`;
 						const amt = Number.parseFloat(t.amount).toLocaleString("en-US", { maximumFractionDigits: 0 });
@@ -833,21 +1187,199 @@ function createWalletCommand(ctx) {
 						for (const r of recentRecords) lines.push(formatTxLine(r));
 					}
 				}
-				lines.push("", "History: `/x_wallet history`");
+				if (!evmWallet) lines.push("", "MPP setup: add an EVM wallet via `x402-proxy setup` or `X402_PROXY_WALLET_EVM_KEY`.");
+				if (!solanaWallet) lines.push("", "x402 setup: add a Solana wallet or mnemonic if you need Solana x402.");
+				lines.push("", "History: `/x_wallet history`", "Send: `/x_send <amount|all> <address>`");
 				if (ctx.dashboardUrl) lines.push(`[Dashboard](${ctx.dashboardUrl})`);
 				return { text: lines.join("\n") };
 			} catch (err) {
-				return { text: `Failed to check balance: ${String(err)}` };
+				return { text: `Failed to check wallet status: ${String(err)}` };
 			}
 		}
 	};
 }
+function createSendCommand(ctx) {
+	return {
+		name: "x_send",
+		description: "Send USDC from the plugin wallet with an explicit confirmation step",
+		acceptsArgs: true,
+		requireAuth: true,
+		handler: async (cmdCtx) => {
+			await ctx.ensureReady();
+			const wallet = ctx.getSolanaWalletAddress();
+			if (!wallet) return { text: "No Solana wallet configured. `/x_send` only works with the Solana USDC wallet." };
+			const key = senderKey(cmdCtx);
+			const now = Date.now();
+			const pending = pendingSends.get(key);
+			if (pending && now - pending.createdAt > SEND_CONFIRM_TTL_MS) pendingSends.delete(key);
+			const parts = (cmdCtx.args?.trim() ?? "").split(/\s+/).filter(Boolean);
+			if (parts.length === 0) return { text: "Usage: `/x_send <amount|all> <address>`\nConfirm with `/x_send confirm`\nCancel with `/x_send cancel`" };
+			if (parts[0]?.toLowerCase() === "confirm") {
+				const next = pendingSends.get(key);
+				if (!next) return { text: "No pending transfer to confirm." };
+				pendingSends.delete(key);
+				return executeSend(next.amount, next.destination, wallet, ctx.getSigner(), ctx.rpcUrl, ctx.historyPath);
+			}
+			if (parts[0]?.toLowerCase() === "cancel") {
+				pendingSends.delete(key);
+				return { text: "Pending transfer cleared." };
+			}
+			if (parts.length !== 2) return { text: "Usage: `/x_send <amount|all> <address>`\nExample: `/x_send 0.5 7xKXtg...`" };
+			const [amount, destination] = parts;
+			if (destination.length < 32 || destination.length > 44) return { text: `Invalid Solana address: ${destination}` };
+			pendingSends.set(key, {
+				amount,
+				destination,
+				createdAt: now
+			});
+			return { text: `Pending transfer: send ${amount} USDC to \`${destination}\`\nConfirm within 5 minutes with \`/x_send confirm\`\nCancel with \`/x_send cancel\`` };
+		}
+	};
+}
+//#endregion
+//#region src/openclaw/defaults.ts
+const DEFAULT_SURF_PROVIDER_ID = "surf";
+const DEFAULT_SURF_BASE_URL = "/x402-proxy/v1";
+const DEFAULT_SURF_UPSTREAM_URL = "https://surf.cascade.fyi/api/v1/inference";
+const DEFAULT_SURF_MODELS = [
+	{
+		id: "anthropic/claude-opus-4.6",
+		name: "Claude Opus 4.6",
+		maxTokens: 2e5,
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: .015,
+			output: .075,
+			cacheRead: .0015,
+			cacheWrite: .01875
+		},
+		contextWindow: 2e5
+	},
+	{
+		id: "anthropic/claude-sonnet-4.6",
+		name: "Claude Sonnet 4.6",
+		maxTokens: 2e5,
+		reasoning: true,
+		input: ["text", "image"],
+		cost: {
+			input: .003,
+			output: .015,
+			cacheRead: 3e-4,
+			cacheWrite: .00375
+		},
+		contextWindow: 2e5
+	},
+	{
+		id: "x-ai/grok-4.20-beta",
+		name: "Grok 4.20 Beta",
+		maxTokens: 131072,
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: .003,
+			output: .015,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		contextWindow: 131072
+	},
+	{
+		id: "minimax/minimax-m2.5",
+		name: "MiniMax M2.5",
+		maxTokens: 1e6,
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: .001,
+			output: .005,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		contextWindow: 1e6
+	},
+	{
+		id: "moonshotai/kimi-k2.5",
+		name: "Kimi K2.5",
+		maxTokens: 131072,
+		reasoning: true,
+		input: ["text"],
+		cost: {
+			input: .002,
+			output: .008,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		contextWindow: 131072
+	},
+	{
+		id: "z-ai/glm-5",
+		name: "GLM-5",
+		maxTokens: 128e3,
+		reasoning: false,
+		input: ["text"],
+		cost: {
+			input: .001,
+			output: .005,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		contextWindow: 128e3
+	}
+];
+function resolveProviders(config) {
+	const defaultProtocol = resolveProtocol(config.protocol);
+	const defaultMppSessionBudget = resolveMppSessionBudget(config.mppSessionBudget);
+	const raw = config.providers ?? {};
+	const entries = Object.entries(raw).length > 0 ? Object.entries(raw).map(([id, provider]) => ({
+		id,
+		baseUrl: provider.baseUrl || "/x402-proxy/v1",
+		upstreamUrl: provider.upstreamUrl || "https://surf.cascade.fyi/api/v1/inference",
+		protocol: resolveProtocol(provider.protocol, defaultProtocol),
+		mppSessionBudget: resolveMppSessionBudget(provider.mppSessionBudget, defaultMppSessionBudget),
+		models: provider.models && provider.models.length > 0 ? provider.models : DEFAULT_SURF_MODELS
+	})) : [{
+		id: DEFAULT_SURF_PROVIDER_ID,
+		baseUrl: DEFAULT_SURF_BASE_URL,
+		upstreamUrl: DEFAULT_SURF_UPSTREAM_URL,
+		protocol: defaultProtocol,
+		mppSessionBudget: defaultMppSessionBudget,
+		models: DEFAULT_SURF_MODELS
+	}];
+	return {
+		providers: entries,
+		models: entries.flatMap((provider) => provider.models.map((model) => ({
+			...model,
+			provider: provider.id
+		})))
+	};
+}
+function routePrefixForBaseUrl(baseUrl) {
+	const segments = baseUrl.split("/").filter(Boolean);
+	return segments.length > 0 ? `/${segments[0]}` : "/";
+}
+function resolveProtocol(value, fallback = "mpp") {
+	return value === "x402" || value === "mpp" || value === "auto" ? value : fallback;
+}
+function resolveMppSessionBudget(value, fallback = "0.5") {
+	return typeof value === "string" && value.trim().length > 0 ? value : fallback;
+}
 //#endregion
 //#region src/openclaw/route.ts
-function createX402RouteHandler(opts) {
-	const { upstreamOrigin, proxy, getWalletAddress, historyPath, allModels, logger } = opts;
+function createInferenceProxyRouteHandler(opts) {
+	const { providers, getX402Proxy, getWalletAddress, getWalletAddressForNetwork, getEvmKey, historyPath, allModels, logger } = opts;
+	const sortedProviders = providers.slice().sort((left, right) => right.baseUrl.length - left.baseUrl.length);
 	return async (req, res) => {
 		const url = new URL(req.url ?? "/", "http://localhost");
+		const provider = sortedProviders.find((entry) => entry.baseUrl === "/" || url.pathname.startsWith(entry.baseUrl));
+		if (!provider) {
+			res.writeHead(404, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: {
+				message: "Unknown inference route",
+				code: "not_found"
+			} }));
+			return true;
+		}
 		const walletAddress = getWalletAddress();
 		if (!walletAddress) {
 			res.writeHead(503, { "Content-Type": "application/json" });
@@ -855,11 +1387,11 @@ function createX402RouteHandler(opts) {
 				message: "Wallet not loaded yet",
 				code: "not_ready"
 			} }));
-			return;
+			return true;
 		}
-		const pathSuffix = url.pathname.slice(5);
-		const upstreamUrl = upstreamOrigin + pathSuffix + url.search;
-		logger.info(`x402: intercepting ${upstreamUrl.substring(0, 80)}`);
+		const pathSuffix = provider.baseUrl === "/" ? url.pathname : url.pathname.slice(provider.baseUrl.length);
+		const upstreamUrl = `${provider.upstreamUrl.replace(/\/+$/, "")}${pathSuffix.startsWith("/") ? pathSuffix : `/${pathSuffix}`}${url.search}`;
+		logger.info(`proxy: intercepting ${upstreamUrl.substring(0, 80)}`);
 		const chunks = [];
 		for await (const chunk of req) chunks.push(Buffer.from(chunk));
 		let body = Buffer.concat(chunks).toString("utf-8");
@@ -891,22 +1423,62 @@ function createX402RouteHandler(opts) {
 		const method = req.method ?? "GET";
 		const startMs = Date.now();
 		try {
-			const response = await proxy.x402Fetch(upstreamUrl, {
+			const requestInit = {
 				method,
 				headers,
 				body: ["GET", "HEAD"].includes(method) ? void 0 : body
-			});
+			};
+			const useMpp = provider.protocol === "mpp" || provider.protocol === "auto";
+			const wantsStreaming = isChatCompletion && /"stream"\s*:\s*true/.test(body);
+			if (useMpp) {
+				const evmKey = getEvmKey();
+				if (!evmKey) {
+					res.writeHead(503, { "Content-Type": "application/json" });
+					res.end(JSON.stringify({ error: {
+						message: "MPP inference requires an EVM wallet. Configure X402_PROXY_WALLET_MNEMONIC or X402_PROXY_WALLET_EVM_KEY.",
+						code: "mpp_wallet_missing"
+					} }));
+					return true;
+				}
+				return await handleMppRequest({
+					req,
+					res,
+					upstreamUrl,
+					requestInit,
+					walletAddress,
+					historyPath,
+					logger,
+					allModels,
+					thinkingMode,
+					wantsStreaming,
+					startMs,
+					evmKey,
+					mppSessionBudget: provider.mppSessionBudget
+				});
+			}
+			const proxy = getX402Proxy();
+			if (!proxy) {
+				res.writeHead(503, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({ error: {
+					message: "x402 wallet not loaded yet. Configure a Solana wallet or switch the provider to mpp.",
+					code: "x402_wallet_missing"
+				} }));
+				return true;
+			}
+			const response = await proxy.x402Fetch(upstreamUrl, requestInit);
 			if (response.status === 402) {
 				const responseBody = await response.text();
 				logger.error(`x402: payment failed, raw response: ${responseBody}`);
 				const payment = proxy.shiftPayment();
 				const amount = paymentAmount(payment);
+				const paymentFrom = (payment?.network && getWalletAddressForNetwork?.(payment.network)) ?? walletAddress;
+				const paymentNetwork = payment?.network ?? "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
 				appendHistory(historyPath, {
 					t: Date.now(),
 					ok: false,
 					kind: "x402_inference",
-					net: SOL_MAINNET,
-					from: walletAddress,
+					net: paymentNetwork,
+					from: paymentFrom,
 					to: payment?.payTo,
 					amount,
 					token: amount != null ? "USDC" : void 0,
@@ -923,19 +1495,21 @@ function createX402RouteHandler(opts) {
 					type: "x402_payment_error",
 					code: "payment_failed"
 				} }));
-				return;
+				return true;
 			}
 			if (!response.ok && isChatCompletion) {
 				const responseBody = await response.text();
 				logger.error(`x402: upstream error ${response.status}: ${responseBody.substring(0, 300)}`);
 				const payment = proxy.shiftPayment();
 				const amount = paymentAmount(payment);
+				const paymentFrom = (payment?.network && getWalletAddressForNetwork?.(payment.network)) ?? walletAddress;
+				const paymentNetwork = payment?.network ?? "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
 				appendHistory(historyPath, {
 					t: Date.now(),
 					ok: false,
 					kind: "x402_inference",
-					net: SOL_MAINNET,
-					from: walletAddress,
+					net: paymentNetwork,
+					from: paymentFrom,
 					to: payment?.payTo,
 					amount,
 					token: amount != null ? "USDC" : void 0,
@@ -948,12 +1522,14 @@ function createX402RouteHandler(opts) {
 					type: "x402_upstream_error",
 					code: "upstream_failed"
 				} }));
-				return;
+				return true;
 			}
 			logger.info(`x402: response ${response.status}`);
 			const txSig = extractTxSignature(response);
 			const payment = proxy.shiftPayment();
 			const amount = paymentAmount(payment);
+			const paymentFrom = (payment?.network && getWalletAddressForNetwork?.(payment.network)) ?? walletAddress;
+			const paymentNetwork = payment?.network ?? "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
 			const resHeaders = {};
 			for (const [key, val] of response.headers.entries()) resHeaders[key] = val;
 			res.writeHead(response.status, resHeaders);
@@ -963,20 +1539,18 @@ function createX402RouteHandler(opts) {
 					t: Date.now(),
 					ok: true,
 					kind: "x402_inference",
-					net: SOL_MAINNET,
-					from: walletAddress,
+					net: paymentNetwork,
+					from: paymentFrom,
 					to: payment?.payTo,
 					tx: txSig,
 					amount,
 					token: "USDC",
 					ms: Date.now() - startMs
 				});
-				return;
+				return true;
 			}
 			const ct = response.headers.get("content-type") || "";
-			const isSSE = isChatCompletion && ct.includes("text/event-stream");
-			let lastDataLine = "";
-			let residual = "";
+			const sse = isChatCompletion && ct.includes("text/event-stream") ? createSseTracker() : null;
 			const reader = response.body.getReader();
 			const decoder = new TextDecoder();
 			try {
@@ -984,27 +1558,23 @@ function createX402RouteHandler(opts) {
 					const { done, value } = await reader.read();
 					if (done) break;
 					res.write(value);
-					if (isSSE) {
-						const lines = (residual + decoder.decode(value, { stream: true })).split("\n");
-						residual = lines.pop() ?? "";
-						for (const line of lines) if (line.startsWith("data: ") && line !== "data: [DONE]") lastDataLine = line.slice(6);
-					}
+					sse?.push(decoder.decode(value, { stream: true }));
 				}
 			} finally {
 				reader.releaseLock();
 			}
 			res.end();
 			const durationMs = Date.now() - startMs;
-			if (isSSE && lastDataLine) try {
-				const parsed = JSON.parse(lastDataLine);
+			if (sse?.lastData) try {
+				const parsed = JSON.parse(sse.lastData);
 				const usage = parsed.usage;
 				const model = parsed.model ?? "";
 				appendHistory(historyPath, {
 					t: Date.now(),
 					ok: true,
 					kind: "x402_inference",
-					net: SOL_MAINNET,
-					from: walletAddress,
+					net: paymentNetwork,
+					from: paymentFrom,
 					to: payment?.payTo,
 					tx: txSig,
 					amount,
@@ -1024,8 +1594,8 @@ function createX402RouteHandler(opts) {
 					t: Date.now(),
 					ok: true,
 					kind: "x402_inference",
-					net: SOL_MAINNET,
-					from: walletAddress,
+					net: paymentNetwork,
+					from: paymentFrom,
 					to: payment?.payTo,
 					tx: txSig,
 					amount,
@@ -1037,19 +1607,19 @@ function createX402RouteHandler(opts) {
 				t: Date.now(),
 				ok: true,
 				kind: "x402_inference",
-				net: SOL_MAINNET,
-				from: walletAddress,
+				net: paymentNetwork,
+				from: paymentFrom,
 				to: payment?.payTo,
 				tx: txSig,
 				amount,
 				token: "USDC",
 				ms: durationMs
 			});
-			return;
+			return true;
 		} catch (err) {
 			const msg = String(err);
 			logger.error(`x402: fetch threw: ${msg}`);
-			proxy.shiftPayment();
+			getX402Proxy()?.shiftPayment();
 			appendHistory(historyPath, {
 				t: Date.now(),
 				ok: false,
@@ -1071,104 +1641,258 @@ function createX402RouteHandler(opts) {
 					code: "payment_failed"
 				} }));
 			}
+			return true;
 		}
 	};
 }
-//#endregion
-//#region src/openclaw/plugin.ts
-function parseProviders(config) {
-	const raw = config.providers ?? {};
-	const models = [];
-	const upstreamOrigins = [];
-	for (const [name, prov] of Object.entries(raw)) {
-		if (prov.upstreamUrl) upstreamOrigins.push(prov.upstreamUrl);
-		for (const m of prov.models) models.push({
-			...m,
-			provider: name
-		});
-	}
+function createSseTracker() {
+	let residual = "";
+	let lastDataLine = "";
 	return {
-		models,
-		upstreamOrigins
+		push(text) {
+			const lines = (residual + text).split("\n");
+			residual = lines.pop() ?? "";
+			for (const line of lines) if (line.startsWith("data: ") && line !== "data: [DONE]") lastDataLine = line.slice(6);
+		},
+		get lastData() {
+			return lastDataLine;
+		}
 	};
 }
+async function closeMppSession(handler) {
+	try {
+		await handler.close();
+	} catch {}
+}
+async function handleMppRequest(opts) {
+	const { req, res, upstreamUrl, requestInit, walletAddress, historyPath, logger, allModels, thinkingMode, wantsStreaming, startMs, evmKey, mppSessionBudget } = opts;
+	const mpp = await createMppProxyHandler({
+		evmKey,
+		maxDeposit: mppSessionBudget
+	});
+	try {
+		if (wantsStreaming) {
+			res.writeHead(200, {
+				"Content-Type": "text/event-stream; charset=utf-8",
+				"Cache-Control": "no-cache, no-transform",
+				Connection: "keep-alive"
+			});
+			const sse = createSseTracker();
+			const stream = await mpp.sse(upstreamUrl, requestInit);
+			for await (const chunk of stream) {
+				const text = String(chunk);
+				res.write(text);
+				sse.push(text);
+			}
+			res.end();
+			mpp.shiftPayment();
+			const payment = mpp.shiftPayment();
+			appendInferenceHistory({
+				historyPath,
+				allModels,
+				walletAddress,
+				paymentNetwork: payment?.network ?? "eip155:4217",
+				paymentTo: void 0,
+				tx: payment?.receipt?.reference ?? payment?.channelId,
+				amount: parseMppAmount(payment?.amount),
+				thinkingMode,
+				lastDataLine: sse.lastData,
+				durationMs: Date.now() - startMs
+			});
+			return true;
+		}
+		const response = await mpp.fetch(upstreamUrl, requestInit);
+		const tx = extractTxSignature(response);
+		if (response.status === 402) {
+			const responseBody = await response.text();
+			logger.error(`mpp: payment failed, raw response: ${responseBody}`);
+			appendHistory(historyPath, {
+				t: Date.now(),
+				ok: false,
+				kind: "x402_inference",
+				net: TEMPO_NETWORK,
+				from: walletAddress,
+				ms: Date.now() - startMs,
+				error: "payment_required"
+			});
+			res.writeHead(402, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: {
+				message: `MPP payment failed: ${responseBody.substring(0, 200) || "unknown error"}. Wallet: ${walletAddress}`,
+				type: "mpp_payment_error",
+				code: "payment_failed"
+			} }));
+			return true;
+		}
+		const resHeaders = {};
+		for (const [key, value] of response.headers.entries()) resHeaders[key] = value;
+		res.writeHead(response.status, resHeaders);
+		const responseBody = await response.text();
+		res.end(responseBody);
+		const payment = mpp.shiftPayment();
+		appendInferenceHistory({
+			historyPath,
+			allModels,
+			walletAddress,
+			paymentNetwork: payment?.network ?? "eip155:4217",
+			paymentTo: void 0,
+			tx: tx ?? payment?.receipt?.reference,
+			amount: parseMppAmount(payment?.amount),
+			thinkingMode,
+			lastDataLine: responseBody,
+			durationMs: Date.now() - startMs
+		});
+		return true;
+	} catch (err) {
+		logger.error(`mpp: fetch threw: ${String(err)}`);
+		appendHistory(historyPath, {
+			t: Date.now(),
+			ok: false,
+			kind: "x402_inference",
+			net: TEMPO_NETWORK,
+			from: walletAddress,
+			ms: Date.now() - startMs,
+			error: String(err).substring(0, 200)
+		});
+		if (!res.headersSent) {
+			res.writeHead(402, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: {
+				message: `MPP request failed: ${String(err)}`,
+				type: "mpp_payment_error",
+				code: "payment_failed"
+			} }));
+		}
+		return true;
+	} finally {
+		await closeMppSession(mpp);
+		if (!res.writableEnded) res.end();
+		req.resume();
+	}
+}
+function appendInferenceHistory(opts) {
+	const { historyPath, allModels, walletAddress, paymentNetwork, paymentTo, tx, amount, thinkingMode, lastDataLine, durationMs } = opts;
+	try {
+		const parsed = JSON.parse(lastDataLine);
+		const usage = parsed.usage;
+		const model = parsed.model ?? "";
+		appendHistory(historyPath, {
+			t: Date.now(),
+			ok: true,
+			kind: "x402_inference",
+			net: paymentNetwork,
+			from: walletAddress,
+			to: paymentTo,
+			tx,
+			amount,
+			token: "USDC",
+			provider: allModels.find((entry) => entry.id === model || `${entry.provider}/${entry.id}` === model)?.provider,
+			model,
+			inputTokens: usage?.prompt_tokens ?? 0,
+			outputTokens: usage?.completion_tokens ?? 0,
+			reasoningTokens: usage?.completion_tokens_details?.reasoning_tokens,
+			cacheRead: usage?.prompt_tokens_details?.cached_tokens,
+			cacheWrite: usage?.prompt_tokens_details?.cache_creation_input_tokens,
+			thinking: thinkingMode,
+			ms: durationMs
+		});
+	} catch {
+		appendHistory(historyPath, {
+			t: Date.now(),
+			ok: true,
+			kind: "x402_inference",
+			net: paymentNetwork,
+			from: walletAddress,
+			to: paymentTo,
+			tx,
+			amount,
+			token: "USDC",
+			ms: durationMs
+		});
+	}
+}
+//#endregion
+//#region src/openclaw/plugin.ts
 function register(api) {
 	const config = api.pluginConfig ?? {};
 	const explicitKeypairPath = config.keypairPath;
 	const rpcUrl = config.rpcUrl || "https://api.mainnet-beta.solana.com";
 	const dashboardUrl = config.dashboardUrl || "";
-	const { models: allModels, upstreamOrigins } = parseProviders(config);
-	if (allModels.length === 0) {
-		api.logger.error("x402-proxy: no providers configured");
-		return;
-	}
-	const raw = config.providers ?? {};
-	for (const [name, prov] of Object.entries(raw)) api.registerProvider({
-		id: name,
-		label: `${name} (x402)`,
+	const { providers, models: allModels } = resolveProviders(config);
+	const defaultProvider = providers[0];
+	for (const provider of providers) api.registerProvider({
+		id: provider.id,
+		label: provider.id,
 		auth: [],
 		catalog: {
 			order: "simple",
 			run: async () => ({ provider: {
-				baseUrl: prov.baseUrl,
+				baseUrl: provider.baseUrl,
 				api: "openai-completions",
 				authHeader: false,
-				models: prov.models
+				models: provider.models
 			} })
 		}
 	});
-	api.logger.info(`x402-proxy: ${Object.keys(raw).join(", ")} - ${allModels.length} models, ${upstreamOrigins.length} x402 endpoints`);
-	let walletAddress = null;
+	api.logger.info(`x402-proxy: ${providers.map((provider) => `${provider.id}:${provider.protocol}`).join(", ")} - ${allModels.length} models`);
+	let solanaWalletAddress = null;
+	let evmWalletAddress = null;
 	let signerRef = null;
 	let proxyRef = null;
-	let walletLoading = false;
+	let evmKeyRef = null;
+	let walletLoadPromise = null;
 	const historyPath = getHistoryPath();
+	const routePrefixes = [...new Set(providers.map((provider) => routePrefixForBaseUrl(provider.baseUrl)))];
+	const handler = createInferenceProxyRouteHandler({
+		providers,
+		getX402Proxy: () => proxyRef,
+		getWalletAddress: () => solanaWalletAddress ?? evmWalletAddress,
+		getWalletAddressForNetwork: (network) => addressForNetwork(evmWalletAddress, solanaWalletAddress, network),
+		getEvmKey: () => evmKeyRef,
+		historyPath,
+		allModels,
+		logger: api.logger
+	});
+	for (const path of routePrefixes) api.registerHttpRoute({
+		path,
+		match: "prefix",
+		auth: "plugin",
+		handler
+	});
+	api.logger.info(`proxy: HTTP routes ${routePrefixes.join(", ")} registered for ${providers.map((provider) => provider.upstreamUrl).join(", ")}`);
 	async function ensureWalletLoaded() {
-		if (walletLoading || walletAddress) return;
-		walletLoading = true;
-		let signer;
-		try {
-			if (explicitKeypairPath) {
-				signer = await loadSvmWallet(explicitKeypairPath.startsWith("~/") ? join(homedir(), explicitKeypairPath.slice(2)) : explicitKeypairPath);
-				walletAddress = signer.address;
-			} else {
+		if (walletLoadPromise) {
+			await walletLoadPromise;
+			return;
+		}
+		walletLoadPromise = (async () => {
+			try {
 				const resolution = resolveWallet();
-				if (resolution.source === "none" || !resolution.solanaKey || !resolution.solanaAddress) {
-					walletLoading = false;
-					api.logger.error("x402-proxy: no wallet found. Run `x402-proxy setup` to create one, or set X402_PROXY_WALLET_MNEMONIC env var.");
+				evmKeyRef = resolution.evmKey ?? null;
+				evmWalletAddress = resolution.evmAddress ?? null;
+				if (explicitKeypairPath) {
+					signerRef = await loadSvmWallet(explicitKeypairPath.startsWith("~/") ? join(homedir(), explicitKeypairPath.slice(2)) : explicitKeypairPath);
+					solanaWalletAddress = signerRef.address;
+				} else if (resolution.solanaKey && resolution.solanaAddress) {
+					signerRef = await createKeyPairSignerFromBytes(resolution.solanaKey);
+					solanaWalletAddress = resolution.solanaAddress;
+				} else {
+					signerRef = null;
+					solanaWalletAddress = null;
+				}
+				if (!solanaWalletAddress && !evmWalletAddress) {
+					api.logger.error("x402-proxy: no wallet found. Run `x402-proxy setup` to create one, or set X402_PROXY_WALLET_MNEMONIC / X402_PROXY_WALLET_EVM_KEY.");
 					return;
 				}
-				signer = await createKeyPairSignerFromBytes(resolution.solanaKey);
-				walletAddress = resolution.solanaAddress;
+				if (signerRef) {
+					const client = new x402Client();
+					client.register(SOL_MAINNET, new OptimizedSvmScheme(signerRef, { rpcUrl }));
+					proxyRef = createX402ProxyHandler({ client });
+				} else proxyRef = null;
+				api.logger.info(`wallets: solana=${solanaWalletAddress ?? "missing"} evm=${evmWalletAddress ?? "missing"}`);
+			} catch (err) {
+				api.logger.error(`wallet load failed: ${err}`);
 			}
-			signerRef = signer;
-			api.logger.info(`x402: wallet ${walletAddress}`);
-		} catch (err) {
-			walletLoading = false;
-			api.logger.error(`x402: failed to load wallet: ${err}`);
-			return;
-		}
-		const client = new x402Client();
-		client.register(SOL_MAINNET, new OptimizedSvmScheme(signer, { rpcUrl }));
-		proxyRef = createX402ProxyHandler({ client });
-		const upstreamOrigin = upstreamOrigins[0];
-		if (upstreamOrigin) {
-			const handler = createX402RouteHandler({
-				upstreamOrigin,
-				proxy: proxyRef,
-				getWalletAddress: () => walletAddress,
-				historyPath,
-				allModels,
-				logger: api.logger
-			});
-			api.registerHttpRoute({
-				path: "/x402",
-				match: "prefix",
-				auth: "plugin",
-				handler
-			});
-			api.logger.info(`x402: HTTP route registered for ${upstreamOrigin}`);
-		}
+		})();
+		await walletLoadPromise;
 	}
 	ensureWalletLoaded();
 	api.registerService({
@@ -1179,27 +1903,40 @@ function register(api) {
 		async stop() {}
 	});
 	const toolCtx = {
-		getWalletAddress: () => walletAddress,
+		ensureReady: ensureWalletLoaded,
+		getSolanaWalletAddress: () => solanaWalletAddress,
+		getEvmWalletAddress: () => evmWalletAddress,
 		getSigner: () => signerRef,
+		getX402Proxy: () => proxyRef,
+		getEvmKey: () => evmKeyRef,
+		getDefaultRequestProtocol: () => defaultProvider?.protocol ?? "mpp",
+		getDefaultMppSessionBudget: () => defaultProvider?.mppSessionBudget ?? "0.5",
 		rpcUrl,
 		historyPath,
-		get proxy() {
-			if (!proxyRef) throw new Error("x402 proxy not initialized yet");
-			return proxyRef;
-		},
 		allModels
 	};
-	api.registerTool(createBalanceTool(toolCtx));
-	api.registerTool(createPaymentTool(toolCtx));
+	api.registerTool(createWalletTool(toolCtx), { names: ["x_balance"] });
+	api.registerTool(createRequestTool(toolCtx), { names: ["x_payment"] });
 	const cmdCtx = {
-		getWalletAddress: () => walletAddress,
+		ensureReady: ensureWalletLoaded,
+		getSolanaWalletAddress: () => solanaWalletAddress,
+		getEvmWalletAddress: () => evmWalletAddress,
 		getSigner: () => signerRef,
+		getDefaultRequestProtocol: () => defaultProvider?.protocol ?? "mpp",
+		getDefaultMppSessionBudget: () => defaultProvider?.mppSessionBudget ?? "0.5",
 		rpcUrl,
 		dashboardUrl,
 		historyPath,
 		allModels
 	};
 	api.registerCommand(createWalletCommand(cmdCtx));
+	api.registerCommand(createSendCommand(cmdCtx));
 }
+var plugin_default = definePluginEntry({
+	id: "x402-proxy",
+	name: "mpp/x402 Payments Proxy",
+	description: "x402 and MPP payments, wallet tools, and paid inference proxying",
+	register
+});
 //#endregion
-export { register };
+export { plugin_default as default, register };