x402-proxy-openclaw 0.10.9

package/README.md

@@ -0,0 +1,35 @@
+# x402-proxy-openclaw
+
+OpenClaw plugin for x402 and MPP payments, wallet tools, and paid inference proxying.
+
+## Install
+
+```bash
+openclaw plugins install x402-proxy-openclaw
+```
+
+## What It Adds
+
+- `x_wallet` and `x_request` tools, with `x_balance` and `x_payment` aliases
+- `/x_wallet` and `/x_send` commands
+- an HTTP route proxy for upstream inference endpoints
+- a built-in `surf` provider at `/x402-proxy/v1`
+
+By default, the plugin proxies `https://surf.cascade.fyi/api/v1/inference` and prefers MPP.
+
+## Relationship To The CLI Package
+
+The standalone CLI and library remain published as `x402-proxy`.
+
+Use `x402-proxy` when you want:
+- paid HTTP requests from the command line
+- the MCP proxy
+- local wallet setup and export flows
+
+Use `x402-proxy-openclaw` when you want:
+- OpenClaw gateway integration
+- plugin-managed tools, commands, and routes
+
+## License
+
+Apache-2.0

package/dist/commands/wallet.js

@@ -0,0 +1,149 @@
+import { getHistoryPath } from "../lib/config.js";
+import { resolveWallet } from "../lib/wallet-resolution.js";
+import { calcSpend, formatAmount, formatTxLine, formatUsdcValue, readHistory } from "../history.js";
+import { dim, info } from "../lib/output.js";
+import { address, getAddressEncoder, getProgramDerivedAddress } from "@solana/kit";
+import { buildCommand } from "@stricli/core";
+import pc from "picocolors";
+//#region packages/x402-proxy/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
+export { fetchAllBalances };

package/dist/commands.js

@@ -0,0 +1,218 @@
+import { appendHistory, formatTxLine, readHistory } from "./history.js";
+import { checkAtaExists, getUsdcBalance, transferUsdc } from "./solana.js";
+import { SOL_MAINNET, getWalletSnapshot } from "./tools.js";
+//#region packages/x402-proxy/src/openclaw/commands.ts
+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 = [];
+	for (const m of mints) {
+		const cached = tokenSymbolCache.get(m);
+		if (cached) result.set(m, cached);
+		else toResolve.push(m);
+	}
+	if (toResolve.length === 0) return result;
+	try {
+		const res = await globalThis.fetch(`https://api.dexscreener.com/tokens/v1/solana/${toResolve.join(",")}`, { signal: AbortSignal.timeout(5e3) });
+		if (!res.ok) return result;
+		const pairs = await res.json();
+		for (const pair of pairs) {
+			const addr = pair.baseToken?.address;
+			const sym = pair.baseToken?.symbol;
+			if (addr && sym && toResolve.includes(addr)) {
+				if (tokenSymbolCache.size >= TOKEN_SYMBOL_CACHE_MAX) {
+					const oldest = tokenSymbolCache.keys().next();
+					if (!oldest.done) tokenSymbolCache.delete(oldest.value);
+				}
+				tokenSymbolCache.set(addr, sym);
+				result.set(addr, sym);
+			}
+		}
+	} catch {}
+	return result;
+}
+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." };
+	try {
+		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") {
+			const balance = await getUsdcBalance(rpc, wallet);
+			if (balance.raw === 0n) return { text: "Wallet has no USDC to send." };
+			amountRaw = balance.raw;
+			amountUi = balance.ui;
+		} else {
+			const amount = Number.parseFloat(amountStr);
+			if (Number.isNaN(amount) || amount <= 0) return { text: `Invalid amount: ${amountStr}` };
+			amountRaw = BigInt(Math.round(amount * 1e6));
+			amountUi = amount.toString();
+		}
+		const sig = await transferUsdc(signer, rpc, destination, amountRaw);
+		appendHistory(histPath, {
+			t: Date.now(),
+			ok: true,
+			kind: "transfer",
+			net: SOL_MAINNET,
+			from: wallet,
+			to: destination,
+			tx: sig,
+			amount: Number.parseFloat(amountUi),
+			token: "USDC",
+			label: `${destination.slice(0, 4)}...${destination.slice(-4)}`
+		});
+		return { text: `Sent ${amountUi} USDC to \`${destination}\`\n[View transaction](https://solscan.io/tx/${sig})` };
+	} catch (err) {
+		appendHistory(histPath, {
+			t: Date.now(),
+			ok: false,
+			kind: "transfer",
+			net: SOL_MAINNET,
+			from: wallet,
+			to: destination,
+			token: "USDC",
+			error: String(err).substring(0, 200)
+		});
+		const msg = String(err);
+		const detail = err.cause?.message || msg;
+		if (detail.includes("insufficient") || detail.includes("lamports")) return { text: "Send failed - insufficient SOL for fees\nBalance too low for transaction fees. Fund wallet with SOL." };
+		return { text: `Send failed: ${detail}` };
+	}
+}
+function handleHistory(histPath, page) {
+	const records = readHistory(histPath);
+	const totalTxs = records.length;
+	const start = (page - 1) * HISTORY_PAGE_SIZE;
+	const fromEnd = totalTxs - start;
+	const pageRecords = records.slice(Math.max(0, fromEnd - HISTORY_PAGE_SIZE), fromEnd).reverse();
+	if (pageRecords.length === 0) return { text: page === 1 ? "No transactions yet." : "No more transactions." };
+	const lines = [`**History** (${start + 1}-${start + pageRecords.length})`, ""];
+	for (const r of pageRecords) lines.push(formatTxLine(r));
+	const nav = [];
+	if (page > 1) nav.push(`Newer: \`/x_wallet history${page === 2 ? "" : ` ${page - 1}`}\``);
+	if (start + HISTORY_PAGE_SIZE < totalTxs) nav.push(`Older: \`/x_wallet history ${page + 1}\``);
+	if (nav.length > 0) lines.push("", nav.join(" · "));
+	return { text: lines.join("\n") };
+}
+function createWalletCommand(ctx) {
+	return {
+		name: "x_wallet",
+		description: "Wallet status, balances, payment readiness, and transaction history",
+		acceptsArgs: true,
+		requireAuth: true,
+		handler: async (cmdCtx) => {
+			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() === "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, solanaWallet, evmWallet, ctx.historyPath);
+				const lines = [`x402-proxy v0.10.9`];
+				const defaultModel = ctx.allModels[0];
+				if (defaultModel) lines.push("", `**Model** - ${defaultModel.name} (${defaultModel.provider})`);
+				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("", "**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 });
+						lines.push(`  ${amt} ${label}`);
+					}
+					if (snap.tokens.length > 10) lines.push(`  ...and ${snap.tokens.length - 10} more`);
+				}
+				if (snap.tokens.length <= INLINE_HISTORY_TOKEN_THRESHOLD) {
+					const recentRecords = snap.records.slice(-STATUS_HISTORY_COUNT).reverse();
+					if (recentRecords.length > 0) {
+						lines.push("", "**Recent**");
+						for (const r of recentRecords) lines.push(formatTxLine(r));
+					}
+				}
+				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 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
+export { createSendCommand, createWalletCommand };

package/dist/defaults.js

@@ -0,0 +1,129 @@
+//#region packages/x402-proxy/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
+export { resolveProviders, routePrefixForBaseUrl };