@dominusnode/mastra-tools 1.3.0 → 1.3.2

package/dist/toolkit.js

@@ -66,6 +66,7 @@ exports.formatCents = formatCents;
 // @ts-ignore -- available when installed in Mastra project
 const tools_1 = require("@mastra/core/tools");
 const zod_1 = require("zod");
+const crypto = __importStar(require("node:crypto"));
 const http = __importStar(require("node:http"));
 const tls = __importStar(require("node:tls"));
 const dns = __importStar(require("dns/promises"));
@@ -86,7 +87,7 @@ const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
 // ---------------------------------------------------------------------------
 /** Remove any dn_live_* or dn_test_* tokens from error messages. */
 function scrubCredentials(msg) {
-    return msg.replace(/dn_(live|test)_[A-Za-z0-9_-]+/g, "dn_$1_***REDACTED***");
+    return msg.replace(/dn_(live|test|proxy)_[A-Za-z0-9_-]+/g, "dn_$1_***REDACTED***");
 }
 function safeError(err) {
     const raw = err instanceof Error ? err.message : String(err);
@@ -98,7 +99,8 @@ function safeError(err) {
 function truncate(text, max = MAX_RESPONSE_CHARS) {
     if (text.length <= max)
         return text;
-    return text.slice(0, max) + `\n\n... [truncated, ${text.length - max} chars omitted]`;
+    return (text.slice(0, max) +
+        `\n\n... [truncated, ${text.length - max} chars omitted]`);
 }
 // ---------------------------------------------------------------------------
 // SSRF Protection
@@ -389,18 +391,80 @@ class DominusNodeToolkit {
     jwtExpiresAt = 0;
     constructor(config = {}) {
         this.apiKey = config.apiKey || process.env.DOMINUSNODE_API_KEY || "";
-        this.baseUrl = (config.baseUrl || process.env.DOMINUSNODE_BASE_URL || "https://api.dominusnode.com").replace(/\/+$/, "");
-        this.proxyHost = config.proxyHost || process.env.DOMINUSNODE_PROXY_HOST || "proxy.dominusnode.com";
-        const portStr = config.proxyPort?.toString() || process.env.DOMINUSNODE_PROXY_PORT || "8080";
+        this.baseUrl = (config.baseUrl ||
+            process.env.DOMINUSNODE_BASE_URL ||
+            "https://api.dominusnode.com").replace(/\/+$/, "");
+        this.proxyHost =
+            config.proxyHost ||
+                process.env.DOMINUSNODE_PROXY_HOST ||
+                "proxy.dominusnode.com";
+        const portStr = config.proxyPort?.toString() ||
+            process.env.DOMINUSNODE_PROXY_PORT ||
+            "8080";
         const port = parseInt(portStr, 10);
         this.proxyPort = isNaN(port) || port < 1 || port > 65535 ? 8080 : port;
-        this.agentSecret = config.agentSecret || process.env.DOMINUSNODE_AGENT_SECRET;
+        this.agentSecret =
+            config.agentSecret || process.env.DOMINUSNODE_AGENT_SECRET;
+    }
+    // -----------------------------------------------------------------------
+    // SHA-256 Proof-of-Work solver
+    // -----------------------------------------------------------------------
+    static countLeadingZeroBits(buf) {
+        let count = 0;
+        for (const byte of buf) {
+            if (byte === 0) {
+                count += 8;
+                continue;
+            }
+            let mask = 0x80;
+            while (mask && !(byte & mask)) {
+                count++;
+                mask >>= 1;
+            }
+            break;
+        }
+        return count;
+    }
+    async solvePoW() {
+        try {
+            const resp = await fetch(`${this.baseUrl}/api/auth/pow/challenge`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                redirect: "error",
+            });
+            if (!resp.ok)
+                return null;
+            const text = await resp.text();
+            if (text.length > 10_485_760)
+                return null;
+            const challenge = JSON.parse(text);
+            const prefix = challenge.prefix ?? "";
+            const difficulty = challenge.difficulty ?? 20;
+            const challengeId = challenge.challengeId ?? "";
+            if (!prefix || !challengeId)
+                return null;
+            for (let nonce = 0; nonce < 100_000_000; nonce++) {
+                const hash = crypto
+                    .createHash("sha256")
+                    .update(prefix + nonce.toString())
+                    .digest();
+                if (DominusNodeToolkit.countLeadingZeroBits(hash) >= difficulty) {
+                    return { challengeId, nonce: nonce.toString() };
+                }
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
     }
     // -----------------------------------------------------------------------
     // Authentication
     // -----------------------------------------------------------------------
     getApiKey() {
-        if (!this.apiKey || typeof this.apiKey !== "string" || this.apiKey.trim().length === 0) {
+        if (!this.apiKey ||
+            typeof this.apiKey !== "string" ||
+            this.apiKey.trim().length === 0) {
             throw new Error("DOMINUSNODE_API_KEY is required. " +
                 'Set it to your Dominus Node API key (starts with "dn_live_" or "dn_test_").');
         }
@@ -602,50 +666,138 @@ class DominusNodeToolkit {
     // Tool implementations
     // -----------------------------------------------------------------------
     async proxiedFetch(url, method = "GET", country, proxyType = "dc") {
-        const parsedUrl = validateTargetUrl(url);
-        await checkDnsRebinding(parsedUrl.hostname);
-        const validCountry = validateCountry(country);
-        const ALLOWED_METHODS = new Set(["GET", "HEAD", "OPTIONS"]);
-        const methodUpper = method.toUpperCase();
-        if (!ALLOWED_METHODS.has(methodUpper)) {
-            throw new Error(`HTTP method "${methodUpper}" is not allowed. Only GET, HEAD, and OPTIONS are permitted.`);
-        }
-        const apiKey = this.getApiKey();
-        const parts = [];
-        if (proxyType && proxyType !== "auto")
-            parts.push(proxyType);
-        if (validCountry)
-            parts.push(`country-${validCountry.toUpperCase()}`);
-        const username = parts.length > 0 ? parts.join("-") : "auto";
-        const proxyAuth = "Basic " + Buffer.from(`${username}:${apiKey}`).toString("base64");
-        const parsed = new URL(url);
-        const MAX_RESP = 1_048_576; // 1MB
-        const result = await new Promise((resolve, reject) => {
-            const timer = setTimeout(() => reject(new Error("Proxy request timed out")), REQUEST_TIMEOUT_MS);
-            if (parsed.protocol === "https:") {
-                const connectHost = parsed.hostname.includes(":") ? `[${parsed.hostname}]` : parsed.hostname;
-                const connectReq = http.request({
-                    hostname: this.proxyHost,
-                    port: this.proxyPort,
-                    method: "CONNECT",
-                    path: `${connectHost}:${parsed.port || 443}`,
-                    headers: { "Proxy-Authorization": proxyAuth, Host: `${connectHost}:${parsed.port || 443}` },
-                });
-                connectReq.on("connect", (_res, sock) => {
-                    if (_res.statusCode !== 200) {
+        try {
+            const parsedUrl = validateTargetUrl(url);
+            await checkDnsRebinding(parsedUrl.hostname);
+            const validCountry = validateCountry(country);
+            const ALLOWED_METHODS = new Set(["GET", "HEAD", "OPTIONS"]);
+            const methodUpper = method.toUpperCase();
+            if (!ALLOWED_METHODS.has(methodUpper)) {
+                return {
+                    status: 0,
+                    headers: {},
+                    body: "",
+                    bytes: 0,
+                    pool: proxyType,
+                    country: country ?? "auto",
+                    error: `HTTP method "${methodUpper}" is not allowed. Only GET, HEAD, and OPTIONS are permitted.`,
+                };
+            }
+            const apiKey = this.getApiKey();
+            const parts = [];
+            if (proxyType && proxyType !== "auto")
+                parts.push(proxyType);
+            if (validCountry)
+                parts.push(`country-${validCountry.toUpperCase()}`);
+            const username = parts.length > 0 ? parts.join("-") : "auto";
+            const proxyAuth = "Basic " + Buffer.from(`${username}:${apiKey}`).toString("base64");
+            const parsed = new URL(url);
+            const MAX_RESP = 1_048_576; // 1MB
+            const result = await new Promise((resolve, reject) => {
+                const timer = setTimeout(() => reject(new Error("Proxy request timed out")), REQUEST_TIMEOUT_MS);
+                if (parsed.protocol === "https:") {
+                    const connectHost = parsed.hostname.includes(":")
+                        ? `[${parsed.hostname}]`
+                        : parsed.hostname;
+                    const connectReq = http.request({
+                        hostname: this.proxyHost,
+                        port: this.proxyPort,
+                        method: "CONNECT",
+                        path: `${connectHost}:${parsed.port || 443}`,
+                        headers: {
+                            "Proxy-Authorization": proxyAuth,
+                            Host: `${connectHost}:${parsed.port || 443}`,
+                        },
+                    });
+                    connectReq.on("connect", (_res, sock) => {
+                        if (_res.statusCode !== 200) {
+                            clearTimeout(timer);
+                            sock.destroy();
+                            reject(new Error(`CONNECT failed: ${_res.statusCode}`));
+                            return;
+                        }
+                        const tlsSock = tls.connect({
+                            host: parsed.hostname,
+                            socket: sock,
+                            servername: parsed.hostname,
+                            minVersion: "TLSv1.2",
+                        }, () => {
+                            const reqLine = `${methodUpper} ${parsed.pathname + parsed.search} HTTP/1.1\r\nHost: ${parsed.host}\r\nUser-Agent: dominusnode-mastra/1.0.0\r\nConnection: close\r\n\r\n`;
+                            tlsSock.write(reqLine);
+                            const chunks = [];
+                            let bytes = 0;
+                            tlsSock.on("data", (c) => {
+                                bytes += c.length;
+                                if (bytes <= MAX_RESP + 16384)
+                                    chunks.push(c);
+                            });
+                            let done = false;
+                            const fin = () => {
+                                if (done)
+                                    return;
+                                done = true;
+                                clearTimeout(timer);
+                                const raw = Buffer.concat(chunks).toString("utf-8");
+                                const hEnd = raw.indexOf("\r\n\r\n");
+                                if (hEnd === -1) {
+                                    reject(new Error("Malformed response"));
+                                    return;
+                                }
+                                const hdr = raw.substring(0, hEnd);
+                                const body = raw.substring(hEnd + 4).substring(0, MAX_RESP);
+                                const bodyBytes = new TextEncoder().encode(body).length;
+                                const sm = hdr
+                                    .split("\r\n")[0]
+                                    .match(/^HTTP\/\d\.\d\s+(\d+)/);
+                                const hdrs = {};
+                                for (const l of hdr.split("\r\n").slice(1)) {
+                                    const ci = l.indexOf(":");
+                                    if (ci > 0)
+                                        hdrs[l.substring(0, ci).trim().toLowerCase()] = l
+                                            .substring(ci + 1)
+                                            .trim();
+                                }
+                                resolve({
+                                    status: sm ? parseInt(sm[1], 10) : 0,
+                                    headers: hdrs,
+                                    body,
+                                    bytes: bodyBytes,
+                                });
+                            };
+                            tlsSock.on("end", fin);
+                            tlsSock.on("close", fin);
+                            tlsSock.on("error", (e) => {
+                                clearTimeout(timer);
+                                reject(e);
+                            });
+                        });
+                        tlsSock.on("error", (e) => {
+                            clearTimeout(timer);
+                            reject(e);
+                        });
+                    });
+                    connectReq.on("error", (e) => {
                         clearTimeout(timer);
-                        sock.destroy();
-                        reject(new Error(`CONNECT failed: ${_res.statusCode}`));
-                        return;
-                    }
-                    const tlsSock = tls.connect({ host: parsed.hostname, socket: sock, servername: parsed.hostname, minVersion: "TLSv1.2" }, () => {
-                        const reqLine = `${methodUpper} ${parsed.pathname + parsed.search} HTTP/1.1\r\nHost: ${parsed.host}\r\nUser-Agent: dominusnode-mastra/1.0.0\r\nConnection: close\r\n\r\n`;
-                        tlsSock.write(reqLine);
+                        reject(e);
+                    });
+                    connectReq.end();
+                }
+                else {
+                    const req = http.request({
+                        hostname: this.proxyHost,
+                        port: this.proxyPort,
+                        method: methodUpper,
+                        path: url,
+                        headers: {
+                            "Proxy-Authorization": proxyAuth,
+                            Host: parsed.host ?? "",
+                        },
+                    }, (res) => {
                         const chunks = [];
                         let bytes = 0;
-                        tlsSock.on("data", (c) => {
+                        res.on("data", (c) => {
                             bytes += c.length;
-                            if (bytes <= MAX_RESP + 16384)
+                            if (bytes <= MAX_RESP)
                                 chunks.push(c);
                         });
                         let done = false;
@@ -654,76 +806,56 @@ class DominusNodeToolkit {
                                 return;
                             done = true;
                             clearTimeout(timer);
-                            const raw = Buffer.concat(chunks).toString("utf-8");
-                            const hEnd = raw.indexOf("\r\n\r\n");
-                            if (hEnd === -1) {
-                                reject(new Error("Malformed response"));
-                                return;
-                            }
-                            const hdr = raw.substring(0, hEnd);
-                            const body = raw.substring(hEnd + 4).substring(0, MAX_RESP);
-                            const sm = hdr.split("\r\n")[0].match(/^HTTP\/\d\.\d\s+(\d+)/);
+                            const body = Buffer.concat(chunks)
+                                .toString("utf-8")
+                                .substring(0, MAX_RESP);
+                            const bodyBytes = new TextEncoder().encode(body).length;
                             const hdrs = {};
-                            for (const l of hdr.split("\r\n").slice(1)) {
-                                const ci = l.indexOf(":");
-                                if (ci > 0)
-                                    hdrs[l.substring(0, ci).trim().toLowerCase()] = l.substring(ci + 1).trim();
+                            for (const [k, v] of Object.entries(res.headers)) {
+                                if (v)
+                                    hdrs[k] = Array.isArray(v) ? v.join(", ") : v;
                             }
-                            resolve({ status: sm ? parseInt(sm[1], 10) : 0, headers: hdrs, body });
+                            resolve({
+                                status: res.statusCode ?? 0,
+                                headers: hdrs,
+                                body,
+                                bytes: bodyBytes,
+                            });
                         };
-                        tlsSock.on("end", fin);
-                        tlsSock.on("close", fin);
-                        tlsSock.on("error", (e) => { clearTimeout(timer); reject(e); });
-                    });
-                    tlsSock.on("error", (e) => { clearTimeout(timer); reject(e); });
-                });
-                connectReq.on("error", (e) => { clearTimeout(timer); reject(e); });
-                connectReq.end();
-            }
-            else {
-                const req = http.request({
-                    hostname: this.proxyHost,
-                    port: this.proxyPort,
-                    method: methodUpper,
-                    path: url,
-                    headers: { "Proxy-Authorization": proxyAuth, Host: parsed.host ?? "" },
-                }, (res) => {
-                    const chunks = [];
-                    let bytes = 0;
-                    res.on("data", (c) => {
-                        bytes += c.length;
-                        if (bytes <= MAX_RESP)
-                            chunks.push(c);
+                        res.on("end", fin);
+                        res.on("close", fin);
+                        res.on("error", (e) => {
+                            clearTimeout(timer);
+                            reject(e);
+                        });
                     });
-                    let done = false;
-                    const fin = () => {
-                        if (done)
-                            return;
-                        done = true;
+                    req.on("error", (e) => {
                         clearTimeout(timer);
-                        const body = Buffer.concat(chunks).toString("utf-8").substring(0, MAX_RESP);
-                        const hdrs = {};
-                        for (const [k, v] of Object.entries(res.headers)) {
-                            if (v)
-                                hdrs[k] = Array.isArray(v) ? v.join(", ") : v;
-                        }
-                        resolve({ status: res.statusCode ?? 0, headers: hdrs, body });
-                    };
-                    res.on("end", fin);
-                    res.on("close", fin);
-                    res.on("error", (e) => { clearTimeout(timer); reject(e); });
-                });
-                req.on("error", (e) => { clearTimeout(timer); reject(e); });
-                req.end();
-            }
-        });
-        return {
-            status: result.status,
-            headers: result.headers,
-            body: truncate(scrubCredentials(result.body)),
-            pool: proxyType,
-            country: validCountry ?? "auto",
-        };
+                        reject(e);
+                    });
+                    req.end();
+                }
+            });
+            return {
+                status: result.status,
+                headers: result.headers,
+                body: truncate(scrubCredentials(result.body)),
+                bytes: result.bytes,
+                pool: proxyType,
+                country: validCountry ?? "auto",
+            };
+        }
+        catch (err) {
+            return {
+                status: 0,
+                headers: {},
+                body: "",
+                bytes: 0,
+                pool: proxyType,
+                country: country ?? "auto",
+                error: safeError(err),
+            };
+        }
     }
     async checkBalance() {
         const data = await this.apiGet("/api/wallet");
@@ -757,9 +889,14 @@ class DominusNodeToolkit {
             throw new Error("label contains invalid control characters.");
         }
         const safeLimitCents = Math.min(Math.max(spendingLimitCents, 0), 1000000);
-        const body = { label, spendingLimitCents: safeLimitCents };
+        const body = {
+            label,
+            spendingLimitCents: safeLimitCents,
+        };
         if (dailyLimitCents !== undefined && dailyLimitCents !== null) {
-            if (!Number.isInteger(dailyLimitCents) || dailyLimitCents < 1 || dailyLimitCents > 1000000) {
+            if (!Number.isInteger(dailyLimitCents) ||
+                dailyLimitCents < 1 ||
+                dailyLimitCents > 1000000) {
                 throw new Error("daily_limit_cents must be an integer between 1 and 1,000,000.");
             }
             body.dailyLimitCents = dailyLimitCents;
@@ -785,7 +922,9 @@ class DominusNodeToolkit {
                 body.dailyLimitCents = null;
             }
             else {
-                if (!Number.isInteger(dailyLimitCents) || dailyLimitCents < 1 || dailyLimitCents > 1000000) {
+                if (!Number.isInteger(dailyLimitCents) ||
+                    dailyLimitCents < 1 ||
+                    dailyLimitCents > 1000000) {
                     throw new Error("daily_limit_cents must be an integer between 1 and 1,000,000, or null to remove.");
                 }
                 body.dailyLimitCents = dailyLimitCents;
@@ -814,7 +953,9 @@ class DominusNodeToolkit {
     }
     async fundAgenticWallet(walletId, amountCents) {
         validateUuid(walletId, "wallet_id");
-        if (!Number.isInteger(amountCents) || amountCents < 100 || amountCents > 1000000) {
+        if (!Number.isInteger(amountCents) ||
+            amountCents < 100 ||
+            amountCents > 1000000) {
             throw new Error("amount_cents must be an integer between 100 ($1) and 1000000 ($10,000).");
         }
         return this.apiPost(`/api/agent-wallet/${encodeURIComponent(walletId)}/fund`, { amountCents });
@@ -868,7 +1009,9 @@ class DominusNodeToolkit {
     }
     async teamFund(teamId, amountCents) {
         validateUuid(teamId, "team_id");
-        if (!Number.isInteger(amountCents) || amountCents < 100 || amountCents > 1000000) {
+        if (!Number.isInteger(amountCents) ||
+            amountCents < 100 ||
+            amountCents > 1000000) {
             throw new Error("amount_cents must be an integer between 100 ($1) and 1000000 ($10,000).");
         }
         return this.apiPost(`/api/teams/${encodeURIComponent(teamId)}/wallet/fund`, { amountCents });
@@ -881,7 +1024,9 @@ class DominusNodeToolkit {
         if (/[\x00-\x1f\x7f]/.test(label)) {
             throw new Error("label contains invalid control characters.");
         }
-        return this.apiPost(`/api/teams/${encodeURIComponent(teamId)}/keys`, { label });
+        return this.apiPost(`/api/teams/${encodeURIComponent(teamId)}/keys`, {
+            label,
+        });
     }
     async teamUsage(teamId, limit = 20) {
         validateUuid(teamId, "team_id");
@@ -921,29 +1066,49 @@ class DominusNodeToolkit {
         return this.apiPatch(`/api/teams/${encodeURIComponent(teamId)}/members/${encodeURIComponent(userId)}`, { role });
     }
     async topupPaypal(amountCents) {
-        if (!Number.isInteger(amountCents) || amountCents < 500 || amountCents > 100000) {
+        if (!Number.isInteger(amountCents) ||
+            amountCents < 500 ||
+            amountCents > 100000) {
             throw new Error("amount_cents must be an integer between 500 ($5) and 100000 ($1,000).");
         }
         return this.apiPost("/api/wallet/topup/paypal", { amountCents });
     }
     async topupStripe(amountCents) {
-        if (!Number.isInteger(amountCents) || amountCents < 500 || amountCents > 100000) {
+        if (!Number.isInteger(amountCents) ||
+            amountCents < 500 ||
+            amountCents > 100000) {
             throw new Error("amount_cents must be an integer between 500 ($5) and 100000 ($1,000).");
         }
         return this.apiPost("/api/wallet/topup/stripe", { amountCents });
     }
     static VALID_CRYPTO_CURRENCIES = new Set([
-        "btc", "eth", "ltc", "xmr", "zec", "usdc", "sol", "usdt", "dai", "bnb", "link",
+        "btc",
+        "eth",
+        "ltc",
+        "xmr",
+        "zec",
+        "usdc",
+        "sol",
+        "usdt",
+        "dai",
+        "bnb",
+        "link",
     ]);
     async topupCrypto(amountUsd, currency) {
-        if (typeof amountUsd !== "number" || !Number.isFinite(amountUsd) || amountUsd < 5 || amountUsd > 1000) {
+        if (typeof amountUsd !== "number" ||
+            !Number.isFinite(amountUsd) ||
+            amountUsd < 5 ||
+            amountUsd > 1000) {
             throw new Error("amount_usd must be a number between 5 and 1,000.");
         }
         const cur = String(currency ?? "").toLowerCase();
         if (!DominusNodeToolkit.VALID_CRYPTO_CURRENCIES.has(cur)) {
             throw new Error(`currency must be one of: ${[...DominusNodeToolkit.VALID_CRYPTO_CURRENCIES].join(", ")}.`);
         }
-        return this.apiPost("/api/wallet/topup/crypto", { amountUsd, currency: cur });
+        return this.apiPost("/api/wallet/topup/crypto", {
+            amountUsd,
+            currency: cur,
+        });
     }
     async x402Info() {
         return this.apiGet("/api/x402/info");
@@ -997,12 +1162,23 @@ class DominusNodeToolkit {
     async register(email, password) {
         const safeEmail = DominusNodeToolkit.validateEmail(email);
         const safePassword = DominusNodeToolkit.validatePassword(password);
-        return this.rawRequest("POST", "/api/auth/register", { email: safeEmail, password: safePassword });
+        // Solve PoW for CAPTCHA-free registration
+        const pow = await this.solvePoW();
+        const body = {
+            email: safeEmail,
+            password: safePassword,
+        };
+        if (pow)
+            body.pow = pow;
+        return this.rawRequest("POST", "/api/auth/register", body);
     }
     async login(email, password) {
         const safeEmail = DominusNodeToolkit.validateEmail(email);
         const safePassword = DominusNodeToolkit.validatePassword(password);
-        return this.rawRequest("POST", "/api/auth/login", { email: safeEmail, password: safePassword });
+        return this.rawRequest("POST", "/api/auth/login", {
+            email: safeEmail,
+            password: safePassword,
+        });
     }
     async getAccountInfo() {
         return this.apiGet("/api/auth/me");
@@ -1014,7 +1190,9 @@ class DominusNodeToolkit {
         if (/[\x00-\x1f\x7f]/.test(token)) {
             throw new Error("Token contains invalid control characters.");
         }
-        return this.rawRequest("POST", "/api/auth/verify-email", { token: token.trim() });
+        return this.rawRequest("POST", "/api/auth/verify-email", {
+            token: token.trim(),
+        });
     }
     async resendVerification() {
         return this.apiPost("/api/auth/resend-verification");
@@ -1079,7 +1257,10 @@ class DominusNodeToolkit {
         if (role !== "member" && role !== "admin") {
             throw new Error("role must be 'member' or 'admin'.");
         }
-        return this.apiPost(`/api/teams/${encodeURIComponent(teamId)}/members`, { userId, role });
+        return this.apiPost(`/api/teams/${encodeURIComponent(teamId)}/members`, {
+            userId,
+            role,
+        });
     }
     async teamRemoveMember(teamId, userId) {
         validateUuid(teamId, "team_id");
@@ -1092,7 +1273,10 @@ class DominusNodeToolkit {
         if (role !== "member" && role !== "admin") {
             throw new Error("role must be 'member' or 'admin'.");
         }
-        return this.apiPost(`/api/teams/${encodeURIComponent(teamId)}/invites`, { email: safeEmail, role });
+        return this.apiPost(`/api/teams/${encodeURIComponent(teamId)}/invites`, {
+            email: safeEmail,
+            role,
+        });
     }
     async teamListInvites(teamId) {
         validateUuid(teamId, "team_id");
@@ -1104,7 +1288,47 @@ class DominusNodeToolkit {
         return this.apiDelete(`/api/teams/${encodeURIComponent(teamId)}/invites/${encodeURIComponent(inviteId)}`);
     }
     // -----------------------------------------------------------------------
-    // getTools() -- returns Mastra createTool() instances for all 53 tools
+    // MPP (Machine Payment Protocol) methods
+    // -----------------------------------------------------------------------
+    async mppInfo() {
+        return this.apiGet("/api/mpp/info");
+    }
+    async payMpp(amountCents, method) {
+        if (!Number.isInteger(amountCents) ||
+            amountCents < 500 ||
+            amountCents > 100_000) {
+            throw new Error("amount_cents must be an integer between 500 and 100,000");
+        }
+        if (!["tempo", "stripe_spt", "lightning"].includes(method)) {
+            throw new Error("method must be one of: tempo, stripe_spt, lightning");
+        }
+        return this.apiPost("/api/mpp/topup", { amountCents, method });
+    }
+    async mppSessionOpen(maxDepositCents, method, poolType = "dc") {
+        if (!Number.isInteger(maxDepositCents) ||
+            maxDepositCents < 500 ||
+            maxDepositCents > 100_000) {
+            throw new Error("max_deposit_cents must be an integer between 500 and 100,000");
+        }
+        if (!["tempo", "stripe_spt", "lightning"].includes(method)) {
+            throw new Error("method must be one of: tempo, stripe_spt, lightning");
+        }
+        if (!["dc", "residential"].includes(poolType)) {
+            throw new Error("pool_type must be dc or residential");
+        }
+        return this.apiPost("/api/mpp/session/open", {
+            maxDepositCents,
+            method,
+            poolType,
+        });
+    }
+    async mppSessionClose(channelId) {
+        if (!channelId)
+            throw new Error("channel_id is required");
+        return this.apiPost("/api/mpp/session/close", { channelId });
+    }
+    // -----------------------------------------------------------------------
+    // getTools() -- returns Mastra createTool() instances for all 57 tools
     // -----------------------------------------------------------------------
     getTools() {
         return [
@@ -1116,25 +1340,30 @@ class DominusNodeToolkit {
                     "Only GET, HEAD, and OPTIONS methods are allowed.",
                 inputSchema: zod_1.z.object({
                     url: zod_1.z.string().describe("Target URL to fetch (http or https)"),
-                    method: zod_1.z.enum(["GET", "HEAD", "OPTIONS"]).default("GET").describe("HTTP method"),
-                    country: zod_1.z.string().optional().describe("ISO 3166-1 alpha-2 country code for geo-targeting (e.g., US, GB, DE)"),
-                    proxyType: zod_1.z.enum(["dc", "residential"]).default("dc").describe("Proxy pool type: dc (datacenter, $3/GB) or residential ($5/GB)"),
+                    method: zod_1.z
+                        .enum(["GET", "HEAD", "OPTIONS"])
+                        .default("GET")
+                        .describe("HTTP method"),
+                    country: zod_1.z
+                        .string()
+                        .optional()
+                        .describe("ISO 3166-1 alpha-2 country code for geo-targeting (e.g., US, GB, DE)"),
+                    proxyType: zod_1.z
+                        .enum(["dc", "residential"])
+                        .default("dc")
+                        .describe("Proxy pool type: dc (datacenter, $3/GB) or residential ($5/GB)"),
                 }),
                 outputSchema: zod_1.z.object({
                     status: zod_1.z.number(),
                     headers: zod_1.z.record(zod_1.z.string()),
                     body: zod_1.z.string(),
+                    bytes: zod_1.z.number(),
                     pool: zod_1.z.string(),
                     country: zod_1.z.string(),
                     error: zod_1.z.string().optional(),
                 }),
                 execute: async ({ context }) => {
-                    try {
-                        return await this.proxiedFetch(context.url, context.method, context.country, context.proxyType);
-                    }
-                    catch (err) {
-                        return { status: 0, headers: {}, body: "", pool: context.proxyType ?? "dc", country: context.country ?? "auto", error: safeError(err) };
-                    }
+                    return await this.proxiedFetch(context.url, context.method, context.country, context.proxyType);
                 },
             }),
             // 2. check_balance
@@ -1155,7 +1384,13 @@ class DominusNodeToolkit {
                         return await this.checkBalance();
                     }
                     catch (err) {
-                        return { balanceCents: 0, balanceUsd: 0, dcGbRemaining: "0", resGbRemaining: "0", error: safeError(err) };
+                        return {
+                            balanceCents: 0,
+                            balanceUsd: 0,
+                            dcGbRemaining: "0",
+                            resGbRemaining: "0",
+                            error: safeError(err),
+                        };
                     }
                 },
             }),
@@ -1165,7 +1400,12 @@ class DominusNodeToolkit {
                 description: "View bandwidth usage statistics for a specified time period. " +
                     "Shows total bytes transferred, total cost, and request count.",
                 inputSchema: zod_1.z.object({
-                    days: zod_1.z.number().min(1).max(365).default(30).describe("Number of days to look back (1-365)"),
+                    days: zod_1.z
+                        .number()
+                        .min(1)
+                        .max(365)
+                        .default(30)
+                        .describe("Number of days to look back (1-365)"),
                 }),
                 outputSchema: zod_1.z.object({
                     totalBytes: zod_1.z.number(),
@@ -1179,7 +1419,13 @@ class DominusNodeToolkit {
                         return await this.checkUsage(context.days);
                     }
                     catch (err) {
-                        return { totalBytes: 0, totalCostUsd: 0, requestCount: 0, period: `${context.days} days`, error: safeError(err) };
+                        return {
+                            totalBytes: 0,
+                            totalCostUsd: 0,
+                            requestCount: 0,
+                            period: `${context.days} days`,
+                            error: safeError(err),
+                        };
                     }
                 },
             }),
@@ -1226,12 +1472,29 @@ class DominusNodeToolkit {
                 description: "Create a server-side custodial agentic wallet for autonomous proxy billing. " +
                     "Set a spending limit per transaction for safety. Optionally set a daily budget cap and domain allowlist.",
                 inputSchema: zod_1.z.object({
-                    label: zod_1.z.string().min(1).max(100).describe('Label for this wallet (e.g., "scraper-bot", "research-agent")'),
-                    spendingLimitCents: zod_1.z.number().int().min(0).max(1000000).default(10000)
+                    label: zod_1.z
+                        .string()
+                        .min(1)
+                        .max(100)
+                        .describe('Label for this wallet (e.g., "scraper-bot", "research-agent")'),
+                    spendingLimitCents: zod_1.z
+                        .number()
+                        .int()
+                        .min(0)
+                        .max(1000000)
+                        .default(10000)
                         .describe("Max spend per transaction in cents (0 = no limit, default $100 = 10000 cents)"),
-                    dailyLimitCents: zod_1.z.number().int().positive().max(1000000).optional()
+                    dailyLimitCents: zod_1.z
+                        .number()
+                        .int()
+                        .positive()
+                        .max(1000000)
+                        .optional()
                         .describe("Optional daily budget cap in cents (max 1,000,000 = $10,000)"),
-                    allowedDomains: zod_1.z.array(zod_1.z.string().max(253)).max(100).optional()
+                    allowedDomains: zod_1.z
+                        .array(zod_1.z.string().max(253))
+                        .max(100)
+                        .optional()
                         .describe("Optional list of allowed domains for proxy access (max 100 entries)"),
                 }),
                 outputSchema: zod_1.z.object({
@@ -1240,7 +1503,9 @@ class DominusNodeToolkit {
                 }),
                 execute: async ({ context }) => {
                     try {
-                        return { data: await this.createAgenticWallet(context.label, context.spendingLimitCents, context.dailyLimitCents, context.allowedDomains) };
+                        return {
+                            data: await this.createAgenticWallet(context.label, context.spendingLimitCents, context.dailyLimitCents, context.allowedDomains),
+                        };
                     }
                     catch (err) {
                         return { data: null, error: safeError(err) };
@@ -1254,7 +1519,12 @@ class DominusNodeToolkit {
                     "Minimum $1 (100 cents), maximum $10,000 (1000000 cents).",
                 inputSchema: zod_1.z.object({
                     walletId: zod_1.z.string().describe("Agentic wallet ID (UUID)"),
-                    amountCents: zod_1.z.number().int().min(100).max(1000000).describe("Amount in cents to transfer (min 100, max 1000000)"),
+                    amountCents: zod_1.z
+                        .number()
+                        .int()
+                        .min(100)
+                        .max(1000000)
+                        .describe("Amount in cents to transfer (min 100, max 1000000)"),
                 }),
                 outputSchema: zod_1.z.object({
                     data: zod_1.z.unknown(),
@@ -1262,7 +1532,9 @@ class DominusNodeToolkit {
                 }),
                 execute: async ({ context }) => {
                     try {
-                        return { data: await this.fundAgenticWallet(context.walletId, context.amountCents) };
+                        return {
+                            data: await this.fundAgenticWallet(context.walletId, context.amountCents),
+                        };
                     }
                     catch (err) {
                         return { data: null, error: safeError(err) };
@@ -1313,7 +1585,13 @@ class DominusNodeToolkit {
                 description: "Get transaction history for an agentic wallet.",
                 inputSchema: zod_1.z.object({
                     walletId: zod_1.z.string().describe("Agentic wallet ID (UUID)"),
-                    limit: zod_1.z.number().int().min(1).max(100).default(20).describe("Number of transactions to return (1-100, default 20)"),
+                    limit: zod_1.z
+                        .number()
+                        .int()
+                        .min(1)
+                        .max(100)
+                        .default(20)
+                        .describe("Number of transactions to return (1-100, default 20)"),
                 }),
                 outputSchema: zod_1.z.object({
                     data: zod_1.z.unknown(),
@@ -1321,7 +1599,9 @@ class DominusNodeToolkit {
                 }),
                 execute: async ({ context }) => {
                     try {
-                        return { data: await this.agenticTransactions(context.walletId, context.limit) };
+                        return {
+                            data: await this.agenticTransactions(context.walletId, context.limit),
+                        };
                     }
                     catch (err) {
                         return { data: null, error: safeError(err) };
@@ -1397,9 +1677,19 @@ class DominusNodeToolkit {
                     "Set or remove daily budget caps and domain restrictions.",
                 inputSchema: zod_1.z.object({
                     walletId: zod_1.z.string().describe("Agentic wallet ID (UUID)"),
-                    dailyLimitCents: zod_1.z.number().int().positive().max(1000000).nullable().optional()
+                    dailyLimitCents: zod_1.z
+                        .number()
+                        .int()
+                        .positive()
+                        .max(1000000)
+                        .nullable()
+                        .optional()
                         .describe("Daily budget cap in cents (max 1,000,000). Set null to remove."),
-                    allowedDomains: zod_1.z.array(zod_1.z.string().max(253)).max(100).nullable().optional()
+                    allowedDomains: zod_1.z
+                        .array(zod_1.z.string().max(253))
+                        .max(100)
+                        .nullable()
+                        .optional()
                         .describe("List of allowed domains (max 100). Set null to remove restriction."),
                 }),
                 outputSchema: zod_1.z.object({
@@ -1408,7 +1698,9 @@ class DominusNodeToolkit {
                 }),
                 execute: async ({ context }) => {
                     try {
-                        return { data: await this.updateWalletPolicy(context.walletId, context.dailyLimitCents, context.allowedDomains) };
+                        return {
+                            data: await this.updateWalletPolicy(context.walletId, context.dailyLimitCents, context.allowedDomains),
+                        };
                     }
                     catch (err) {
                         return { data: null, error: safeError(err) };
@@ -1421,8 +1713,18 @@ class DominusNodeToolkit {
                 description: "Create a new team with shared wallet billing. " +
                     "Teams allow multiple users to share proxy access and costs.",
                 inputSchema: zod_1.z.object({
-                    name: zod_1.z.string().min(1).max(100).describe("Team name (1-100 characters)"),
-                    maxMembers: zod_1.z.number().int().min(1).max(100).optional().describe("Maximum number of team members (1-100, optional)"),
+                    name: zod_1.z
+                        .string()
+                        .min(1)
+                        .max(100)
+                        .describe("Team name (1-100 characters)"),
+                    maxMembers: zod_1.z
+                        .number()
+                        .int()
+                        .min(1)
+                        .max(100)
+                        .optional()
+                        .describe("Maximum number of team members (1-100, optional)"),
                 }),
                 outputSchema: zod_1.z.object({
                     data: zod_1.z.unknown(),
@@ -1430,7 +1732,9 @@ class DominusNodeToolkit {
                 }),
                 execute: async ({ context }) => {
                     try {
-                        return { data: await this.createTeam(context.name, context.maxMembers) };
+                        return {
+                            data: await this.createTeam(context.name, context.maxMembers),
+                        };
                     }
                     catch (err) {
                         return { data: null, error: safeError(err) };
@@ -1482,7 +1786,12 @@ class DominusNodeToolkit {
                     "Minimum $1 (100 cents), maximum $10,000 (1000000 cents).",
                 inputSchema: zod_1.z.object({
                     teamId: zod_1.z.string().describe("Team ID (UUID)"),
-                    amountCents: zod_1.z.number().int().min(100).max(1000000).describe("Amount in cents to transfer (min 100, max 1000000)"),
+                    amountCents: zod_1.z
+                        .number()
+                        .int()
+                        .min(100)
+                        .max(1000000)
+                        .describe("Amount in cents to transfer (min 100, max 1000000)"),
                 }),
                 outputSchema: zod_1.z.object({
                     data: zod_1.z.unknown(),
@@ -1490,7 +1799,9 @@ class DominusNodeToolkit {
                 }),
                 execute: async ({ context }) => {
                     try {
-                        return { data: await this.teamFund(context.teamId, context.amountCents) };
+                        return {
+                            data: await this.teamFund(context.teamId, context.amountCents),
+                        };
                     }
                     catch (err) {
                         return { data: null, error: safeError(err) };
@@ -1504,7 +1815,11 @@ class DominusNodeToolkit {
                     "The key is shown only once -- save it immediately.",
                 inputSchema: zod_1.z.object({
                     teamId: zod_1.z.string().describe("Team ID (UUID)"),
-                    label: zod_1.z.string().min(1).max(100).describe('Label for the API key (e.g., "production", "staging")'),
+                    label: zod_1.z
+                        .string()
+                        .min(1)
+                        .max(100)
+                        .describe('Label for the API key (e.g., "production", "staging")'),
                 }),
                 outputSchema: zod_1.z.object({
                     data: zod_1.z.unknown(),
@@ -1512,7 +1827,9 @@ class DominusNodeToolkit {
                 }),
                 execute: async ({ context }) => {
                     try {
-                        return { data: await this.teamCreateKey(context.teamId, context.label) };
+                        return {
+                            data: await this.teamCreateKey(context.teamId, context.label),
+                        };
                     }
                     catch (err) {
                         return { data: null, error: safeError(err) };
@@ -1525,7 +1842,13 @@ class DominusNodeToolkit {
                 description: "Get the team wallet transaction history (funding, usage charges, refunds).",
                 inputSchema: zod_1.z.object({
                     teamId: zod_1.z.string().describe("Team ID (UUID)"),
-                    limit: zod_1.z.number().int().min(1).max(100).default(20).describe("Number of transactions to return (1-100, default 20)"),
+                    limit: zod_1.z
+                        .number()
+                        .int()
+                        .min(1)
+                        .max(100)
+                        .default(20)
+                        .describe("Number of transactions to return (1-100, default 20)"),
                 }),
                 outputSchema: zod_1.z.object({
                     data: zod_1.z.unknown(),
@@ -1533,7 +1856,9 @@ class DominusNodeToolkit {
                 }),
                 execute: async ({ context }) => {
                     try {
-                        return { data: await this.teamUsage(context.teamId, context.limit) };
+                        return {
+                            data: await this.teamUsage(context.teamId, context.limit),
+                        };
                     }
                     catch (err) {
                         return { data: null, error: safeError(err) };
@@ -1546,8 +1871,19 @@ class DominusNodeToolkit {
                 description: "Update a team's settings (name and/or max member count). Only owners and admins can update.",
                 inputSchema: zod_1.z.object({
                     teamId: zod_1.z.string().describe("Team ID (UUID)"),
-                    name: zod_1.z.string().min(1).max(100).optional().describe("New team name (1-100 characters)"),
-                    maxMembers: zod_1.z.number().int().min(1).max(100).optional().describe("New max member count (1-100)"),
+                    name: zod_1.z
+                        .string()
+                        .min(1)
+                        .max(100)
+                        .optional()
+                        .describe("New team name (1-100 characters)"),
+                    maxMembers: zod_1.z
+                        .number()
+                        .int()
+                        .min(1)
+                        .max(100)
+                        .optional()
+                        .describe("New max member count (1-100)"),
                 }),
                 outputSchema: zod_1.z.object({
                     data: zod_1.z.unknown(),
@@ -1555,7 +1891,9 @@ class DominusNodeToolkit {
                 }),
                 execute: async ({ context }) => {
                     try {
-                        return { data: await this.updateTeam(context.teamId, context.name, context.maxMembers) };
+                        return {
+                            data: await this.updateTeam(context.teamId, context.name, context.maxMembers),
+                        };
                     }
                     catch (err) {
                         return { data: null, error: safeError(err) };
@@ -1568,7 +1906,9 @@ class DominusNodeToolkit {
                 description: "Update a team member's role (member or admin). Only owners and admins can change roles.",
                 inputSchema: zod_1.z.object({
                     teamId: zod_1.z.string().describe("Team ID (UUID)"),
-                    userId: zod_1.z.string().describe("User ID (UUID) of the member whose role to change"),
+                    userId: zod_1.z
+                        .string()
+                        .describe("User ID (UUID) of the member whose role to change"),
                     role: zod_1.z.enum(["member", "admin"]).describe("New role for the member"),
                 }),
                 outputSchema: zod_1.z.object({
@@ -1577,7 +1917,9 @@ class DominusNodeToolkit {
                 }),
                 execute: async ({ context }) => {
                     try {
-                        return { data: await this.updateTeamMemberRole(context.teamId, context.userId, context.role) };
+                        return {
+                            data: await this.updateTeamMemberRole(context.teamId, context.userId, context.role),
+                        };
                     }
                     catch (err) {
                         return { data: null, error: safeError(err) };
@@ -1590,7 +1932,11 @@ class DominusNodeToolkit {
                 description: "Top up your Dominus Node wallet balance via PayPal. Creates a PayPal order and returns " +
                     "an approval URL to complete payment. Minimum $5 (500 cents), maximum $1,000 (100000 cents).",
                 inputSchema: zod_1.z.object({
-                    amountCents: zod_1.z.number().int().min(500).max(100000)
+                    amountCents: zod_1.z
+                        .number()
+                        .int()
+                        .min(500)
+                        .max(100000)
                         .describe("Amount in cents to top up (min 500 = $5, max 100000 = $1,000)"),
                 }),
                 outputSchema: zod_1.z.object({
@@ -1612,7 +1958,11 @@ class DominusNodeToolkit {
                 description: "Top up your Dominus Node wallet balance via Stripe. Creates a Stripe checkout session and returns " +
                     "a checkout URL to complete payment. Minimum $5 (500 cents), maximum $1,000 (100000 cents).",
                 inputSchema: zod_1.z.object({
-                    amountCents: zod_1.z.number().int().min(500).max(100000)
+                    amountCents: zod_1.z
+                        .number()
+                        .int()
+                        .min(500)
+                        .max(100000)
                         .describe("Amount in cents to top up (min 500 = $5, max 100000 = $1,000)"),
                 }),
                 outputSchema: zod_1.z.object({
@@ -1635,9 +1985,25 @@ class DominusNodeToolkit {
                     "Supports BTC, ETH, LTC, XMR, ZEC, USDC, SOL, USDT, DAI, BNB, LINK. " +
                     "Minimum $5, maximum $1,000.",
                 inputSchema: zod_1.z.object({
-                    amountUsd: zod_1.z.number().min(5).max(1000)
+                    amountUsd: zod_1.z
+                        .number()
+                        .min(5)
+                        .max(1000)
                         .describe("Amount in USD to top up (5-1000)"),
-                    currency: zod_1.z.enum(["btc", "eth", "ltc", "xmr", "zec", "usdc", "sol", "usdt", "dai", "bnb", "link"])
+                    currency: zod_1.z
+                        .enum([
+                        "btc",
+                        "eth",
+                        "ltc",
+                        "xmr",
+                        "zec",
+                        "usdc",
+                        "sol",
+                        "usdt",
+                        "dai",
+                        "bnb",
+                        "link",
+                    ])
                         .describe("Cryptocurrency to pay with"),
                 }),
                 outputSchema: zod_1.z.object({
@@ -1646,7 +2012,9 @@ class DominusNodeToolkit {
                 }),
                 execute: async ({ context }) => {
                     try {
-                        return { data: await this.topupCrypto(context.amountUsd, context.currency) };
+                        return {
+                            data: await this.topupCrypto(context.amountUsd, context.currency),
+                        };
                     }
                     catch (err) {
                         return { data: null, error: safeError(err) };
@@ -1696,7 +2064,13 @@ class DominusNodeToolkit {
                 id: "dominusnode_get_transactions",
                 description: "Get wallet transaction history showing top-ups, charges, and refunds.",
                 inputSchema: zod_1.z.object({
-                    limit: zod_1.z.number().int().min(1).max(100).default(20).describe("Number of transactions to return (1-100, default 20)"),
+                    limit: zod_1.z
+                        .number()
+                        .int()
+                        .min(1)
+                        .max(100)
+                        .default(20)
+                        .describe("Number of transactions to return (1-100, default 20)"),
                 }),
                 outputSchema: zod_1.z.object({
                     data: zod_1.z.unknown(),
@@ -1736,7 +2110,9 @@ class DominusNodeToolkit {
                 description: "Check the status of a crypto top-up payment by invoice ID. " +
                     "Returns payment status (pending, confirming, completed, expired).",
                 inputSchema: zod_1.z.object({
-                    invoiceId: zod_1.z.string().describe("Crypto invoice ID (UUID) returned from topup_crypto"),
+                    invoiceId: zod_1.z
+                        .string()
+                        .describe("Crypto invoice ID (UUID) returned from topup_crypto"),
                 }),
                 outputSchema: zod_1.z.object({
                     data: zod_1.z.unknown(),
@@ -1757,7 +2133,13 @@ class DominusNodeToolkit {
                 description: "Get daily bandwidth usage breakdown for the specified number of days. " +
                     "Returns per-day bytes transferred and cost.",
                 inputSchema: zod_1.z.object({
-                    days: zod_1.z.number().int().min(1).max(365).default(7).describe("Number of days to look back (1-365, default 7)"),
+                    days: zod_1.z
+                        .number()
+                        .int()
+                        .min(1)
+                        .max(365)
+                        .default(7)
+                        .describe("Number of days to look back (1-365, default 7)"),
                 }),
                 outputSchema: zod_1.z.object({
                     data: zod_1.z.unknown(),
@@ -1777,7 +2159,13 @@ class DominusNodeToolkit {
                 id: "dominusnode_get_top_hosts",
                 description: "Get the top hosts by bandwidth usage. Shows which domains consume the most proxy traffic.",
                 inputSchema: zod_1.z.object({
-                    limit: zod_1.z.number().int().min(1).max(100).default(10).describe("Number of top hosts to return (1-100, default 10)"),
+                    limit: zod_1.z
+                        .number()
+                        .int()
+                        .min(1)
+                        .max(100)
+                        .default(10)
+                        .describe("Number of top hosts to return (1-100, default 10)"),
                 }),
                 outputSchema: zod_1.z.object({
                     data: zod_1.z.unknown(),
@@ -1799,7 +2187,11 @@ class DominusNodeToolkit {
                     "Returns user info and initial API key.",
                 inputSchema: zod_1.z.object({
                     email: zod_1.z.string().describe("Email address for the new account"),
-                    password: zod_1.z.string().min(8).max(128).describe("Password (8-128 characters)"),
+                    password: zod_1.z
+                        .string()
+                        .min(8)
+                        .max(128)
+                        .describe("Password (8-128 characters)"),
                 }),
                 outputSchema: zod_1.z.object({
                     data: zod_1.z.unknown(),
@@ -1807,7 +2199,9 @@ class DominusNodeToolkit {
                 }),
                 execute: async ({ context }) => {
                     try {
-                        return { data: await this.register(context.email, context.password) };
+                        return {
+                            data: await this.register(context.email, context.password),
+                        };
                     }
                     catch (err) {
                         return { data: null, error: safeError(err) };
@@ -1860,7 +2254,9 @@ class DominusNodeToolkit {
                 description: "Verify an email address using the verification token sent to the user's email. " +
                     "Does not require authentication.",
                 inputSchema: zod_1.z.object({
-                    token: zod_1.z.string().describe("Email verification token from the verification email"),
+                    token: zod_1.z
+                        .string()
+                        .describe("Email verification token from the verification email"),
                 }),
                 outputSchema: zod_1.z.object({
                     data: zod_1.z.unknown(),
@@ -1898,8 +2294,16 @@ class DominusNodeToolkit {
                 id: "dominusnode_update_password",
                 description: "Change your account password. Requires current password for verification.",
                 inputSchema: zod_1.z.object({
-                    currentPassword: zod_1.z.string().min(8).max(128).describe("Current account password"),
-                    newPassword: zod_1.z.string().min(8).max(128).describe("New password (8-128 characters)"),
+                    currentPassword: zod_1.z
+                        .string()
+                        .min(8)
+                        .max(128)
+                        .describe("Current account password"),
+                    newPassword: zod_1.z
+                        .string()
+                        .min(8)
+                        .max(128)
+                        .describe("New password (8-128 characters)"),
                 }),
                 outputSchema: zod_1.z.object({
                     data: zod_1.z.unknown(),
@@ -1907,7 +2311,9 @@ class DominusNodeToolkit {
                 }),
                 execute: async ({ context }) => {
                     try {
-                        return { data: await this.updatePassword(context.currentPassword, context.newPassword) };
+                        return {
+                            data: await this.updatePassword(context.currentPassword, context.newPassword),
+                        };
                     }
                     catch (err) {
                         return { data: null, error: safeError(err) };
@@ -1938,7 +2344,11 @@ class DominusNodeToolkit {
                 description: "Create a new personal API key. The key is shown only once -- save it immediately. " +
                     "Usage is billed against your personal wallet.",
                 inputSchema: zod_1.z.object({
-                    label: zod_1.z.string().min(1).max(100).describe('Label for the API key (e.g., "production", "dev-testing")'),
+                    label: zod_1.z
+                        .string()
+                        .min(1)
+                        .max(100)
+                        .describe('Label for the API key (e.g., "production", "dev-testing")'),
                 }),
                 outputSchema: zod_1.z.object({
                     data: zod_1.z.unknown(),
@@ -2067,7 +2477,9 @@ class DominusNodeToolkit {
                 }),
                 execute: async ({ context }) => {
                     try {
-                        return { data: await this.teamRevokeKey(context.teamId, context.keyId) };
+                        return {
+                            data: await this.teamRevokeKey(context.teamId, context.keyId),
+                        };
                     }
                     catch (err) {
                         return { data: null, error: safeError(err) };
@@ -2122,7 +2534,10 @@ class DominusNodeToolkit {
                 inputSchema: zod_1.z.object({
                     teamId: zod_1.z.string().describe("Team ID (UUID)"),
                     userId: zod_1.z.string().describe("User ID (UUID) of the user to add"),
-                    role: zod_1.z.enum(["member", "admin"]).default("member").describe("Role for the new member"),
+                    role: zod_1.z
+                        .enum(["member", "admin"])
+                        .default("member")
+                        .describe("Role for the new member"),
                 }),
                 outputSchema: zod_1.z.object({
                     data: zod_1.z.unknown(),
@@ -2130,7 +2545,9 @@ class DominusNodeToolkit {
                 }),
                 execute: async ({ context }) => {
                     try {
-                        return { data: await this.teamAddMember(context.teamId, context.userId, context.role) };
+                        return {
+                            data: await this.teamAddMember(context.teamId, context.userId, context.role),
+                        };
                     }
                     catch (err) {
                         return { data: null, error: safeError(err) };
@@ -2151,7 +2568,9 @@ class DominusNodeToolkit {
                 }),
                 execute: async ({ context }) => {
                     try {
-                        return { data: await this.teamRemoveMember(context.teamId, context.userId) };
+                        return {
+                            data: await this.teamRemoveMember(context.teamId, context.userId),
+                        };
                     }
                     catch (err) {
                         return { data: null, error: safeError(err) };
@@ -2166,7 +2585,10 @@ class DominusNodeToolkit {
                 inputSchema: zod_1.z.object({
                     teamId: zod_1.z.string().describe("Team ID (UUID)"),
                     email: zod_1.z.string().describe("Email address of the user to invite"),
-                    role: zod_1.z.enum(["member", "admin"]).default("member").describe("Role for the invited member"),
+                    role: zod_1.z
+                        .enum(["member", "admin"])
+                        .default("member")
+                        .describe("Role for the invited member"),
                 }),
                 outputSchema: zod_1.z.object({
                     data: zod_1.z.unknown(),
@@ -2174,7 +2596,9 @@ class DominusNodeToolkit {
                 }),
                 execute: async ({ context }) => {
                     try {
-                        return { data: await this.teamInviteMember(context.teamId, context.email, context.role) };
+                        return {
+                            data: await this.teamInviteMember(context.teamId, context.email, context.role),
+                        };
                     }
                     catch (err) {
                         return { data: null, error: safeError(err) };
@@ -2215,7 +2639,116 @@ class DominusNodeToolkit {
                 }),
                 execute: async ({ context }) => {
                     try {
-                        return { data: await this.teamCancelInvite(context.teamId, context.inviteId) };
+                        return {
+                            data: await this.teamCancelInvite(context.teamId, context.inviteId),
+                        };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 54 (MPP). mpp_info
+            (0, tools_1.createTool)({
+                id: "dominusnode_mpp_info",
+                description: "Get Machine Payment Protocol (MPP) information including enabled status, " +
+                    "supported payment methods, pricing, and session limits.",
+                inputSchema: zod_1.z.object({}),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async () => {
+                    try {
+                        return { data: await this.mppInfo() };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 55 (MPP). pay_mpp
+            (0, tools_1.createTool)({
+                id: "dominusnode_pay_mpp",
+                description: "Top up wallet via Machine Payment Protocol (MPP). " +
+                    "Supports tempo, stripe_spt, and lightning payment methods.",
+                inputSchema: zod_1.z.object({
+                    amountCents: zod_1.z
+                        .number()
+                        .int()
+                        .min(500)
+                        .max(100000)
+                        .describe("Amount in cents to top up"),
+                    method: zod_1.z
+                        .enum(["tempo", "stripe_spt", "lightning"])
+                        .describe("MPP payment method"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return {
+                            data: await this.payMpp(context.amountCents, context.method),
+                        };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 56 (MPP). mpp_session_open
+            (0, tools_1.createTool)({
+                id: "dominusnode_mpp_session_open",
+                description: "Open a pay-as-you-go MPP session. Returns a channelId for metered proxy usage.",
+                inputSchema: zod_1.z.object({
+                    maxDepositCents: zod_1.z
+                        .number()
+                        .int()
+                        .min(500)
+                        .max(100000)
+                        .describe("Maximum deposit in cents"),
+                    method: zod_1.z
+                        .enum(["tempo", "stripe_spt", "lightning"])
+                        .describe("MPP payment method"),
+                    poolType: zod_1.z
+                        .enum(["dc", "residential"])
+                        .default("dc")
+                        .describe("Proxy pool type"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return {
+                            data: await this.mppSessionOpen(context.maxDepositCents, context.method, context.poolType),
+                        };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 57 (MPP). mpp_session_close
+            (0, tools_1.createTool)({
+                id: "dominusnode_mpp_session_close",
+                description: "Close an MPP pay-as-you-go session. Returns the amount spent and refunded.",
+                inputSchema: zod_1.z.object({
+                    channelId: zod_1.z
+                        .string()
+                        .min(1)
+                        .describe("The channelId returned from mpp_session_open"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.mppSessionClose(context.channelId) };
                     }
                     catch (err) {
                         return { data: null, error: safeError(err) };