@dominusnode/mastra-tools 1.3.1 → 1.5.2

package/CHANGELOG.md

@@ -3,12 +3,14 @@
 ## 1.1.0
 
 ### Added
+
 - Stripe checkout top-up tool (`dominusnode_topup_stripe`) — create Stripe Checkout sessions ($5–$1,000)
 - Crypto top-up tool (`dominusnode_topup_crypto`) — NOWPayments invoices for BTC, ETH, LTC, XMR, ZEC, USDC, SOL, USDT, DAI, BNB, LINK ($5–$1,000)
 - `dominusnode_update_wallet_policy` tool — update daily limits and domain allowlists for agentic wallets
 - Comprehensive test suite: 167 tests covering SSRF protection (incl. DNS rebinding), input validation, credential scrubbing, payment response fields, and all 26 tools
 
 ### Fixed
+
 - `topupCrypto`: use `Number.isFinite()` instead of `isNaN()` to correctly reject `NaN` and `Infinity` inputs
 
 ## 1.0.1

package/README.md

@@ -28,16 +28,17 @@ const balance = await toolkit.checkBalance();
 
 ## Configuration
 
-| Environment Variable | Description | Default |
-|---|---|---|
-| `DOMINUSNODE_API_KEY` | API key (required) | -- |
-| `DOMINUSNODE_BASE_URL` | REST API base URL | `https://api.dominusnode.com` |
-| `DOMINUSNODE_PROXY_HOST` | Proxy gateway host | `proxy.dominusnode.com` |
-| `DOMINUSNODE_PROXY_PORT` | Proxy gateway port | `8080` |
+| Environment Variable     | Description        | Default                       |
+| ------------------------ | ------------------ | ----------------------------- |
+| `DOMINUSNODE_API_KEY`    | API key (required) | --                            |
+| `DOMINUSNODE_BASE_URL`   | REST API base URL  | `https://api.dominusnode.com` |
+| `DOMINUSNODE_PROXY_HOST` | Proxy gateway host | `proxy.dominusnode.com`       |
+| `DOMINUSNODE_PROXY_PORT` | Proxy gateway port | `8080`                        |
 
 ## Available Tools (26)
 
 ### Proxy Operations
+
 - `dominusnode_proxied_fetch` - Fetch a URL through the rotating proxy with geo-targeting
 - `dominusnode_check_balance` - Check wallet balance and remaining bandwidth
 - `dominusnode_check_usage` - View bandwidth usage statistics
@@ -45,6 +46,7 @@ const balance = await toolkit.checkBalance();
 - `dominusnode_list_sessions` - List active proxy sessions
 
 ### Agentic Wallet Management
+
 - `dominusnode_create_agentic_wallet` - Create a custodial sub-wallet
 - `dominusnode_fund_agentic_wallet` - Transfer funds to an agentic wallet
 - `dominusnode_agentic_wallet_balance` - Check agentic wallet balance
@@ -56,6 +58,7 @@ const balance = await toolkit.checkBalance();
 - `dominusnode_update_wallet_policy` - Update daily limits and domain restrictions
 
 ### Team Management
+
 - `dominusnode_create_team` - Create a team with shared wallet
 - `dominusnode_list_teams` - List all teams
 - `dominusnode_team_details` - Get team details
@@ -66,6 +69,7 @@ const balance = await toolkit.checkBalance();
 - `dominusnode_update_team_member_role` - Change a member's role
 
 ### Payments
+
 - `dominusnode_topup_paypal` - Top up wallet via PayPal ($5–$1,000)
 - `dominusnode_topup_stripe` - Top up wallet via Stripe ($5–$1,000)
 - `dominusnode_topup_crypto` - Top up wallet via crypto (BTC/ETH/LTC/XMR/ZEC/USDC/SOL/USDT/DAI/BNB/LINK)

package/dist/toolkit.d.ts

@@ -69,6 +69,8 @@ export declare class DominusNodeToolkit {
     private cachedJwt;
     private jwtExpiresAt;
     constructor(config?: DominusNodeToolkitConfig);
+    private static countLeadingZeroBits;
+    private solvePoW;
     private getApiKey;
     private ensureAuth;
     private apiRequest;
@@ -157,6 +159,10 @@ export declare class DominusNodeToolkit {
     teamInviteMember(teamId: string, email: string, role?: string): Promise<Record<string, unknown>>;
     teamListInvites(teamId: string): Promise<Record<string, unknown>>;
     teamCancelInvite(teamId: string, inviteId: string): Promise<Record<string, unknown>>;
+    mppInfo(): Promise<Record<string, unknown>>;
+    payMpp(amountCents: number, method: string): Promise<Record<string, unknown>>;
+    mppSessionOpen(maxDepositCents: number, method: string, poolType?: string): Promise<Record<string, unknown>>;
+    mppSessionClose(channelId: string): Promise<Record<string, unknown>>;
     getTools(): (import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
         context: any;
     }, {
@@ -417,5 +423,23 @@ export declare class DominusNodeToolkit {
     }, {
         error?: string | undefined;
         data?: unknown;
-    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_team_cancel_invite", unknown>)[];
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_team_cancel_invite", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<unknown, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_mpp_info", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_pay_mpp", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_mpp_session_open", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_mpp_session_close", unknown>)[];
 }

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_").');
         }
@@ -609,7 +673,15 @@ class DominusNodeToolkit {
             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.` };
+                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 = [];
@@ -624,13 +696,18 @@ class DominusNodeToolkit {
             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 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}` },
+                        headers: {
+                            "Proxy-Authorization": proxyAuth,
+                            Host: `${connectHost}:${parsed.port || 443}`,
+                        },
                     });
                     connectReq.on("connect", (_res, sock) => {
                         if (_res.statusCode !== 200) {
@@ -639,7 +716,12 @@ class DominusNodeToolkit {
                             reject(new Error(`CONNECT failed: ${_res.statusCode}`));
                             return;
                         }
-                        const tlsSock = tls.connect({ host: parsed.hostname, socket: sock, servername: parsed.hostname, minVersion: "TLSv1.2" }, () => {
+                        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 = [];
@@ -664,22 +746,40 @@ class DominusNodeToolkit {
                                 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 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();
+                                        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 });
+                                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);
+                            });
+                        });
+                        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.on("error", (e) => {
+                        clearTimeout(timer);
+                        reject(e);
+                    });
                     connectReq.end();
                 }
                 else {
@@ -688,7 +788,10 @@ class DominusNodeToolkit {
                         port: this.proxyPort,
                         method: methodUpper,
                         path: url,
-                        headers: { "Proxy-Authorization": proxyAuth, Host: parsed.host ?? "" },
+                        headers: {
+                            "Proxy-Authorization": proxyAuth,
+                            Host: parsed.host ?? "",
+                        },
                     }, (res) => {
                         const chunks = [];
                         let bytes = 0;
@@ -703,20 +806,33 @@ class DominusNodeToolkit {
                                 return;
                             done = true;
                             clearTimeout(timer);
-                            const body = Buffer.concat(chunks).toString("utf-8").substring(0, MAX_RESP);
+                            const body = Buffer.concat(chunks)
+                                .toString("utf-8")
+                                .substring(0, MAX_RESP);
                             const bodyBytes = new TextEncoder().encode(body).length;
                             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, bytes: bodyBytes });
+                            resolve({
+                                status: res.statusCode ?? 0,
+                                headers: hdrs,
+                                body,
+                                bytes: bodyBytes,
+                            });
                         };
                         res.on("end", fin);
                         res.on("close", fin);
-                        res.on("error", (e) => { clearTimeout(timer); reject(e); });
+                        res.on("error", (e) => {
+                            clearTimeout(timer);
+                            reject(e);
+                        });
+                    });
+                    req.on("error", (e) => {
+                        clearTimeout(timer);
+                        reject(e);
                     });
-                    req.on("error", (e) => { clearTimeout(timer); reject(e); });
                     req.end();
                 }
             });
@@ -773,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;
@@ -801,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;
@@ -830,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 });
@@ -884,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 });
@@ -897,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");
@@ -937,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");
@@ -1013,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");
@@ -1030,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");
@@ -1095,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");
@@ -1108,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");
@@ -1120,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 [
@@ -1132,9 +1340,18 @@ 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(),
@@ -1167,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),
+                        };
                     }
                 },
             }),
@@ -1177,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(),
@@ -1191,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),
+                        };
                     }
                 },
             }),
@@ -1238,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({
@@ -1252,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) };
@@ -1266,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(),
@@ -1274,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) };
@@ -1325,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(),
@@ -1333,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) };
@@ -1409,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({
@@ -1420,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) };
@@ -1433,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(),
@@ -1442,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) };
@@ -1494,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(),
@@ -1502,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) };
@@ -1516,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(),
@@ -1524,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) };
@@ -1537,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(),
@@ -1545,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) };
@@ -1558,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(),
@@ -1567,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) };
@@ -1580,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({
@@ -1589,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) };
@@ -1602,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({
@@ -1624,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({
@@ -1647,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({
@@ -1658,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) };
@@ -1708,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(),
@@ -1748,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(),
@@ -1769,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(),
@@ -1789,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(),
@@ -1811,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(),
@@ -1819,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) };
@@ -1872,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(),
@@ -1910,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(),
@@ -1919,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) };
@@ -1950,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(),
@@ -2079,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) };
@@ -2134,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(),
@@ -2142,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) };
@@ -2163,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) };
@@ -2178,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(),
@@ -2186,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) };
@@ -2227,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) };

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@dominusnode/mastra-tools",
-  "version": "1.3.1",
+  "version": "1.5.2",
   "description": "Dominus Node rotating proxy tools for Mastra AI",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
+    "prepare": "npm run build",
     "test": "vitest run"
   },
   "dependencies": {