@dominusnode/mastra-tools 1.0.1 → 1.3.0

package/dist/toolkit.js

@@ -2,7 +2,7 @@
 /**
  * Dominus Node Mastra AI Toolkit
  *
- * Implements 24 tools for interacting with Dominus Node's rotating proxy service
+ * Implements 53 tools for interacting with Dominus Node's rotating proxy service
  * from Mastra AI agents and workflows.
  *
  * Uses createTool() from @mastra/core/tools with Zod schemas.
@@ -51,7 +51,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DominusNodeToolkit = void 0;
+exports.DominusNodeToolkit = exports.BLOCKED_HOSTNAMES = exports.SANCTIONED_COUNTRIES = void 0;
 exports.scrubCredentials = scrubCredentials;
 exports.truncate = truncate;
 exports.normalizeIpv4 = normalizeIpv4;
@@ -59,6 +59,7 @@ exports.isPrivateIp = isPrivateIp;
 exports.validateTargetUrl = validateTargetUrl;
 exports.validateCountry = validateCountry;
 exports.validateUuid = validateUuid;
+exports.checkDnsRebinding = checkDnsRebinding;
 exports.stripDangerousKeys = stripDangerousKeys;
 exports.formatBytes = formatBytes;
 exports.formatCents = formatCents;
@@ -75,7 +76,7 @@ const MAX_RESPONSE_CHARS = 4000;
 const REQUEST_TIMEOUT_MS = 30_000;
 const MAX_RESPONSE_BYTES = 10 * 1024 * 1024; // 10 MB hard cap
 /** OFAC sanctioned countries -- must never be used as geo-targeting destinations. */
-const SANCTIONED_COUNTRIES = new Set(["CU", "IR", "KP", "RU", "SY"]);
+exports.SANCTIONED_COUNTRIES = new Set(["CU", "IR", "KP", "RU", "SY"]);
 /** ISO 3166-1 alpha-2 country code pattern. */
 const COUNTRY_CODE_RE = /^[A-Z]{2}$/;
 /** UUID v4 pattern for wallet/team IDs. */
@@ -102,7 +103,7 @@ function truncate(text, max = MAX_RESPONSE_CHARS) {
 // ---------------------------------------------------------------------------
 // SSRF Protection
 // ---------------------------------------------------------------------------
-const BLOCKED_HOSTNAMES = new Set([
+exports.BLOCKED_HOSTNAMES = new Set([
     "localhost",
     "localhost.localdomain",
     "ip6-localhost",
@@ -261,7 +262,7 @@ function validateTargetUrl(url) {
         throw new Error("URLs with embedded credentials are not allowed");
     }
     const hostname = parsed.hostname.toLowerCase();
-    if (BLOCKED_HOSTNAMES.has(hostname)) {
+    if (exports.BLOCKED_HOSTNAMES.has(hostname)) {
         throw new Error("Requests to localhost/loopback addresses are blocked");
     }
     if (isPrivateIp(hostname)) {
@@ -291,7 +292,7 @@ function validateCountry(country) {
     if (!COUNTRY_CODE_RE.test(upper)) {
         throw new Error(`Invalid country code: "${country}". Must be a 2-letter ISO 3166-1 code.`);
     }
-    if (SANCTIONED_COUNTRIES.has(upper)) {
+    if (exports.SANCTIONED_COUNTRIES.has(upper)) {
         throw new Error(`Country "${upper}" is OFAC sanctioned and cannot be used as a proxy target.`);
     }
     return upper;
@@ -383,6 +384,7 @@ class DominusNodeToolkit {
     baseUrl;
     proxyHost;
     proxyPort;
+    agentSecret;
     cachedJwt = null;
     jwtExpiresAt = 0;
     constructor(config = {}) {
@@ -392,6 +394,7 @@ class DominusNodeToolkit {
         const portStr = config.proxyPort?.toString() || process.env.DOMINUSNODE_PROXY_PORT || "8080";
         const port = parseInt(portStr, 10);
         this.proxyPort = isNaN(port) || port < 1 || port > 65535 ? 8080 : port;
+        this.agentSecret = config.agentSecret || process.env.DOMINUSNODE_AGENT_SECRET;
     }
     // -----------------------------------------------------------------------
     // Authentication
@@ -411,12 +414,17 @@ class DominusNodeToolkit {
         if (this.cachedJwt && Date.now() < this.jwtExpiresAt)
             return this.cachedJwt;
         const apiKey = this.getApiKey();
+        const authHeaders = {
+            "Content-Type": "application/json",
+            "User-Agent": "dominusnode-mastra/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-mastra/1.0.0",
-            },
+            headers: authHeaders,
             body: JSON.stringify({ apiKey }),
             redirect: "error",
         });
@@ -441,6 +449,10 @@ class DominusNodeToolkit {
             Accept: "application/json",
             "User-Agent": "dominusnode-mastra/1.0.0",
         };
+        if (this.agentSecret) {
+            headers["X-DominusNode-Agent"] = "mcp";
+            headers["X-DominusNode-Agent-Secret"] = this.agentSecret;
+        }
         const init = {
             method,
             headers,
@@ -511,6 +523,81 @@ class DominusNodeToolkit {
     async apiPatch(path, body) {
         return this.apiRequest("PATCH", path, body);
     }
+    async apiPut(path, body) {
+        return this.apiRequest("PUT", path, body);
+    }
+    /**
+     * Raw POST/GET for unauthenticated endpoints (register, login, verify-email).
+     * Does NOT use ensureAuth(). Includes agent headers if configured.
+     */
+    async rawRequest(method, path, body) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+            Accept: "application/json",
+            "User-Agent": "dominusnode-mastra/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 && (method === "POST" || method === "PUT" || method === "PATCH")) {
+            headers["Content-Type"] = "application/json";
+            init.body = JSON.stringify(body);
+        }
+        let res;
+        try {
+            res = await fetch(url, init);
+        }
+        catch (err) {
+            throw new Error(`API 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("API response too large");
+        }
+        if (!res.ok) {
+            let errorMsg = `API error ${res.status}`;
+            if (rawText) {
+                try {
+                    const parsed = JSON.parse(rawText);
+                    stripDangerousKeys(parsed);
+                    if (parsed.error) {
+                        errorMsg = `API error ${res.status}: ${scrubCredentials(String(parsed.error))}`;
+                    }
+                    else if (parsed.message) {
+                        errorMsg = `API error ${res.status}: ${scrubCredentials(String(parsed.message))}`;
+                    }
+                }
+                catch {
+                    errorMsg = `API 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 API response as JSON");
+        }
+    }
     // -----------------------------------------------------------------------
     // Tool implementations
     // -----------------------------------------------------------------------
@@ -839,11 +926,185 @@ class DominusNodeToolkit {
         }
         return this.apiPost("/api/wallet/topup/paypal", { amountCents });
     }
+    async topupStripe(amountCents) {
+        if (!Number.isInteger(amountCents) || amountCents < 500 || amountCents > 100000) {
+            throw new Error("amount_cents must be an integer between 500 ($5) and 100000 ($1,000).");
+        }
+        return this.apiPost("/api/wallet/topup/stripe", { amountCents });
+    }
+    static VALID_CRYPTO_CURRENCIES = new Set([
+        "btc", "eth", "ltc", "xmr", "zec", "usdc", "sol", "usdt", "dai", "bnb", "link",
+    ]);
+    async topupCrypto(amountUsd, currency) {
+        if (typeof amountUsd !== "number" || !Number.isFinite(amountUsd) || amountUsd < 5 || amountUsd > 1000) {
+            throw new Error("amount_usd must be a number between 5 and 1,000.");
+        }
+        const cur = String(currency ?? "").toLowerCase();
+        if (!DominusNodeToolkit.VALID_CRYPTO_CURRENCIES.has(cur)) {
+            throw new Error(`currency must be one of: ${[...DominusNodeToolkit.VALID_CRYPTO_CURRENCIES].join(", ")}.`);
+        }
+        return this.apiPost("/api/wallet/topup/crypto", { amountUsd, currency: cur });
+    }
     async x402Info() {
         return this.apiGet("/api/x402/info");
     }
+    // -- Proxy --
+    async getProxyStatus() {
+        return this.apiGet("/api/proxy/status");
+    }
+    // -- Wallet --
+    async getTransactions(limit = 20) {
+        const safeLimit = Math.min(Math.max(limit, 1), 100);
+        return this.apiGet(`/api/wallet/transactions?limit=${safeLimit}`);
+    }
+    async getForecast() {
+        return this.apiGet("/api/wallet/forecast");
+    }
+    async checkPayment(invoiceId) {
+        validateUuid(invoiceId, "invoice_id");
+        return this.apiGet(`/api/wallet/topup/crypto/${encodeURIComponent(invoiceId)}/status`);
+    }
+    // -- Usage --
+    async getDailyUsage(days = 7) {
+        const safeDays = Math.min(Math.max(days, 1), 365);
+        return this.apiGet(`/api/usage/daily?days=${safeDays}`);
+    }
+    async getTopHosts(limit = 10) {
+        const safeLimit = Math.min(Math.max(limit, 1), 100);
+        return this.apiGet(`/api/usage/top-hosts?limit=${safeLimit}`);
+    }
+    // -- Account (unauthenticated) --
+    static EMAIL_RE = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    static validateEmail(email) {
+        const trimmed = email.trim();
+        if (!trimmed || !DominusNodeToolkit.EMAIL_RE.test(trimmed)) {
+            throw new Error("Invalid email address.");
+        }
+        if (trimmed.length > 254) {
+            throw new Error("Email address too long (max 254 characters).");
+        }
+        return trimmed;
+    }
+    static validatePassword(password) {
+        if (!password || password.length < 8) {
+            throw new Error("Password must be at least 8 characters.");
+        }
+        if (password.length > 128) {
+            throw new Error("Password must be at most 128 characters.");
+        }
+        return password;
+    }
+    async register(email, password) {
+        const safeEmail = DominusNodeToolkit.validateEmail(email);
+        const safePassword = DominusNodeToolkit.validatePassword(password);
+        return this.rawRequest("POST", "/api/auth/register", { email: safeEmail, password: safePassword });
+    }
+    async login(email, password) {
+        const safeEmail = DominusNodeToolkit.validateEmail(email);
+        const safePassword = DominusNodeToolkit.validatePassword(password);
+        return this.rawRequest("POST", "/api/auth/login", { email: safeEmail, password: safePassword });
+    }
+    async getAccountInfo() {
+        return this.apiGet("/api/auth/me");
+    }
+    async verifyEmail(token) {
+        if (!token || typeof token !== "string" || token.trim().length === 0) {
+            throw new Error("Verification token is required.");
+        }
+        if (/[\x00-\x1f\x7f]/.test(token)) {
+            throw new Error("Token contains invalid control characters.");
+        }
+        return this.rawRequest("POST", "/api/auth/verify-email", { token: token.trim() });
+    }
+    async resendVerification() {
+        return this.apiPost("/api/auth/resend-verification");
+    }
+    async updatePassword(currentPassword, newPassword) {
+        DominusNodeToolkit.validatePassword(currentPassword);
+        DominusNodeToolkit.validatePassword(newPassword);
+        return this.apiPost("/api/auth/change-password", {
+            currentPassword,
+            newPassword,
+        });
+    }
+    // -- API Keys --
+    async listKeys() {
+        return this.apiGet("/api/keys");
+    }
+    async createKey(label) {
+        if (!label || label.length === 0 || label.length > 100) {
+            throw new Error("label is required and must be 1-100 characters.");
+        }
+        if (/[\x00-\x1f\x7f]/.test(label)) {
+            throw new Error("label contains invalid control characters.");
+        }
+        return this.apiPost("/api/keys", { label });
+    }
+    async revokeKey(keyId) {
+        validateUuid(keyId, "key_id");
+        return this.apiDelete(`/api/keys/${encodeURIComponent(keyId)}`);
+    }
+    // -- Plans --
+    async getPlan() {
+        return this.apiGet("/api/plans/user/plan");
+    }
+    async listPlans() {
+        return this.apiGet("/api/plans");
+    }
+    async changePlan(planId) {
+        validateUuid(planId, "plan_id");
+        return this.apiPut("/api/plans/user/plan", { planId });
+    }
+    // -- Teams (additional) --
+    async teamDelete(teamId) {
+        validateUuid(teamId, "team_id");
+        return this.apiDelete(`/api/teams/${encodeURIComponent(teamId)}`);
+    }
+    async teamRevokeKey(teamId, keyId) {
+        validateUuid(teamId, "team_id");
+        validateUuid(keyId, "key_id");
+        return this.apiDelete(`/api/teams/${encodeURIComponent(teamId)}/keys/${encodeURIComponent(keyId)}`);
+    }
+    async teamListKeys(teamId) {
+        validateUuid(teamId, "team_id");
+        return this.apiGet(`/api/teams/${encodeURIComponent(teamId)}/keys`);
+    }
+    async teamListMembers(teamId) {
+        validateUuid(teamId, "team_id");
+        return this.apiGet(`/api/teams/${encodeURIComponent(teamId)}/members`);
+    }
+    async teamAddMember(teamId, userId, role = "member") {
+        validateUuid(teamId, "team_id");
+        validateUuid(userId, "user_id");
+        if (role !== "member" && role !== "admin") {
+            throw new Error("role must be 'member' or 'admin'.");
+        }
+        return this.apiPost(`/api/teams/${encodeURIComponent(teamId)}/members`, { userId, role });
+    }
+    async teamRemoveMember(teamId, userId) {
+        validateUuid(teamId, "team_id");
+        validateUuid(userId, "user_id");
+        return this.apiDelete(`/api/teams/${encodeURIComponent(teamId)}/members/${encodeURIComponent(userId)}`);
+    }
+    async teamInviteMember(teamId, email, role = "member") {
+        validateUuid(teamId, "team_id");
+        const safeEmail = DominusNodeToolkit.validateEmail(email);
+        if (role !== "member" && role !== "admin") {
+            throw new Error("role must be 'member' or 'admin'.");
+        }
+        return this.apiPost(`/api/teams/${encodeURIComponent(teamId)}/invites`, { email: safeEmail, role });
+    }
+    async teamListInvites(teamId) {
+        validateUuid(teamId, "team_id");
+        return this.apiGet(`/api/teams/${encodeURIComponent(teamId)}/invites`);
+    }
+    async teamCancelInvite(teamId, inviteId) {
+        validateUuid(teamId, "team_id");
+        validateUuid(inviteId, "invite_id");
+        return this.apiDelete(`/api/teams/${encodeURIComponent(teamId)}/invites/${encodeURIComponent(inviteId)}`);
+    }
     // -----------------------------------------------------------------------
-    // getTools() -- returns Mastra createTool() instances for all 24 tools
+    // getTools() -- returns Mastra createTool() instances for all 53 tools
     // -----------------------------------------------------------------------
     getTools() {
         return [
@@ -1345,7 +1606,54 @@ class DominusNodeToolkit {
                     }
                 },
             }),
-            // 24. x402_info
+            // 23. topup_stripe
+            (0, tools_1.createTool)({
+                id: "dominusnode_topup_stripe",
+                description: "Top up your Dominus Node wallet balance via Stripe. Creates a Stripe checkout session and returns " +
+                    "a checkout URL to complete payment. Minimum $5 (500 cents), maximum $1,000 (100000 cents).",
+                inputSchema: zod_1.z.object({
+                    amountCents: zod_1.z.number().int().min(500).max(100000)
+                        .describe("Amount in cents to top up (min 500 = $5, max 100000 = $1,000)"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.topupStripe(context.amountCents) };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 24. topup_crypto
+            (0, tools_1.createTool)({
+                id: "dominusnode_topup_crypto",
+                description: "Top up your Dominus Node wallet balance via cryptocurrency. Creates a crypto payment invoice. " +
+                    "Supports BTC, ETH, LTC, XMR, ZEC, USDC, SOL, USDT, DAI, BNB, LINK. " +
+                    "Minimum $5, maximum $1,000.",
+                inputSchema: zod_1.z.object({
+                    amountUsd: zod_1.z.number().min(5).max(1000)
+                        .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"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.topupCrypto(context.amountUsd, context.currency) };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 26. x402_info
             (0, tools_1.createTool)({
                 id: "dominusnode_x402_info",
                 description: "Get x402 micropayment protocol information including supported " +
@@ -1364,6 +1672,556 @@ class DominusNodeToolkit {
                     }
                 },
             }),
+            // 27. get_proxy_status
+            (0, tools_1.createTool)({
+                id: "dominusnode_get_proxy_status",
+                description: "Get the current status of the proxy gateway including uptime, active connections, " +
+                    "and pool health.",
+                inputSchema: zod_1.z.object({}),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async () => {
+                    try {
+                        return { data: await this.getProxyStatus() };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 28. get_transactions
+            (0, tools_1.createTool)({
+                id: "dominusnode_get_transactions",
+                description: "Get wallet transaction history showing top-ups, charges, and refunds.",
+                inputSchema: zod_1.z.object({
+                    limit: zod_1.z.number().int().min(1).max(100).default(20).describe("Number of transactions to return (1-100, default 20)"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.getTransactions(context.limit) };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 29. get_forecast
+            (0, tools_1.createTool)({
+                id: "dominusnode_get_forecast",
+                description: "Get a spending forecast based on recent usage patterns. " +
+                    "Shows estimated days until balance runs out and projected monthly cost.",
+                inputSchema: zod_1.z.object({}),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async () => {
+                    try {
+                        return { data: await this.getForecast() };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 30. check_payment
+            (0, tools_1.createTool)({
+                id: "dominusnode_check_payment",
+                description: "Check the status of a crypto top-up payment by invoice ID. " +
+                    "Returns payment status (pending, confirming, completed, expired).",
+                inputSchema: zod_1.z.object({
+                    invoiceId: zod_1.z.string().describe("Crypto invoice ID (UUID) returned from topup_crypto"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.checkPayment(context.invoiceId) };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 31. get_daily_usage
+            (0, tools_1.createTool)({
+                id: "dominusnode_get_daily_usage",
+                description: "Get daily bandwidth usage breakdown for the specified number of days. " +
+                    "Returns per-day bytes transferred and cost.",
+                inputSchema: zod_1.z.object({
+                    days: zod_1.z.number().int().min(1).max(365).default(7).describe("Number of days to look back (1-365, default 7)"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.getDailyUsage(context.days) };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 32. get_top_hosts
+            (0, tools_1.createTool)({
+                id: "dominusnode_get_top_hosts",
+                description: "Get the top hosts by bandwidth usage. Shows which domains consume the most proxy traffic.",
+                inputSchema: zod_1.z.object({
+                    limit: zod_1.z.number().int().min(1).max(100).default(10).describe("Number of top hosts to return (1-100, default 10)"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.getTopHosts(context.limit) };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 33. register
+            (0, tools_1.createTool)({
+                id: "dominusnode_register",
+                description: "Register a new Dominus Node account. Does not require authentication. " +
+                    "Returns user info and initial API key.",
+                inputSchema: zod_1.z.object({
+                    email: zod_1.z.string().describe("Email address for the new account"),
+                    password: zod_1.z.string().min(8).max(128).describe("Password (8-128 characters)"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.register(context.email, context.password) };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 34. login
+            (0, tools_1.createTool)({
+                id: "dominusnode_login",
+                description: "Log in to an existing Dominus Node account. Does not require authentication. " +
+                    "Returns JWT access and refresh tokens.",
+                inputSchema: zod_1.z.object({
+                    email: zod_1.z.string().describe("Account email address"),
+                    password: zod_1.z.string().min(8).max(128).describe("Account password"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.login(context.email, context.password) };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 35. get_account_info
+            (0, tools_1.createTool)({
+                id: "dominusnode_get_account_info",
+                description: "Get your account profile information including email, plan, verification status, and creation date.",
+                inputSchema: zod_1.z.object({}),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async () => {
+                    try {
+                        return { data: await this.getAccountInfo() };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 36. verify_email
+            (0, tools_1.createTool)({
+                id: "dominusnode_verify_email",
+                description: "Verify an email address using the verification token sent to the user's email. " +
+                    "Does not require authentication.",
+                inputSchema: zod_1.z.object({
+                    token: zod_1.z.string().describe("Email verification token from the verification email"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.verifyEmail(context.token) };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 37. resend_verification
+            (0, tools_1.createTool)({
+                id: "dominusnode_resend_verification",
+                description: "Resend the email verification link. Requires authentication.",
+                inputSchema: zod_1.z.object({}),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async () => {
+                    try {
+                        return { data: await this.resendVerification() };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 38. update_password
+            (0, tools_1.createTool)({
+                id: "dominusnode_update_password",
+                description: "Change your account password. Requires current password for verification.",
+                inputSchema: zod_1.z.object({
+                    currentPassword: zod_1.z.string().min(8).max(128).describe("Current account password"),
+                    newPassword: zod_1.z.string().min(8).max(128).describe("New password (8-128 characters)"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.updatePassword(context.currentPassword, context.newPassword) };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 39. list_keys
+            (0, tools_1.createTool)({
+                id: "dominusnode_list_keys",
+                description: "List all your personal API keys with their labels, creation dates, and last-used timestamps.",
+                inputSchema: zod_1.z.object({}),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async () => {
+                    try {
+                        return { data: await this.listKeys() };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 40. create_key
+            (0, tools_1.createTool)({
+                id: "dominusnode_create_key",
+                description: "Create a new personal API key. The key is shown only once -- save it immediately. " +
+                    "Usage is billed against your personal wallet.",
+                inputSchema: zod_1.z.object({
+                    label: zod_1.z.string().min(1).max(100).describe('Label for the API key (e.g., "production", "dev-testing")'),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.createKey(context.label) };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 41. revoke_key
+            (0, tools_1.createTool)({
+                id: "dominusnode_revoke_key",
+                description: "Revoke (delete) a personal API key. This action is irreversible -- " +
+                    "any applications using this key will lose access immediately.",
+                inputSchema: zod_1.z.object({
+                    keyId: zod_1.z.string().describe("API key ID (UUID) to revoke"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.revokeKey(context.keyId) };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 42. get_plan
+            (0, tools_1.createTool)({
+                id: "dominusnode_get_plan",
+                description: "Get your current subscription plan including tier, bandwidth limits, and pricing.",
+                inputSchema: zod_1.z.object({}),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async () => {
+                    try {
+                        return { data: await this.getPlan() };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 43. list_plans
+            (0, tools_1.createTool)({
+                id: "dominusnode_list_plans",
+                description: "List all available subscription plans with features, pricing, and bandwidth limits.",
+                inputSchema: zod_1.z.object({}),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async () => {
+                    try {
+                        return { data: await this.listPlans() };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 44. change_plan
+            (0, tools_1.createTool)({
+                id: "dominusnode_change_plan",
+                description: "Change your subscription plan. Takes effect immediately. " +
+                    "Use list_plans to see available options.",
+                inputSchema: zod_1.z.object({
+                    planId: zod_1.z.string().describe("Plan ID (UUID) to switch to"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.changePlan(context.planId) };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 45. team_delete
+            (0, tools_1.createTool)({
+                id: "dominusnode_team_delete",
+                description: "Delete a team. Only the team owner can delete. " +
+                    "All team keys are revoked and remaining balance is refunded.",
+                inputSchema: zod_1.z.object({
+                    teamId: zod_1.z.string().describe("Team ID (UUID) to delete"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.teamDelete(context.teamId) };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 46. team_revoke_key
+            (0, tools_1.createTool)({
+                id: "dominusnode_team_revoke_key",
+                description: "Revoke a team API key. Only owners and admins can revoke keys. " +
+                    "Applications using this key will lose access immediately.",
+                inputSchema: zod_1.z.object({
+                    teamId: zod_1.z.string().describe("Team ID (UUID)"),
+                    keyId: zod_1.z.string().describe("API key ID (UUID) to revoke"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.teamRevokeKey(context.teamId, context.keyId) };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 47. team_list_keys
+            (0, tools_1.createTool)({
+                id: "dominusnode_team_list_keys",
+                description: "List all API keys for a team with labels, creation dates, and last-used timestamps.",
+                inputSchema: zod_1.z.object({
+                    teamId: zod_1.z.string().describe("Team ID (UUID)"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.teamListKeys(context.teamId) };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 48. team_list_members
+            (0, tools_1.createTool)({
+                id: "dominusnode_team_list_members",
+                description: "List all members of a team with their roles and join dates.",
+                inputSchema: zod_1.z.object({
+                    teamId: zod_1.z.string().describe("Team ID (UUID)"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.teamListMembers(context.teamId) };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 49. team_add_member
+            (0, tools_1.createTool)({
+                id: "dominusnode_team_add_member",
+                description: "Add a user directly to a team by user ID. " +
+                    "Only owners and admins can add members.",
+                inputSchema: zod_1.z.object({
+                    teamId: zod_1.z.string().describe("Team ID (UUID)"),
+                    userId: zod_1.z.string().describe("User ID (UUID) of the user to add"),
+                    role: zod_1.z.enum(["member", "admin"]).default("member").describe("Role for the new member"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.teamAddMember(context.teamId, context.userId, context.role) };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 50. team_remove_member
+            (0, tools_1.createTool)({
+                id: "dominusnode_team_remove_member",
+                description: "Remove a member from a team. Only owners and admins can remove members.",
+                inputSchema: zod_1.z.object({
+                    teamId: zod_1.z.string().describe("Team ID (UUID)"),
+                    userId: zod_1.z.string().describe("User ID (UUID) of the member to remove"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.teamRemoveMember(context.teamId, context.userId) };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 51. team_invite_member
+            (0, tools_1.createTool)({
+                id: "dominusnode_team_invite_member",
+                description: "Invite a user to join a team by email address. " +
+                    "The user will receive an invitation email.",
+                inputSchema: zod_1.z.object({
+                    teamId: zod_1.z.string().describe("Team ID (UUID)"),
+                    email: zod_1.z.string().describe("Email address of the user to invite"),
+                    role: zod_1.z.enum(["member", "admin"]).default("member").describe("Role for the invited member"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.teamInviteMember(context.teamId, context.email, context.role) };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 52. team_list_invites
+            (0, tools_1.createTool)({
+                id: "dominusnode_team_list_invites",
+                description: "List all pending invitations for a team.",
+                inputSchema: zod_1.z.object({
+                    teamId: zod_1.z.string().describe("Team ID (UUID)"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.teamListInvites(context.teamId) };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
+            // 53. team_cancel_invite
+            (0, tools_1.createTool)({
+                id: "dominusnode_team_cancel_invite",
+                description: "Cancel a pending team invitation. Only owners and admins can cancel invites.",
+                inputSchema: zod_1.z.object({
+                    teamId: zod_1.z.string().describe("Team ID (UUID)"),
+                    inviteId: zod_1.z.string().describe("Invite ID (UUID) to cancel"),
+                }),
+                outputSchema: zod_1.z.object({
+                    data: zod_1.z.unknown(),
+                    error: zod_1.z.string().optional(),
+                }),
+                execute: async ({ context }) => {
+                    try {
+                        return { data: await this.teamCancelInvite(context.teamId, context.inviteId) };
+                    }
+                    catch (err) {
+                        return { data: null, error: safeError(err) };
+                    }
+                },
+            }),
         ];
     }
 }