@dominusnode/flowise-tools 1.0.1 → 1.3.0

package/dist/toolkit.js

@@ -2,9 +2,10 @@
 /**
  * Dominus Node Flowise Toolkit
  *
- * Provides 24 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, PayPal 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,
@@ -391,6 +392,7 @@ class DominusNodeToolkit {
         const portVal = Number(options.proxyPort || process.env.DOMINUSNODE_PROXY_PORT || 8080);
         this.proxyPort = isNaN(portVal) || portVal < 1 || portVal > 65535 ? 8080 : portVal;
         this.timeout = options.timeout || 30000;
+        this.agentSecret = options.agentSecret || process.env.DOMINUSNODE_AGENT_SECRET;
     }
     // -----------------------------------------------------------------------
     // Authentication
@@ -402,12 +404,17 @@ class DominusNodeToolkit {
         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 = {
+            "Content-Type": "application/json",
+            "User-Agent": "dominusnode-flowise/1.0.0",
+        };
+        if (this.agentSecret) {
+            authHeaders["X-DominusNode-Agent"] = "mcp";
+            authHeaders["X-DominusNode-Agent-Secret"] = this.agentSecret;
+        }
         const res = await fetch(`${this.baseUrl}/api/auth/verify-key`, {
             method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                "User-Agent": "dominusnode-flowise/1.0.0",
-            },
+            headers: authHeaders,
             body: JSON.stringify({ apiKey: this.apiKey }),
             redirect: "error",
             signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
@@ -439,6 +446,10 @@ class DominusNodeToolkit {
             Accept: "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,
@@ -511,6 +522,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") {
@@ -1342,7 +1423,57 @@ class DominusNodeToolkit {
         }
     }
     // -----------------------------------------------------------------------
-    // Tool 23: x402Info
+    // Tool 23: topupStripe
+    // -----------------------------------------------------------------------
+    async topupStripe(amountCents) {
+        try {
+            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 });
+            return [
+                "Stripe Checkout Session Created",
+                "",
+                `Session ID: ${data.sessionId}`,
+                `Amount: ${formatCents(amountCents)}`,
+                `Checkout URL: ${data.url}`,
+                "",
+                "Open the checkout URL in a browser to complete payment.",
+                "Once paid, the funds will be credited to your wallet automatically.",
+            ].join("\n");
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    async topupCrypto(amountUsd, currency) {
+        try {
+            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();
+            if (!DominusNodeToolkit.VALID_CRYPTO_CURRENCIES.has(cur)) {
+                return `Error: currency must be one of: ${[...DominusNodeToolkit.VALID_CRYPTO_CURRENCIES].join(", ")}.`;
+            }
+            const data = await this._requestWithRetry("POST", "/api/wallet/topup/crypto", { amountUsd, currency: cur });
+            return [
+                "Crypto Payment Invoice Created",
+                "",
+                `Invoice ID: ${data.invoiceId}`,
+                `Amount: $${amountUsd}`,
+                `Pay: ${data.priceAmount} ${data.payCurrency?.toUpperCase() ?? cur.toUpperCase()}`,
+                `Payment URL: ${data.invoiceUrl}`,
+                "",
+                "Open the payment URL to complete payment.",
+                "Once confirmed on-chain, the funds will be credited to your wallet.",
+            ].join("\n");
+        }
+        catch (err) {
+            return `Error: ${safeError(err)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Tool 25: x402Info
     // -----------------------------------------------------------------------
     async x402Info() {
         try {
@@ -1354,176 +1485,804 @@ 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({
+    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.";
+            }
+            const data = await this._unauthenticatedRequest("POST", "/api/auth/register", { email, password });
+            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)}`;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // 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()
@@ -1651,7 +2410,34 @@ class DominusNodeToolkit {
                     return this.topupPaypal(amountCents);
                 },
             }),
-            // 24. x402_info
+            // 23. topup_stripe
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_topup_stripe",
+                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)"),
+                }),
+                func: async ({ amountCents }) => {
+                    return this.topupStripe(amountCents);
+                },
+            }),
+            // 24. topup_crypto
+            new tools_1.DynamicStructuredTool({
+                name: "dominusnode_topup_crypto",
+                description: "Top up your Dominus Node wallet via cryptocurrency. Creates a crypto payment invoice. " +
+                    "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"])
+                        .describe("Cryptocurrency to pay with"),
+                }),
+                func: async ({ amountUsd, currency }) => {
+                    return this.topupCrypto(amountUsd, currency);
+                },
+            }),
+            // 25. x402_info
             new tools_1.DynamicStructuredTool({
                 name: "dominusnode_x402_info",
                 description: "Get x402 micropayment protocol information including supported facilitators, " +
@@ -1661,8 +2447,310 @@ 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);
+                },
+            }),
         ];
     }
 }
 exports.DominusNodeToolkit = DominusNodeToolkit;
+// -----------------------------------------------------------------------
+// Tool 24: topupCrypto
+// -----------------------------------------------------------------------
+DominusNodeToolkit.VALID_CRYPTO_CURRENCIES = new Set([
+    "btc", "eth", "ltc", "xmr", "zec", "usdc", "sol", "usdt", "dai", "bnb", "link",
+]);
 //# sourceMappingURL=toolkit.js.map