@dominusnode/mastra-tools 1.2.0 → 1.3.0

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,6 +76,12 @@ 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>;
@@ -119,6 +125,36 @@ 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;
     }, {
@@ -263,5 +299,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,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
     // -----------------------------------------------------------------------
@@ -873,8 +948,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 [
@@ -1442,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) };
+                    }
+                },
+            }),
         ];
     }
 }

package/package.json

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