x402-proxy 0.9.4 → 0.10.1

package/dist/bin/cli.js

@@ -1,16 +1,1063 @@
 #!/usr/bin/env node
-import { a as getHistoryPath, c as loadConfig, i as getConfigDirShort, l as loadWalletFile, s as isConfigured, u as saveConfig } from "../derive-EDXzwKW2.js";
-import { _ as error, b as warn, c as resolveWallet, d as displayNetwork, f as formatAmount, g as dim, h as readHistory, l as appendHistory, m as formatUsdcValue, n as fetchAllBalances, o as walletInfoCommand, p as formatTxLine, s as buildX402Client, u as calcSpend, v as info, y as isTTY } from "../wallet-CqUc-ZFn.js";
-import { n as setupCommand, t as runSetup } from "../setup-Dp5fS7ob.js";
-import { n as statusCommand } from "../status-BZTToWE_.js";
+import { _ as error, b as success, c as resolveWallet, d as displayNetwork, f as formatAmount, g as dim, h as readHistory, l as appendHistory, m as formatUsdcValue, n as fetchAllBalances, o as walletInfoCommand, p as formatTxLine, s as buildX402Client, u as calcSpend, v as info, x as warn, y as isTTY } from "../wallet-DqGROXlC.js";
+import { a as getHistoryPath, c as loadConfig, i as getConfigDirShort, l as loadWalletFile, s as isConfigured, u as saveConfig } from "../derive-CY0En_Y3.js";
+import { n as setupCommand, t as runSetup } from "../setup-DtKrojW1.js";
+import { n as statusCommand } from "../status-B5oH1nHv.js";
 import { dirname, join, normalize, resolve } from "node:path";
 import { buildApplication, buildCommand, buildRouteMap, run } from "@stricli/core";
+import { spawn } from "node:child_process";
 import pc from "picocolors";
+import { once } from "node:events";
+import http from "node:http";
+import { decodePaymentResponseHeader, wrapFetchWithPayment } from "@x402/fetch";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
-import { decodePaymentResponseHeader, wrapFetchWithPayment } from "@x402/fetch";
 import { base58 } from "@scure/base";
+import "@sinclair/typebox";
 import * as prompts from "@clack/prompts";
+//#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 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/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 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.
+*/
+function createX402ProxyHandler(opts) {
+	const { client } = opts;
+	const paymentQueue = [];
+	client.onAfterPaymentCreation(async (hookCtx) => {
+		const raw = hookCtx.selectedRequirements.amount;
+		paymentQueue.push({
+			protocol: "x402",
+			network: hookCtx.selectedRequirements.network,
+			payTo: hookCtx.selectedRequirements.payTo,
+			amount: raw,
+			asset: hookCtx.selectedRequirements.asset
+		});
+	});
+	return {
+		x402Fetch: wrapFetchWithPayment(globalThis.fetch, client),
+		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/openclaw/tools.ts
+const SOL_MAINNET = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+const USDC_DECIMALS = 6;
+function paymentAmount(payment) {
+	if (!payment?.amount) return void 0;
+	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 addressForNetwork(evmAddress, solanaAddress, network) {
+	if (network?.startsWith("eip155:")) return evmAddress ?? solanaAddress;
+	if (network?.startsWith("solana:")) return solanaAddress ?? evmAddress;
+	return solanaAddress ?? evmAddress;
+}
+//#endregion
+//#region src/openclaw/route.ts
+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" });
+			res.end(JSON.stringify({ error: {
+				message: "Wallet not loaded yet",
+				code: "not_ready"
+			} }));
+			return true;
+		}
+		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");
+		const HOP_BY_HOP = new Set([
+			"authorization",
+			"host",
+			"connection",
+			"content-length",
+			"transfer-encoding",
+			"keep-alive",
+			"te",
+			"upgrade"
+		]);
+		const headers = {};
+		for (const [key, val] of Object.entries(req.headers)) {
+			if (HOP_BY_HOP.has(key)) continue;
+			if (typeof val === "string") headers[key] = val;
+		}
+		const isChatCompletion = pathSuffix.includes("/chat/completions");
+		let thinkingMode;
+		if (isChatCompletion && body) try {
+			const parsed = JSON.parse(body);
+			if (parsed.reasoning_effort) thinkingMode = String(parsed.reasoning_effort);
+			if (!parsed.stream_options) {
+				parsed.stream_options = { include_usage: true };
+				body = JSON.stringify(parsed);
+			}
+		} catch {}
+		const method = req.method ?? "GET";
+		const startMs = Date.now();
+		try {
+			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: paymentNetwork,
+					from: paymentFrom,
+					to: payment?.payTo,
+					amount,
+					token: amount != null ? "USDC" : void 0,
+					ms: Date.now() - startMs,
+					error: "payment_required"
+				});
+				let userMessage;
+				if (responseBody.includes("simulation") || responseBody.includes("Simulation")) userMessage = `Insufficient USDC or SOL in wallet ${walletAddress}. Fund it with USDC (SPL token) to pay for inference.`;
+				else if (responseBody.includes("insufficient") || responseBody.includes("balance")) userMessage = `Insufficient funds in wallet ${walletAddress}. Top up with USDC on Solana mainnet.`;
+				else userMessage = `x402 payment failed: ${responseBody.substring(0, 200) || "unknown error"}. Wallet: ${walletAddress}`;
+				res.writeHead(402, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({ error: {
+					message: userMessage,
+					type: "x402_payment_error",
+					code: "payment_failed"
+				} }));
+				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: paymentNetwork,
+					from: paymentFrom,
+					to: payment?.payTo,
+					amount,
+					token: amount != null ? "USDC" : void 0,
+					ms: Date.now() - startMs,
+					error: `upstream_${response.status}`
+				});
+				res.writeHead(502, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({ error: {
+					message: `LLM provider temporarily unavailable (HTTP ${response.status}). Try again shortly.`,
+					type: "x402_upstream_error",
+					code: "upstream_failed"
+				} }));
+				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);
+			if (!response.body) {
+				res.end();
+				appendHistory(historyPath, {
+					t: Date.now(),
+					ok: true,
+					kind: "x402_inference",
+					net: paymentNetwork,
+					from: paymentFrom,
+					to: payment?.payTo,
+					tx: txSig,
+					amount,
+					token: "USDC",
+					ms: Date.now() - startMs
+				});
+				return true;
+			}
+			const ct = response.headers.get("content-type") || "";
+			const sse = isChatCompletion && ct.includes("text/event-stream") ? createSseTracker() : null;
+			const reader = response.body.getReader();
+			const decoder = new TextDecoder();
+			try {
+				while (true) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					res.write(value);
+					sse?.push(decoder.decode(value, { stream: true }));
+				}
+			} finally {
+				reader.releaseLock();
+			}
+			res.end();
+			const durationMs = Date.now() - startMs;
+			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: paymentNetwork,
+					from: paymentFrom,
+					to: payment?.payTo,
+					tx: txSig,
+					amount,
+					token: "USDC",
+					provider: allModels.find((m) => m.id === model || `${m.provider}/${m.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: paymentFrom,
+					to: payment?.payTo,
+					tx: txSig,
+					amount,
+					token: "USDC",
+					ms: durationMs
+				});
+			}
+			else appendHistory(historyPath, {
+				t: Date.now(),
+				ok: true,
+				kind: "x402_inference",
+				net: paymentNetwork,
+				from: paymentFrom,
+				to: payment?.payTo,
+				tx: txSig,
+				amount,
+				token: "USDC",
+				ms: durationMs
+			});
+			return true;
+		} catch (err) {
+			const msg = String(err);
+			logger.error(`x402: fetch threw: ${msg}`);
+			getX402Proxy()?.shiftPayment();
+			appendHistory(historyPath, {
+				t: Date.now(),
+				ok: false,
+				kind: "x402_inference",
+				net: SOL_MAINNET,
+				from: walletAddress,
+				ms: Date.now() - startMs,
+				error: msg.substring(0, 200)
+			});
+			let userMessage;
+			if (msg.includes("Simulation failed") || msg.includes("simulation")) userMessage = `Insufficient USDC or SOL in wallet ${walletAddress}. Fund it with USDC and SOL to pay for inference.`;
+			else if (msg.includes("Failed to create payment")) userMessage = `x402 payment creation failed: ${msg}. Wallet: ${walletAddress}`;
+			else userMessage = `x402 request failed: ${msg}`;
+			if (!res.headersSent) {
+				res.writeHead(402, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({ error: {
+					message: userMessage,
+					type: "x402_payment_error",
+					code: "payment_failed"
+				} }));
+			}
+			return true;
+		}
+	};
+}
+function createSseTracker() {
+	let residual = "";
+	let lastDataLine = "";
+	return {
+		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/commands/serve.ts
+async function resolveWalletForServe(flags) {
+	let wallet = resolveWallet({
+		evmKey: flags.evmKey,
+		solanaKey: flags.solanaKey
+	});
+	if (wallet.source !== "none") return wallet;
+	const { runSetup } = await import("../setup-EX1_teNg.js");
+	if (isTTY()) {
+		dim("  No wallet found. Let's set one up first.\n");
+		await runSetup();
+	} else {
+		dim("No wallet found. Auto-generating...");
+		await runSetup({ nonInteractive: true });
+	}
+	wallet = resolveWallet({
+		evmKey: flags.evmKey,
+		solanaKey: flags.solanaKey
+	});
+	if (wallet.source === "none") {
+		error("Wallet setup failed. Run: $ npx x402-proxy setup");
+		process.exit(1);
+	}
+	return wallet;
+}
+async function detectPreferredNetwork(wallet) {
+	if (!wallet.evmAddress || !wallet.solanaAddress) return;
+	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) return "base";
+	if (solUsdc > evmUsdc) return "solana";
+}
+function walletAddressForNetwork(wallet, network) {
+	return addressForNetwork(wallet.evmAddress ?? null, wallet.solanaAddress ?? null, network);
+}
+function createRequestHandler(routeHandler) {
+	return (req, res) => {
+		routeHandler(req, res).then((handled) => {
+			if (!handled && !res.headersSent) {
+				res.writeHead(404, { "Content-Type": "application/json" });
+				res.end(JSON.stringify({ error: {
+					message: "Not found",
+					code: "not_found"
+				} }));
+			}
+		}).catch((err) => {
+			if (!res.headersSent) res.writeHead(500, { "Content-Type": "application/json" });
+			res.end(JSON.stringify({ error: {
+				message: err instanceof Error ? err.message : String(err),
+				code: "proxy_failed"
+			} }));
+		});
+	};
+}
+async function startServeServer(options = {}) {
+	const config = loadConfig();
+	const wallet = await resolveWalletForServe(options);
+	const resolvedProtocol = resolveProtocol(options.protocol ?? config?.preferredProtocol);
+	const configuredMppBudget = resolveMppSessionBudget(config?.mppSessionBudget);
+	const preferredNetwork = config?.defaultNetwork ?? await detectPreferredNetwork(wallet);
+	const upstreamUrl = options.upstreamUrl ?? "https://surf.cascade.fyi/api/v1/inference";
+	const x402Proxy = createX402ProxyHandler({ client: await buildX402Client(wallet, {
+		preferredNetwork: preferredNetwork || void 0,
+		network: options.network,
+		spendLimitDaily: config?.spendLimitDaily,
+		spendLimitPerTx: config?.spendLimitPerTx
+	}) });
+	const { providers, models } = resolveProviders({
+		protocol: resolvedProtocol,
+		mppSessionBudget: configuredMppBudget,
+		providers: { [DEFAULT_SURF_PROVIDER_ID]: {
+			baseUrl: "/",
+			upstreamUrl,
+			protocol: resolvedProtocol,
+			mppSessionBudget: configuredMppBudget
+		} }
+	});
+	const routeHandler = createInferenceProxyRouteHandler({
+		providers,
+		getX402Proxy: () => x402Proxy,
+		getWalletAddress: () => wallet.solanaAddress ?? wallet.evmAddress ?? null,
+		getWalletAddressForNetwork: (network) => walletAddressForNetwork(wallet, network),
+		getEvmKey: () => wallet.evmKey ?? null,
+		historyPath: getHistoryPath(),
+		allModels: models,
+		logger: {
+			info: (msg) => {
+				if (!options.quiet) dim(msg);
+			},
+			error: (msg) => {
+				if (!options.quiet) error(msg);
+			}
+		}
+	});
+	const server = http.createServer(createRequestHandler(routeHandler));
+	server.on("clientError", (err, socket) => {
+		socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
+		if (!options.quiet) error(`client error: ${err.message}`);
+	});
+	server.listen(options.port ?? 0, "127.0.0.1");
+	await once(server, "listening");
+	const address = server.address();
+	const port = address && typeof address === "object" && typeof address.port === "number" ? address.port : 0;
+	if (!options.quiet) {
+		success(`Proxy listening on http://127.0.0.1:${port}`);
+		info(`Upstream: ${upstreamUrl}`);
+		info(`Protocol: ${resolvedProtocol}`);
+	}
+	return {
+		server,
+		port,
+		close: async () => {
+			if (!server.listening) return;
+			server.close();
+			await once(server, "close");
+		}
+	};
+}
+function waitForSignal() {
+	return new Promise((resolve) => {
+		const onSignal = (signal) => {
+			process.off("SIGINT", onSigInt);
+			process.off("SIGTERM", onSigTerm);
+			resolve(signal);
+		};
+		const onSigInt = () => onSignal("SIGINT");
+		const onSigTerm = () => onSignal("SIGTERM");
+		process.on("SIGINT", onSigInt);
+		process.on("SIGTERM", onSigTerm);
+	});
+}
+const serveCommand = buildCommand({
+	docs: {
+		brief: "Start a local paid inference proxy",
+		fullDescription: `Start a local HTTP proxy that forwards inference requests upstream and auto-pays x402 or MPP 402 challenges.
+
+Examples:
+  $ x402-proxy serve
+  $ x402-proxy serve --port 8402
+  $ x402-proxy serve https://surf.cascade.fyi/api/v1/inference --protocol mpp`
+	},
+	parameters: {
+		flags: {
+			port: {
+				kind: "parsed",
+				brief: "Listen port (0 = ephemeral)",
+				parse: String,
+				default: "0"
+			},
+			protocol: {
+				kind: "parsed",
+				brief: "Payment protocol (x402, mpp, auto)",
+				parse: String,
+				optional: true
+			},
+			network: {
+				kind: "parsed",
+				brief: "Preferred or required network (base, solana, tempo)",
+				parse: String,
+				optional: true
+			},
+			evmKey: {
+				kind: "parsed",
+				brief: "EVM private key (hex)",
+				parse: String,
+				optional: true
+			},
+			solanaKey: {
+				kind: "parsed",
+				brief: "Solana private key (base58)",
+				parse: String,
+				optional: true
+			}
+		},
+		positional: {
+			kind: "tuple",
+			parameters: [{
+				brief: "Upstream inference URL",
+				parse: String,
+				optional: true
+			}]
+		}
+	},
+	async func(flags, upstreamUrl) {
+		const started = await startServeServer({
+			upstreamUrl,
+			port: Number(flags.port),
+			protocol: flags.protocol,
+			network: flags.network,
+			evmKey: flags.evmKey,
+			solanaKey: flags.solanaKey
+		});
+		const signal = await waitForSignal();
+		dim(`Received ${signal}, shutting down...`);
+		await started.close();
+		process.exit(signal === "SIGINT" ? 130 : 143);
+	}
+});
+//#endregion
+//#region src/commands/claude.ts
+const DEFAULT_MODEL = "minimax/minimax-m2.7";
+function normalizeClaudeArgs(args) {
+	return args[0] === "--" ? args.slice(1) : args;
+}
+const claudeCommand = buildCommand({
+	docs: {
+		brief: "Run Claude Code through a paid local proxy",
+		fullDescription: `Start a local x402-proxy server and launch Claude Code with ANTHROPIC_BASE_URL pointed at it.
+
+Examples:
+  $ x402-proxy claude
+  $ x402-proxy claude --model z-ai/glm-5
+  $ x402-proxy claude -- --print "explain this codebase"`
+	},
+	parameters: {
+		flags: {
+			model: {
+				kind: "parsed",
+				brief: "Model to use (default: minimax/minimax-m2.7)",
+				parse: String,
+				default: DEFAULT_MODEL
+			},
+			upstream: {
+				kind: "parsed",
+				brief: "Upstream inference URL",
+				parse: String,
+				optional: true
+			},
+			protocol: {
+				kind: "parsed",
+				brief: "Payment protocol (x402, mpp, auto)",
+				parse: String,
+				optional: true
+			},
+			network: {
+				kind: "parsed",
+				brief: "Preferred or required network (base, solana, tempo)",
+				parse: String,
+				optional: true
+			},
+			port: {
+				kind: "parsed",
+				brief: "Proxy listen port (0 = ephemeral)",
+				parse: String,
+				default: "0"
+			},
+			evmKey: {
+				kind: "parsed",
+				brief: "EVM private key (hex)",
+				parse: String,
+				optional: true
+			},
+			solanaKey: {
+				kind: "parsed",
+				brief: "Solana private key (base58)",
+				parse: String,
+				optional: true
+			}
+		},
+		positional: {
+			kind: "array",
+			parameter: {
+				brief: "Arguments to forward to claude",
+				parse: String
+			}
+		}
+	},
+	async func(flags, ...rawClaudeArgs) {
+		const started = await startServeServer({
+			upstreamUrl: flags.upstream ?? "https://surf.cascade.fyi/api/v1/inference",
+			port: Number(flags.port),
+			protocol: flags.protocol,
+			network: flags.network,
+			evmKey: flags.evmKey,
+			solanaKey: flags.solanaKey,
+			quiet: false
+		});
+		const child = spawn("claude", normalizeClaudeArgs(rawClaudeArgs), {
+			stdio: "inherit",
+			env: {
+				...process.env,
+				ANTHROPIC_BASE_URL: `http://127.0.0.1:${started.port}`,
+				ANTHROPIC_MODEL: flags.model,
+				ANTHROPIC_CUSTOM_MODEL_OPTION: flags.model
+			}
+		});
+		const stopProxy = async () => {
+			await started.close().catch(() => {});
+		};
+		const forwardSignal = (signal) => {
+			dim(`Forwarding ${signal} to claude...`);
+			child.kill(signal);
+		};
+		const onSigInt = () => forwardSignal("SIGINT");
+		const onSigTerm = () => forwardSignal("SIGTERM");
+		process.on("SIGINT", onSigInt);
+		process.on("SIGTERM", onSigTerm);
+		child.once("error", async (err) => {
+			process.off("SIGINT", onSigInt);
+			process.off("SIGTERM", onSigTerm);
+			await stopProxy();
+			if (err.code === "ENOENT") error("Claude Code CLI not found. Install: npm i -g @anthropic-ai/claude-code");
+			else error(err instanceof Error ? err.message : String(err));
+			process.exit(1);
+		});
+		child.once("exit", async (code, signal) => {
+			process.off("SIGINT", onSigInt);
+			process.off("SIGTERM", onSigTerm);
+			await stopProxy();
+			if (signal) process.exit(signal === "SIGINT" ? 130 : 143);
+			process.exit(code ?? 1);
+		});
+	}
+});
+//#endregion
 //#region src/commands/config.ts
 const VALID_KEYS = {
 	defaultNetwork: {
@@ -161,145 +1208,6 @@ const configUnsetCommand = buildCommand({
 	}
 });
 //#endregion
-//#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 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.
-*/
-function createX402ProxyHandler(opts) {
-	const { client } = opts;
-	const paymentQueue = [];
-	client.onAfterPaymentCreation(async (hookCtx) => {
-		const raw = hookCtx.selectedRequirements.amount;
-		paymentQueue.push({
-			protocol: "x402",
-			network: hookCtx.selectedRequirements.network,
-			payTo: hookCtx.selectedRequirements.payTo,
-			amount: raw,
-			asset: hookCtx.selectedRequirements.asset
-		});
-	});
-	return {
-		x402Fetch: wrapFetchWithPayment(globalThis.fetch, client),
-		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/commands/fetch.ts
 function isStreamingResponse(res) {
 	return (res.headers.get("content-type") ?? "").includes("text/event-stream");
@@ -398,7 +1306,7 @@ Examples:
 		};
 		if (!url) {
 			if (isConfigured()) {
-				const { displayStatus } = await import("../status-Bj3U-W2M.js");
+				const { displayStatus } = await import("../status-DlR8yBrK.js");
 				await displayStatus();
 				console.log();
 				console.log(pc.dim("  Commands:"));
@@ -450,7 +1358,7 @@ Examples:
 				process.exit(1);
 			}
 			dim("  No wallet found. Let's set one up first.\n");
-			const { runSetup } = await import("../setup-B6xRV8Ue.js");
+			const { runSetup } = await import("../setup-EX1_teNg.js");
 			await runSetup();
 			console.log();
 			wallet = resolveWallet();
@@ -463,7 +1371,7 @@ Examples:
 		verbose(`protocol: ${resolvedProtocol ?? "auto-detect"}, maxDeposit: ${maxDeposit}`);
 		let preferredNetwork = config?.defaultNetwork;
 		if (!preferredNetwork && wallet.evmAddress && wallet.solanaAddress) {
-			const { fetchAllBalances } = await import("../wallet-4C9EL4Iv.js");
+			const { fetchAllBalances } = await import("../wallet-7XKcknNZ.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;
@@ -630,7 +1538,7 @@ Examples:
 			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 { fetchAllBalances } = await import("../wallet-4C9EL4Iv.js");
+			const { fetchAllBalances } = await import("../wallet-7XKcknNZ.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;
@@ -806,7 +1714,7 @@ Wallet is auto-generated on first run. No env vars needed.`
 		});
 		if (wallet.source === "none") {
 			dim("No wallet found. Auto-generating...");
-			const { runSetup } = await import("../setup-B6xRV8Ue.js");
+			const { runSetup } = await import("../setup-EX1_teNg.js");
 			await runSetup({ nonInteractive: true });
 			const fresh = resolveWallet({
 				evmKey: flags.evmKey,
@@ -850,7 +1758,7 @@ Wallet is auto-generated on first run. No env vars needed.`
 		async function startX402Proxy() {
 			let preferredNetwork = config?.defaultNetwork;
 			if (!preferredNetwork && wallet.evmAddress && wallet.solanaAddress) {
-				const { fetchAllBalances } = await import("../wallet-4C9EL4Iv.js");
+				const { fetchAllBalances } = await import("../wallet-7XKcknNZ.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;
@@ -870,7 +1778,7 @@ Wallet is auto-generated on first run. No env vars needed.`
 			}
 			const remoteClient = new Client({
 				name: "x402-proxy",
-				version: "0.9.4"
+				version: "0.10.1"
 			});
 			const x402Mcp = new x402MCPClient(remoteClient, x402PaymentClient, {
 				autoPayment: true,
@@ -908,7 +1816,7 @@ Wallet is auto-generated on first run. No env vars needed.`
 			}
 			const localServer = new Server({
 				name: "x402-proxy",
-				version: "0.9.4"
+				version: "0.10.1"
 			}, { capabilities: {
 				tools: tools.length > 0 ? {} : void 0,
 				resources: remoteResources.length > 0 ? {} : void 0
@@ -1003,7 +1911,7 @@ Wallet is auto-generated on first run. No env vars needed.`
 			}));
 			const remoteClient = new Client({
 				name: "x402-proxy",
-				version: "0.9.4"
+				version: "0.10.1"
 			});
 			await connectTransport(remoteClient);
 			const mppClient = McpClient.wrap(remoteClient, { methods: wrappedMethods });
@@ -1018,7 +1926,7 @@ Wallet is auto-generated on first run. No env vars needed.`
 			}
 			const localServer = new Server({
 				name: "x402-proxy",
-				version: "0.9.4"
+				version: "0.10.1"
 			}, { capabilities: {
 				tools: tools.length > 0 ? {} : void 0,
 				resources: remoteResources.length > 0 ? {} : void 0
@@ -1398,6 +2306,8 @@ const configRoutes = buildRouteMap({
 const app = buildApplication(buildRouteMap({
 	routes: {
 		fetch: fetchCommand,
+		serve: serveCommand,
+		claude: claudeCommand,
 		mcp: buildRouteMap({
 			routes: {
 				proxy: mcpCommand,
@@ -1415,7 +2325,7 @@ const app = buildApplication(buildRouteMap({
 	docs: { brief: "curl for x402 paid APIs" }
 }), {
 	name: "x402-proxy",
-	versionInfo: { currentVersion: "0.9.4" },
+	versionInfo: { currentVersion: "0.10.1" },
 	scanner: { caseStyle: "allow-kebab-for-camel" }
 });
 //#endregion
@@ -1425,7 +2335,6 @@ function buildContext(process) {
 }
 //#endregion
 //#region src/bin/cli.ts
-process.on("SIGINT", () => process.exit(130));
 const rawArgs = process.argv.slice(2);
 const args = [];
 for (let i = 0; i < rawArgs.length; i++) {
@@ -1441,6 +2350,8 @@ for (let i = 0; i < rawArgs.length; i++) {
 		process.env.X402_PROXY_CONFIG_DIR_OVERRIDE = dir;
 	} else args.push(a);
 }
+const topLevelCommand = args[0];
+if (topLevelCommand !== "serve" && topLevelCommand !== "claude") process.on("SIGINT", () => process.exit(130));
 await run(app, args, buildContext(process));
 //#endregion
 export {};