@dominusnode/gemini-functions 1.0.1 → 1.2.0

package/dist/handler.d.ts

@@ -1,6 +1,8 @@
 /**
  * Dominus Node Gemini / Vertex AI function calling handler (TypeScript).
  *
+ * 53 tools for AI agents to interact with the Dominus Node REST API.
+ *
  * Provides a factory function that creates a handler for dispatching
  * Google Gemini function calls to the Dominus Node REST API. Works with
  * Gemini, Vertex AI, or any system that uses Gemini-format function
@@ -46,6 +48,8 @@ export interface DominusNodeFunctionConfig {
     baseUrl?: string;
     /** Request timeout in milliseconds. Defaults to 30000. */
     timeoutMs?: number;
+    /** Optional agent secret for MCP agent auto-verification (bypasses reCAPTCHA). */
+    agentSecret?: string;
 }
 /**
  * Handler function type returned by createDominusNodeFunctionHandler.

package/dist/handler.js

@@ -1,6 +1,8 @@
 /**
  * Dominus Node Gemini / Vertex AI function calling handler (TypeScript).
  *
+ * 53 tools for AI agents to interact with the Dominus Node REST API.
+ *
  * Provides a factory function that creates a handler for dispatching
  * Google Gemini function calls to the Dominus Node REST API. Works with
  * Gemini, Vertex AI, or any system that uses Gemini-format function
@@ -325,6 +327,10 @@ async function apiRequest(config, method, path, body) {
         "Content-Type": "application/json",
         Authorization: `Bearer ${config.token}`,
     };
+    if (config.agentSecret) {
+        headers["X-DominusNode-Agent"] = "mcp";
+        headers["X-DominusNode-Agent-Secret"] = config.agentSecret;
+    }
     const response = await fetch(url, {
         method,
         headers,
@@ -405,6 +411,7 @@ export { isPrivateIp, validateUrl, normalizeIpv4, sanitizeError, stripDangerousK
 export function createDominusNodeFunctionHandler(config) {
     const baseUrl = config.baseUrl ?? "https://api.dominusnode.com";
     const timeoutMs = config.timeoutMs ?? 30_000;
+    const agentSecret = config.agentSecret || process.env.DOMINUSNODE_AGENT_SECRET;
     if (!config.apiKey || typeof config.apiKey !== "string") {
         throw new Error("apiKey is required and must be a non-empty string");
     }
@@ -412,12 +419,17 @@ export function createDominusNodeFunctionHandler(config) {
     let authToken = null;
     let authPromise = null;
     async function authenticate() {
+        const authHeaders = {
+            "User-Agent": "dominusnode-gemini/1.0.0",
+            "Content-Type": "application/json",
+        };
+        if (agentSecret) {
+            authHeaders["X-DominusNode-Agent"] = "mcp";
+            authHeaders["X-DominusNode-Agent-Secret"] = agentSecret;
+        }
         const response = await fetch(`${baseUrl}/api/auth/verify-key`, {
             method: "POST",
-            headers: {
-                "User-Agent": "dominusnode-gemini/1.0.0",
-                "Content-Type": "application/json",
-            },
+            headers: authHeaders,
             body: JSON.stringify({ apiKey: config.apiKey }),
             signal: AbortSignal.timeout(timeoutMs),
             redirect: "error",
@@ -445,7 +457,7 @@ export function createDominusNodeFunctionHandler(config) {
     function api(method, path, body) {
         if (!authToken)
             throw new Error("Not authenticated");
-        return apiRequest({ baseUrl, timeoutMs, token: authToken }, method, path, body);
+        return apiRequest({ baseUrl, timeoutMs, token: authToken, agentSecret }, method, path, body);
     }
     // -----------------------------------------------------------------------
     // Function handlers
@@ -953,6 +965,504 @@ export function createDominusNodeFunctionHandler(config) {
         const result = await api("POST", "/api/wallet/topup/paypal", { amountCents });
         return JSON.stringify(result);
     }
+    async function handleTopupStripe(args) {
+        const amountCents = args.amount_cents;
+        if (!Number.isInteger(amountCents) ||
+            amountCents < 500 ||
+            amountCents > 100_000) {
+            return JSON.stringify({
+                error: "amount_cents must be an integer between 500 ($5) and 100,000 ($1,000)",
+            });
+        }
+        const result = await api("POST", "/api/wallet/topup/stripe", { amountCents });
+        return JSON.stringify(result);
+    }
+    const VALID_CRYPTO_CURRENCIES = new Set([
+        "btc", "eth", "ltc", "xmr", "zec", "usdc", "sol", "usdt", "dai", "bnb", "link",
+    ]);
+    async function handleTopupCrypto(args) {
+        const amountUsd = args.amount_usd;
+        const currency = String(args.currency ?? "").toLowerCase();
+        if (typeof amountUsd !== "number" ||
+            !Number.isFinite(amountUsd) ||
+            amountUsd < 5 ||
+            amountUsd > 1_000) {
+            return JSON.stringify({
+                error: "amount_usd must be a number between 5 and 1,000",
+            });
+        }
+        if (!VALID_CRYPTO_CURRENCIES.has(currency)) {
+            return JSON.stringify({
+                error: `currency must be one of: ${[...VALID_CRYPTO_CURRENCIES].join(", ")}`,
+            });
+        }
+        const result = await api("POST", "/api/wallet/topup/crypto", {
+            amountUsd,
+            currency,
+        });
+        return JSON.stringify(result);
+    }
+    // -----------------------------------------------------------------------
+    // Proxy extended
+    // -----------------------------------------------------------------------
+    async function handleGetProxyStatus() {
+        const result = await api("GET", "/api/proxy/status");
+        return JSON.stringify(result);
+    }
+    // -----------------------------------------------------------------------
+    // Wallet extended
+    // -----------------------------------------------------------------------
+    async function handleGetTransactions(args) {
+        const params = new URLSearchParams();
+        if (args.limit !== undefined) {
+            const limit = Number(args.limit);
+            if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
+                return JSON.stringify({ error: "limit must be an integer between 1 and 100" });
+            }
+            params.set("limit", String(limit));
+        }
+        const qs = params.toString();
+        const result = await api("GET", `/api/wallet/transactions${qs ? `?${qs}` : ""}`);
+        return JSON.stringify(result);
+    }
+    async function handleGetForecast() {
+        const result = await api("GET", "/api/wallet/forecast");
+        return JSON.stringify(result);
+    }
+    async function handleCheckPayment(args) {
+        const invoiceId = args.invoice_id;
+        if (!invoiceId || typeof invoiceId !== "string") {
+            return JSON.stringify({ error: "invoice_id is required and must be a string" });
+        }
+        if (/[\x00-\x1f\x7f]/.test(invoiceId)) {
+            return JSON.stringify({ error: "invoice_id contains invalid control characters" });
+        }
+        const result = await api("GET", `/api/wallet/topup/crypto/${encodeURIComponent(invoiceId)}/status`);
+        return JSON.stringify(result);
+    }
+    // -----------------------------------------------------------------------
+    // Usage extended
+    // -----------------------------------------------------------------------
+    async function handleGetDailyUsage(args) {
+        const params = new URLSearchParams();
+        if (args.days !== undefined) {
+            const days = Number(args.days);
+            if (!Number.isInteger(days) || days < 1 || days > 90) {
+                return JSON.stringify({ error: "days must be an integer between 1 and 90" });
+            }
+            params.set("days", String(days));
+        }
+        const qs = params.toString();
+        const result = await api("GET", `/api/usage/daily${qs ? `?${qs}` : ""}`);
+        return JSON.stringify(result);
+    }
+    async function handleGetTopHosts(args) {
+        const params = new URLSearchParams();
+        if (args.limit !== undefined) {
+            const limit = Number(args.limit);
+            if (!Number.isInteger(limit) || limit < 1 || limit > 50) {
+                return JSON.stringify({ error: "limit must be an integer between 1 and 50" });
+            }
+            params.set("limit", String(limit));
+        }
+        const qs = params.toString();
+        const result = await api("GET", `/api/usage/top-hosts${qs ? `?${qs}` : ""}`);
+        return JSON.stringify(result);
+    }
+    // -----------------------------------------------------------------------
+    // Account lifecycle
+    // -----------------------------------------------------------------------
+    async function handleRegister(args) {
+        const email = args.email;
+        const password = args.password;
+        if (!email || typeof email !== "string") {
+            return JSON.stringify({ error: "email is required and must be a string" });
+        }
+        if (!/^[^@]+@[^@]+\.[^@]+$/.test(email)) {
+            return JSON.stringify({ error: "email must be a valid email address" });
+        }
+        if (/[\x00-\x1f\x7f]/.test(email)) {
+            return JSON.stringify({ error: "email contains invalid control characters" });
+        }
+        if (!password || typeof password !== "string") {
+            return JSON.stringify({ error: "password is required and must be a string" });
+        }
+        if (password.length < 8 || password.length > 128) {
+            return JSON.stringify({ error: "password must be between 8 and 128 characters" });
+        }
+        try {
+            const reqHeaders = {
+                "User-Agent": "dominusnode-gemini/1.0.0",
+                "Content-Type": "application/json",
+            };
+            if (agentSecret) {
+                reqHeaders["X-DominusNode-Agent"] = "mcp";
+                reqHeaders["X-DominusNode-Agent-Secret"] = agentSecret;
+            }
+            const response = await fetch(`${baseUrl}/api/auth/register`, {
+                method: "POST",
+                headers: reqHeaders,
+                body: JSON.stringify({ email, password }),
+                signal: AbortSignal.timeout(timeoutMs),
+                redirect: "error",
+            });
+            const responseText = await response.text();
+            if (responseText.length > MAX_RESPONSE_BYTES) {
+                return JSON.stringify({ error: "Response body exceeds size limit" });
+            }
+            if (!response.ok) {
+                let message;
+                try {
+                    const parsed = JSON.parse(responseText);
+                    message = parsed.error ?? parsed.message ?? responseText;
+                }
+                catch {
+                    message = responseText;
+                }
+                if (message.length > 500)
+                    message = message.slice(0, 500) + "... [truncated]";
+                return JSON.stringify({ error: sanitizeError(message) });
+            }
+            const data = safeJsonParse(responseText);
+            return JSON.stringify({ userId: data.userId, email: data.email, message: data.message ?? "Registration successful" });
+        }
+        catch (err) {
+            return JSON.stringify({ error: sanitizeError(err instanceof Error ? err.message : String(err)) });
+        }
+    }
+    async function handleLogin(args) {
+        const email = args.email;
+        const password = args.password;
+        if (!email || typeof email !== "string") {
+            return JSON.stringify({ error: "email is required and must be a string" });
+        }
+        if (!/^[^@]+@[^@]+\.[^@]+$/.test(email)) {
+            return JSON.stringify({ error: "email must be a valid email address" });
+        }
+        if (/[\x00-\x1f\x7f]/.test(email)) {
+            return JSON.stringify({ error: "email contains invalid control characters" });
+        }
+        if (!password || typeof password !== "string") {
+            return JSON.stringify({ error: "password is required and must be a string" });
+        }
+        if (password.length < 8 || password.length > 128) {
+            return JSON.stringify({ error: "password must be between 8 and 128 characters" });
+        }
+        try {
+            const reqHeaders = {
+                "User-Agent": "dominusnode-gemini/1.0.0",
+                "Content-Type": "application/json",
+            };
+            if (agentSecret) {
+                reqHeaders["X-DominusNode-Agent"] = "mcp";
+                reqHeaders["X-DominusNode-Agent-Secret"] = agentSecret;
+            }
+            const response = await fetch(`${baseUrl}/api/auth/login`, {
+                method: "POST",
+                headers: reqHeaders,
+                body: JSON.stringify({ email, password }),
+                signal: AbortSignal.timeout(timeoutMs),
+                redirect: "error",
+            });
+            const responseText = await response.text();
+            if (responseText.length > MAX_RESPONSE_BYTES) {
+                return JSON.stringify({ error: "Response body exceeds size limit" });
+            }
+            if (!response.ok) {
+                let message;
+                try {
+                    const parsed = JSON.parse(responseText);
+                    message = parsed.error ?? parsed.message ?? responseText;
+                }
+                catch {
+                    message = responseText;
+                }
+                if (message.length > 500)
+                    message = message.slice(0, 500) + "... [truncated]";
+                return JSON.stringify({ error: sanitizeError(message) });
+            }
+            const data = safeJsonParse(responseText);
+            return JSON.stringify({ token: data.token, message: data.message ?? "Login successful" });
+        }
+        catch (err) {
+            return JSON.stringify({ error: sanitizeError(err instanceof Error ? err.message : String(err)) });
+        }
+    }
+    async function handleGetAccountInfo() {
+        const result = await api("GET", "/api/auth/me");
+        return JSON.stringify(result);
+    }
+    async function handleVerifyEmail(args) {
+        const token = args.token;
+        if (!token || typeof token !== "string") {
+            return JSON.stringify({ error: "token is required and must be a string" });
+        }
+        if (/[\x00-\x1f\x7f]/.test(token)) {
+            return JSON.stringify({ error: "token contains invalid control characters" });
+        }
+        try {
+            const reqHeaders = {
+                "User-Agent": "dominusnode-gemini/1.0.0",
+                "Content-Type": "application/json",
+            };
+            if (agentSecret) {
+                reqHeaders["X-DominusNode-Agent"] = "mcp";
+                reqHeaders["X-DominusNode-Agent-Secret"] = agentSecret;
+            }
+            const response = await fetch(`${baseUrl}/api/auth/verify-email`, {
+                method: "POST",
+                headers: reqHeaders,
+                body: JSON.stringify({ token }),
+                signal: AbortSignal.timeout(timeoutMs),
+                redirect: "error",
+            });
+            const responseText = await response.text();
+            if (responseText.length > MAX_RESPONSE_BYTES) {
+                return JSON.stringify({ error: "Response body exceeds size limit" });
+            }
+            if (!response.ok) {
+                let message;
+                try {
+                    const parsed = JSON.parse(responseText);
+                    message = parsed.error ?? parsed.message ?? responseText;
+                }
+                catch {
+                    message = responseText;
+                }
+                if (message.length > 500)
+                    message = message.slice(0, 500) + "... [truncated]";
+                return JSON.stringify({ error: sanitizeError(message) });
+            }
+            const data = safeJsonParse(responseText);
+            return JSON.stringify(data);
+        }
+        catch (err) {
+            return JSON.stringify({ error: sanitizeError(err instanceof Error ? err.message : String(err)) });
+        }
+    }
+    async function handleResendVerification() {
+        const result = await api("POST", "/api/auth/resend-verification");
+        return JSON.stringify(result);
+    }
+    async function handleUpdatePassword(args) {
+        const currentPassword = args.current_password;
+        const newPassword = args.new_password;
+        if (!currentPassword || typeof currentPassword !== "string") {
+            return JSON.stringify({ error: "current_password is required and must be a string" });
+        }
+        if (currentPassword.length < 8 || currentPassword.length > 128) {
+            return JSON.stringify({ error: "current_password must be between 8 and 128 characters" });
+        }
+        if (!newPassword || typeof newPassword !== "string") {
+            return JSON.stringify({ error: "new_password is required and must be a string" });
+        }
+        if (newPassword.length < 8 || newPassword.length > 128) {
+            return JSON.stringify({ error: "new_password must be between 8 and 128 characters" });
+        }
+        const result = await api("POST", "/api/auth/change-password", {
+            currentPassword,
+            newPassword,
+        });
+        return JSON.stringify(result);
+    }
+    // -----------------------------------------------------------------------
+    // API Keys
+    // -----------------------------------------------------------------------
+    async function handleListKeys() {
+        const result = await api("GET", "/api/keys");
+        return JSON.stringify(result);
+    }
+    async function handleCreateKey(args) {
+        const label = args.label;
+        if (!label || typeof label !== "string") {
+            return JSON.stringify({ error: "label is required and must be a string" });
+        }
+        if (label.length > 100) {
+            return JSON.stringify({ error: "label must be 100 characters or fewer" });
+        }
+        if (/[\x00-\x1f\x7f]/.test(label)) {
+            return JSON.stringify({ error: "label contains invalid control characters" });
+        }
+        const result = await api("POST", "/api/keys", { label });
+        return JSON.stringify(result);
+    }
+    async function handleRevokeKey(args) {
+        const keyId = args.key_id;
+        if (!keyId || typeof keyId !== "string") {
+            return JSON.stringify({ error: "key_id is required and must be a string" });
+        }
+        if (/[\x00-\x1f\x7f]/.test(keyId)) {
+            return JSON.stringify({ error: "key_id contains invalid control characters" });
+        }
+        const result = await api("DELETE", `/api/keys/${encodeURIComponent(keyId)}`);
+        return JSON.stringify(result);
+    }
+    // -----------------------------------------------------------------------
+    // Plans
+    // -----------------------------------------------------------------------
+    async function handleGetPlan() {
+        const result = await api("GET", "/api/plans/user/plan");
+        return JSON.stringify(result);
+    }
+    async function handleListPlans() {
+        const result = await api("GET", "/api/plans");
+        return JSON.stringify(result);
+    }
+    async function handleChangePlan(args) {
+        const planId = args.plan_id;
+        if (!planId || typeof planId !== "string") {
+            return JSON.stringify({ error: "plan_id is required and must be a string" });
+        }
+        if (/[\x00-\x1f\x7f]/.test(planId)) {
+            return JSON.stringify({ error: "plan_id contains invalid control characters" });
+        }
+        const result = await api("PUT", "/api/plans/user/plan", { planId });
+        return JSON.stringify(result);
+    }
+    // -----------------------------------------------------------------------
+    // Teams extended
+    // -----------------------------------------------------------------------
+    async function handleTeamDelete(args) {
+        const teamId = args.team_id;
+        if (!teamId || typeof teamId !== "string") {
+            return JSON.stringify({ error: "team_id is required and must be a string" });
+        }
+        if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(teamId)) {
+            return JSON.stringify({ error: "team_id must be a valid UUID" });
+        }
+        const result = await api("DELETE", `/api/teams/${encodeURIComponent(teamId)}`);
+        return JSON.stringify(result);
+    }
+    async function handleTeamRevokeKey(args) {
+        const teamId = args.team_id;
+        const keyId = args.key_id;
+        if (!teamId || typeof teamId !== "string") {
+            return JSON.stringify({ error: "team_id is required and must be a string" });
+        }
+        if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(teamId)) {
+            return JSON.stringify({ error: "team_id must be a valid UUID" });
+        }
+        if (!keyId || typeof keyId !== "string") {
+            return JSON.stringify({ error: "key_id is required and must be a string" });
+        }
+        if (/[\x00-\x1f\x7f]/.test(keyId)) {
+            return JSON.stringify({ error: "key_id contains invalid control characters" });
+        }
+        const result = await api("DELETE", `/api/teams/${encodeURIComponent(teamId)}/keys/${encodeURIComponent(keyId)}`);
+        return JSON.stringify(result);
+    }
+    async function handleTeamListKeys(args) {
+        const teamId = args.team_id;
+        if (!teamId || typeof teamId !== "string") {
+            return JSON.stringify({ error: "team_id is required and must be a string" });
+        }
+        if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(teamId)) {
+            return JSON.stringify({ error: "team_id must be a valid UUID" });
+        }
+        const result = await api("GET", `/api/teams/${encodeURIComponent(teamId)}/keys`);
+        return JSON.stringify(result);
+    }
+    async function handleTeamListMembers(args) {
+        const teamId = args.team_id;
+        if (!teamId || typeof teamId !== "string") {
+            return JSON.stringify({ error: "team_id is required and must be a string" });
+        }
+        if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(teamId)) {
+            return JSON.stringify({ error: "team_id must be a valid UUID" });
+        }
+        const result = await api("GET", `/api/teams/${encodeURIComponent(teamId)}/members`);
+        return JSON.stringify(result);
+    }
+    async function handleTeamAddMember(args) {
+        const teamId = args.team_id;
+        const userId = args.user_id;
+        if (!teamId || typeof teamId !== "string") {
+            return JSON.stringify({ error: "team_id is required and must be a string" });
+        }
+        if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(teamId)) {
+            return JSON.stringify({ error: "team_id must be a valid UUID" });
+        }
+        if (!userId || typeof userId !== "string") {
+            return JSON.stringify({ error: "user_id is required and must be a string" });
+        }
+        if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(userId)) {
+            return JSON.stringify({ error: "user_id must be a valid UUID" });
+        }
+        const result = await api("POST", `/api/teams/${encodeURIComponent(teamId)}/members`, { userId });
+        return JSON.stringify(result);
+    }
+    async function handleTeamRemoveMember(args) {
+        const teamId = args.team_id;
+        const userId = args.user_id;
+        if (!teamId || typeof teamId !== "string") {
+            return JSON.stringify({ error: "team_id is required and must be a string" });
+        }
+        if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(teamId)) {
+            return JSON.stringify({ error: "team_id must be a valid UUID" });
+        }
+        if (!userId || typeof userId !== "string") {
+            return JSON.stringify({ error: "user_id is required and must be a string" });
+        }
+        if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(userId)) {
+            return JSON.stringify({ error: "user_id must be a valid UUID" });
+        }
+        const result = await api("DELETE", `/api/teams/${encodeURIComponent(teamId)}/members/${encodeURIComponent(userId)}`);
+        return JSON.stringify(result);
+    }
+    async function handleTeamInviteMember(args) {
+        const teamId = args.team_id;
+        const email = args.email;
+        const role = args.role ?? "member";
+        if (!teamId || typeof teamId !== "string") {
+            return JSON.stringify({ error: "team_id is required and must be a string" });
+        }
+        if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(teamId)) {
+            return JSON.stringify({ error: "team_id must be a valid UUID" });
+        }
+        if (!email || typeof email !== "string") {
+            return JSON.stringify({ error: "email is required and must be a string" });
+        }
+        if (!/^[^@]+@[^@]+\.[^@]+$/.test(email)) {
+            return JSON.stringify({ error: "email must be a valid email address" });
+        }
+        if (/[\x00-\x1f\x7f]/.test(email)) {
+            return JSON.stringify({ error: "email contains invalid control characters" });
+        }
+        if (role !== "member" && role !== "admin") {
+            return JSON.stringify({ error: "role must be 'member' or 'admin'" });
+        }
+        const result = await api("POST", `/api/teams/${encodeURIComponent(teamId)}/invites`, { email, role });
+        return JSON.stringify(result);
+    }
+    async function handleTeamListInvites(args) {
+        const teamId = args.team_id;
+        if (!teamId || typeof teamId !== "string") {
+            return JSON.stringify({ error: "team_id is required and must be a string" });
+        }
+        if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(teamId)) {
+            return JSON.stringify({ error: "team_id must be a valid UUID" });
+        }
+        const result = await api("GET", `/api/teams/${encodeURIComponent(teamId)}/invites`);
+        return JSON.stringify(result);
+    }
+    async function handleTeamCancelInvite(args) {
+        const teamId = args.team_id;
+        const inviteId = args.invite_id;
+        if (!teamId || typeof teamId !== "string") {
+            return JSON.stringify({ error: "team_id is required and must be a string" });
+        }
+        if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(teamId)) {
+            return JSON.stringify({ error: "team_id must be a valid UUID" });
+        }
+        if (!inviteId || typeof inviteId !== "string") {
+            return JSON.stringify({ error: "invite_id is required and must be a string" });
+        }
+        if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(inviteId)) {
+            return JSON.stringify({ error: "invite_id must be a valid UUID" });
+        }
+        const result = await api("DELETE", `/api/teams/${encodeURIComponent(teamId)}/invites/${encodeURIComponent(inviteId)}`);
+        return JSON.stringify(result);
+    }
     // -----------------------------------------------------------------------
     // Dispatch table
     // -----------------------------------------------------------------------
@@ -961,6 +1471,7 @@ export function createDominusNodeFunctionHandler(config) {
         dominusnode_check_balance: handleCheckBalance,
         dominusnode_check_usage: handleCheckUsage,
         dominusnode_get_proxy_config: handleGetProxyConfig,
+        dominusnode_get_proxy_status: handleGetProxyStatus,
         dominusnode_list_sessions: handleListSessions,
         dominusnode_create_agentic_wallet: handleCreateAgenticWallet,
         dominusnode_fund_agentic_wallet: handleFundAgenticWallet,
@@ -970,6 +1481,23 @@ export function createDominusNodeFunctionHandler(config) {
         dominusnode_freeze_agentic_wallet: handleFreezeAgenticWallet,
         dominusnode_unfreeze_agentic_wallet: handleUnfreezeAgenticWallet,
         dominusnode_delete_agentic_wallet: handleDeleteAgenticWallet,
+        dominusnode_get_transactions: handleGetTransactions,
+        dominusnode_get_forecast: handleGetForecast,
+        dominusnode_check_payment: handleCheckPayment,
+        dominusnode_get_daily_usage: handleGetDailyUsage,
+        dominusnode_get_top_hosts: handleGetTopHosts,
+        dominusnode_register: handleRegister,
+        dominusnode_login: handleLogin,
+        dominusnode_get_account_info: handleGetAccountInfo,
+        dominusnode_verify_email: handleVerifyEmail,
+        dominusnode_resend_verification: handleResendVerification,
+        dominusnode_update_password: handleUpdatePassword,
+        dominusnode_list_keys: handleListKeys,
+        dominusnode_create_key: handleCreateKey,
+        dominusnode_revoke_key: handleRevokeKey,
+        dominusnode_get_plan: handleGetPlan,
+        dominusnode_list_plans: handleListPlans,
+        dominusnode_change_plan: handleChangePlan,
         dominusnode_create_team: handleCreateTeam,
         dominusnode_list_teams: handleListTeams,
         dominusnode_team_details: handleTeamDetails,
@@ -978,7 +1506,18 @@ export function createDominusNodeFunctionHandler(config) {
         dominusnode_team_usage: handleTeamUsage,
         dominusnode_update_team: handleUpdateTeam,
         dominusnode_update_team_member_role: handleUpdateTeamMemberRole,
+        dominusnode_team_delete: handleTeamDelete,
+        dominusnode_team_revoke_key: handleTeamRevokeKey,
+        dominusnode_team_list_keys: handleTeamListKeys,
+        dominusnode_team_list_members: handleTeamListMembers,
+        dominusnode_team_add_member: handleTeamAddMember,
+        dominusnode_team_remove_member: handleTeamRemoveMember,
+        dominusnode_team_invite_member: handleTeamInviteMember,
+        dominusnode_team_list_invites: handleTeamListInvites,
+        dominusnode_team_cancel_invite: handleTeamCancelInvite,
         dominusnode_topup_paypal: handleTopupPaypal,
+        dominusnode_topup_stripe: handleTopupStripe,
+        dominusnode_topup_crypto: handleTopupCrypto,
         dominusnode_x402_info: handleX402Info,
         dominusnode_update_wallet_policy: handleUpdateWalletPolicy,
     };

package/functions.json

@@ -362,16 +362,48 @@
   },
   {
     "name": "dominusnode_topup_paypal",
-    "description": "Create a PayPal wallet top-up session. Initiates a PayPal payment for the specified amount to add funds to your Dominus Node wallet. Returns a PayPal approval URL to complete the payment.",
+    "description": "Create a PayPal wallet top-up session. Initiates a PayPal payment for the specified amount to add funds to your Dominus Node wallet. Returns a PayPal approval URL to complete the payment. Minimum $5 (500 cents), maximum $1,000 (100000 cents).",
     "parameters": {
       "type": "OBJECT",
       "properties": {
         "amount_cents": {
           "type": "INTEGER",
-          "description": "Amount to top up in cents. Must be a positive integer, no greater than 2,147,483,647. Example: 1000 = $10.00."
+          "description": "Amount to top up in cents. Must be an integer between 500 ($5) and 100000 ($1,000). Example: 1000 = $10.00."
         }
       },
       "required": ["amount_cents"]
     }
+  },
+  {
+    "name": "dominusnode_topup_stripe",
+    "description": "Create a Stripe wallet top-up checkout session. Initiates a Stripe payment for the specified amount to add funds to your Dominus Node wallet. Returns a Stripe checkout URL to complete the payment. Minimum $5 (500 cents), maximum $1,000 (100000 cents).",
+    "parameters": {
+      "type": "OBJECT",
+      "properties": {
+        "amount_cents": {
+          "type": "INTEGER",
+          "description": "Amount to top up in cents. Must be an integer between 500 ($5) and 100000 ($1,000). Example: 1000 = $10.00."
+        }
+      },
+      "required": ["amount_cents"]
+    }
+  },
+  {
+    "name": "dominusnode_topup_crypto",
+    "description": "Create a cryptocurrency wallet top-up invoice. Initiates a crypto payment for the specified amount to add funds to your Dominus Node wallet. Returns payment address and amount. Minimum $5, maximum $1,000. Supported currencies: BTC, ETH, LTC, XMR, ZEC, USDC, SOL, USDT, DAI, BNB, LINK.",
+    "parameters": {
+      "type": "OBJECT",
+      "properties": {
+        "amount_usd": {
+          "type": "NUMBER",
+          "description": "Amount to top up in USD. Must be between 5 and 1000."
+        },
+        "currency": {
+          "type": "STRING",
+          "description": "Cryptocurrency to pay with. One of: btc, eth, ltc, xmr, zec, usdc, sol, usdt, dai, bnb, link."
+        }
+      },
+      "required": ["amount_usd", "currency"]
+    }
   }
 ]

package/package.json

@@ -1,18 +1,29 @@
 {
   "name": "@dominusnode/gemini-functions",
-  "version": "1.0.1",
+  "version": "1.2.0",
   "description": "Dominus Node function declarations and handlers for Google Gemini / Vertex AI",
   "main": "dist/handler.js",
   "types": "dist/handler.d.ts",
   "type": "module",
-  "files": ["dist/", "functions.json", "README.md", "LICENSE"],
+  "files": [
+    "dist/",
+    "functions.json",
+    "README.md",
+    "LICENSE"
+  ],
   "scripts": {
     "build": "tsc",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:py": "python -m pytest test_handler.py -v"
   },
-  "keywords": ["dominusnode", "gemini", "vertex-ai", "proxy", "function-calling"],
+  "keywords": [
+    "dominusnode",
+    "gemini",
+    "vertex-ai",
+    "proxy",
+    "function-calling"
+  ],
   "license": "MIT",
   "repository": {
     "type": "git",