@dominusnode/mastra-tools 1.2.0 → 1.3.1

package/dist/toolkit.d.ts

@@ -1,7 +1,7 @@
 /**
  * Dominus Node Mastra AI Toolkit
  *
- * Implements 26 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.
@@ -76,12 +76,20 @@ export declare class DominusNodeToolkit {
     private apiPost;
     private apiDelete;
     private apiPatch;
+    private apiPut;
+    /**
+     * Raw POST/GET for unauthenticated endpoints (register, login, verify-email).
+     * Does NOT use ensureAuth(). Includes agent headers if configured.
+     */
+    private rawRequest;
     proxiedFetch(url: string, method?: string, country?: string, proxyType?: string): Promise<{
         status: number;
         headers: Record<string, string>;
         body: string;
+        bytes: number;
         pool: string;
         country: string;
+        error?: string;
     }>;
     checkBalance(): Promise<{
         balanceCents: number;
@@ -119,21 +127,46 @@ export declare class DominusNodeToolkit {
     private static readonly VALID_CRYPTO_CURRENCIES;
     topupCrypto(amountUsd: number, currency: string): Promise<Record<string, unknown>>;
     x402Info(): Promise<Record<string, unknown>>;
+    getProxyStatus(): Promise<Record<string, unknown>>;
+    getTransactions(limit?: number): Promise<Record<string, unknown>>;
+    getForecast(): Promise<Record<string, unknown>>;
+    checkPayment(invoiceId: string): Promise<Record<string, unknown>>;
+    getDailyUsage(days?: number): Promise<Record<string, unknown>>;
+    getTopHosts(limit?: number): Promise<Record<string, unknown>>;
+    private static readonly EMAIL_RE;
+    private static validateEmail;
+    private static validatePassword;
+    register(email: string, password: string): Promise<Record<string, unknown>>;
+    login(email: string, password: string): Promise<Record<string, unknown>>;
+    getAccountInfo(): Promise<Record<string, unknown>>;
+    verifyEmail(token: string): Promise<Record<string, unknown>>;
+    resendVerification(): Promise<Record<string, unknown>>;
+    updatePassword(currentPassword: string, newPassword: string): Promise<Record<string, unknown>>;
+    listKeys(): Promise<Record<string, unknown>>;
+    createKey(label: string): Promise<Record<string, unknown>>;
+    revokeKey(keyId: string): Promise<Record<string, unknown>>;
+    getPlan(): Promise<Record<string, unknown>>;
+    listPlans(): Promise<Record<string, unknown>>;
+    changePlan(planId: string): Promise<Record<string, unknown>>;
+    teamDelete(teamId: string): Promise<Record<string, unknown>>;
+    teamRevokeKey(teamId: string, keyId: string): Promise<Record<string, unknown>>;
+    teamListKeys(teamId: string): Promise<Record<string, unknown>>;
+    teamListMembers(teamId: string): Promise<Record<string, unknown>>;
+    teamAddMember(teamId: string, userId: string, role?: string): Promise<Record<string, unknown>>;
+    teamRemoveMember(teamId: string, userId: string): Promise<Record<string, unknown>>;
+    teamInviteMember(teamId: string, email: string, role?: string): Promise<Record<string, unknown>>;
+    teamListInvites(teamId: string): Promise<Record<string, unknown>>;
+    teamCancelInvite(teamId: string, inviteId: string): Promise<Record<string, unknown>>;
     getTools(): (import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
         context: any;
     }, {
         status: number;
         headers: Record<string, string>;
         body: string;
+        bytes: number;
         pool: string;
         country: string;
-    } | {
-        status: number;
-        headers: {};
-        body: string;
-        pool: any;
-        country: any;
-        error: string;
+        error?: string;
     }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_proxied_fetch", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<unknown, {
         balanceCents: number;
         balanceUsd: number;
@@ -263,5 +296,126 @@ export declare class DominusNodeToolkit {
     }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_topup_crypto", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<unknown, {
         error?: string | undefined;
         data?: unknown;
-    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_x402_info", unknown>)[];
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_x402_info", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<unknown, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_get_proxy_status", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_get_transactions", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<unknown, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_get_forecast", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_check_payment", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_get_daily_usage", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_get_top_hosts", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_register", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_login", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<unknown, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_get_account_info", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_verify_email", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<unknown, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_resend_verification", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_update_password", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<unknown, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_list_keys", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_create_key", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_revoke_key", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<unknown, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_get_plan", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<unknown, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_list_plans", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_change_plan", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_team_delete", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_team_revoke_key", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_team_list_keys", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_team_list_members", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_team_add_member", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_team_remove_member", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_team_invite_member", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_team_list_invites", unknown> | import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).Tool<{
+        context: any;
+    }, {
+        error?: string | undefined;
+        data?: unknown;
+    }, unknown, unknown, import("@mastra/core/tools", { with: { "resolution-mode": "import" } }).ToolExecutionContext<unknown, unknown, unknown>, "dominusnode_team_cancel_invite", unknown>)[];
 }

package/dist/toolkit.js

@@ -2,7 +2,7 @@
 /**
  * Dominus Node Mastra AI Toolkit
  *
- * Implements 26 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.
@@ -523,54 +523,178 @@ 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
     // -----------------------------------------------------------------------
     async proxiedFetch(url, method = "GET", country, proxyType = "dc") {
-        const parsedUrl = validateTargetUrl(url);
-        await checkDnsRebinding(parsedUrl.hostname);
-        const validCountry = validateCountry(country);
-        const ALLOWED_METHODS = new Set(["GET", "HEAD", "OPTIONS"]);
-        const methodUpper = method.toUpperCase();
-        if (!ALLOWED_METHODS.has(methodUpper)) {
-            throw new Error(`HTTP method "${methodUpper}" is not allowed. Only GET, HEAD, and OPTIONS are permitted.`);
-        }
-        const apiKey = this.getApiKey();
-        const parts = [];
-        if (proxyType && proxyType !== "auto")
-            parts.push(proxyType);
-        if (validCountry)
-            parts.push(`country-${validCountry.toUpperCase()}`);
-        const username = parts.length > 0 ? parts.join("-") : "auto";
-        const proxyAuth = "Basic " + Buffer.from(`${username}:${apiKey}`).toString("base64");
-        const parsed = new URL(url);
-        const MAX_RESP = 1_048_576; // 1MB
-        const result = await new Promise((resolve, reject) => {
-            const timer = setTimeout(() => reject(new Error("Proxy request timed out")), REQUEST_TIMEOUT_MS);
-            if (parsed.protocol === "https:") {
-                const connectHost = parsed.hostname.includes(":") ? `[${parsed.hostname}]` : parsed.hostname;
-                const connectReq = http.request({
-                    hostname: this.proxyHost,
-                    port: this.proxyPort,
-                    method: "CONNECT",
-                    path: `${connectHost}:${parsed.port || 443}`,
-                    headers: { "Proxy-Authorization": proxyAuth, Host: `${connectHost}:${parsed.port || 443}` },
-                });
-                connectReq.on("connect", (_res, sock) => {
-                    if (_res.statusCode !== 200) {
-                        clearTimeout(timer);
-                        sock.destroy();
-                        reject(new Error(`CONNECT failed: ${_res.statusCode}`));
-                        return;
-                    }
-                    const tlsSock = tls.connect({ host: parsed.hostname, socket: sock, servername: parsed.hostname, minVersion: "TLSv1.2" }, () => {
-                        const reqLine = `${methodUpper} ${parsed.pathname + parsed.search} HTTP/1.1\r\nHost: ${parsed.host}\r\nUser-Agent: dominusnode-mastra/1.0.0\r\nConnection: close\r\n\r\n`;
-                        tlsSock.write(reqLine);
+        try {
+            const parsedUrl = validateTargetUrl(url);
+            await checkDnsRebinding(parsedUrl.hostname);
+            const validCountry = validateCountry(country);
+            const ALLOWED_METHODS = new Set(["GET", "HEAD", "OPTIONS"]);
+            const methodUpper = method.toUpperCase();
+            if (!ALLOWED_METHODS.has(methodUpper)) {
+                return { status: 0, headers: {}, body: "", bytes: 0, pool: proxyType, country: country ?? "auto", error: `HTTP method "${methodUpper}" is not allowed. Only GET, HEAD, and OPTIONS are permitted.` };
+            }
+            const apiKey = this.getApiKey();
+            const parts = [];
+            if (proxyType && proxyType !== "auto")
+                parts.push(proxyType);
+            if (validCountry)
+                parts.push(`country-${validCountry.toUpperCase()}`);
+            const username = parts.length > 0 ? parts.join("-") : "auto";
+            const proxyAuth = "Basic " + Buffer.from(`${username}:${apiKey}`).toString("base64");
+            const parsed = new URL(url);
+            const MAX_RESP = 1_048_576; // 1MB
+            const result = await new Promise((resolve, reject) => {
+                const timer = setTimeout(() => reject(new Error("Proxy request timed out")), REQUEST_TIMEOUT_MS);
+                if (parsed.protocol === "https:") {
+                    const connectHost = parsed.hostname.includes(":") ? `[${parsed.hostname}]` : parsed.hostname;
+                    const connectReq = http.request({
+                        hostname: this.proxyHost,
+                        port: this.proxyPort,
+                        method: "CONNECT",
+                        path: `${connectHost}:${parsed.port || 443}`,
+                        headers: { "Proxy-Authorization": proxyAuth, Host: `${connectHost}:${parsed.port || 443}` },
+                    });
+                    connectReq.on("connect", (_res, sock) => {
+                        if (_res.statusCode !== 200) {
+                            clearTimeout(timer);
+                            sock.destroy();
+                            reject(new Error(`CONNECT failed: ${_res.statusCode}`));
+                            return;
+                        }
+                        const tlsSock = tls.connect({ host: parsed.hostname, socket: sock, servername: parsed.hostname, minVersion: "TLSv1.2" }, () => {
+                            const reqLine = `${methodUpper} ${parsed.pathname + parsed.search} HTTP/1.1\r\nHost: ${parsed.host}\r\nUser-Agent: dominusnode-mastra/1.0.0\r\nConnection: close\r\n\r\n`;
+                            tlsSock.write(reqLine);
+                            const chunks = [];
+                            let bytes = 0;
+                            tlsSock.on("data", (c) => {
+                                bytes += c.length;
+                                if (bytes <= MAX_RESP + 16384)
+                                    chunks.push(c);
+                            });
+                            let done = false;
+                            const fin = () => {
+                                if (done)
+                                    return;
+                                done = true;
+                                clearTimeout(timer);
+                                const raw = Buffer.concat(chunks).toString("utf-8");
+                                const hEnd = raw.indexOf("\r\n\r\n");
+                                if (hEnd === -1) {
+                                    reject(new Error("Malformed response"));
+                                    return;
+                                }
+                                const hdr = raw.substring(0, hEnd);
+                                const body = raw.substring(hEnd + 4).substring(0, MAX_RESP);
+                                const bodyBytes = new TextEncoder().encode(body).length;
+                                const sm = hdr.split("\r\n")[0].match(/^HTTP\/\d\.\d\s+(\d+)/);
+                                const hdrs = {};
+                                for (const l of hdr.split("\r\n").slice(1)) {
+                                    const ci = l.indexOf(":");
+                                    if (ci > 0)
+                                        hdrs[l.substring(0, ci).trim().toLowerCase()] = l.substring(ci + 1).trim();
+                                }
+                                resolve({ status: sm ? parseInt(sm[1], 10) : 0, headers: hdrs, body, bytes: bodyBytes });
+                            };
+                            tlsSock.on("end", fin);
+                            tlsSock.on("close", fin);
+                            tlsSock.on("error", (e) => { clearTimeout(timer); reject(e); });
+                        });
+                        tlsSock.on("error", (e) => { clearTimeout(timer); reject(e); });
+                    });
+                    connectReq.on("error", (e) => { clearTimeout(timer); reject(e); });
+                    connectReq.end();
+                }
+                else {
+                    const req = http.request({
+                        hostname: this.proxyHost,
+                        port: this.proxyPort,
+                        method: methodUpper,
+                        path: url,
+                        headers: { "Proxy-Authorization": proxyAuth, Host: parsed.host ?? "" },
+                    }, (res) => {
                         const chunks = [];
                         let bytes = 0;
-                        tlsSock.on("data", (c) => {
+                        res.on("data", (c) => {
                             bytes += c.length;
-                            if (bytes <= MAX_RESP + 16384)
+                            if (bytes <= MAX_RESP)
                                 chunks.push(c);
                         });
                         let done = false;
@@ -579,76 +703,43 @@ class DominusNodeToolkit {
                                 return;
                             done = true;
                             clearTimeout(timer);
-                            const raw = Buffer.concat(chunks).toString("utf-8");
-                            const hEnd = raw.indexOf("\r\n\r\n");
-                            if (hEnd === -1) {
-                                reject(new Error("Malformed response"));
-                                return;
-                            }
-                            const hdr = raw.substring(0, hEnd);
-                            const body = raw.substring(hEnd + 4).substring(0, MAX_RESP);
-                            const sm = hdr.split("\r\n")[0].match(/^HTTP\/\d\.\d\s+(\d+)/);
+                            const body = Buffer.concat(chunks).toString("utf-8").substring(0, MAX_RESP);
+                            const bodyBytes = new TextEncoder().encode(body).length;
                             const hdrs = {};
-                            for (const l of hdr.split("\r\n").slice(1)) {
-                                const ci = l.indexOf(":");
-                                if (ci > 0)
-                                    hdrs[l.substring(0, ci).trim().toLowerCase()] = l.substring(ci + 1).trim();
+                            for (const [k, v] of Object.entries(res.headers)) {
+                                if (v)
+                                    hdrs[k] = Array.isArray(v) ? v.join(", ") : v;
                             }
-                            resolve({ status: sm ? parseInt(sm[1], 10) : 0, headers: hdrs, body });
+                            resolve({ status: res.statusCode ?? 0, headers: hdrs, body, bytes: bodyBytes });
                         };
-                        tlsSock.on("end", fin);
-                        tlsSock.on("close", fin);
-                        tlsSock.on("error", (e) => { clearTimeout(timer); reject(e); });
-                    });
-                    tlsSock.on("error", (e) => { clearTimeout(timer); reject(e); });
-                });
-                connectReq.on("error", (e) => { clearTimeout(timer); reject(e); });
-                connectReq.end();
-            }
-            else {
-                const req = http.request({
-                    hostname: this.proxyHost,
-                    port: this.proxyPort,
-                    method: methodUpper,
-                    path: url,
-                    headers: { "Proxy-Authorization": proxyAuth, Host: parsed.host ?? "" },
-                }, (res) => {
-                    const chunks = [];
-                    let bytes = 0;
-                    res.on("data", (c) => {
-                        bytes += c.length;
-                        if (bytes <= MAX_RESP)
-                            chunks.push(c);
+                        res.on("end", fin);
+                        res.on("close", fin);
+                        res.on("error", (e) => { clearTimeout(timer); reject(e); });
                     });
-                    let done = false;
-                    const fin = () => {
-                        if (done)
-                            return;
-                        done = true;
-                        clearTimeout(timer);
-                        const body = Buffer.concat(chunks).toString("utf-8").substring(0, MAX_RESP);
-                        const hdrs = {};
-                        for (const [k, v] of Object.entries(res.headers)) {
-                            if (v)
-                                hdrs[k] = Array.isArray(v) ? v.join(", ") : v;
-                        }
-                        resolve({ status: res.statusCode ?? 0, headers: hdrs, body });
-                    };
-                    res.on("end", fin);
-                    res.on("close", fin);
-                    res.on("error", (e) => { clearTimeout(timer); reject(e); });
-                });
-                req.on("error", (e) => { clearTimeout(timer); reject(e); });
-                req.end();
-            }
-        });
-        return {
-            status: result.status,
-            headers: result.headers,
-            body: truncate(scrubCredentials(result.body)),
-            pool: proxyType,
-            country: validCountry ?? "auto",
-        };
+                    req.on("error", (e) => { clearTimeout(timer); reject(e); });
+                    req.end();
+                }
+            });
+            return {
+                status: result.status,
+                headers: result.headers,
+                body: truncate(scrubCredentials(result.body)),
+                bytes: result.bytes,
+                pool: proxyType,
+                country: validCountry ?? "auto",
+            };
+        }
+        catch (err) {
+            return {
+                status: 0,
+                headers: {},
+                body: "",
+                bytes: 0,
+                pool: proxyType,
+                country: country ?? "auto",
+                error: safeError(err),
+            };
+        }
     }
     async checkBalance() {
         const data = await this.apiGet("/api/wallet");
@@ -873,8 +964,163 @@ class DominusNodeToolkit {
     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 26 tools
+    // getTools() -- returns Mastra createTool() instances for all 53 tools
     // -----------------------------------------------------------------------
     getTools() {
         return [
@@ -894,17 +1140,13 @@ class DominusNodeToolkit {
                     status: zod_1.z.number(),
                     headers: zod_1.z.record(zod_1.z.string()),
                     body: zod_1.z.string(),
+                    bytes: zod_1.z.number(),
                     pool: zod_1.z.string(),
                     country: zod_1.z.string(),
                     error: zod_1.z.string().optional(),
                 }),
                 execute: async ({ context }) => {
-                    try {
-                        return await this.proxiedFetch(context.url, context.method, context.country, context.proxyType);
-                    }
-                    catch (err) {
-                        return { status: 0, headers: {}, body: "", pool: context.proxyType ?? "dc", country: context.country ?? "auto", error: safeError(err) };
-                    }
+                    return await this.proxiedFetch(context.url, context.method, context.country, context.proxyType);
                 },
             }),
             // 2. check_balance
@@ -1442,6 +1684,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) };
+                    }
+                },
+            }),
         ];
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dominusnode/mastra-tools",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "description": "Dominus Node rotating proxy tools for Mastra AI",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",