@dominusnode/gemini-functions 1.2.0 → 1.5.2

package/README.md

@@ -6,40 +6,40 @@ Gemini-format function declarations and handler implementations for the Dominus
 
 This directory contains:
 
-| File | Description |
-|------|-------------|
-| `functions.json` | Array of 22 Gemini `FunctionDeclaration` objects |
-| `handler.ts` | TypeScript handler that dispatches function calls to the Dominus Node API |
-| `handler.py` | Python handler that dispatches function calls to the Dominus Node API |
+| File             | Description                                                               |
+| ---------------- | ------------------------------------------------------------------------- |
+| `functions.json` | Array of 22 Gemini `FunctionDeclaration` objects                          |
+| `handler.ts`     | TypeScript handler that dispatches function calls to the Dominus Node API |
+| `handler.py`     | Python handler that dispatches function calls to the Dominus Node API     |
 
 The function declarations follow the [Gemini function calling specification](https://ai.google.dev/docs/function_calling), using uppercase types (`STRING`, `INTEGER`, `OBJECT`, `BOOLEAN`, `ARRAY`) and embedding constraints in description text rather than using JSON Schema keywords like `minimum`, `maximum`, `enum`, or `default`.
 
 ## Available Functions (22)
 
-| Function | Description | Auth Required |
-|----------|-------------|---------------|
-| `dominusnode_proxied_fetch` | Make an HTTP request through Dominus Node's rotating proxy network | Yes |
-| `dominusnode_check_balance` | Check wallet balance (cents, USD, currency) | Yes |
-| `dominusnode_check_usage` | Check usage stats for a time period (day/week/month) | Yes |
-| `dominusnode_get_proxy_config` | Get proxy endpoints, supported countries, geo-targeting info | Yes |
-| `dominusnode_list_sessions` | List currently active proxy sessions | Yes |
-| `dominusnode_create_agentic_wallet` | Create a sub-wallet for an AI agent with spending limits | Yes |
-| `dominusnode_fund_agentic_wallet` | Transfer funds from main wallet to an agentic wallet | Yes |
-| `dominusnode_agentic_wallet_balance` | Check an agentic wallet's balance and status | Yes |
-| `dominusnode_list_agentic_wallets` | List all agentic wallets | Yes |
-| `dominusnode_agentic_transactions` | Get agentic wallet transaction history | Yes |
-| `dominusnode_freeze_agentic_wallet` | Freeze an agentic wallet | Yes |
-| `dominusnode_unfreeze_agentic_wallet` | Unfreeze an agentic wallet | Yes |
-| `dominusnode_delete_agentic_wallet` | Delete an agentic wallet (refunds balance) | Yes |
-| `dominusnode_create_team` | Create a team for shared proxy billing | Yes |
-| `dominusnode_list_teams` | List teams you belong to | Yes |
-| `dominusnode_team_details` | Get team details | Yes |
-| `dominusnode_team_fund` | Fund a team wallet | Yes |
-| `dominusnode_team_create_key` | Create a shared team API key | Yes |
-| `dominusnode_team_usage` | Get team wallet transaction history | Yes |
-| `dominusnode_update_team` | Update team settings | Yes |
-| `dominusnode_update_team_member_role` | Update a team member's role | Yes |
-| `dominusnode_topup_paypal` | Create a PayPal wallet top-up session | Yes |
+| Function                              | Description                                                        | Auth Required |
+| ------------------------------------- | ------------------------------------------------------------------ | ------------- |
+| `dominusnode_proxied_fetch`           | Make an HTTP request through Dominus Node's rotating proxy network | Yes           |
+| `dominusnode_check_balance`           | Check wallet balance (cents, USD, currency)                        | Yes           |
+| `dominusnode_check_usage`             | Check usage stats for a time period (day/week/month)               | Yes           |
+| `dominusnode_get_proxy_config`        | Get proxy endpoints, supported countries, geo-targeting info       | Yes           |
+| `dominusnode_list_sessions`           | List currently active proxy sessions                               | Yes           |
+| `dominusnode_create_agentic_wallet`   | Create a sub-wallet for an AI agent with spending limits           | Yes           |
+| `dominusnode_fund_agentic_wallet`     | Transfer funds from main wallet to an agentic wallet               | Yes           |
+| `dominusnode_agentic_wallet_balance`  | Check an agentic wallet's balance and status                       | Yes           |
+| `dominusnode_list_agentic_wallets`    | List all agentic wallets                                           | Yes           |
+| `dominusnode_agentic_transactions`    | Get agentic wallet transaction history                             | Yes           |
+| `dominusnode_freeze_agentic_wallet`   | Freeze an agentic wallet                                           | Yes           |
+| `dominusnode_unfreeze_agentic_wallet` | Unfreeze an agentic wallet                                         | Yes           |
+| `dominusnode_delete_agentic_wallet`   | Delete an agentic wallet (refunds balance)                         | Yes           |
+| `dominusnode_create_team`             | Create a team for shared proxy billing                             | Yes           |
+| `dominusnode_list_teams`              | List teams you belong to                                           | Yes           |
+| `dominusnode_team_details`            | Get team details                                                   | Yes           |
+| `dominusnode_team_fund`               | Fund a team wallet                                                 | Yes           |
+| `dominusnode_team_create_key`         | Create a shared team API key                                       | Yes           |
+| `dominusnode_team_usage`              | Get team wallet transaction history                                | Yes           |
+| `dominusnode_update_team`             | Update team settings                                               | Yes           |
+| `dominusnode_update_team_member_role` | Update a team member's role                                        | Yes           |
+| `dominusnode_topup_paypal`            | Create a PayPal wallet top-up session                              | Yes           |
 
 ## Usage with Google Gemini (Python)
 
@@ -154,7 +154,7 @@ console.log(JSON.parse(fetchResult));
 
 // Example: PayPal top-up
 const topup = await handler("dominusnode_topup_paypal", {
-  amount_cents: 5000,  // $50.00
+  amount_cents: 5000, // $50.00
 });
 console.log(JSON.parse(topup));
 ```
@@ -163,14 +163,14 @@ console.log(JSON.parse(topup));
 
 Gemini function declarations differ from OpenAI's JSON Schema format:
 
-| Feature | OpenAI/JSON Schema | Gemini |
-|---------|-------------------|--------|
-| Type names | `"string"`, `"integer"` | `"STRING"`, `"INTEGER"` |
-| `default` | Supported | Not supported -- moved to description |
-| `minimum`/`maximum` | Supported | Not supported -- moved to description |
-| `enum` | Supported | Not supported -- listed in description |
-| `minLength`/`maxLength` | Supported | Not supported -- moved to description |
-| `additionalProperties` | Supported | Not supported -- omitted |
+| Feature                 | OpenAI/JSON Schema      | Gemini                                 |
+| ----------------------- | ----------------------- | -------------------------------------- |
+| Type names              | `"string"`, `"integer"` | `"STRING"`, `"INTEGER"`                |
+| `default`               | Supported               | Not supported -- moved to description  |
+| `minimum`/`maximum`     | Supported               | Not supported -- moved to description  |
+| `enum`                  | Supported               | Not supported -- listed in description |
+| `minLength`/`maxLength` | Supported               | Not supported -- moved to description  |
+| `additionalProperties`  | Supported               | Not supported -- omitted               |
 
 All constraints are expressed in the `description` field text for Gemini compatibility.
 
@@ -207,18 +207,20 @@ API keys (`dn_live_*`, `dn_test_*`) are scrubbed from all error messages returne
 
 ## Proxy Pricing
 
-| Proxy Type | Price | Best For |
-|------------|-------|----------|
+| Proxy Type        | Price    | Best For                               |
+| ----------------- | -------- | -------------------------------------- |
 | Datacenter (`dc`) | $3.00/GB | General scraping, speed-critical tasks |
-| Residential | $5.00/GB | Anti-detection, geo-restricted content |
+| Residential       | $5.00/GB | Anti-detection, geo-restricted content |
 
 ## Dependencies
 
 ### TypeScript Handler
+
 - Node.js 18+ (uses native `fetch` and `AbortSignal.timeout`)
 - No external dependencies
 
 ### Python Handler
+
 - Python 3.8+
 - `httpx` (`pip install httpx`)
 

package/dist/handler.d.ts

@@ -1,7 +1,7 @@
 /**
  * Dominus Node Gemini / Vertex AI function calling handler (TypeScript).
  *
- * 53 tools for AI agents to interact with the Dominus Node REST API.
+ * 57 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

package/dist/handler.js

@@ -1,7 +1,7 @@
 /**
  * Dominus Node Gemini / Vertex AI function calling handler (TypeScript).
  *
- * 53 tools for AI agents to interact with the Dominus Node REST API.
+ * 57 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
@@ -24,10 +24,63 @@
  *
  * @module
  */
+import * as crypto from "node:crypto";
 import dns from "dns/promises";
 import * as http from "node:http";
 import * as tls from "node:tls";
 // ---------------------------------------------------------------------------
+// SHA-256 Proof-of-Work solver
+// ---------------------------------------------------------------------------
+function countLeadingZeroBits(buf) {
+    let count = 0;
+    for (const byte of buf) {
+        if (byte === 0) {
+            count += 8;
+            continue;
+        }
+        let mask = 0x80;
+        while (mask && !(byte & mask)) {
+            count++;
+            mask >>= 1;
+        }
+        break;
+    }
+    return count;
+}
+async function solvePoW(baseUrl) {
+    try {
+        const resp = await fetch(`${baseUrl}/api/auth/pow/challenge`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            redirect: "error",
+        });
+        if (!resp.ok)
+            return null;
+        const text = await resp.text();
+        if (text.length > 10_485_760)
+            return null;
+        const challenge = JSON.parse(text);
+        const prefix = challenge.prefix ?? "";
+        const difficulty = challenge.difficulty ?? 20;
+        const challengeId = challenge.challengeId ?? "";
+        if (!prefix || !challengeId)
+            return null;
+        for (let nonce = 0; nonce < 100_000_000; nonce++) {
+            const hash = crypto
+                .createHash("sha256")
+                .update(prefix + nonce.toString())
+                .digest();
+            if (countLeadingZeroBits(hash) >= difficulty) {
+                return { challengeId, nonce: nonce.toString() };
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
 // SSRF Prevention -- URL validation
 // ---------------------------------------------------------------------------
 const BLOCKED_HOSTNAMES = new Set([
@@ -296,7 +349,7 @@ async function checkDnsRebinding(hostname) {
 // ---------------------------------------------------------------------------
 // Credential sanitization
 // ---------------------------------------------------------------------------
-const CREDENTIAL_RE = /dn_(live|test)_[a-zA-Z0-9]+/g;
+const CREDENTIAL_RE = /dn_(live|test|proxy)_[a-zA-Z0-9]+/g;
 function sanitizeError(message) {
     return message.replace(CREDENTIAL_RE, "***");
 }
@@ -509,8 +562,13 @@ export function createDominusNodeFunctionHandler(config) {
         try {
             // Strip security-sensitive headers from user-provided headers
             const BLOCKED_HEADERS = new Set([
-                "host", "connection", "content-length", "transfer-encoding",
-                "proxy-authorization", "authorization", "user-agent",
+                "host",
+                "connection",
+                "content-length",
+                "transfer-encoding",
+                "proxy-authorization",
+                "authorization",
+                "user-agent",
             ]);
             const safeHeaders = {};
             if (headers) {
@@ -546,7 +604,10 @@ export function createDominusNodeFunctionHandler(config) {
                         port: proxyPort,
                         method: "CONNECT",
                         path: `${parsed.hostname.includes(":") ? `[${parsed.hostname}]` : parsed.hostname}:${parsed.port || 443}`,
-                        headers: { "Proxy-Authorization": proxyAuth, Host: `${parsed.hostname.includes(":") ? `[${parsed.hostname}]` : parsed.hostname}:${parsed.port || 443}` },
+                        headers: {
+                            "Proxy-Authorization": proxyAuth,
+                            Host: `${parsed.hostname.includes(":") ? `[${parsed.hostname}]` : parsed.hostname}:${parsed.port || 443}`,
+                        },
                     });
                     connectReq.on("connect", (_res, tunnelSocket) => {
                         if (_res.statusCode !== 200) {
@@ -590,7 +651,9 @@ export function createDominusNodeFunctionHandler(config) {
                                     return;
                                 }
                                 const headerSection = raw.substring(0, headerEnd);
-                                const body = raw.substring(headerEnd + 4).substring(0, MAX_BODY_BYTES);
+                                const body = raw
+                                    .substring(headerEnd + 4)
+                                    .substring(0, MAX_BODY_BYTES);
                                 const statusLine = headerSection.split("\r\n")[0];
                                 const statusMatch = statusLine.match(/^HTTP\/\d\.\d\s+(\d+)/);
                                 const status = statusMatch ? parseInt(statusMatch[1], 10) : 0;
@@ -598,18 +661,29 @@ export function createDominusNodeFunctionHandler(config) {
                                 for (const line of headerSection.split("\r\n").slice(1)) {
                                     const ci = line.indexOf(":");
                                     if (ci > 0)
-                                        headers[line.substring(0, ci).trim().toLowerCase()] = line.substring(ci + 1).trim();
+                                        headers[line.substring(0, ci).trim().toLowerCase()] = line
+                                            .substring(ci + 1)
+                                            .trim();
                                 }
                                 stripDangerousKeys(headers);
                                 resolve({ status, headers, body });
                             };
                             tlsSocket.on("end", finalize);
                             tlsSocket.on("close", finalize);
-                            tlsSocket.on("error", (err) => { clearTimeout(timeout); reject(err); });
+                            tlsSocket.on("error", (err) => {
+                                clearTimeout(timeout);
+                                reject(err);
+                            });
+                        });
+                        tlsSocket.on("error", (err) => {
+                            clearTimeout(timeout);
+                            reject(err);
                         });
-                        tlsSocket.on("error", (err) => { clearTimeout(timeout); reject(err); });
                     });
-                    connectReq.on("error", (err) => { clearTimeout(timeout); reject(err); });
+                    connectReq.on("error", (err) => {
+                        clearTimeout(timeout);
+                        reject(err);
+                    });
                     connectReq.end();
                 }
                 else {
@@ -619,19 +693,28 @@ export function createDominusNodeFunctionHandler(config) {
                         port: proxyPort,
                         method,
                         path: url,
-                        headers: { ...safeHeaders, "Proxy-Authorization": proxyAuth, Host: parsed.host },
+                        headers: {
+                            ...safeHeaders,
+                            "Proxy-Authorization": proxyAuth,
+                            Host: parsed.host,
+                        },
                     }, (res) => {
                         const chunks = [];
                         let byteCount = 0;
                         let httpFinalized = false;
-                        res.on("data", (chunk) => { byteCount += chunk.length; if (byteCount <= MAX_BODY_BYTES)
-                            chunks.push(chunk); });
+                        res.on("data", (chunk) => {
+                            byteCount += chunk.length;
+                            if (byteCount <= MAX_BODY_BYTES)
+                                chunks.push(chunk);
+                        });
                         const finalize = () => {
                             if (httpFinalized)
                                 return;
                             httpFinalized = true;
                             clearTimeout(timeout);
-                            const body = Buffer.concat(chunks).toString("utf-8").substring(0, MAX_BODY_BYTES);
+                            const body = Buffer.concat(chunks)
+                                .toString("utf-8")
+                                .substring(0, MAX_BODY_BYTES);
                             const headers = {};
                             for (const [k, v] of Object.entries(res.headers)) {
                                 if (v)
@@ -642,9 +725,15 @@ export function createDominusNodeFunctionHandler(config) {
                         };
                         res.on("end", finalize);
                         res.on("close", finalize);
-                        res.on("error", (err) => { clearTimeout(timeout); reject(err); });
+                        res.on("error", (err) => {
+                            clearTimeout(timeout);
+                            reject(err);
+                        });
+                    });
+                    req.on("error", (err) => {
+                        clearTimeout(timeout);
+                        reject(err);
                     });
-                    req.on("error", (err) => { clearTimeout(timeout); reject(err); });
                     req.end();
                 }
             });
@@ -684,13 +773,17 @@ export function createDominusNodeFunctionHandler(config) {
         const label = args.label;
         const spendingLimitCents = args.spending_limit_cents;
         if (!label || typeof label !== "string") {
-            return JSON.stringify({ error: "label is required and must be a 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" });
+            return JSON.stringify({
+                error: "label contains invalid control characters",
+            });
         }
         if (!Number.isInteger(spendingLimitCents) ||
             spendingLimitCents <= 0 ||
@@ -704,9 +797,12 @@ export function createDominusNodeFunctionHandler(config) {
             spendingLimitCents,
         };
         // Validate optional daily_limit_cents
-        if (args.daily_limit_cents !== undefined && args.daily_limit_cents !== null) {
+        if (args.daily_limit_cents !== undefined &&
+            args.daily_limit_cents !== null) {
             const dailyLimit = Number(args.daily_limit_cents);
-            if (!Number.isInteger(dailyLimit) || dailyLimit < 1 || dailyLimit > 1_000_000) {
+            if (!Number.isInteger(dailyLimit) ||
+                dailyLimit < 1 ||
+                dailyLimit > 1_000_000) {
                 return JSON.stringify({
                     error: "daily_limit_cents must be a positive integer between 1 and 1,000,000",
                 });
@@ -716,22 +812,32 @@ export function createDominusNodeFunctionHandler(config) {
         // Validate optional allowed_domains
         if (args.allowed_domains !== undefined && args.allowed_domains !== null) {
             if (!Array.isArray(args.allowed_domains)) {
-                return JSON.stringify({ error: "allowed_domains must be an array of domain strings" });
+                return JSON.stringify({
+                    error: "allowed_domains must be an array of domain strings",
+                });
             }
             if (args.allowed_domains.length > 100) {
-                return JSON.stringify({ error: "allowed_domains must have at most 100 entries" });
+                return JSON.stringify({
+                    error: "allowed_domains must have at most 100 entries",
+                });
             }
             const domainRe = /^(?:[a-zA-Z0-9](?:[a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
             for (let i = 0; i < args.allowed_domains.length; i++) {
                 const d = args.allowed_domains[i];
                 if (typeof d !== "string") {
-                    return JSON.stringify({ error: `allowed_domains[${i}] must be a string` });
+                    return JSON.stringify({
+                        error: `allowed_domains[${i}] must be a string`,
+                    });
                 }
                 if (d.length > 253) {
-                    return JSON.stringify({ error: `allowed_domains[${i}] exceeds 253 characters` });
+                    return JSON.stringify({
+                        error: `allowed_domains[${i}] exceeds 253 characters`,
+                    });
                 }
                 if (!domainRe.test(d)) {
-                    return JSON.stringify({ error: `allowed_domains[${i}] is not a valid domain: ${d}` });
+                    return JSON.stringify({
+                        error: `allowed_domains[${i}] is not a valid domain: ${d}`,
+                    });
                 }
             }
             body.allowedDomains = args.allowed_domains;
@@ -743,7 +849,9 @@ export function createDominusNodeFunctionHandler(config) {
         const walletId = args.wallet_id;
         const amountCents = args.amount_cents;
         if (!walletId || typeof walletId !== "string") {
-            return JSON.stringify({ error: "wallet_id is required and must be a string" });
+            return JSON.stringify({
+                error: "wallet_id is required and must be a string",
+            });
         }
         if (!Number.isInteger(amountCents) ||
             amountCents <= 0 ||
@@ -758,7 +866,9 @@ export function createDominusNodeFunctionHandler(config) {
     async function handleAgenticWalletBalance(args) {
         const walletId = args.wallet_id;
         if (!walletId || typeof walletId !== "string") {
-            return JSON.stringify({ error: "wallet_id is required and must be a string" });
+            return JSON.stringify({
+                error: "wallet_id is required and must be a string",
+            });
         }
         const result = await api("GET", `/api/agent-wallet/${encodeURIComponent(walletId)}`);
         return JSON.stringify(result);
@@ -770,13 +880,17 @@ export function createDominusNodeFunctionHandler(config) {
     async function handleAgenticTransactions(args) {
         const walletId = args.wallet_id;
         if (!walletId || typeof walletId !== "string") {
-            return JSON.stringify({ error: "wallet_id is required and must be a string" });
+            return JSON.stringify({
+                error: "wallet_id is required and must be a string",
+            });
         }
         const limit = args.limit;
         const params = new URLSearchParams();
         if (limit !== undefined) {
             if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
-                return JSON.stringify({ error: "limit must be an integer between 1 and 100" });
+                return JSON.stringify({
+                    error: "limit must be an integer between 1 and 100",
+                });
             }
             params.set("limit", String(limit));
         }
@@ -787,7 +901,9 @@ export function createDominusNodeFunctionHandler(config) {
     async function handleFreezeAgenticWallet(args) {
         const walletId = args.wallet_id;
         if (!walletId || typeof walletId !== "string") {
-            return JSON.stringify({ error: "wallet_id is required and must be a string" });
+            return JSON.stringify({
+                error: "wallet_id is required and must be a string",
+            });
         }
         const result = await api("POST", `/api/agent-wallet/${encodeURIComponent(walletId)}/freeze`);
         return JSON.stringify(result);
@@ -795,7 +911,9 @@ export function createDominusNodeFunctionHandler(config) {
     async function handleUnfreezeAgenticWallet(args) {
         const walletId = args.wallet_id;
         if (!walletId || typeof walletId !== "string") {
-            return JSON.stringify({ error: "wallet_id is required and must be a string" });
+            return JSON.stringify({
+                error: "wallet_id is required and must be a string",
+            });
         }
         const result = await api("POST", `/api/agent-wallet/${encodeURIComponent(walletId)}/unfreeze`);
         return JSON.stringify(result);
@@ -803,7 +921,9 @@ export function createDominusNodeFunctionHandler(config) {
     async function handleDeleteAgenticWallet(args) {
         const walletId = args.wallet_id;
         if (!walletId || typeof walletId !== "string") {
-            return JSON.stringify({ error: "wallet_id is required and must be a string" });
+            return JSON.stringify({
+                error: "wallet_id is required and must be a string",
+            });
         }
         const result = await api("DELETE", `/api/agent-wallet/${encodeURIComponent(walletId)}`);
         return JSON.stringify(result);
@@ -817,13 +937,17 @@ export function createDominusNodeFunctionHandler(config) {
             return JSON.stringify({ error: "name must be 100 characters or fewer" });
         }
         if (/[\x00-\x1f\x7f]/.test(name)) {
-            return JSON.stringify({ error: "name contains invalid control characters" });
+            return JSON.stringify({
+                error: "name contains invalid control characters",
+            });
         }
         const body = { name };
         if (args.max_members !== undefined) {
             const maxMembers = Number(args.max_members);
             if (!Number.isInteger(maxMembers) || maxMembers < 1 || maxMembers > 100) {
-                return JSON.stringify({ error: "max_members must be an integer between 1 and 100" });
+                return JSON.stringify({
+                    error: "max_members must be an integer between 1 and 100",
+                });
             }
             body.maxMembers = maxMembers;
         }
@@ -837,7 +961,9 @@ export function createDominusNodeFunctionHandler(config) {
     async function handleTeamDetails(args) {
         const teamId = args.team_id;
         if (!teamId || typeof teamId !== "string") {
-            return JSON.stringify({ error: "team_id is required and must be a string" });
+            return JSON.stringify({
+                error: "team_id is required and must be a string",
+            });
         }
         const result = await api("GET", `/api/teams/${encodeURIComponent(teamId)}`);
         return JSON.stringify(result);
@@ -846,7 +972,9 @@ export function createDominusNodeFunctionHandler(config) {
         const teamId = args.team_id;
         const amountCents = args.amount_cents;
         if (!teamId || typeof teamId !== "string") {
-            return JSON.stringify({ error: "team_id is required and must be a string" });
+            return JSON.stringify({
+                error: "team_id is required and must be a string",
+            });
         }
         if (!Number.isInteger(amountCents) ||
             amountCents < 100 ||
@@ -862,16 +990,22 @@ export function createDominusNodeFunctionHandler(config) {
         const teamId = args.team_id;
         const label = args.label;
         if (!teamId || typeof teamId !== "string") {
-            return JSON.stringify({ error: "team_id is required and must be a string" });
+            return JSON.stringify({
+                error: "team_id is required and must be a string",
+            });
         }
         if (!label || typeof label !== "string") {
-            return JSON.stringify({ error: "label is required and must be a 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" });
+            return JSON.stringify({
+                error: "label contains invalid control characters",
+            });
         }
         const result = await api("POST", `/api/teams/${encodeURIComponent(teamId)}/keys`, { label });
         return JSON.stringify(result);
@@ -879,13 +1013,17 @@ export function createDominusNodeFunctionHandler(config) {
     async function handleTeamUsage(args) {
         const teamId = args.team_id;
         if (!teamId || typeof teamId !== "string") {
-            return JSON.stringify({ error: "team_id is required and must be a string" });
+            return JSON.stringify({
+                error: "team_id is required and must be a string",
+            });
         }
         const limit = args.limit;
         const params = new URLSearchParams();
         if (limit !== undefined) {
             if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
-                return JSON.stringify({ error: "limit must be an integer between 1 and 100" });
+                return JSON.stringify({
+                    error: "limit must be an integer between 1 and 100",
+                });
             }
             params.set("limit", String(limit));
         }
@@ -896,7 +1034,9 @@ export function createDominusNodeFunctionHandler(config) {
     async function handleUpdateTeam(args) {
         const teamId = args.team_id;
         if (!teamId || typeof teamId !== "string") {
-            return JSON.stringify({ error: "team_id is required and must be a 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" });
@@ -908,22 +1048,30 @@ export function createDominusNodeFunctionHandler(config) {
                 return JSON.stringify({ error: "name must be a non-empty string" });
             }
             if (name.length > 100) {
-                return JSON.stringify({ error: "name must be 100 characters or fewer" });
+                return JSON.stringify({
+                    error: "name must be 100 characters or fewer",
+                });
             }
             if (/[\x00-\x1f\x7f]/.test(name)) {
-                return JSON.stringify({ error: "name contains invalid control characters" });
+                return JSON.stringify({
+                    error: "name contains invalid control characters",
+                });
             }
             body.name = name;
         }
         if (args.max_members !== undefined) {
             const maxMembers = Number(args.max_members);
             if (!Number.isInteger(maxMembers) || maxMembers < 1 || maxMembers > 100) {
-                return JSON.stringify({ error: "max_members must be an integer between 1 and 100" });
+                return JSON.stringify({
+                    error: "max_members must be an integer between 1 and 100",
+                });
             }
             body.maxMembers = maxMembers;
         }
         if (Object.keys(body).length === 0) {
-            return JSON.stringify({ error: "At least one of name or max_members must be provided" });
+            return JSON.stringify({
+                error: "At least one of name or max_members must be provided",
+            });
         }
         const result = await api("PATCH", `/api/teams/${encodeURIComponent(teamId)}`, body);
         return JSON.stringify(result);
@@ -933,13 +1081,17 @@ export function createDominusNodeFunctionHandler(config) {
         const userId = args.user_id;
         const role = args.role;
         if (!teamId || typeof teamId !== "string") {
-            return JSON.stringify({ error: "team_id is required and must be a 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" });
+            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" });
@@ -962,7 +1114,9 @@ export function createDominusNodeFunctionHandler(config) {
                 error: "amount_cents must be an integer between 500 ($5) and 100,000 ($1,000)",
             });
         }
-        const result = await api("POST", "/api/wallet/topup/paypal", { amountCents });
+        const result = await api("POST", "/api/wallet/topup/paypal", {
+            amountCents,
+        });
         return JSON.stringify(result);
     }
     async function handleTopupStripe(args) {
@@ -974,11 +1128,23 @@ export function createDominusNodeFunctionHandler(config) {
                 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 });
+        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",
+        "btc",
+        "eth",
+        "ltc",
+        "xmr",
+        "zec",
+        "usdc",
+        "sol",
+        "usdt",
+        "dai",
+        "bnb",
+        "link",
     ]);
     async function handleTopupCrypto(args) {
         const amountUsd = args.amount_usd;
@@ -1017,7 +1183,9 @@ export function createDominusNodeFunctionHandler(config) {
         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" });
+                return JSON.stringify({
+                    error: "limit must be an integer between 1 and 100",
+                });
             }
             params.set("limit", String(limit));
         }
@@ -1032,10 +1200,14 @@ export function createDominusNodeFunctionHandler(config) {
     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" });
+            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" });
+            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);
@@ -1048,7 +1220,9 @@ export function createDominusNodeFunctionHandler(config) {
         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" });
+                return JSON.stringify({
+                    error: "days must be an integer between 1 and 90",
+                });
             }
             params.set("days", String(days));
         }
@@ -1061,7 +1235,9 @@ export function createDominusNodeFunctionHandler(config) {
         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" });
+                return JSON.stringify({
+                    error: "limit must be an integer between 1 and 50",
+                });
             }
             params.set("limit", String(limit));
         }
@@ -1076,19 +1252,27 @@ export function createDominusNodeFunctionHandler(config) {
         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" });
+            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" });
+            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" });
+            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" });
+            return JSON.stringify({
+                error: "password must be between 8 and 128 characters",
+            });
         }
         try {
             const reqHeaders = {
@@ -1099,10 +1283,15 @@ export function createDominusNodeFunctionHandler(config) {
                 reqHeaders["X-DominusNode-Agent"] = "mcp";
                 reqHeaders["X-DominusNode-Agent-Secret"] = agentSecret;
             }
+            // Solve PoW for CAPTCHA-free registration
+            const pow = await solvePoW(baseUrl);
+            const regBody = { email, password };
+            if (pow)
+                regBody.pow = pow;
             const response = await fetch(`${baseUrl}/api/auth/register`, {
                 method: "POST",
                 headers: reqHeaders,
-                body: JSON.stringify({ email, password }),
+                body: JSON.stringify(regBody),
                 signal: AbortSignal.timeout(timeoutMs),
                 redirect: "error",
             });
@@ -1124,29 +1313,43 @@ export function createDominusNodeFunctionHandler(config) {
                 return JSON.stringify({ error: sanitizeError(message) });
             }
             const data = safeJsonParse(responseText);
-            return JSON.stringify({ userId: data.userId, email: data.email, message: data.message ?? "Registration successful" });
+            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)) });
+            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" });
+            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" });
+            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" });
+            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" });
+            return JSON.stringify({
+                error: "password must be between 8 and 128 characters",
+            });
         }
         try {
             const reqHeaders = {
@@ -1182,10 +1385,15 @@ export function createDominusNodeFunctionHandler(config) {
                 return JSON.stringify({ error: sanitizeError(message) });
             }
             const data = safeJsonParse(responseText);
-            return JSON.stringify({ token: data.token, message: data.message ?? "Login successful" });
+            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)) });
+            return JSON.stringify({
+                error: sanitizeError(err instanceof Error ? err.message : String(err)),
+            });
         }
     }
     async function handleGetAccountInfo() {
@@ -1195,10 +1403,14 @@ export function createDominusNodeFunctionHandler(config) {
     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" });
+            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" });
+            return JSON.stringify({
+                error: "token contains invalid control characters",
+            });
         }
         try {
             const reqHeaders = {
@@ -1237,7 +1449,9 @@ export function createDominusNodeFunctionHandler(config) {
             return JSON.stringify(data);
         }
         catch (err) {
-            return JSON.stringify({ error: sanitizeError(err instanceof Error ? err.message : String(err)) });
+            return JSON.stringify({
+                error: sanitizeError(err instanceof Error ? err.message : String(err)),
+            });
         }
     }
     async function handleResendVerification() {
@@ -1248,16 +1462,24 @@ export function createDominusNodeFunctionHandler(config) {
         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" });
+            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" });
+            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" });
+            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" });
+            return JSON.stringify({
+                error: "new_password must be between 8 and 128 characters",
+            });
         }
         const result = await api("POST", "/api/auth/change-password", {
             currentPassword,
@@ -1275,13 +1497,17 @@ export function createDominusNodeFunctionHandler(config) {
     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" });
+            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" });
+            return JSON.stringify({
+                error: "label contains invalid control characters",
+            });
         }
         const result = await api("POST", "/api/keys", { label });
         return JSON.stringify(result);
@@ -1289,10 +1515,14 @@ export function createDominusNodeFunctionHandler(config) {
     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" });
+            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" });
+            return JSON.stringify({
+                error: "key_id contains invalid control characters",
+            });
         }
         const result = await api("DELETE", `/api/keys/${encodeURIComponent(keyId)}`);
         return JSON.stringify(result);
@@ -1311,10 +1541,14 @@ export function createDominusNodeFunctionHandler(config) {
     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" });
+            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" });
+            return JSON.stringify({
+                error: "plan_id contains invalid control characters",
+            });
         }
         const result = await api("PUT", "/api/plans/user/plan", { planId });
         return JSON.stringify(result);
@@ -1325,7 +1559,9 @@ export function createDominusNodeFunctionHandler(config) {
     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" });
+            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" });
@@ -1337,16 +1573,22 @@ export function createDominusNodeFunctionHandler(config) {
         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" });
+            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" });
+            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" });
+            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);
@@ -1354,7 +1596,9 @@ export function createDominusNodeFunctionHandler(config) {
     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" });
+            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" });
@@ -1365,7 +1609,9 @@ export function createDominusNodeFunctionHandler(config) {
     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" });
+            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" });
@@ -1377,13 +1623,17 @@ export function createDominusNodeFunctionHandler(config) {
         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" });
+            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" });
+            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" });
@@ -1395,13 +1645,17 @@ export function createDominusNodeFunctionHandler(config) {
         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" });
+            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" });
+            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" });
@@ -1414,19 +1668,25 @@ export function createDominusNodeFunctionHandler(config) {
         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" });
+            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" });
+            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" });
+            return JSON.stringify({
+                error: "email contains invalid control characters",
+            });
         }
         if (role !== "member" && role !== "admin") {
             return JSON.stringify({ error: "role must be 'member' or 'admin'" });
@@ -1437,7 +1697,9 @@ export function createDominusNodeFunctionHandler(config) {
     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" });
+            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" });
@@ -1449,13 +1711,17 @@ export function createDominusNodeFunctionHandler(config) {
         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" });
+            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" });
+            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" });
@@ -1520,11 +1786,19 @@ export function createDominusNodeFunctionHandler(config) {
         dominusnode_topup_crypto: handleTopupCrypto,
         dominusnode_x402_info: handleX402Info,
         dominusnode_update_wallet_policy: handleUpdateWalletPolicy,
+        // MPP (5)
+        dominusnode_mpp_info: handleMppInfo,
+        dominusnode_mpp_challenge: handleMppChallenge,
+        dominusnode_pay_mpp: handlePayMpp,
+        dominusnode_mpp_session_open: handleMppSessionOpen,
+        dominusnode_mpp_session_close: handleMppSessionClose,
     };
     async function handleUpdateWalletPolicy(args) {
         const walletId = args.wallet_id;
         if (!walletId || typeof walletId !== "string") {
-            return JSON.stringify({ error: "wallet_id is required and must be a string" });
+            return JSON.stringify({
+                error: "wallet_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(walletId)) {
             return JSON.stringify({ error: "wallet_id must be a valid UUID" });
@@ -1536,7 +1810,9 @@ export function createDominusNodeFunctionHandler(config) {
             }
             else {
                 const dailyLimit = Number(args.daily_limit_cents);
-                if (!Number.isInteger(dailyLimit) || dailyLimit < 1 || dailyLimit > 1_000_000) {
+                if (!Number.isInteger(dailyLimit) ||
+                    dailyLimit < 1 ||
+                    dailyLimit > 1_000_000) {
                     return JSON.stringify({
                         error: "daily_limit_cents must be a positive integer between 1 and 1,000,000, or null to clear",
                     });
@@ -1550,22 +1826,32 @@ export function createDominusNodeFunctionHandler(config) {
             }
             else {
                 if (!Array.isArray(args.allowed_domains)) {
-                    return JSON.stringify({ error: "allowed_domains must be an array of domain strings, or null to clear" });
+                    return JSON.stringify({
+                        error: "allowed_domains must be an array of domain strings, or null to clear",
+                    });
                 }
                 if (args.allowed_domains.length > 100) {
-                    return JSON.stringify({ error: "allowed_domains must have at most 100 entries" });
+                    return JSON.stringify({
+                        error: "allowed_domains must have at most 100 entries",
+                    });
                 }
                 const domainRe = /^(?:[a-zA-Z0-9](?:[a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
                 for (let i = 0; i < args.allowed_domains.length; i++) {
                     const d = args.allowed_domains[i];
                     if (typeof d !== "string") {
-                        return JSON.stringify({ error: `allowed_domains[${i}] must be a string` });
+                        return JSON.stringify({
+                            error: `allowed_domains[${i}] must be a string`,
+                        });
                     }
                     if (d.length > 253) {
-                        return JSON.stringify({ error: `allowed_domains[${i}] exceeds 253 characters` });
+                        return JSON.stringify({
+                            error: `allowed_domains[${i}] exceeds 253 characters`,
+                        });
                     }
                     if (!domainRe.test(d)) {
-                        return JSON.stringify({ error: `allowed_domains[${i}] is not a valid domain: ${d}` });
+                        return JSON.stringify({
+                            error: `allowed_domains[${i}] is not a valid domain: ${d}`,
+                        });
                     }
                 }
                 body.allowedDomains = args.allowed_domains;
@@ -1584,6 +1870,121 @@ export function createDominusNodeFunctionHandler(config) {
         return JSON.stringify(result);
     }
     // -----------------------------------------------------------------------
+    // MPP (Machine Payment Protocol) handlers
+    // -----------------------------------------------------------------------
+    async function handleMppInfo() {
+        // MPP info is public (no auth required), but we use the authenticated path
+        // for simplicity since the handler is already authenticated.
+        const result = await api("GET", "/api/mpp/info");
+        return JSON.stringify(result);
+    }
+    async function handleMppChallenge(args) {
+        const poolType = String(args.pool_type ?? "dc");
+        if (poolType !== "dc" && poolType !== "residential") {
+            return JSON.stringify({
+                error: "pool_type must be 'dc' or 'residential'",
+            });
+        }
+        // This is a public endpoint -- no auth required
+        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/mpp/challenge`, {
+                method: "POST",
+                headers: reqHeaders,
+                body: JSON.stringify({ poolType }),
+                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: `MPP challenge failed: ${sanitizeError(message)}`,
+                });
+            }
+            const data = safeJsonParse(responseText);
+            return JSON.stringify(data);
+        }
+        catch (err) {
+            return JSON.stringify({
+                error: `MPP challenge failed: ${sanitizeError(err instanceof Error ? err.message : String(err))}`,
+            });
+        }
+    }
+    async function handlePayMpp(args) {
+        const amountCents = args.amount_cents;
+        const method = String(args.method ?? "");
+        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)",
+            });
+        }
+        if (!["tempo", "stripe_spt", "lightning"].includes(method)) {
+            return JSON.stringify({
+                error: "method must be one of: tempo, stripe_spt, lightning",
+            });
+        }
+        const result = await api("POST", "/api/mpp/topup", { amountCents, method });
+        return JSON.stringify(result);
+    }
+    async function handleMppSessionOpen(args) {
+        const maxDepositCents = args.max_deposit_cents;
+        const method = String(args.method ?? "");
+        const poolType = String(args.pool_type ?? "dc");
+        if (!Number.isInteger(maxDepositCents) ||
+            maxDepositCents < 500 ||
+            maxDepositCents > 100_000) {
+            return JSON.stringify({
+                error: "max_deposit_cents must be an integer between 500 and 100,000",
+            });
+        }
+        if (!["tempo", "stripe_spt", "lightning"].includes(method)) {
+            return JSON.stringify({
+                error: "method must be one of: tempo, stripe_spt, lightning",
+            });
+        }
+        if (!["dc", "residential"].includes(poolType)) {
+            return JSON.stringify({
+                error: "pool_type must be one of: dc, residential",
+            });
+        }
+        const result = await api("POST", "/api/mpp/session/open", {
+            maxDepositCents,
+            method,
+            poolType,
+        });
+        return JSON.stringify(result);
+    }
+    async function handleMppSessionClose(args) {
+        const channelId = String(args.channel_id ?? "");
+        if (!channelId) {
+            return JSON.stringify({ error: "channel_id is required" });
+        }
+        const result = await api("POST", "/api/mpp/session/close", { channelId });
+        return JSON.stringify(result);
+    }
+    // -----------------------------------------------------------------------
     // Main handler
     // -----------------------------------------------------------------------
     return async function handler(name, args) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dominusnode/gemini-functions",
-  "version": "1.2.0",
+  "version": "1.5.2",
   "description": "Dominus Node function declarations and handlers for Google Gemini / Vertex AI",
   "main": "dist/handler.js",
   "types": "dist/handler.d.ts",
@@ -13,6 +13,7 @@
   ],
   "scripts": {
     "build": "tsc",
+    "prepare": "npm run build",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:py": "python -m pytest test_handler.py -v"