@dominusnode/flowise-tools 1.2.0 → 1.3.1

package/dist/toolkit.js

@@ -2,9 +2,10 @@
 /**
  * Dominus Node Flowise Toolkit
  *
- * Provides 26 LangChain-compatible DynamicStructuredTool instances for use
+ * Provides 53 LangChain-compatible DynamicStructuredTool instances for use
  * inside Flowise AI workflows. Covers proxied fetching, wallet management,
- * agentic wallets, teams, Stripe/PayPal/crypto top-up, and x402 micropayment info.
+ * agentic wallets, teams, Stripe/PayPal/crypto top-up, x402 micropayment info,
+ * account management, API key management, plans, sessions, and usage analytics.
  *
  * Security:
  *  - Full SSRF protection (private IP blocking, DNS rebinding, Teredo/6to4,
@@ -67,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"));
@@ -88,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);
@@ -100,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
@@ -386,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
@@ -400,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 = {
@@ -521,6 +584,76 @@ class DominusNodeToolkit {
         }
     }
     // -----------------------------------------------------------------------
+    // Unauthenticated request helper (register, login, verifyEmail)
+    // -----------------------------------------------------------------------
+    async _unauthenticatedRequest(method, path, body) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+            "Content-Type": "application/json",
+            "User-Agent": "dominusnode-flowise/1.0.0",
+        };
+        if (this.agentSecret) {
+            headers["X-DominusNode-Agent"] = "mcp";
+            headers["X-DominusNode-Agent-Secret"] = this.agentSecret;
+        }
+        const init = {
+            method,
+            headers,
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+            redirect: "error",
+        };
+        if (body) {
+            init.body = JSON.stringify(body);
+        }
+        let res;
+        try {
+            res = await fetch(url, init);
+        }
+        catch (err) {
+            throw new Error(`Request failed: ${safeError(err)}`);
+        }
+        let rawText;
+        try {
+            rawText = await res.text();
+        }
+        catch {
+            rawText = "";
+        }
+        if (new TextEncoder().encode(rawText).length > MAX_RESPONSE_BYTES) {
+            throw new Error("Response too large");
+        }
+        if (!res.ok) {
+            let errorMsg = `Error ${res.status}`;
+            if (rawText) {
+                try {
+                    const parsed = JSON.parse(rawText);
+                    stripDangerousKeys(parsed);
+                    if (parsed.error) {
+                        errorMsg = `Error ${res.status}: ${scrubCredentials(String(parsed.error))}`;
+                    }
+                    else if (parsed.message) {
+                        errorMsg = `Error ${res.status}: ${scrubCredentials(String(parsed.message))}`;
+                    }
+                }
+                catch {
+                    errorMsg = `Error ${res.status}: ${scrubCredentials(rawText.slice(0, 200))}`;
+                }
+            }
+            throw new Error(errorMsg);
+        }
+        if (!rawText || rawText.trim().length === 0) {
+            return {};
+        }
+        try {
+            const parsed = JSON.parse(rawText);
+            stripDangerousKeys(parsed);
+            return parsed;
+        }
+        catch {
+            throw new Error("Failed to parse response as JSON");
+        }
+    }
+    // -----------------------------------------------------------------------
     // Tool 1: proxiedFetch
     // -----------------------------------------------------------------------
     async proxiedFetch(url, method = "GET", country, proxyType = "dc") {
@@ -535,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;
@@ -603,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,
@@ -660,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);
@@ -688,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]}`);
@@ -828,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;
@@ -878,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;
@@ -935,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`, {
@@ -989,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("");
@@ -1015,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}`);
             }
@@ -1102,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;
@@ -1184,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`, {
@@ -1280,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;
@@ -1332,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 });
@@ -1356,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 });
@@ -1377,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();
@@ -1414,194 +1590,920 @@ class DominusNodeToolkit {
         }
     }
     // -----------------------------------------------------------------------
-    // getTools() -- returns LangChain DynamicStructuredTool[] for Flowise
+    // Tool 26: getProxyStatus
     // -----------------------------------------------------------------------
-    getTools() {
-        return [
-            // 1. proxied_fetch
-            new tools_1.DynamicStructuredTool({
-                name: "dominusnode_proxied_fetch",
-                description: "Fetch a URL through Dominus Node's rotating proxy network. Supports geo-targeting " +
-                    "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)"),
-                }),
-                func: async ({ url, method, country, proxyType }) => {
-                    return this.proxiedFetch(url, method, country, proxyType);
-                },
-            }),
-            // 2. check_balance
-            new tools_1.DynamicStructuredTool({
-                name: "dominusnode_check_balance",
-                description: "Check your Dominus Node wallet balance and estimated remaining bandwidth at current pricing.",
-                schema: zod_1.z.object({}),
-                func: async () => {
-                    return this.checkBalance();
-                },
-            }),
-            // 3. check_usage
-            new tools_1.DynamicStructuredTool({
-                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)"),
-                }),
-                func: async ({ days }) => {
-                    return this.checkUsage(days);
-                },
-            }),
-            // 4. get_proxy_config
-            new tools_1.DynamicStructuredTool({
-                name: "dominusnode_get_proxy_config",
-                description: "Get available proxy pools, pricing, supported countries, and endpoint configuration.",
-                schema: zod_1.z.object({}),
-                func: async () => {
-                    return this.getProxyConfig();
-                },
-            }),
-            // 5. list_sessions
-            new tools_1.DynamicStructuredTool({
-                name: "dominusnode_list_sessions",
-                description: "List all active proxy sessions showing target hosts, bandwidth used, and status.",
-                schema: zod_1.z.object({}),
-                func: async () => {
-                    return this.listSessions();
-                },
-            }),
-            // 6. create_agentic_wallet
-            new tools_1.DynamicStructuredTool({
-                name: "dominusnode_create_agentic_wallet",
-                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")'),
-                    spendingLimitCents: zod_1.z
-                        .number()
-                        .int()
-                        .min(0)
-                        .max(1000000)
-                        .default(10000)
-                        .describe("Max spend per transaction in cents (0 = no limit, default $100)"),
-                    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()
-                        .describe("Optional list of allowed domains for proxy access (max 100 entries)"),
-                }),
-                func: async ({ label, spendingLimitCents, dailyLimitCents, allowedDomains }) => {
-                    return this.createAgenticWallet(label, spendingLimitCents, dailyLimitCents, allowedDomains);
-                },
-            }),
-            // 7. fund_agentic_wallet
-            new tools_1.DynamicStructuredTool({
-                name: "dominusnode_fund_agentic_wallet",
-                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"),
-                }),
-                func: async ({ walletId, amountCents }) => {
-                    return this.fundAgenticWallet(walletId, amountCents);
-                },
-            }),
-            // 8. agentic_wallet_balance
-            new tools_1.DynamicStructuredTool({
-                name: "dominusnode_agentic_wallet_balance",
-                description: "Check the balance and details of an agentic wallet.",
-                schema: zod_1.z.object({
-                    walletId: zod_1.z.string().uuid().describe("Agentic wallet ID (UUID)"),
-                }),
-                func: async ({ walletId }) => {
-                    return this.agenticWalletBalance(walletId);
-                },
-            }),
-            // 9. list_agentic_wallets
-            new tools_1.DynamicStructuredTool({
-                name: "dominusnode_list_agentic_wallets",
-                description: "List all your agentic wallets with balances and status.",
-                schema: zod_1.z.object({}),
-                func: async () => {
-                    return this.listAgenticWallets();
-                },
-            }),
-            // 10. agentic_transactions
-            new tools_1.DynamicStructuredTool({
-                name: "dominusnode_agentic_transactions",
-                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"),
-                }),
-                func: async ({ walletId, limit }) => {
-                    return this.agenticTransactions(walletId, limit);
-                },
-            }),
-            // 11. freeze_agentic_wallet
-            new tools_1.DynamicStructuredTool({
-                name: "dominusnode_freeze_agentic_wallet",
-                description: "Freeze an agentic wallet to prevent spending. Balance is preserved until unfrozen.",
-                schema: zod_1.z.object({
-                    walletId: zod_1.z.string().uuid().describe("Agentic wallet ID (UUID)"),
-                }),
-                func: async ({ walletId }) => {
-                    return this.freezeAgenticWallet(walletId);
-                },
-            }),
-            // 12. unfreeze_agentic_wallet
-            new tools_1.DynamicStructuredTool({
-                name: "dominusnode_unfreeze_agentic_wallet",
-                description: "Unfreeze a previously frozen agentic wallet to re-enable spending.",
-                schema: zod_1.z.object({
-                    walletId: zod_1.z.string().uuid().describe("Agentic wallet ID (UUID)"),
-                }),
-                func: async ({ walletId }) => {
-                    return this.unfreezeAgenticWallet(walletId);
-                },
-            }),
-            // 13. delete_agentic_wallet
-            new tools_1.DynamicStructuredTool({
-                name: "dominusnode_delete_agentic_wallet",
-                description: "Delete an agentic wallet. Must be unfrozen first. Remaining balance refunded to main wallet.",
-                schema: zod_1.z.object({
-                    walletId: zod_1.z.string().uuid().describe("Agentic wallet ID (UUID)"),
-                }),
-                func: async ({ walletId }) => {
-                    return this.deleteAgenticWallet(walletId);
-                },
-            }),
-            // 13b. update_wallet_policy
-            new tools_1.DynamicStructuredTool({
-                name: "dominusnode_update_wallet_policy",
-                description: "Update spending policy for an agentic wallet. Set or remove daily budget caps and domain restrictions.",
-                schema: zod_1.z.object({
-                    walletId: zod_1.z.string().uuid().describe("Agentic wallet ID (UUID)"),
-                    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()
-                        .describe("List of allowed domains (max 100). Set null to remove restriction."),
-                }),
-                func: async ({ walletId, dailyLimitCents, allowedDomains }) => {
-                    return this.updateWalletPolicy(walletId, dailyLimitCents, allowedDomains);
+    async getProxyStatus() {
+        try {
+            const data = await this._requestWithRetry("GET", "/api/proxy/status");
+            const lines = ["Proxy Status", ""];
+            if (data.status)
+                lines.push(`Status: ${data.status}`);
+            if (data.uptime !== undefined)
+                lines.push(`Uptime: ${data.uptime}`);
+            if (data.activeConnections !== undefined)
+                lines.push(`Active Connections: ${data.activeConnections}`);
+            if (data.providerStatus)
+                lines.push(`Provider Status: ${JSON.stringify(data.providerStatus)}`);
+            if (Object.keys(data).length === 0) {
+                lines.push("No status data available.");
+            }
+            return truncate(lines.join("\n"));
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 27: getTransactions
+    // -----------------------------------------------------------------------
+    async getTransactions(limit = 20) {
+        try {
+            const lim = Math.min(Math.max(Math.floor(limit), 1), 100);
+            const data = await this._requestWithRetry("GET", `/api/wallet/transactions?limit=${lim}`);
+            const txs = data.transactions ?? [];
+            if (txs.length === 0) {
+                return "No wallet transactions found.";
+            }
+            const lines = [`Wallet Transactions (${txs.length})`, ""];
+            for (const tx of txs) {
+                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}`);
+            }
+            return truncate(lines.join("\n"));
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 28: getForecast
+    // -----------------------------------------------------------------------
+    async getForecast() {
+        try {
+            const data = await this._requestWithRetry("GET", "/api/wallet/forecast");
+            const lines = [
+                "Wallet Balance Forecast",
+                "",
+                `Current Balance: ${formatCents(data.balanceCents ?? 0)}`,
+                `Average Daily Spend: ${formatCents(data.avgDailySpendCents ?? 0)}`,
+                `Estimated Days Remaining: ${data.daysRemaining ?? "N/A"}`,
+            ];
+            if (data.estimatedDepletionDate) {
+                lines.push(`Estimated Depletion Date: ${data.estimatedDepletionDate}`);
+            }
+            return lines.join("\n");
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 29: checkPayment
+    // -----------------------------------------------------------------------
+    async checkPayment(invoiceId) {
+        try {
+            if (!invoiceId || invoiceId.trim().length === 0) {
+                return "Error: invoice_id is required.";
+            }
+            if (/[\x00-\x1f\x7f]/.test(invoiceId)) {
+                return "Error: invoice_id contains invalid control characters.";
+            }
+            const data = await this._requestWithRetry("GET", `/api/wallet/topup/crypto/${encodeURIComponent(invoiceId.trim())}/status`);
+            const lines = [
+                "Crypto Payment Status",
+                "",
+                `Invoice ID: ${data.invoiceId ?? invoiceId}`,
+                `Status: ${data.status ?? "unknown"}`,
+                `Amount: $${data.amountUsd ?? "N/A"}`,
+                `Currency: ${data.payCurrency?.toUpperCase() ?? "N/A"}`,
+            ];
+            if (data.paidAt) {
+                lines.push(`Paid At: ${data.paidAt}`);
+            }
+            return lines.join("\n");
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 30: getDailyUsage
+    // -----------------------------------------------------------------------
+    async getDailyUsage(days = 7) {
+        try {
+            const d = Math.min(Math.max(Math.floor(days), 1), 365);
+            const data = await this._requestWithRetry("GET", `/api/usage/daily?days=${d}`);
+            const dayEntries = data.days ?? [];
+            if (dayEntries.length === 0) {
+                return "No daily usage data available.";
+            }
+            const lines = [`Daily Usage (last ${d} days)`, ""];
+            for (const day of dayEntries) {
+                lines.push(`  ${day.date}: ${formatBytes(day.bytes)} | ${formatCents(day.costCents)} | ${day.requests} reqs`);
+            }
+            return truncate(lines.join("\n"));
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 31: getTopHosts
+    // -----------------------------------------------------------------------
+    async getTopHosts(limit = 10) {
+        try {
+            const lim = Math.min(Math.max(Math.floor(limit), 1), 100);
+            const data = await this._requestWithRetry("GET", `/api/usage/top-hosts?limit=${lim}`);
+            const hosts = data.hosts ?? [];
+            if (hosts.length === 0) {
+                return "No top hosts data available.";
+            }
+            const lines = [`Top Hosts by Bandwidth (${hosts.length})`, ""];
+            for (const h of hosts) {
+                lines.push(`  ${h.host}: ${formatBytes(h.bytes)} | ${formatCents(h.costCents)} | ${h.requests} reqs`);
+            }
+            return truncate(lines.join("\n"));
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 32: register (unauthenticated)
+    // -----------------------------------------------------------------------
+    async register(email, password) {
+        try {
+            if (!email || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
+                return "Error: a valid email address is required.";
+            }
+            if (!password || password.length < 8 || password.length > 128) {
+                return "Error: password must be between 8 and 128 characters.";
+            }
+            // 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",
+                "",
+                `User ID: ${data.user?.id ?? "N/A"}`,
+                `Email: ${data.user?.email ?? email}`,
+                "",
+                "Verify your email to unlock financial features.",
+                "MCP agents are auto-verified via agent headers.",
+            ].join("\n");
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 33: login (unauthenticated)
+    // -----------------------------------------------------------------------
+    async login(email, password) {
+        try {
+            if (!email || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
+                return "Error: a valid email address is required.";
+            }
+            if (!password || password.length < 1) {
+                return "Error: password is required.";
+            }
+            const data = await this._unauthenticatedRequest("POST", "/api/auth/login", { email, password });
+            if (data.mfaRequired) {
+                return [
+                    "MFA Required",
+                    "",
+                    `Challenge Token: ${data.challengeToken ?? "N/A"}`,
+                    "",
+                    "Multi-factor authentication is required. Complete the MFA challenge to proceed.",
+                ].join("\n");
+            }
+            return [
+                "Login Successful",
+                "",
+                "Access and refresh tokens have been issued.",
+                "Use get_account_info to view your account details.",
+            ].join("\n");
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 34: getAccountInfo
+    // -----------------------------------------------------------------------
+    async getAccountInfo() {
+        try {
+            const data = await this._requestWithRetry("GET", "/api/auth/me");
+            const user = data.user;
+            return [
+                "Account Information",
+                "",
+                `User ID: ${user?.id ?? "N/A"}`,
+                `Email: ${user?.email ?? "N/A"}`,
+                `Plan: ${user?.plan ?? "N/A"}`,
+                `Email Verified: ${user?.emailVerified ?? false}`,
+                `Status: ${user?.status ?? "N/A"}`,
+                `Created: ${user?.createdAt ?? "N/A"}`,
+            ].join("\n");
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 35: verifyEmail (unauthenticated)
+    // -----------------------------------------------------------------------
+    async verifyEmail(token) {
+        try {
+            if (!token || token.trim().length === 0) {
+                return "Error: verification token is required.";
+            }
+            if (/[\x00-\x1f\x7f]/.test(token)) {
+                return "Error: token contains invalid control characters.";
+            }
+            await this._unauthenticatedRequest("POST", "/api/auth/verify-email", {
+                token: token.trim(),
+            });
+            return "Email verified successfully. Financial features are now unlocked.";
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 36: resendVerification
+    // -----------------------------------------------------------------------
+    async resendVerification() {
+        try {
+            await this._requestWithRetry("POST", "/api/auth/resend-verification");
+            return "Verification email sent. Check your inbox for the verification link.";
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 37: updatePassword
+    // -----------------------------------------------------------------------
+    async updatePassword(currentPassword, newPassword) {
+        try {
+            if (!currentPassword || currentPassword.length < 1) {
+                return "Error: current password is required.";
+            }
+            if (!newPassword || newPassword.length < 8 || newPassword.length > 128) {
+                return "Error: new password must be between 8 and 128 characters.";
+            }
+            await this._requestWithRetry("POST", "/api/auth/change-password", {
+                currentPassword,
+                newPassword,
+            });
+            return "Password updated successfully.";
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 38: listKeys
+    // -----------------------------------------------------------------------
+    async listKeys() {
+        try {
+            const data = await this._requestWithRetry("GET", "/api/keys");
+            const keys = data.keys ?? [];
+            if (keys.length === 0) {
+                return "No API keys found. Use create_key to create one.";
+            }
+            const lines = [`API Keys (${keys.length})`, ""];
+            for (const k of keys) {
+                lines.push(`  ${k.label ?? "unlabeled"} (${k.id.slice(0, 8)}...)`);
+                lines.push(`    Prefix: ${k.prefix} | Created: ${k.createdAt}`);
+            }
+            return truncate(lines.join("\n"));
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 39: createKey
+    // -----------------------------------------------------------------------
+    async createKey(label) {
+        try {
+            if (label !== undefined) {
+                if (label.length === 0 || label.length > 100) {
+                    return "Error: label must be 1-100 characters.";
+                }
+                if (/[\x00-\x1f\x7f]/.test(label)) {
+                    return "Error: label contains invalid control characters.";
+                }
+            }
+            const body = {};
+            if (label)
+                body.label = label.trim();
+            const data = await this._requestWithRetry("POST", "/api/keys", body);
+            return [
+                "API Key Created",
+                "",
+                `Key ID: ${data.id}`,
+                `API Key: ${data.key}`,
+                `Prefix: ${data.prefix}`,
+                `Label: ${data.label ?? ""}`,
+                `Created: ${data.createdAt}`,
+                "",
+                "IMPORTANT: Save this API key now -- it will not be shown again.",
+            ].join("\n");
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 40: revokeKey
+    // -----------------------------------------------------------------------
+    async revokeKey(keyId) {
+        try {
+            const kid = validateUuid(keyId, "key_id");
+            await this._requestWithRetry("DELETE", `/api/keys/${encodeURIComponent(kid)}`);
+            return [
+                "API Key Revoked",
+                "",
+                `Key ID: ${kid}`,
+                "",
+                "The key is now permanently deactivated and cannot be used.",
+            ].join("\n");
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 41: getPlan
+    // -----------------------------------------------------------------------
+    async getPlan() {
+        try {
+            const data = await this._requestWithRetry("GET", "/api/plans/user/plan");
+            const lines = [
+                "Current Plan",
+                "",
+                `Plan ID: ${data.id ?? "N/A"}`,
+                `Name: ${data.name ?? "N/A"}`,
+            ];
+            if (data.bandwidthLimitBytes !== undefined) {
+                lines.push(`Bandwidth Limit: ${formatBytes(data.bandwidthLimitBytes)}`);
+            }
+            if (data.pricePerGbCents !== undefined) {
+                lines.push(`Price Per GB: ${formatCents(data.pricePerGbCents)}`);
+            }
+            if (data.features && data.features.length > 0) {
+                lines.push(`Features: ${data.features.join(", ")}`);
+            }
+            return lines.join("\n");
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 42: listPlans
+    // -----------------------------------------------------------------------
+    async listPlans() {
+        try {
+            const data = await this._requestWithRetry("GET", "/api/plans");
+            const plans = data.plans ?? [];
+            if (plans.length === 0) {
+                return "No plans available.";
+            }
+            const lines = [`Available Plans (${plans.length})`, ""];
+            for (const p of plans) {
+                lines.push(`  ${p.name} (${p.id})`);
+                if (p.bandwidthLimitBytes !== undefined) {
+                    lines.push(`    Bandwidth: ${formatBytes(p.bandwidthLimitBytes)} | Price: ${formatCents(p.pricePerGbCents)}/GB`);
+                }
+                if (p.features && p.features.length > 0) {
+                    lines.push(`    Features: ${p.features.join(", ")}`);
+                }
+                lines.push("");
+            }
+            return truncate(lines.join("\n"));
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 43: changePlan
+    // -----------------------------------------------------------------------
+    async changePlan(planId) {
+        try {
+            if (!planId || planId.trim().length === 0) {
+                return "Error: plan_id is required.";
+            }
+            if (/[\x00-\x1f\x7f]/.test(planId)) {
+                return "Error: plan_id contains invalid control characters.";
+            }
+            const data = await this._requestWithRetry("PUT", "/api/plans/user/plan", { planId: planId.trim() });
+            return [
+                "Plan Changed",
+                "",
+                `New Plan: ${data.name ?? data.id ?? planId}`,
+                data.message ? `Message: ${data.message}` : "",
+            ]
+                .filter(Boolean)
+                .join("\n");
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 44: teamDelete
+    // -----------------------------------------------------------------------
+    async teamDelete(teamId) {
+        try {
+            const tid = validateUuid(teamId, "team_id");
+            await this._requestWithRetry("DELETE", `/api/teams/${encodeURIComponent(tid)}`);
+            return [
+                "Team Deleted",
+                "",
+                `Team ID: ${tid}`,
+                "",
+                "The team has been permanently deleted.",
+            ].join("\n");
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 45: teamRevokeKey
+    // -----------------------------------------------------------------------
+    async teamRevokeKey(teamId, keyId) {
+        try {
+            const tid = validateUuid(teamId, "team_id");
+            const kid = validateUuid(keyId, "key_id");
+            await this._requestWithRetry("DELETE", `/api/teams/${encodeURIComponent(tid)}/keys/${encodeURIComponent(kid)}`);
+            return [
+                "Team API Key Revoked",
+                "",
+                `Team ID: ${tid}`,
+                `Key ID: ${kid}`,
+                "",
+                "The team key is now permanently deactivated.",
+            ].join("\n");
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 46: teamListKeys
+    // -----------------------------------------------------------------------
+    async teamListKeys(teamId) {
+        try {
+            const tid = validateUuid(teamId, "team_id");
+            const data = await this._requestWithRetry("GET", `/api/teams/${encodeURIComponent(tid)}/keys`);
+            const keys = data.keys ?? [];
+            if (keys.length === 0) {
+                return "No API keys found for this team. Use team_create_key to create one.";
+            }
+            const lines = [`Team API Keys (${keys.length})`, ""];
+            for (const k of keys) {
+                lines.push(`  ${k.label ?? "unlabeled"} (${k.id.slice(0, 8)}...)`);
+                lines.push(`    Prefix: ${k.prefix} | Created: ${k.createdAt}`);
+            }
+            return truncate(lines.join("\n"));
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 47: teamListMembers
+    // -----------------------------------------------------------------------
+    async teamListMembers(teamId) {
+        try {
+            const tid = validateUuid(teamId, "team_id");
+            const data = await this._requestWithRetry("GET", `/api/teams/${encodeURIComponent(tid)}/members`);
+            const members = data.members ?? [];
+            if (members.length === 0) {
+                return "No members found for this team.";
+            }
+            const lines = [`Team Members (${members.length})`, ""];
+            for (const m of members) {
+                lines.push(`  ${m.email} -- ${m.role}`);
+                lines.push(`    User ID: ${m.userId} | Joined: ${m.joinedAt}`);
+            }
+            return truncate(lines.join("\n"));
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 48: teamAddMember
+    // -----------------------------------------------------------------------
+    async teamAddMember(teamId, email, role) {
+        try {
+            const tid = validateUuid(teamId, "team_id");
+            if (!email || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
+                return "Error: a valid email address is required.";
+            }
+            if (role !== undefined && role !== "member" && role !== "admin") {
+                return "Error: role must be 'member' or 'admin'.";
+            }
+            const body = { email };
+            if (role)
+                body.role = role;
+            const data = await this._requestWithRetry("POST", `/api/teams/${encodeURIComponent(tid)}/members`, body);
+            return [
+                "Team Member Added",
+                "",
+                `Team ID: ${tid}`,
+                `Email: ${data.email ?? email}`,
+                `Role: ${data.role ?? role ?? "member"}`,
+            ].join("\n");
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 49: teamRemoveMember
+    // -----------------------------------------------------------------------
+    async teamRemoveMember(teamId, userId) {
+        try {
+            const tid = validateUuid(teamId, "team_id");
+            const uid = validateUuid(userId, "user_id");
+            await this._requestWithRetry("DELETE", `/api/teams/${encodeURIComponent(tid)}/members/${encodeURIComponent(uid)}`);
+            return [
+                "Team Member Removed",
+                "",
+                `Team ID: ${tid}`,
+                `User ID: ${uid}`,
+            ].join("\n");
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 50: teamInviteMember
+    // -----------------------------------------------------------------------
+    async teamInviteMember(teamId, email, role) {
+        try {
+            const tid = validateUuid(teamId, "team_id");
+            if (!email || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
+                return "Error: a valid email address is required.";
+            }
+            if (role !== undefined && role !== "member" && role !== "admin") {
+                return "Error: role must be 'member' or 'admin'.";
+            }
+            const body = { email };
+            if (role)
+                body.role = role;
+            const data = await this._requestWithRetry("POST", `/api/teams/${encodeURIComponent(tid)}/invites`, body);
+            return [
+                "Team Invitation Sent",
+                "",
+                `Invite ID: ${data.id ?? "N/A"}`,
+                `Team ID: ${tid}`,
+                `Email: ${data.email ?? email}`,
+                `Role: ${data.role ?? role ?? "member"}`,
+                data.expiresAt ? `Expires: ${data.expiresAt}` : "",
+            ]
+                .filter(Boolean)
+                .join("\n");
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 51: teamListInvites
+    // -----------------------------------------------------------------------
+    async teamListInvites(teamId) {
+        try {
+            const tid = validateUuid(teamId, "team_id");
+            const data = await this._requestWithRetry("GET", `/api/teams/${encodeURIComponent(tid)}/invites`);
+            const invites = data.invites ?? [];
+            if (invites.length === 0) {
+                return "No pending invitations for this team.";
+            }
+            const lines = [`Team Invitations (${invites.length})`, ""];
+            for (const inv of invites) {
+                lines.push(`  ${inv.email} -- ${inv.role} [${inv.status}]`);
+                lines.push(`    Invite ID: ${inv.id.slice(0, 8)}... | Created: ${inv.createdAt}`);
+            }
+            return truncate(lines.join("\n"));
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 52: teamCancelInvite
+    // -----------------------------------------------------------------------
+    async teamCancelInvite(teamId, inviteId) {
+        try {
+            const tid = validateUuid(teamId, "team_id");
+            const iid = validateUuid(inviteId, "invite_id");
+            await this._requestWithRetry("DELETE", `/api/teams/${encodeURIComponent(tid)}/invites/${encodeURIComponent(iid)}`);
+            return [
+                "Team Invitation Cancelled",
+                "",
+                `Team ID: ${tid}`,
+                `Invite ID: ${iid}`,
+            ].join("\n");
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // 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() {
+        return [
+            // 1. proxied_fetch
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_proxied_fetch",
+                description: "Fetch a URL through Dominus Node's rotating proxy network. Supports geo-targeting " +
+                    "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)"),
+                }),
+                func: async ({ url, method, country, proxyType, }) => {
+                    return this.proxiedFetch(url, method, country, proxyType);
+                },
+            }),
+            // 2. check_balance
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_check_balance",
+                description: "Check your Dominus Node wallet balance and estimated remaining bandwidth at current pricing.",
+                schema: zod_1.z.object({}),
+                func: async () => {
+                    return this.checkBalance();
+                },
+            }),
+            // 3. check_usage
+            new tools_1.DynamicStructuredTool({
+                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)"),
+                }),
+                func: async ({ days }) => {
+                    return this.checkUsage(days);
+                },
+            }),
+            // 4. get_proxy_config
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_get_proxy_config",
+                description: "Get available proxy pools, pricing, supported countries, and endpoint configuration.",
+                schema: zod_1.z.object({}),
+                func: async () => {
+                    return this.getProxyConfig();
+                },
+            }),
+            // 5. list_sessions
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_list_sessions",
+                description: "List all active proxy sessions showing target hosts, bandwidth used, and status.",
+                schema: zod_1.z.object({}),
+                func: async () => {
+                    return this.listSessions();
+                },
+            }),
+            // 6. create_agentic_wallet
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_create_agentic_wallet",
+                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")'),
+                    spendingLimitCents: zod_1.z
+                        .number()
+                        .int()
+                        .min(0)
+                        .max(1000000)
+                        .default(10000)
+                        .describe("Max spend per transaction in cents (0 = no limit, default $100)"),
+                    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()
+                        .describe("Optional list of allowed domains for proxy access (max 100 entries)"),
+                }),
+                func: async ({ label, spendingLimitCents, dailyLimitCents, allowedDomains, }) => {
+                    return this.createAgenticWallet(label, spendingLimitCents, dailyLimitCents, allowedDomains);
+                },
+            }),
+            // 7. fund_agentic_wallet
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_fund_agentic_wallet",
+                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"),
+                }),
+                func: async ({ walletId, amountCents }) => {
+                    return this.fundAgenticWallet(walletId, amountCents);
+                },
+            }),
+            // 8. agentic_wallet_balance
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_agentic_wallet_balance",
+                description: "Check the balance and details of an agentic wallet.",
+                schema: zod_1.z.object({
+                    walletId: zod_1.z.string().uuid().describe("Agentic wallet ID (UUID)"),
+                }),
+                func: async ({ walletId }) => {
+                    return this.agenticWalletBalance(walletId);
+                },
+            }),
+            // 9. list_agentic_wallets
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_list_agentic_wallets",
+                description: "List all your agentic wallets with balances and status.",
+                schema: zod_1.z.object({}),
+                func: async () => {
+                    return this.listAgenticWallets();
+                },
+            }),
+            // 10. agentic_transactions
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_agentic_transactions",
+                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"),
+                }),
+                func: async ({ walletId, limit }) => {
+                    return this.agenticTransactions(walletId, limit);
+                },
+            }),
+            // 11. freeze_agentic_wallet
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_freeze_agentic_wallet",
+                description: "Freeze an agentic wallet to prevent spending. Balance is preserved until unfrozen.",
+                schema: zod_1.z.object({
+                    walletId: zod_1.z.string().uuid().describe("Agentic wallet ID (UUID)"),
+                }),
+                func: async ({ walletId }) => {
+                    return this.freezeAgenticWallet(walletId);
+                },
+            }),
+            // 12. unfreeze_agentic_wallet
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_unfreeze_agentic_wallet",
+                description: "Unfreeze a previously frozen agentic wallet to re-enable spending.",
+                schema: zod_1.z.object({
+                    walletId: zod_1.z.string().uuid().describe("Agentic wallet ID (UUID)"),
+                }),
+                func: async ({ walletId }) => {
+                    return this.unfreezeAgenticWallet(walletId);
+                },
+            }),
+            // 13. delete_agentic_wallet
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_delete_agentic_wallet",
+                description: "Delete an agentic wallet. Must be unfrozen first. Remaining balance refunded to main wallet.",
+                schema: zod_1.z.object({
+                    walletId: zod_1.z.string().uuid().describe("Agentic wallet ID (UUID)"),
+                }),
+                func: async ({ walletId }) => {
+                    return this.deleteAgenticWallet(walletId);
+                },
+            }),
+            // 13b. update_wallet_policy
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_update_wallet_policy",
+                description: "Update spending policy for an agentic wallet. Set or remove daily budget caps and domain restrictions.",
+                schema: zod_1.z.object({
+                    walletId: zod_1.z.string().uuid().describe("Agentic wallet ID (UUID)"),
+                    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()
+                        .describe("List of allowed domains (max 100). Set null to remove restriction."),
+                }),
+                func: async ({ walletId, dailyLimitCents, allowedDomains, }) => {
+                    return this.updateWalletPolicy(walletId, dailyLimitCents, allowedDomains);
                 },
             }),
             // 14. create_team
@@ -1609,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);
@@ -1642,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);
@@ -1655,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);
@@ -1667,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);
@@ -1680,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);
@@ -1705,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);
@@ -1717,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);
@@ -1730,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 }) => {
@@ -1748,6 +2708,427 @@ class DominusNodeToolkit {
                     return this.x402Info();
                 },
             }),
+            // 26. get_proxy_status
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_get_proxy_status",
+                description: "Get proxy health and status information including uptime, active connections, and provider status.",
+                schema: zod_1.z.object({}),
+                func: async () => {
+                    return this.getProxyStatus();
+                },
+            }),
+            // 27. get_transactions
+            new tools_1.DynamicStructuredTool({
+                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)"),
+                }),
+                func: async ({ limit }) => {
+                    return this.getTransactions(limit);
+                },
+            }),
+            // 28. get_forecast
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_get_forecast",
+                description: "Get a wallet balance forecast based on recent usage patterns. Shows estimated days until balance depletion.",
+                schema: zod_1.z.object({}),
+                func: async () => {
+                    return this.getForecast();
+                },
+            }),
+            // 29. check_payment
+            new tools_1.DynamicStructuredTool({
+                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"),
+                }),
+                func: async ({ invoiceId }) => {
+                    return this.checkPayment(invoiceId);
+                },
+            }),
+            // 30. get_daily_usage
+            new tools_1.DynamicStructuredTool({
+                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)"),
+                }),
+                func: async ({ days }) => {
+                    return this.getDailyUsage(days);
+                },
+            }),
+            // 31. get_top_hosts
+            new tools_1.DynamicStructuredTool({
+                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)"),
+                }),
+                func: async ({ limit }) => {
+                    return this.getTopHosts(limit);
+                },
+            }),
+            // 32. register
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_register",
+                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)"),
+                }),
+                func: async ({ email, password }) => {
+                    return this.register(email, password);
+                },
+            }),
+            // 33. login
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_login",
+                description: "Log into an existing Dominus Node account. Returns login status. " +
+                    "Detects MFA requirements and surfaces challenge tokens.",
+                schema: zod_1.z.object({
+                    email: zod_1.z.string().email().describe("Account email address"),
+                    password: zod_1.z.string().min(1).describe("Account password"),
+                }),
+                func: async ({ email, password }) => {
+                    return this.login(email, password);
+                },
+            }),
+            // 34. get_account_info
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_get_account_info",
+                description: "Get the current authenticated account information including email, plan, verification status, and creation date.",
+                schema: zod_1.z.object({}),
+                func: async () => {
+                    return this.getAccountInfo();
+                },
+            }),
+            // 35. verify_email
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_verify_email",
+                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"),
+                }),
+                func: async ({ token }) => {
+                    return this.verifyEmail(token);
+                },
+            }),
+            // 36. resend_verification
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_resend_verification",
+                description: "Resend the email verification token to the account's email address.",
+                schema: zod_1.z.object({}),
+                func: async () => {
+                    return this.resendVerification();
+                },
+            }),
+            // 37. update_password
+            new tools_1.DynamicStructuredTool({
+                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)"),
+                }),
+                func: async ({ currentPassword, newPassword }) => {
+                    return this.updatePassword(currentPassword, newPassword);
+                },
+            }),
+            // 38. list_keys
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_list_keys",
+                description: "List all API keys for the current account. Shows key ID, label, prefix, and creation date.",
+                schema: zod_1.z.object({}),
+                func: async () => {
+                    return this.listKeys();
+                },
+            }),
+            // 39. create_key
+            new tools_1.DynamicStructuredTool({
+                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")'),
+                }),
+                func: async ({ label }) => {
+                    return this.createKey(label);
+                },
+            }),
+            // 40. revoke_key
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_revoke_key",
+                description: "Revoke (permanently delete) an API key. The key will immediately stop working.",
+                schema: zod_1.z.object({
+                    keyId: zod_1.z.string().uuid().describe("UUID of the API key to revoke"),
+                }),
+                func: async ({ keyId }) => {
+                    return this.revokeKey(keyId);
+                },
+            }),
+            // 41. get_plan
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_get_plan",
+                description: "Get the current user's plan details including bandwidth limits, pricing tier, and features.",
+                schema: zod_1.z.object({}),
+                func: async () => {
+                    return this.getPlan();
+                },
+            }),
+            // 42. list_plans
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_list_plans",
+                description: "List all available Dominus Node plans with pricing, bandwidth limits, and features.",
+                schema: zod_1.z.object({}),
+                func: async () => {
+                    return this.listPlans();
+                },
+            }),
+            // 43. change_plan
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_change_plan",
+                description: "Change the current user's plan. Provide the plan ID of the desired plan from list_plans.",
+                schema: zod_1.z.object({
+                    planId: zod_1.z.string().min(1).describe("ID of the plan to switch to"),
+                }),
+                func: async ({ planId }) => {
+                    return this.changePlan(planId);
+                },
+            }),
+            // 44. team_delete
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_team_delete",
+                description: "Delete a team permanently. Requires owner role. All team keys are revoked and members removed.",
+                schema: zod_1.z.object({
+                    teamId: zod_1.z.string().uuid().describe("Team ID (UUID) to delete"),
+                }),
+                func: async ({ teamId }) => {
+                    return this.teamDelete(teamId);
+                },
+            }),
+            // 45. team_revoke_key
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_team_revoke_key",
+                description: "Revoke (delete) a team API key. Requires owner or admin role.",
+                schema: zod_1.z.object({
+                    teamId: zod_1.z.string().uuid().describe("Team ID (UUID)"),
+                    keyId: zod_1.z.string().uuid().describe("UUID of the team key to revoke"),
+                }),
+                func: async ({ teamId, keyId }) => {
+                    return this.teamRevokeKey(teamId, keyId);
+                },
+            }),
+            // 46. team_list_keys
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_team_list_keys",
+                description: "List all API keys for a team. Shows key ID, label, prefix, and creation date.",
+                schema: zod_1.z.object({
+                    teamId: zod_1.z.string().uuid().describe("Team ID (UUID)"),
+                }),
+                func: async ({ teamId }) => {
+                    return this.teamListKeys(teamId);
+                },
+            }),
+            // 47. team_list_members
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_team_list_members",
+                description: "List all members of a team with their roles and join dates.",
+                schema: zod_1.z.object({
+                    teamId: zod_1.z.string().uuid().describe("Team ID (UUID)"),
+                }),
+                func: async ({ teamId }) => {
+                    return this.teamListMembers(teamId);
+                },
+            }),
+            // 48. team_add_member
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_team_add_member",
+                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)"),
+                }),
+                func: async ({ teamId, email, role }) => {
+                    return this.teamAddMember(teamId, email, role);
+                },
+            }),
+            // 49. team_remove_member
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_team_remove_member",
+                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"),
+                }),
+                func: async ({ teamId, userId }) => {
+                    return this.teamRemoveMember(teamId, userId);
+                },
+            }),
+            // 50. team_invite_member
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_team_invite_member",
+                description: "Send a team invitation to an email address. Invited users can accept to join the team.",
+                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)"),
+                }),
+                func: async ({ teamId, email, role }) => {
+                    return this.teamInviteMember(teamId, email, role);
+                },
+            }),
+            // 51. team_list_invites
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_team_list_invites",
+                description: "List all pending invitations for a team. Shows invite ID, email, role, and status.",
+                schema: zod_1.z.object({
+                    teamId: zod_1.z.string().uuid().describe("Team ID (UUID)"),
+                }),
+                func: async ({ teamId }) => {
+                    return this.teamListInvites(teamId);
+                },
+            }),
+            // 52. team_cancel_invite
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_team_cancel_invite",
+                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"),
+                }),
+                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);
+                },
+            }),
         ];
     }
 }
@@ -1756,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