@dominusnode/flowise-tools 1.3.0 → 1.5.2

package/dist/toolkit.js

@@ -68,6 +68,7 @@ exports.formatCents = formatCents;
 // @ts-ignore
 const tools_1 = require("@langchain/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"));
@@ -89,7 +90,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);
@@ -101,7 +102,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
@@ -387,12 +389,71 @@ class DominusNodeToolkit {
         this.token = null;
         this.tokenExpiresAt = 0;
         this.apiKey = options.apiKey || process.env.DOMINUSNODE_API_KEY || "";
-        this.baseUrl = (options.baseUrl || process.env.DOMINUSNODE_BASE_URL || "https://api.dominusnode.com").replace(/\/+$/, "");
-        this.proxyHost = options.proxyHost || process.env.DOMINUSNODE_PROXY_HOST || "proxy.dominusnode.com";
+        this.baseUrl = (options.baseUrl ||
+            process.env.DOMINUSNODE_BASE_URL ||
+            "https://api.dominusnode.com").replace(/\/+$/, "");
+        this.proxyHost =
+            options.proxyHost ||
+                process.env.DOMINUSNODE_PROXY_HOST ||
+                "proxy.dominusnode.com";
         const portVal = Number(options.proxyPort || process.env.DOMINUSNODE_PROXY_PORT || 8080);
-        this.proxyPort = isNaN(portVal) || portVal < 1 || portVal > 65535 ? 8080 : portVal;
+        this.proxyPort =
+            isNaN(portVal) || portVal < 1 || portVal > 65535 ? 8080 : portVal;
         this.timeout = options.timeout || 30000;
-        this.agentSecret = options.agentSecret || process.env.DOMINUSNODE_AGENT_SECRET;
+        this.agentSecret =
+            options.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 > 10485760)
+                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 < 100000000; 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
@@ -401,7 +462,8 @@ class DominusNodeToolkit {
         if (!this.apiKey) {
             throw new Error("Dominus Node API key is required. Pass apiKey in options or set DOMINUSNODE_API_KEY env var.");
         }
-        if (!this.apiKey.startsWith("dn_live_") && !this.apiKey.startsWith("dn_test_")) {
+        if (!this.apiKey.startsWith("dn_live_") &&
+            !this.apiKey.startsWith("dn_test_")) {
             throw new Error('DOMINUSNODE_API_KEY must start with "dn_live_" or "dn_test_".');
         }
         const authHeaders = {
@@ -606,7 +668,9 @@ class DominusNodeToolkit {
             if (!ALLOWED_METHODS.has(methodUpper)) {
                 return `Error: HTTP method "${methodUpper}" is not allowed. Only GET, HEAD, and OPTIONS are permitted.`;
             }
-            if (proxyType !== "dc" && proxyType !== "residential" && proxyType !== "auto") {
+            if (proxyType !== "dc" &&
+                proxyType !== "residential" &&
+                proxyType !== "auto") {
                 return "Error: proxyType must be 'dc', 'residential', or 'auto'.";
             }
             const apiKey = this.apiKey;
@@ -674,13 +738,19 @@ class DominusNodeToolkit {
                                     return;
                                 }
                                 const hdr = raw.substring(0, hEnd);
-                                const respBody = raw.substring(hEnd + 4).substring(0, MAX_PROXY_RESPONSE_BYTES);
-                                const sm = hdr.split("\r\n")[0].match(/^HTTP\/\d\.\d\s+(\d+)/);
+                                const respBody = raw
+                                    .substring(hEnd + 4)
+                                    .substring(0, MAX_PROXY_RESPONSE_BYTES);
+                                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,
@@ -731,13 +801,19 @@ class DominusNodeToolkit {
                                 return;
                             done = true;
                             clearTimeout(timer);
-                            const respBody = Buffer.concat(chunks).toString("utf-8").substring(0, MAX_PROXY_RESPONSE_BYTES);
+                            const respBody = Buffer.concat(chunks)
+                                .toString("utf-8")
+                                .substring(0, MAX_PROXY_RESPONSE_BYTES);
                             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: respBody });
+                            resolve({
+                                status: res.statusCode ?? 0,
+                                headers: hdrs,
+                                body: respBody,
+                            });
                         };
                         res.on("end", fin);
                         res.on("close", fin);
@@ -759,7 +835,13 @@ class DominusNodeToolkit {
                 "",
             ];
             if (result.headers) {
-                const showHeaders = ["content-type", "content-length", "server", "x-cache", "cache-control"];
+                const showHeaders = [
+                    "content-type",
+                    "content-length",
+                    "server",
+                    "x-cache",
+                    "cache-control",
+                ];
                 for (const h of showHeaders) {
                     if (result.headers[h]) {
                         lines.push(`${h}: ${result.headers[h]}`);
@@ -899,7 +981,9 @@ class DominusNodeToolkit {
                 spendingLimitCents: limitCents,
             };
             if (dailyLimitCents !== undefined && dailyLimitCents !== null) {
-                if (!Number.isInteger(dailyLimitCents) || dailyLimitCents < 1 || dailyLimitCents > 1000000) {
+                if (!Number.isInteger(dailyLimitCents) ||
+                    dailyLimitCents < 1 ||
+                    dailyLimitCents > 1000000) {
                     return "Error: daily_limit_cents must be an integer between 1 and 1,000,000.";
                 }
                 body.dailyLimitCents = dailyLimitCents;
@@ -949,7 +1033,9 @@ class DominusNodeToolkit {
                     body.dailyLimitCents = null;
                 }
                 else {
-                    if (!Number.isInteger(dailyLimitCents) || dailyLimitCents < 1 || dailyLimitCents > 1000000) {
+                    if (!Number.isInteger(dailyLimitCents) ||
+                        dailyLimitCents < 1 ||
+                        dailyLimitCents > 1000000) {
                         return "Error: daily_limit_cents must be an integer between 1 and 1,000,000, or null to remove.";
                     }
                     body.dailyLimitCents = dailyLimitCents;
@@ -1006,7 +1092,9 @@ class DominusNodeToolkit {
     async fundAgenticWallet(walletId, amountCents) {
         try {
             const wid = validateUuid(walletId, "wallet_id");
-            if (!Number.isInteger(amountCents) || amountCents < 100 || amountCents > 1000000) {
+            if (!Number.isInteger(amountCents) ||
+                amountCents < 100 ||
+                amountCents > 1000000) {
                 return "Error: amount_cents must be an integer between 100 ($1) and 1000000 ($10,000).";
             }
             const data = await this._requestWithRetry("POST", `/api/agent-wallet/${encodeURIComponent(wid)}/fund`, {
@@ -1060,7 +1148,9 @@ class DominusNodeToolkit {
             }
             const lines = [`Agentic Wallets (${wallets.length})`, ""];
             for (const w of wallets) {
-                const limit = w.spendingLimitCents > 0 ? `${formatCents(w.spendingLimitCents)}/tx` : "none";
+                const limit = w.spendingLimitCents > 0
+                    ? `${formatCents(w.spendingLimitCents)}/tx`
+                    : "none";
                 lines.push(`  ${w.label} (${w.id.slice(0, 8)}...)`);
                 lines.push(`    Balance: ${formatCents(w.balanceCents)} | Limit: ${limit} | Status: ${w.status}`);
                 lines.push("");
@@ -1086,7 +1176,9 @@ class DominusNodeToolkit {
             const lines = [`Wallet Transactions (${txs.length})`, ""];
             for (const tx of txs) {
                 const sign = tx.type === "fund" || tx.type === "refund" ? "+" : "-";
-                const session = tx.sessionId ? ` | Session: ${tx.sessionId.slice(0, 8)}` : "";
+                const session = tx.sessionId
+                    ? ` | Session: ${tx.sessionId.slice(0, 8)}`
+                    : "";
                 lines.push(`  ${sign}${formatCents(tx.amountCents)} [${tx.type}] ${tx.description}`);
                 lines.push(`    ${tx.createdAt}${session}`);
             }
@@ -1173,7 +1265,9 @@ class DominusNodeToolkit {
             }
             const body = { name: name.trim() };
             if (maxMembers !== undefined) {
-                if (!Number.isInteger(maxMembers) || maxMembers < 1 || maxMembers > 100) {
+                if (!Number.isInteger(maxMembers) ||
+                    maxMembers < 1 ||
+                    maxMembers > 100) {
                     return "Error: max_members must be an integer between 1 and 100.";
                 }
                 body.maxMembers = maxMembers;
@@ -1255,7 +1349,9 @@ class DominusNodeToolkit {
     async teamFund(teamId, amountCents) {
         try {
             const tid = validateUuid(teamId, "team_id");
-            if (!Number.isInteger(amountCents) || amountCents < 100 || amountCents > 1000000) {
+            if (!Number.isInteger(amountCents) ||
+                amountCents < 100 ||
+                amountCents > 1000000) {
                 return "Error: amount_cents must be an integer between 100 ($1) and 1000000 ($10,000).";
             }
             const data = await this._requestWithRetry("POST", `/api/teams/${encodeURIComponent(tid)}/wallet/fund`, {
@@ -1351,7 +1447,9 @@ class DominusNodeToolkit {
                 body.name = name.trim();
             }
             if (maxMembers !== undefined) {
-                if (!Number.isInteger(maxMembers) || maxMembers < 1 || maxMembers > 100) {
+                if (!Number.isInteger(maxMembers) ||
+                    maxMembers < 1 ||
+                    maxMembers > 100) {
                     return "Error: max_members must be an integer between 1 and 100.";
                 }
                 body.maxMembers = maxMembers;
@@ -1403,7 +1501,9 @@ class DominusNodeToolkit {
     // -----------------------------------------------------------------------
     async topupPaypal(amountCents) {
         try {
-            if (!Number.isInteger(amountCents) || amountCents < 500 || amountCents > 100000) {
+            if (!Number.isInteger(amountCents) ||
+                amountCents < 500 ||
+                amountCents > 100000) {
                 return "Error: amount_cents must be an integer between 500 ($5) and 100000 ($1,000).";
             }
             const data = await this._requestWithRetry("POST", "/api/wallet/topup/paypal", { amountCents });
@@ -1427,7 +1527,9 @@ class DominusNodeToolkit {
     // -----------------------------------------------------------------------
     async topupStripe(amountCents) {
         try {
-            if (!Number.isInteger(amountCents) || amountCents < 500 || amountCents > 100000) {
+            if (!Number.isInteger(amountCents) ||
+                amountCents < 500 ||
+                amountCents > 100000) {
                 return "Error: amount_cents must be an integer between 500 ($5) and 100000 ($1,000).";
             }
             const data = await this._requestWithRetry("POST", "/api/wallet/topup/stripe", { amountCents });
@@ -1448,7 +1550,10 @@ class DominusNodeToolkit {
     }
     async topupCrypto(amountUsd, currency) {
         try {
-            if (typeof amountUsd !== "number" || !Number.isFinite(amountUsd) || amountUsd < 5 || amountUsd > 1000) {
+            if (typeof amountUsd !== "number" ||
+                !Number.isFinite(amountUsd) ||
+                amountUsd < 5 ||
+                amountUsd > 1000) {
                 return "Error: amount_usd must be a number between 5 and 1,000.";
             }
             const cur = String(currency ?? "").toLowerCase();
@@ -1490,10 +1595,7 @@ class DominusNodeToolkit {
     async getProxyStatus() {
         try {
             const data = await this._requestWithRetry("GET", "/api/proxy/status");
-            const lines = [
-                "Proxy Status",
-                "",
-            ];
+            const lines = ["Proxy Status", ""];
             if (data.status)
                 lines.push(`Status: ${data.status}`);
             if (data.uptime !== undefined)
@@ -1524,7 +1626,9 @@ class DominusNodeToolkit {
             }
             const lines = [`Wallet Transactions (${txs.length})`, ""];
             for (const tx of txs) {
-                const sign = tx.type === "topup" || tx.type === "fund" || tx.type === "refund" ? "+" : "-";
+                const sign = tx.type === "topup" || tx.type === "fund" || tx.type === "refund"
+                    ? "+"
+                    : "-";
                 lines.push(`  ${sign}${formatCents(tx.amountCents)} [${tx.type}] ${tx.description}`);
                 lines.push(`    ${tx.createdAt}`);
             }
@@ -1638,7 +1742,12 @@ class DominusNodeToolkit {
             if (!password || password.length < 8 || password.length > 128) {
                 return "Error: password must be between 8 and 128 characters.";
             }
-            const data = await this._unauthenticatedRequest("POST", "/api/auth/register", { email, password });
+            // Solve PoW for CAPTCHA-free registration
+            const pow = await this._solvePoW();
+            const regBody = { email, password };
+            if (pow)
+                regBody.pow = pow;
+            const data = await this._unauthenticatedRequest("POST", "/api/auth/register", regBody);
             return [
                 "Account Created",
                 "",
@@ -1904,7 +2013,9 @@ class DominusNodeToolkit {
                 "",
                 `New Plan: ${data.name ?? data.id ?? planId}`,
                 data.message ? `Message: ${data.message}` : "",
-            ].filter(Boolean).join("\n");
+            ]
+                .filter(Boolean)
+                .join("\n");
         }
         catch (err) {
             return `Error: ${safeError(err)}`;
@@ -2065,7 +2176,9 @@ class DominusNodeToolkit {
                 `Email: ${data.email ?? email}`,
                 `Role: ${data.role ?? role ?? "member"}`,
                 data.expiresAt ? `Expires: ${data.expiresAt}` : "",
-            ].filter(Boolean).join("\n");
+            ]
+                .filter(Boolean)
+                .join("\n");
         }
         catch (err) {
             return `Error: ${safeError(err)}`;
@@ -2113,6 +2226,67 @@ class DominusNodeToolkit {
         }
     }
     // -----------------------------------------------------------------------
+    // MPP (Machine Payment Protocol) tools
+    // -----------------------------------------------------------------------
+    async mppInfo() {
+        try {
+            const data = await this._requestWithRetry("GET", "/api/mpp/info");
+            return JSON.stringify(data, null, 2);
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    async payMpp(amountCents, method) {
+        if (!Number.isInteger(amountCents) ||
+            amountCents < 500 ||
+            amountCents > 100000) {
+            return "Error: amount_cents must be an integer between 500 and 100,000";
+        }
+        if (!["tempo", "stripe_spt", "lightning"].includes(method)) {
+            return "Error: method must be one of: tempo, stripe_spt, lightning";
+        }
+        try {
+            const data = await this._requestWithRetry("POST", "/api/mpp/topup", { amountCents, method });
+            return JSON.stringify(data, null, 2);
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    async mppSessionOpen(maxDepositCents, method, poolType = "dc") {
+        if (!Number.isInteger(maxDepositCents) ||
+            maxDepositCents < 500 ||
+            maxDepositCents > 100000) {
+            return "Error: max_deposit_cents must be an integer between 500 and 100,000";
+        }
+        if (!["tempo", "stripe_spt", "lightning"].includes(method)) {
+            return "Error: method must be one of: tempo, stripe_spt, lightning";
+        }
+        if (!["dc", "residential"].includes(poolType)) {
+            return "Error: pool_type must be dc or residential";
+        }
+        try {
+            const data = await this._requestWithRetry("POST", "/api/mpp/session/open", { maxDepositCents, method, poolType });
+            return JSON.stringify(data, null, 2);
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    async mppSessionClose(channelId) {
+        if (!channelId) {
+            return "Error: channel_id is required";
+        }
+        try {
+            const data = await this._requestWithRetry("POST", "/api/mpp/session/close", { channelId });
+            return JSON.stringify(data, null, 2);
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
     // getTools() -- returns LangChain DynamicStructuredTool[] for Flowise
     // -----------------------------------------------------------------------
     getTools() {
@@ -2124,11 +2298,20 @@ class DominusNodeToolkit {
                     "by country. Returns status code, headers, and response body (truncated).",
                 schema: zod_1.z.object({
                     url: zod_1.z.string().describe("The 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: dc ($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: dc ($3/GB) or residential ($5/GB)"),
                 }),
-                func: async ({ url, method, country, proxyType }) => {
+                func: async ({ url, method, country, proxyType, }) => {
                     return this.proxiedFetch(url, method, country, proxyType);
                 },
             }),
@@ -2146,7 +2329,12 @@ class DominusNodeToolkit {
                 name: "dominusnode_check_usage",
                 description: "View bandwidth usage statistics for a specified time period. Shows total bytes, cost, and request count.",
                 schema: 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)"),
                 }),
                 func: async ({ days }) => {
                     return this.checkUsage(days);
@@ -2176,7 +2364,11 @@ 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.",
                 schema: zod_1.z.object({
-                    label: zod_1.z.string().min(1).max(100).describe('Label for this wallet (e.g., "scraper-bot")'),
+                    label: zod_1.z
+                        .string()
+                        .min(1)
+                        .max(100)
+                        .describe('Label for this wallet (e.g., "scraper-bot")'),
                     spendingLimitCents: zod_1.z
                         .number()
                         .int()
@@ -2197,7 +2389,7 @@ class DominusNodeToolkit {
                         .optional()
                         .describe("Optional list of allowed domains for proxy access (max 100 entries)"),
                 }),
-                func: async ({ label, spendingLimitCents, dailyLimitCents, allowedDomains }) => {
+                func: async ({ label, spendingLimitCents, dailyLimitCents, allowedDomains, }) => {
                     return this.createAgenticWallet(label, spendingLimitCents, dailyLimitCents, allowedDomains);
                 },
             }),
@@ -2207,7 +2399,12 @@ class DominusNodeToolkit {
                 description: "Transfer funds from your main wallet to an agentic wallet. Min $1, max $10,000.",
                 schema: zod_1.z.object({
                     walletId: zod_1.z.string().uuid().describe("Agentic wallet ID (UUID)"),
-                    amountCents: zod_1.z.number().int().min(100).max(1000000).describe("Amount in cents to transfer"),
+                    amountCents: zod_1.z
+                        .number()
+                        .int()
+                        .min(100)
+                        .max(1000000)
+                        .describe("Amount in cents to transfer"),
                 }),
                 func: async ({ walletId, amountCents }) => {
                     return this.fundAgenticWallet(walletId, amountCents);
@@ -2239,7 +2436,13 @@ class DominusNodeToolkit {
                 description: "Get transaction history for an agentic wallet.",
                 schema: zod_1.z.object({
                     walletId: zod_1.z.string().uuid().describe("Agentic wallet ID (UUID)"),
-                    limit: zod_1.z.number().int().min(1).max(100).default(20).describe("Number of transactions to return"),
+                    limit: zod_1.z
+                        .number()
+                        .int()
+                        .min(1)
+                        .max(100)
+                        .default(20)
+                        .describe("Number of transactions to return"),
                 }),
                 func: async ({ walletId, limit }) => {
                     return this.agenticTransactions(walletId, limit);
@@ -2299,7 +2502,7 @@ class DominusNodeToolkit {
                         .optional()
                         .describe("List of allowed domains (max 100). Set null to remove restriction."),
                 }),
-                func: async ({ walletId, dailyLimitCents, allowedDomains }) => {
+                func: async ({ walletId, dailyLimitCents, allowedDomains, }) => {
                     return this.updateWalletPolicy(walletId, dailyLimitCents, allowedDomains);
                 },
             }),
@@ -2308,8 +2511,18 @@ class DominusNodeToolkit {
                 name: "dominusnode_create_team",
                 description: "Create a new team with shared wallet billing. Teams let multiple users share proxy access.",
                 schema: 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 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 team members (1-100, optional)"),
                 }),
                 func: async ({ name, maxMembers }) => {
                     return this.createTeam(name, maxMembers);
@@ -2341,7 +2554,12 @@ class DominusNodeToolkit {
                 description: "Transfer funds from your personal wallet to a team wallet. Min $1, max $10,000.",
                 schema: zod_1.z.object({
                     teamId: zod_1.z.string().uuid().describe("Team ID (UUID)"),
-                    amountCents: zod_1.z.number().int().min(100).max(1000000).describe("Amount in cents to transfer"),
+                    amountCents: zod_1.z
+                        .number()
+                        .int()
+                        .min(100)
+                        .max(1000000)
+                        .describe("Amount in cents to transfer"),
                 }),
                 func: async ({ teamId, amountCents }) => {
                     return this.teamFund(teamId, amountCents);
@@ -2354,7 +2572,11 @@ class DominusNodeToolkit {
                     "The key is shown only once.",
                 schema: zod_1.z.object({
                     teamId: zod_1.z.string().uuid().describe("Team ID (UUID)"),
-                    label: zod_1.z.string().min(1).max(100).describe('Label for the API key (e.g., "production")'),
+                    label: zod_1.z
+                        .string()
+                        .min(1)
+                        .max(100)
+                        .describe('Label for the API key (e.g., "production")'),
                 }),
                 func: async ({ teamId, label }) => {
                     return this.teamCreateKey(teamId, label);
@@ -2366,7 +2588,13 @@ class DominusNodeToolkit {
                 description: "Get the team wallet transaction history (funding, usage charges, refunds).",
                 schema: zod_1.z.object({
                     teamId: zod_1.z.string().uuid().describe("Team ID (UUID)"),
-                    limit: zod_1.z.number().int().min(1).max(100).default(20).describe("Number of transactions to return"),
+                    limit: zod_1.z
+                        .number()
+                        .int()
+                        .min(1)
+                        .max(100)
+                        .default(20)
+                        .describe("Number of transactions to return"),
                 }),
                 func: async ({ teamId, limit }) => {
                     return this.teamUsage(teamId, limit);
@@ -2379,7 +2607,13 @@ class DominusNodeToolkit {
                 schema: zod_1.z.object({
                     teamId: zod_1.z.string().uuid().describe("Team ID (UUID)"),
                     name: zod_1.z.string().min(1).max(100).optional().describe("New team name"),
-                    maxMembers: zod_1.z.number().int().min(1).max(100).optional().describe("New max member count"),
+                    maxMembers: zod_1.z
+                        .number()
+                        .int()
+                        .min(1)
+                        .max(100)
+                        .optional()
+                        .describe("New max member count"),
                 }),
                 func: async ({ teamId, name, maxMembers }) => {
                     return this.updateTeam(teamId, name, maxMembers);
@@ -2404,7 +2638,12 @@ class DominusNodeToolkit {
                 description: "Top up your Dominus Node wallet via PayPal. Creates a PayPal order and returns an " +
                     "approval URL. Minimum $5, maximum $1,000.",
                 schema: zod_1.z.object({
-                    amountCents: zod_1.z.number().int().min(500).max(100000).describe("Amount in cents to top up (min 500 = $5)"),
+                    amountCents: zod_1.z
+                        .number()
+                        .int()
+                        .min(500)
+                        .max(100000)
+                        .describe("Amount in cents to top up (min 500 = $5)"),
                 }),
                 func: async ({ amountCents }) => {
                     return this.topupPaypal(amountCents);
@@ -2416,7 +2655,12 @@ class DominusNodeToolkit {
                 description: "Top up your Dominus Node wallet via Stripe. Creates a Stripe checkout session and returns " +
                     "a checkout URL. Minimum $5 (500 cents), maximum $1,000 (100000 cents).",
                 schema: zod_1.z.object({
-                    amountCents: zod_1.z.number().int().min(500).max(100000).describe("Amount in cents to top up (min 500 = $5)"),
+                    amountCents: zod_1.z
+                        .number()
+                        .int()
+                        .min(500)
+                        .max(100000)
+                        .describe("Amount in cents to top up (min 500 = $5)"),
                 }),
                 func: async ({ amountCents }) => {
                     return this.topupStripe(amountCents);
@@ -2429,8 +2673,25 @@ class DominusNodeToolkit {
                     "Supports BTC, ETH, LTC, XMR, ZEC, USDC, SOL, USDT, DAI, BNB, LINK. " +
                     "Minimum $5, maximum $1,000.",
                 schema: zod_1.z.object({
-                    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"])
+                    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",
+                    ])
                         .describe("Cryptocurrency to pay with"),
                 }),
                 func: async ({ amountUsd, currency }) => {
@@ -2461,7 +2722,13 @@ class DominusNodeToolkit {
                 name: "dominusnode_get_transactions",
                 description: "Get wallet transaction history including top-ups, usage charges, and refunds.",
                 schema: zod_1.z.object({
-                    limit: zod_1.z.number().int().min(1).max(100).default(20).describe("Number of transactions to return (1-100)"),
+                    limit: zod_1.z
+                        .number()
+                        .int()
+                        .min(1)
+                        .max(100)
+                        .default(20)
+                        .describe("Number of transactions to return (1-100)"),
                 }),
                 func: async ({ limit }) => {
                     return this.getTransactions(limit);
@@ -2481,7 +2748,10 @@ class DominusNodeToolkit {
                 name: "dominusnode_check_payment",
                 description: "Check the status of a cryptocurrency payment invoice. Use after creating a crypto top-up.",
                 schema: zod_1.z.object({
-                    invoiceId: zod_1.z.string().min(1).describe("The invoice ID from the crypto top-up creation"),
+                    invoiceId: zod_1.z
+                        .string()
+                        .min(1)
+                        .describe("The invoice ID from the crypto top-up creation"),
                 }),
                 func: async ({ invoiceId }) => {
                     return this.checkPayment(invoiceId);
@@ -2492,7 +2762,13 @@ class DominusNodeToolkit {
                 name: "dominusnode_get_daily_usage",
                 description: "Get daily usage breakdown showing bandwidth, cost, and request count per day.",
                 schema: 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)"),
+                    days: zod_1.z
+                        .number()
+                        .int()
+                        .min(1)
+                        .max(365)
+                        .default(7)
+                        .describe("Number of days to look back (1-365)"),
                 }),
                 func: async ({ days }) => {
                     return this.getDailyUsage(days);
@@ -2503,7 +2779,13 @@ class DominusNodeToolkit {
                 name: "dominusnode_get_top_hosts",
                 description: "Get the top accessed hosts ranked by bandwidth usage. Useful for understanding proxy usage patterns.",
                 schema: 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)"),
+                    limit: zod_1.z
+                        .number()
+                        .int()
+                        .min(1)
+                        .max(100)
+                        .default(10)
+                        .describe("Number of top hosts to return (1-100)"),
                 }),
                 func: async ({ limit }) => {
                     return this.getTopHosts(limit);
@@ -2515,8 +2797,15 @@ class DominusNodeToolkit {
                 description: "Register a new Dominus Node account. Returns user info. " +
                     "After registering, verify email or rely on MCP agent auto-verification.",
                 schema: zod_1.z.object({
-                    email: zod_1.z.string().email().describe("Email address for the new account"),
-                    password: zod_1.z.string().min(8).max(128).describe("Password (min 8, max 128 characters)"),
+                    email: zod_1.z
+                        .string()
+                        .email()
+                        .describe("Email address for the new account"),
+                    password: zod_1.z
+                        .string()
+                        .min(8)
+                        .max(128)
+                        .describe("Password (min 8, max 128 characters)"),
                 }),
                 func: async ({ email, password }) => {
                     return this.register(email, password);
@@ -2550,7 +2839,10 @@ class DominusNodeToolkit {
                 description: "Verify email address using the verification token sent to email. " +
                     "MCP agents are auto-verified via agent headers.",
                 schema: zod_1.z.object({
-                    token: zod_1.z.string().min(1).describe("Email verification token from the verification email"),
+                    token: zod_1.z
+                        .string()
+                        .min(1)
+                        .describe("Email verification token from the verification email"),
                 }),
                 func: async ({ token }) => {
                     return this.verifyEmail(token);
@@ -2570,8 +2862,15 @@ class DominusNodeToolkit {
                 name: "dominusnode_update_password",
                 description: "Change the password for the current Dominus Node account. Requires the current password.",
                 schema: zod_1.z.object({
-                    currentPassword: zod_1.z.string().min(1).describe("Current account password"),
-                    newPassword: zod_1.z.string().min(8).max(128).describe("New password (min 8, max 128 characters)"),
+                    currentPassword: zod_1.z
+                        .string()
+                        .min(1)
+                        .describe("Current account password"),
+                    newPassword: zod_1.z
+                        .string()
+                        .min(8)
+                        .max(128)
+                        .describe("New password (min 8, max 128 characters)"),
                 }),
                 func: async ({ currentPassword, newPassword }) => {
                     return this.updatePassword(currentPassword, newPassword);
@@ -2591,7 +2890,12 @@ class DominusNodeToolkit {
                 name: "dominusnode_create_key",
                 description: "Create a new API key for the current account. The key is shown only once on creation.",
                 schema: zod_1.z.object({
-                    label: zod_1.z.string().min(1).max(100).optional().describe('Optional label for the API key (e.g., "production")'),
+                    label: zod_1.z
+                        .string()
+                        .min(1)
+                        .max(100)
+                        .optional()
+                        .describe('Optional label for the API key (e.g., "production")'),
                 }),
                 func: async ({ label }) => {
                     return this.createKey(label);
@@ -2688,8 +2992,14 @@ class DominusNodeToolkit {
                 description: "Add a member to a team by email address. Optionally specify their role (member or admin).",
                 schema: zod_1.z.object({
                     teamId: zod_1.z.string().uuid().describe("Team ID (UUID)"),
-                    email: zod_1.z.string().email().describe("Email address of the user to add"),
-                    role: zod_1.z.enum(["member", "admin"]).optional().describe("Role for the new member (default: member)"),
+                    email: zod_1.z
+                        .string()
+                        .email()
+                        .describe("Email address of the user to add"),
+                    role: zod_1.z
+                        .enum(["member", "admin"])
+                        .optional()
+                        .describe("Role for the new member (default: member)"),
                 }),
                 func: async ({ teamId, email, role }) => {
                     return this.teamAddMember(teamId, email, role);
@@ -2701,7 +3011,10 @@ class DominusNodeToolkit {
                 description: "Remove a member from a team. Requires owner or admin role. Cannot remove the owner.",
                 schema: zod_1.z.object({
                     teamId: zod_1.z.string().uuid().describe("Team ID (UUID)"),
-                    userId: zod_1.z.string().uuid().describe("User ID (UUID) of the member to remove"),
+                    userId: zod_1.z
+                        .string()
+                        .uuid()
+                        .describe("User ID (UUID) of the member to remove"),
                 }),
                 func: async ({ teamId, userId }) => {
                     return this.teamRemoveMember(teamId, userId);
@@ -2714,7 +3027,10 @@ class DominusNodeToolkit {
                 schema: zod_1.z.object({
                     teamId: zod_1.z.string().uuid().describe("Team ID (UUID)"),
                     email: zod_1.z.string().email().describe("Email address to invite"),
-                    role: zod_1.z.enum(["member", "admin"]).optional().describe("Role for the invited member (default: member)"),
+                    role: zod_1.z
+                        .enum(["member", "admin"])
+                        .optional()
+                        .describe("Role for the invited member (default: member)"),
                 }),
                 func: async ({ teamId, email, role }) => {
                     return this.teamInviteMember(teamId, email, role);
@@ -2737,12 +3053,82 @@ class DominusNodeToolkit {
                 description: "Cancel a pending team invitation. Requires owner or admin role.",
                 schema: zod_1.z.object({
                     teamId: zod_1.z.string().uuid().describe("Team ID (UUID)"),
-                    inviteId: zod_1.z.string().uuid().describe("UUID of the invitation to cancel"),
+                    inviteId: zod_1.z
+                        .string()
+                        .uuid()
+                        .describe("UUID of the invitation to cancel"),
                 }),
                 func: async ({ teamId, inviteId }) => {
                     return this.teamCancelInvite(teamId, inviteId);
                 },
             }),
+            // 53 (MPP). mpp_info
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_mpp_info",
+                description: "Get Machine Payment Protocol (MPP) information including enabled status, " +
+                    "supported payment methods, pricing, and session limits.",
+                schema: zod_1.z.object({}),
+                func: async () => {
+                    return this.mppInfo();
+                },
+            }),
+            // 54 (MPP). pay_mpp
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_pay_mpp",
+                description: "Top up wallet via Machine Payment Protocol (MPP). " +
+                    "Supports tempo, stripe_spt, and lightning payment methods.",
+                schema: zod_1.z.object({
+                    amountCents: zod_1.z
+                        .number()
+                        .int()
+                        .min(500)
+                        .max(100000)
+                        .describe("Amount in cents to top up (min 500, max 100000)"),
+                    method: zod_1.z
+                        .enum(["tempo", "stripe_spt", "lightning"])
+                        .describe("MPP payment method"),
+                }),
+                func: async ({ amountCents, method }) => {
+                    return this.payMpp(amountCents, method);
+                },
+            }),
+            // 55 (MPP). mpp_session_open
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_mpp_session_open",
+                description: "Open a pay-as-you-go MPP session. Returns a channelId for metered proxy usage.",
+                schema: 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"),
+                }),
+                func: async ({ maxDepositCents, method, poolType, }) => {
+                    return this.mppSessionOpen(maxDepositCents, method, poolType);
+                },
+            }),
+            // 56 (MPP). mpp_session_close
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_mpp_session_close",
+                description: "Close an MPP pay-as-you-go session. Returns the amount spent and refunded.",
+                schema: zod_1.z.object({
+                    channelId: zod_1.z
+                        .string()
+                        .min(1)
+                        .describe("The channelId returned from mpp_session_open"),
+                }),
+                func: async ({ channelId }) => {
+                    return this.mppSessionClose(channelId);
+                },
+            }),
         ];
     }
 }
@@ -2751,6 +3137,16 @@ exports.DominusNodeToolkit = DominusNodeToolkit;
 // Tool 24: topupCrypto
 // -----------------------------------------------------------------------
 DominusNodeToolkit.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",
 ]);
 //# sourceMappingURL=toolkit.js.map