x402-proxy 0.5.2 → 0.7.0

package/dist/bin/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { a as buildX402Client, c as error, d as warn, f as appendHistory, g as readHistory, h as formatTxLine, i as walletInfoCommand, l as info, m as displayNetwork, o as resolveWallet, p as calcSpend, s as dim, u as isTTY } from "../wallet-BMYYtAP6.js";
-import { c as isConfigured, i as ensureConfigDir, l as loadConfig, o as getHistoryPath, u as loadWalletFile } from "../derive-CISr_ond.js";
-import { n as setupCommand } from "../setup-gla-Qyqi.js";
-import { n as statusCommand } from "../status-BoH_1kIH.js";
+import { _ as formatTxLine, c as resolveWallet, d as info, f as isTTY, g as displayNetwork, h as calcSpend, l as dim, m as appendHistory, o as walletInfoCommand, p as warn, s as buildX402Client, u as error, v as readHistory } from "../wallet-DxKCHa7U.js";
+import { a as getHistoryPath, c as loadConfig, l as loadWalletFile, s as isConfigured } from "../derive-ibF2UinV.js";
+import { n as setupCommand } from "../setup-hJGkO2Lo.js";
+import { n as statusCommand } from "../status-JNGv2Ghp.js";
 import { buildApplication, buildCommand, buildRouteMap, run } from "@stricli/core";
 import pc from "picocolors";
 import { decodePaymentResponseHeader, wrapFetchWithPayment } from "@x402/fetch";
@@ -11,25 +11,35 @@ import * as prompts from "@clack/prompts";
 
 //#region src/handler.ts
 /**
+* Detect which payment protocols a 402 response advertises.
+* - x402: PAYMENT-REQUIRED or X-PAYMENT-REQUIRED header
+* - MPP: WWW-Authenticate header with Payment scheme
+*/
+function detectProtocols(response) {
+	const pr = response.headers.get("PAYMENT-REQUIRED") ?? response.headers.get("X-PAYMENT-REQUIRED");
+	const wwwAuth = response.headers.get("WWW-Authenticate");
+	return {
+		x402: !!pr,
+		mpp: !!(wwwAuth && /^Payment\b/i.test(wwwAuth.trim()))
+	};
+}
+/**
 * Extract the on-chain transaction signature from an x402 payment response header.
 */
 function extractTxSignature(response) {
-	const header = response.headers.get("PAYMENT-RESPONSE") ?? response.headers.get("X-PAYMENT-RESPONSE");
-	if (!header) return void 0;
-	try {
-		return decodePaymentResponseHeader(header).transaction ?? void 0;
+	const x402Header = response.headers.get("PAYMENT-RESPONSE") ?? response.headers.get("X-PAYMENT-RESPONSE");
+	if (x402Header) try {
+		return decodePaymentResponseHeader(x402Header).transaction ?? void 0;
+	} catch {}
+	const mppHeader = response.headers.get("Payment-Receipt");
+	if (mppHeader) try {
+		return JSON.parse(Buffer.from(mppHeader, "base64url").toString()).reference ?? void 0;
 	} catch {
 		return;
 	}
 }
 /**
 * Create an x402 proxy handler that wraps fetch with automatic payment.
-*
-* Chain-agnostic: accepts a pre-configured x402Client with any registered
-* schemes (SVM, EVM, etc). The handler captures payment info via the
-* onAfterPaymentCreation hook. Callers use `x402Fetch` for requests that
-* may require x402 payment, and `shiftPayment` to retrieve captured
-* payment info after each call.
 */
 function createX402ProxyHandler(opts) {
 	const { client } = opts;
@@ -37,6 +47,7 @@ function createX402ProxyHandler(opts) {
 	client.onAfterPaymentCreation(async (hookCtx) => {
 		const raw = hookCtx.selectedRequirements.amount;
 		paymentQueue.push({
+			protocol: "x402",
 			network: hookCtx.selectedRequirements.network,
 			payTo: hookCtx.selectedRequirements.payTo,
 			amount: raw,
@@ -48,6 +59,84 @@ 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 = [];
+	const mppx = Mppx.create({
+		methods: [tempo({
+			account,
+			maxDeposit
+		})],
+		polyfill: false
+	});
+	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,
+					receipt
+				});
+			} catch {
+				paymentQueue.push({
+					protocol: "mpp",
+					network: TEMPO_NETWORK
+				});
+			}
+			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/commands/fetch.ts
@@ -96,7 +185,13 @@ Examples:
 			},
 			network: {
 				kind: "parsed",
-				brief: "Require specific network (base, solana)",
+				brief: "Require specific network (base, solana, tempo)",
+				parse: String,
+				optional: true
+			},
+			protocol: {
+				kind: "parsed",
+				brief: "Payment protocol (x402, mpp)",
 				parse: String,
 				optional: true
 			},
@@ -104,6 +199,11 @@ Examples:
 				kind: "boolean",
 				brief: "Force JSON output",
 				default: false
+			},
+			verbose: {
+				kind: "boolean",
+				brief: "Show debug details (protocol negotiation, headers, payment flow)",
+				default: false
 			}
 		},
 		positional: {
@@ -116,9 +216,21 @@ Examples:
 		}
 	},
 	async func(flags, url) {
+		const verbose = (msg) => {
+			if (flags.verbose) dim(`  [verbose] ${msg}`);
+		};
+		const closeMppSession = async (handler) => {
+			verbose("closing MPP session...");
+			try {
+				await handler.close();
+				verbose("session closed successfully");
+			} catch (closeErr) {
+				verbose(`session close failed: ${closeErr instanceof Error ? closeErr.message : String(closeErr)}`);
+			}
+		};
 		if (!url) {
 			if (isConfigured()) {
-				const { displayStatus } = await import("../status-BVIU3-b6.js");
+				const { displayStatus } = await import("../status-w5y-fhhe.js");
 				await displayStatus();
 				console.log();
 				console.log(pc.dim("  Commands:"));
@@ -170,28 +282,26 @@ Examples:
 				process.exit(1);
 			}
 			dim("  No wallet found. Let's set one up first.\n");
-			const { runSetup } = await import("../setup-Crq9TylJ.js");
+			const { runSetup } = await import("../setup-j_xQ14-4.js");
 			await runSetup();
 			console.log();
 			wallet = resolveWallet();
 			if (wallet.source === "none") return;
 		}
 		const config = loadConfig();
+		const resolvedProtocol = flags.protocol ?? config?.preferredProtocol;
+		const maxDeposit = config?.mppSessionBudget ?? "1";
+		verbose(`wallet source: ${wallet.source}`);
+		verbose(`protocol: ${resolvedProtocol ?? "auto-detect"}, maxDeposit: ${maxDeposit}`);
 		let preferredNetwork = config?.defaultNetwork;
 		if (!preferredNetwork && wallet.evmAddress && wallet.solanaAddress) {
-			const { fetchEvmBalances, fetchSolanaBalances } = await import("../wallet-BoY0fgX7.js");
-			const [evmBal, solBal] = await Promise.allSettled([fetchEvmBalances(wallet.evmAddress), fetchSolanaBalances(wallet.solanaAddress)]);
-			const evmUsdc = evmBal.status === "fulfilled" ? Number(evmBal.value?.usdc ?? 0) : 0;
-			const solUsdc = solBal.status === "fulfilled" ? Number(solBal.value?.usdc ?? 0) : 0;
+			const { fetchAllBalances } = await import("../wallet-DjixXCHy.js");
+			const balances = await fetchAllBalances(wallet.evmAddress, wallet.solanaAddress);
+			const evmUsdc = balances.evm ? Number(balances.evm.usdc) : 0;
+			const solUsdc = balances.sol ? Number(balances.sol.usdc) : 0;
 			if (evmUsdc > solUsdc) preferredNetwork = "base";
 			else if (solUsdc > evmUsdc) preferredNetwork = "solana";
 		}
-		const { x402Fetch, shiftPayment } = createX402ProxyHandler({ client: await buildX402Client(wallet, {
-			preferredNetwork,
-			network: flags.network,
-			spendLimitDaily: config?.spendLimitDaily,
-			spendLimitPerTx: config?.spendLimitPerTx
-		}) });
 		const headers = new Headers();
 		if (flags.header) for (const h of flags.header) {
 			const idx = h.indexOf(":");
@@ -200,22 +310,129 @@ Examples:
 		const method = flags.method || "GET";
 		const init = {
 			method,
-			headers
+			headers: Object.fromEntries(headers.entries())
 		};
 		if (flags.body) init.body = flags.body;
 		if (isTTY()) dim(`  ${method} ${parsedUrl.toString()}`);
 		const startMs = Date.now();
 		let response;
+		let x402Payment;
+		let mppPayment;
+		let usedProtocol;
 		try {
-			response = await x402Fetch(parsedUrl.toString(), init);
+			if (resolvedProtocol === "mpp") {
+				if (!wallet.evmKey) {
+					error("MPP requires an EVM wallet. Configure one with: npx x402-proxy setup");
+					process.exit(1);
+				}
+				const mppHandler = await createMppProxyHandler({
+					evmKey: wallet.evmKey,
+					maxDeposit
+				});
+				const isStreamingRequest = flags.body != null && /"stream"\s*:\s*true/.test(flags.body);
+				verbose(`mpp handler created, streaming: ${isStreamingRequest}`);
+				if (isStreamingRequest) {
+					try {
+						verbose("opening SSE session...");
+						const tokens = await mppHandler.sse(parsedUrl.toString(), init);
+						verbose("SSE stream opened, reading tokens...");
+						for await (const token of tokens) process.stdout.write(token);
+						verbose("SSE stream complete");
+					} finally {
+						await closeMppSession(mppHandler);
+					}
+					mppHandler.shiftPayment();
+					const closeReceipt = mppHandler.shiftPayment();
+					verbose(closeReceipt ? `close receipt: amount=${closeReceipt.amount ?? "none"}, channelId=${closeReceipt.channelId ?? "none"}, txHash=${closeReceipt.receipt?.txHash ?? "none"}` : "no close receipt (session close may have failed)");
+					mppPayment = closeReceipt ?? {
+						protocol: "mpp",
+						network: TEMPO_NETWORK,
+						intent: "session"
+					};
+					usedProtocol = "mpp";
+					const elapsedMs = Date.now() - startMs;
+					const spentAmount = mppPayment.amount ? Number(mppPayment.amount) : void 0;
+					if (mppPayment && isTTY()) info(`  MPP session: ${spentAmount != null ? `${spentAmount.toFixed(4)} USDC ` : ""}(${displayNetwork(mppPayment.network)})`);
+					if (isTTY()) dim(`  Streamed (${elapsedMs}ms)`);
+					if (mppPayment) {
+						const record = {
+							t: Date.now(),
+							ok: true,
+							kind: "mpp_payment",
+							net: mppPayment.network,
+							from: wallet.evmAddress ?? "unknown",
+							tx: mppPayment.receipt?.reference ?? mppPayment.channelId,
+							amount: spentAmount,
+							token: "USDC",
+							ms: elapsedMs,
+							label: parsedUrl.hostname
+						};
+						appendHistory(getHistoryPath(), record);
+					}
+					if (isTTY()) process.stdout.write("\n");
+					return;
+				}
+				verbose("sending non-streaming MPP request...");
+				try {
+					response = await mppHandler.fetch(parsedUrl.toString(), init);
+					verbose(`response: ${response.status} ${response.statusText}`);
+				} finally {
+					await closeMppSession(mppHandler);
+				}
+				mppPayment = mppHandler.shiftPayment();
+				usedProtocol = "mpp";
+			} else if (resolvedProtocol === "x402") {
+				const handler = createX402ProxyHandler({ client: await buildX402Client(wallet, {
+					preferredNetwork,
+					network: flags.network,
+					spendLimitDaily: config?.spendLimitDaily,
+					spendLimitPerTx: config?.spendLimitPerTx
+				}) });
+				response = await handler.x402Fetch(parsedUrl.toString(), init);
+				x402Payment = handler.shiftPayment();
+				usedProtocol = "x402";
+			} else {
+				const handler = createX402ProxyHandler({ client: await buildX402Client(wallet, {
+					preferredNetwork,
+					network: flags.network,
+					spendLimitDaily: config?.spendLimitDaily,
+					spendLimitPerTx: config?.spendLimitPerTx
+				}) });
+				response = await handler.x402Fetch(parsedUrl.toString(), init);
+				x402Payment = handler.shiftPayment();
+				usedProtocol = "x402";
+				if (response.status === 402 && wallet.evmKey) {
+					const detected = detectProtocols(response);
+					verbose(`auto-detect: x402=${detected.x402}, mpp=${detected.mpp}`);
+					if (detected.mpp) {
+						verbose("falling through to MPP...");
+						const mppHandler = await createMppProxyHandler({
+							evmKey: wallet.evmKey,
+							maxDeposit
+						});
+						try {
+							response = await mppHandler.fetch(parsedUrl.toString(), init);
+							verbose(`MPP response: ${response.status} ${response.statusText}`);
+						} finally {
+							await closeMppSession(mppHandler);
+						}
+						mppPayment = mppHandler.shiftPayment();
+						x402Payment = void 0;
+						usedProtocol = "mpp";
+					}
+				}
+			}
 		} catch (err) {
 			error(`Request failed: ${err instanceof Error ? err.message : String(err)}`);
 			process.exit(1);
 		}
 		const elapsedMs = Date.now() - startMs;
-		const payment = shiftPayment();
+		const payment = x402Payment ?? mppPayment;
 		const txSig = extractTxSignature(response);
+		verbose(`protocol used: ${usedProtocol ?? "none"}`);
+		for (const [k, v] of response.headers) if (/payment|auth|www|x-pay/i.test(k)) verbose(`header ${k}: ${v.slice(0, 200)}`);
 		if (response.status === 402 && isTTY()) {
+			const detected = detectProtocols(response);
 			const prHeader = response.headers.get("PAYMENT-REQUIRED") ?? response.headers.get("X-PAYMENT-REQUIRED");
 			let accepts = [];
 			if (prHeader) try {
@@ -230,19 +447,14 @@ Examples:
 			}
 			const hasEvm = accepts.some((a) => a.network.startsWith("eip155:"));
 			const hasSolana = accepts.some((a) => a.network.startsWith("solana:"));
+			const hasMpp = detected.mpp;
 			const hasOther = accepts.some((a) => !a.network.startsWith("eip155:") && !a.network.startsWith("solana:"));
-			const { fetchEvmBalances, fetchSolanaBalances } = await import("../wallet-BoY0fgX7.js");
-			let evmUsdc = 0;
-			let solUsdc = 0;
-			if (hasEvm && wallet.evmAddress) try {
-				const bal = await fetchEvmBalances(wallet.evmAddress);
-				evmUsdc = Number(bal.usdc);
-			} catch {}
-			if (hasSolana && wallet.solanaAddress) try {
-				const bal = await fetchSolanaBalances(wallet.solanaAddress);
-				solUsdc = Number(bal.usdc);
-			} catch {}
-			if (hasEvm && evmUsdc >= costNum || hasSolana && solUsdc >= costNum) {
+			const { fetchAllBalances } = await import("../wallet-DjixXCHy.js");
+			const balances = await fetchAllBalances(wallet.evmAddress, wallet.solanaAddress);
+			const evmUsdc = hasEvm && balances.evm ? Number(balances.evm.usdc) : 0;
+			const solUsdc = hasSolana && balances.sol ? Number(balances.sol.usdc) : 0;
+			const tempoUsdc = hasMpp && balances.tempo ? Number(balances.tempo.usdc) : 0;
+			if (hasEvm && evmUsdc >= costNum || hasSolana && solUsdc >= costNum || hasMpp && tempoUsdc >= costNum) {
 				let serverReason;
 				try {
 					const body = await response.text();
@@ -257,24 +469,30 @@ Examples:
 				else dim("  Payment was not attempted despite sufficient balance.");
 				if (serverReason) dim(`  Reason: ${serverReason}`);
 				if (hasEvm && wallet.evmAddress && evmUsdc > 0) console.error(`    Base:   ${pc.cyan(wallet.evmAddress)} ${pc.dim(`(${evmUsdc.toFixed(4)} USDC)`)}`);
+				if (hasMpp && wallet.evmAddress && tempoUsdc > 0) console.error(`    Tempo:  ${pc.cyan(wallet.evmAddress)} ${pc.dim(`(${tempoUsdc.toFixed(4)} USDC)`)}`);
 				if (hasSolana && wallet.solanaAddress && solUsdc > 0) console.error(`    Solana: ${pc.cyan(wallet.solanaAddress)} ${pc.dim(`(${solUsdc.toFixed(4)} USDC)`)}`);
 				console.error();
 				dim("  This may be a temporary server-side issue. Try again in a moment.");
 				console.error();
 			} else {
 				error(`Payment required: ${costStr} USDC`);
-				if (hasEvm || hasSolana) {
+				if (hasEvm || hasSolana || hasMpp) {
 					console.error();
 					dim("  Fund your wallet with USDC:");
 					if (hasEvm && wallet.evmAddress) {
 						const balHint = evmUsdc > 0 ? pc.dim(` (${evmUsdc.toFixed(4)} USDC)`) : "";
 						console.error(`    Base:   ${pc.cyan(wallet.evmAddress)}${balHint}`);
 					}
+					if (hasMpp && wallet.evmAddress) {
+						const balHint = tempoUsdc > 0 ? pc.dim(` (${tempoUsdc.toFixed(4)} USDC)`) : "";
+						console.error(`    Tempo:  ${pc.cyan(wallet.evmAddress)}${balHint}`);
+					}
 					if (hasSolana && wallet.solanaAddress) {
 						const balHint = solUsdc > 0 ? pc.dim(` (${solUsdc.toFixed(4)} USDC)`) : "";
 						console.error(`    Solana: ${pc.cyan(wallet.solanaAddress)}${balHint}`);
 					}
 					if (hasEvm && !wallet.evmAddress) dim("    Base:   endpoint accepts EVM but no EVM wallet configured");
+					if (hasMpp && !wallet.evmAddress) dim("    Tempo:  endpoint accepts MPP but no EVM wallet configured");
 					if (hasSolana && !wallet.solanaAddress) dim("    Solana: endpoint accepts Solana but no Solana wallet configured");
 				} else if (hasOther) {
 					const networks = [...new Set(accepts.map((a) => a.network))].join(", ");
@@ -289,21 +507,35 @@ Examples:
 			return;
 		}
 		if (payment && isTTY()) {
-			info(`  Payment: ${payment.amount ? (Number(payment.amount) / 1e6).toFixed(4) : "?"} USDC (${displayNetwork(payment.network ?? "unknown")})`);
+			if (usedProtocol === "mpp" && mppPayment) info(`  Payment: MPP (${displayNetwork(mppPayment.network)})`);
+			else if (x402Payment) info(`  Payment: ${x402Payment.amount ? (Number(x402Payment.amount) / 1e6).toFixed(4) : "?"} USDC (${displayNetwork(x402Payment.network ?? "unknown")})`);
 			if (txSig) dim(`  Tx: ${txSig}`);
 		}
 		if (isTTY()) dim(`  ${response.status} ${response.statusText} (${elapsedMs}ms)`);
-		if (payment) {
-			ensureConfigDir();
+		if (x402Payment) {
 			const record = {
 				t: Date.now(),
 				ok: response.ok,
 				kind: "x402_payment",
-				net: payment.network ?? "unknown",
+				net: x402Payment.network ?? "unknown",
 				from: wallet.evmAddress ?? wallet.solanaAddress ?? "unknown",
-				to: payment.payTo,
+				to: x402Payment.payTo,
 				tx: txSig,
-				amount: payment.amount ? Number(payment.amount) / 1e6 : void 0,
+				amount: x402Payment.amount ? Number(x402Payment.amount) / 1e6 : void 0,
+				token: "USDC",
+				ms: elapsedMs,
+				label: parsedUrl.hostname
+			};
+			appendHistory(getHistoryPath(), record);
+		} else if (mppPayment) {
+			const record = {
+				t: Date.now(),
+				ok: response.ok,
+				kind: "mpp_payment",
+				net: mppPayment.network,
+				from: wallet.evmAddress ?? "unknown",
+				tx: mppPayment.receipt?.reference ?? txSig,
+				amount: mppPayment.amount ? Number(mppPayment.amount) : void 0,
 				token: "USDC",
 				ms: elapsedMs,
 				label: parsedUrl.hostname
@@ -330,8 +562,8 @@ Examples:
 //#region src/commands/mcp.ts
 const mcpCommand = buildCommand({
 	docs: {
-		brief: "Start MCP stdio proxy with x402 payment",
-		fullDescription: `Start an MCP stdio proxy with automatic x402 payment for AI agents.
+		brief: "Start MCP stdio proxy with automatic payment",
+		fullDescription: `Start an MCP stdio proxy with automatic payment (x402 or MPP) for AI agents.
 
 Add to your MCP client config (Claude, Cursor, etc.):
   "command": "npx",
@@ -354,7 +586,13 @@ Add to your MCP client config (Claude, Cursor, etc.):
 			},
 			network: {
 				kind: "parsed",
-				brief: "Require specific network (base, solana)",
+				brief: "Require specific network (base, solana, tempo)",
+				parse: String,
+				optional: true
+			},
+			protocol: {
+				kind: "parsed",
+				brief: "Payment protocol (x402, mpp)",
 				parse: String,
 				optional: true
 			}
@@ -380,132 +618,244 @@ Add to your MCP client config (Claude, Cursor, etc.):
 		if (wallet.evmAddress) dim(`  EVM:    ${wallet.evmAddress}`);
 		if (wallet.solanaAddress) dim(`  Solana: ${wallet.solanaAddress}`);
 		const config = loadConfig();
-		let preferredNetwork = config?.defaultNetwork;
-		if (!preferredNetwork && wallet.evmAddress && wallet.solanaAddress) {
-			const { fetchEvmBalances, fetchSolanaBalances } = await import("../wallet-BoY0fgX7.js");
-			const [evmBal, solBal] = await Promise.allSettled([fetchEvmBalances(wallet.evmAddress), fetchSolanaBalances(wallet.solanaAddress)]);
-			const evmUsdc = evmBal.status === "fulfilled" ? Number(evmBal.value?.usdc ?? 0) : 0;
-			const solUsdc = solBal.status === "fulfilled" ? Number(solBal.value?.usdc ?? 0) : 0;
-			if (evmUsdc > solUsdc) preferredNetwork = "base";
-			else if (solUsdc > evmUsdc) preferredNetwork = "solana";
-		}
-		const x402PaymentClient = await buildX402Client(wallet, {
-			preferredNetwork,
-			network: flags.network,
-			spendLimitDaily: config?.spendLimitDaily,
-			spendLimitPerTx: config?.spendLimitPerTx
-		});
+		const resolvedProtocol = flags.protocol ?? config?.preferredProtocol ?? "x402";
 		const { Client } = await import("@modelcontextprotocol/sdk/client/index.js");
 		const { SSEClientTransport } = await import("@modelcontextprotocol/sdk/client/sse.js");
 		const { StreamableHTTPClientTransport } = await import("@modelcontextprotocol/sdk/client/streamableHttp.js");
 		const { Server } = await import("@modelcontextprotocol/sdk/server/index.js");
 		const { StdioServerTransport } = await import("@modelcontextprotocol/sdk/server/stdio.js");
-		const { x402MCPClient } = await import("@x402/mcp");
-		const remoteClient = new Client({
-			name: "x402-proxy",
-			version: "0.5.2"
-		});
-		const x402Mcp = new x402MCPClient(remoteClient, x402PaymentClient, {
-			autoPayment: true,
-			onPaymentRequested: (ctx) => {
-				const accept = ctx.paymentRequired.accepts?.[0];
-				if (accept) warn(`  Payment: ${accept.amount ? (Number(accept.amount) / 1e6).toFixed(4) : "?"} USDC on ${displayNetwork(accept.network)} for tool "${ctx.toolName}"`);
-				return true;
+		const { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ToolListChangedNotificationSchema, ResourceListChangedNotificationSchema } = await import("@modelcontextprotocol/sdk/types.js");
+		async function connectTransport(target) {
+			try {
+				const transport = new StreamableHTTPClientTransport(new URL(remoteUrl));
+				await target.connect(transport);
+				dim("  Connected via StreamableHTTP");
+				return;
+			} catch {}
+			try {
+				const transport = new SSEClientTransport(new URL(remoteUrl));
+				await target.connect(transport);
+				dim("  Connected via SSE");
+			} catch (err) {
+				error(`Failed to connect to ${remoteUrl}: ${err instanceof Error ? err.message : String(err)}`);
+				process.exit(1);
 			}
-		});
-		x402Mcp.onAfterPayment(async (ctx) => {
-			ensureConfigDir();
-			const accepted = ctx.paymentPayload.accepted;
-			const tx = ctx.settleResponse?.transaction;
-			const record = {
-				t: Date.now(),
-				ok: true,
-				kind: "x402_payment",
-				net: accepted?.network ?? "unknown",
-				from: wallet.evmAddress ?? wallet.solanaAddress ?? "unknown",
-				to: accepted?.payTo,
-				tx: typeof tx === "string" ? tx : void 0,
-				amount: accepted?.amount ? Number(accepted.amount) / 1e6 : void 0,
-				token: "USDC",
-				label: `mcp:${ctx.toolName}`
-			};
-			appendHistory(getHistoryPath(), record);
-		});
-		let connected = false;
-		try {
-			const transport = new StreamableHTTPClientTransport(new URL(remoteUrl));
-			await x402Mcp.connect(transport);
-			connected = true;
-			dim("  Connected via StreamableHTTP");
-		} catch {}
-		if (!connected) try {
-			const transport = new SSEClientTransport(new URL(remoteUrl));
-			await x402Mcp.connect(transport);
-			connected = true;
-			dim("  Connected via SSE");
-		} catch (err) {
-			error(`Failed to connect to ${remoteUrl}: ${err instanceof Error ? err.message : String(err)}`);
-			process.exit(1);
 		}
-		let { tools } = await x402Mcp.listTools();
-		dim(`  ${tools.length} tools available`);
-		let remoteResources = [];
-		try {
-			remoteResources = (await x402Mcp.listResources()).resources;
-			if (remoteResources.length > 0) dim(`  ${remoteResources.length} resources available`);
-		} catch {
-			dim("  Resources not available from remote");
-		}
-		const localServer = new Server({
-			name: "x402-proxy",
-			version: "0.5.2"
-		}, { capabilities: {
-			tools: tools.length > 0 ? {} : void 0,
-			resources: remoteResources.length > 0 ? {} : void 0
-		} });
-		const { ListToolsRequestSchema, CallToolRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ToolListChangedNotificationSchema, ResourceListChangedNotificationSchema } = await import("@modelcontextprotocol/sdk/types.js");
-		localServer.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: tools.map((t) => ({
-			name: t.name,
-			description: t.description,
-			inputSchema: t.inputSchema,
-			annotations: t.annotations
-		})) }));
-		localServer.setRequestHandler(CallToolRequestSchema, async (request) => {
-			const { name, arguments: args } = request.params;
-			const result = await x402Mcp.callTool(name, args ?? {});
-			return {
-				content: result.content,
-				isError: result.isError
+		if (resolvedProtocol === "mpp") await startMppProxy();
+		else await startX402Proxy();
+		async function startX402Proxy() {
+			let preferredNetwork = config?.defaultNetwork;
+			if (!preferredNetwork && wallet.evmAddress && wallet.solanaAddress) {
+				const { fetchAllBalances } = await import("../wallet-DjixXCHy.js");
+				const balances = await fetchAllBalances(wallet.evmAddress, wallet.solanaAddress);
+				const evmUsdc = balances.evm ? Number(balances.evm.usdc) : 0;
+				const solUsdc = balances.sol ? Number(balances.sol.usdc) : 0;
+				if (evmUsdc > solUsdc) preferredNetwork = "base";
+				else if (solUsdc > evmUsdc) preferredNetwork = "solana";
+			}
+			const x402PaymentClient = await buildX402Client(wallet, {
+				preferredNetwork,
+				network: flags.network,
+				spendLimitDaily: config?.spendLimitDaily,
+				spendLimitPerTx: config?.spendLimitPerTx
+			});
+			const { x402MCPClient } = await import("@x402/mcp");
+			const remoteClient = new Client({
+				name: "x402-proxy",
+				version: "0.7.0"
+			});
+			const x402Mcp = new x402MCPClient(remoteClient, x402PaymentClient, {
+				autoPayment: true,
+				onPaymentRequested: (ctx) => {
+					const accept = ctx.paymentRequired.accepts?.[0];
+					if (accept) warn(`  Payment: ${accept.amount ? (Number(accept.amount) / 1e6).toFixed(4) : "?"} USDC on ${displayNetwork(accept.network)} for tool "${ctx.toolName}"`);
+					return true;
+				}
+			});
+			x402Mcp.onAfterPayment(async (ctx) => {
+				const accepted = ctx.paymentPayload.accepted;
+				const tx = ctx.settleResponse?.transaction;
+				const record = {
+					t: Date.now(),
+					ok: true,
+					kind: "x402_payment",
+					net: accepted?.network ?? "unknown",
+					from: wallet.evmAddress ?? wallet.solanaAddress ?? "unknown",
+					to: accepted?.payTo,
+					tx: typeof tx === "string" ? tx : void 0,
+					amount: accepted?.amount ? Number(accepted.amount) / 1e6 : void 0,
+					token: "USDC",
+					label: `mcp:${ctx.toolName}`
+				};
+				appendHistory(getHistoryPath(), record);
+			});
+			await connectTransport(x402Mcp);
+			let { tools } = await x402Mcp.listTools();
+			dim(`  ${tools.length} tools available`);
+			let remoteResources = [];
+			try {
+				remoteResources = (await x402Mcp.listResources()).resources;
+				if (remoteResources.length > 0) dim(`  ${remoteResources.length} resources available`);
+			} catch {
+				dim("  Resources not available from remote");
+			}
+			const localServer = new Server({
+				name: "x402-proxy",
+				version: "0.7.0"
+			}, { capabilities: {
+				tools: tools.length > 0 ? {} : void 0,
+				resources: remoteResources.length > 0 ? {} : void 0
+			} });
+			localServer.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: tools.map((t) => ({
+				name: t.name,
+				description: t.description,
+				inputSchema: t.inputSchema,
+				annotations: t.annotations
+			})) }));
+			localServer.setRequestHandler(CallToolRequestSchema, async (request) => {
+				const { name, arguments: args } = request.params;
+				const result = await x402Mcp.callTool(name, args ?? {});
+				return {
+					content: result.content,
+					isError: result.isError
+				};
+			});
+			if (remoteResources.length > 0) {
+				localServer.setRequestHandler(ListResourcesRequestSchema, async () => ({ resources: remoteResources.map((r) => ({
+					name: r.name,
+					uri: r.uri,
+					description: r.description,
+					mimeType: r.mimeType
+				})) }));
+				localServer.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+					return { contents: (await x402Mcp.readResource({ uri: request.params.uri })).contents.map((c) => ({ ...c })) };
+				});
+			}
+			remoteClient.setNotificationHandler(ToolListChangedNotificationSchema, async () => {
+				tools = (await x402Mcp.listTools()).tools;
+				dim(`  Tools updated: ${tools.length} available`);
+				await localServer.notification({ method: "notifications/tools/list_changed" });
+			});
+			if (remoteResources.length > 0) remoteClient.setNotificationHandler(ResourceListChangedNotificationSchema, async () => {
+				remoteResources = (await x402Mcp.listResources()).resources;
+				dim(`  Resources updated: ${remoteResources.length} available`);
+				await localServer.notification({ method: "notifications/resources/list_changed" });
+			});
+			const stdioTransport = new StdioServerTransport();
+			await localServer.connect(stdioTransport);
+			dim("  MCP proxy running (stdio, x402)");
+			let closing = false;
+			const cleanup = async () => {
+				if (closing) return;
+				closing = true;
+				await x402Mcp.close();
+				process.exit(0);
 			};
-		});
-		if (remoteResources.length > 0) {
-			localServer.setRequestHandler(ListResourcesRequestSchema, async () => ({ resources: remoteResources.map((r) => ({
-				name: r.name,
-				uri: r.uri,
-				description: r.description,
-				mimeType: r.mimeType
+			process.stdin.on("end", cleanup);
+			process.on("SIGINT", cleanup);
+			process.on("SIGTERM", cleanup);
+		}
+		async function startMppProxy() {
+			if (!wallet.evmKey) {
+				error("MPP requires an EVM wallet. Configure one with: npx x402-proxy setup");
+				process.exit(1);
+			}
+			const { tempo } = await import("mppx/client");
+			const { McpClient } = await import("mppx/mcp-sdk/client");
+			const { privateKeyToAccount } = await import("viem/accounts");
+			const account = privateKeyToAccount(wallet.evmKey);
+			const maxDeposit = config?.mppSessionBudget ?? "1";
+			const remoteClient = new Client({
+				name: "x402-proxy",
+				version: "0.7.0"
+			});
+			await connectTransport(remoteClient);
+			const mppClient = McpClient.wrap(remoteClient, { methods: [tempo({
+				account,
+				maxDeposit
+			})] });
+			let { tools } = await remoteClient.listTools();
+			dim(`  ${tools.length} tools available`);
+			let remoteResources = [];
+			try {
+				remoteResources = (await remoteClient.listResources()).resources;
+				if (remoteResources.length > 0) dim(`  ${remoteResources.length} resources available`);
+			} catch {
+				dim("  Resources not available from remote");
+			}
+			const localServer = new Server({
+				name: "x402-proxy",
+				version: "0.7.0"
+			}, { capabilities: {
+				tools: tools.length > 0 ? {} : void 0,
+				resources: remoteResources.length > 0 ? {} : void 0
+			} });
+			localServer.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: tools.map((t) => ({
+				name: t.name,
+				description: t.description,
+				inputSchema: t.inputSchema,
+				annotations: t.annotations
 			})) }));
-			localServer.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-				return { contents: (await x402Mcp.readResource({ uri: request.params.uri })).contents.map((c) => ({ ...c })) };
+			localServer.setRequestHandler(CallToolRequestSchema, async (request) => {
+				const { name, arguments: args } = request.params;
+				const result = await mppClient.callTool({
+					name,
+					arguments: args ?? {}
+				});
+				if (result.receipt) {
+					const record = {
+						t: Date.now(),
+						ok: true,
+						kind: "mpp_payment",
+						net: TEMPO_NETWORK,
+						from: wallet.evmAddress ?? "unknown",
+						tx: result.receipt.reference,
+						token: "USDC",
+						label: `mcp:${name}`
+					};
+					appendHistory(getHistoryPath(), record);
+					warn(`  MPP payment for tool "${name}" (Tempo)`);
+				}
+				return {
+					content: result.content,
+					isError: result.isError
+				};
 			});
+			if (remoteResources.length > 0) {
+				localServer.setRequestHandler(ListResourcesRequestSchema, async () => ({ resources: remoteResources.map((r) => ({
+					name: r.name,
+					uri: r.uri,
+					description: r.description,
+					mimeType: r.mimeType
+				})) }));
+				localServer.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+					return { contents: (await remoteClient.readResource({ uri: request.params.uri })).contents.map((c) => ({ ...c })) };
+				});
+			}
+			remoteClient.setNotificationHandler(ToolListChangedNotificationSchema, async () => {
+				tools = (await remoteClient.listTools()).tools;
+				dim(`  Tools updated: ${tools.length} available`);
+				await localServer.notification({ method: "notifications/tools/list_changed" });
+			});
+			if (remoteResources.length > 0) remoteClient.setNotificationHandler(ResourceListChangedNotificationSchema, async () => {
+				remoteResources = (await remoteClient.listResources()).resources;
+				dim(`  Resources updated: ${remoteResources.length} available`);
+				await localServer.notification({ method: "notifications/resources/list_changed" });
+			});
+			const stdioTransport = new StdioServerTransport();
+			await localServer.connect(stdioTransport);
+			dim("  MCP proxy running (stdio, mpp)");
+			let closing = false;
+			const cleanup = async () => {
+				if (closing) return;
+				closing = true;
+				await remoteClient.close();
+				process.exit(0);
+			};
+			process.stdin.on("end", cleanup);
+			process.on("SIGINT", cleanup);
+			process.on("SIGTERM", cleanup);
 		}
-		remoteClient.setNotificationHandler(ToolListChangedNotificationSchema, async () => {
-			tools = (await x402Mcp.listTools()).tools;
-			dim(`  Tools updated: ${tools.length} available`);
-			await localServer.notification({ method: "notifications/tools/list_changed" });
-		});
-		if (remoteResources.length > 0) remoteClient.setNotificationHandler(ResourceListChangedNotificationSchema, async () => {
-			remoteResources = (await x402Mcp.listResources()).resources;
-			dim(`  Resources updated: ${remoteResources.length} available`);
-			await localServer.notification({ method: "notifications/resources/list_changed" });
-		});
-		const stdioTransport = new StdioServerTransport();
-		await localServer.connect(stdioTransport);
-		dim("  MCP proxy running (stdio)");
-		process.stdin.on("end", async () => {
-			await x402Mcp.close();
-			process.exit(0);
-		});
 	}
 });
 
@@ -635,7 +985,7 @@ const routes = buildRouteMap({
 });
 const app = buildApplication(routes, {
 	name: "x402-proxy",
-	versionInfo: { currentVersion: "0.5.2" },
+	versionInfo: { currentVersion: "0.7.0" },
 	scanner: { caseStyle: "allow-kebab-for-camel" }
 });