httpcat-cli 0.3.0 → 0.3.1

package/dist/mcp/tools.js

@@ -1,5 +1,6 @@
 import { HttpcatClient } from "../client.js";
 import { config } from "../config.js";
+import { getAdminCommands, isCurrentUserAdmin } from "../utils/admin.js";
 import { createToken } from "../commands/create.js";
 import { buyToken } from "../commands/buy.js";
 import { sellToken, parseTokenAmount } from "../commands/sell.js";
@@ -9,8 +10,12 @@ import { getPositions } from "../commands/positions.js";
 import { privateKeyToAccount } from "viem/accounts";
 import { checkHealth } from "../commands/health.js";
 import { checkBalance } from "../commands/balances.js";
-import { viewFees, claimFees } from "../commands/claim.js";
+import { viewFees, claimFees, getUserCreatedTokens, getAllTokenFees, claimAllFees, } from "../commands/claim.js";
 import { getTransactions } from "../commands/transactions.js";
+import { swap, shieldedSwap } from "../commands/swap.js";
+import { submitGaslessSwap, submitGaslessSwapOur, } from "../commands/gasless-swap.js";
+import { getPerpsMarkets, onboardPerps, depositPerps, tradePerps, getPerpsPositions, } from "../commands/perps.js";
+import { getPredictionMarkets, getPredictionMarket, searchPredictionMarkets, placePredictionBet, detectPredictionArbs, calculatePredictionHedge, executePredictionArb, detectPredictionInsiders, } from "../commands/predictions.js";
 import { getOrCreateChatSession, getChatSession, ensureValidSession, sendMessage, getRecentMessages, } from "./chat-state.js";
 // Helper to resolve private key with priority: param > env > config
 function resolvePrivateKey(paramKey, accountIndex) {
@@ -68,13 +73,85 @@ async function createClient(privateKey, accountIndex) {
 // Helper to get network for test mode detection
 function isTestMode(client) {
     const network = client.getNetwork();
-    return network === "eip155:84532" || network === "eip155:11155111" || network.includes("sepolia");
+    return (network === "eip155:84532" ||
+        network === "eip155:11155111" ||
+        network.includes("sepolia"));
 }
+/**
+ * Map MCP tool name to CLI command name for admin filtering
+ * Examples:
+ * - "market_price" -> "market"
+ * - "tools_address_validate" -> "address"
+ * - "create_token" -> "create"
+ * - "gasless_swap_submit" -> "gasless-submit"
+ */
+function toolNameToCommandName(toolName) {
+    // Special cases first
+    const specialCases = {
+        "create_token": "create",
+        "claim_fees": "claim",
+        "gasless_swap_submit": "gasless-submit",
+        "gasless_swap_submit_our": "gasless-submit-our",
+        "gasless_swap_quote": "gasless-quote",
+        "gasless_swap_status": "gasless-status",
+        "system_status": "status",
+        "system_limits": "limits",
+        "system_sources": "sources",
+    };
+    if (specialCases[toolName]) {
+        return specialCases[toolName];
+    }
+    // Extract category prefix (first part before underscore)
+    const parts = toolName.split("_");
+    if (parts.length === 0)
+        return null;
+    // Handle tools_* category - extract subcategory
+    if (parts[0] === "tools" && parts.length > 1) {
+        return parts[1]; // e.g., "tools_address_validate" -> "address"
+    }
+    // Default: use first part as command name
+    return parts[0]; // e.g., "market_price" -> "market"
+}
+/**
+ * Returns all available MCP tools for the httpcat CLI.
+ *
+ * Tool Categories (100+ total):
+ * - Launchpad/Tokens: 7 tools (create, buy, sell, info, list, positions, transactions)
+ * - Swaps: 5 tools (universal, shielded, gasless quote/submit/status)
+ * - Perps: 5 tools (markets, onboard, deposit, trade, positions)
+ * - Predictions: 9 tools (markets, market, search, bet, detect-arbs, calculate-hedge, execute-arb, detect-insiders, stream)
+ * - Chat: 4 tools (join, send message, renew lease, get messages)
+ * - Fees: 2 tools (view, claim)
+ * - Market Intelligence: 8 tools
+ * - Security: 3 tools
+ * - Risk: 2 tools
+ * - Trading: 2 tools
+ * - Opportunities: 5 tools
+ * - Portfolio: 4 tools
+ * - Automation: 4 tools
+ * - System: 3 tools
+ * - Agent: 1 tool
+ * - Tools: 40+ utility tools
+ * - Other: 6 tools (health check, balance check, RPC proxy, etc.)
+ */
 export function getTools() {
-    return [
+    const allTools = [
         {
             name: "create_token",
-            description: "Create a new token on the bonding curve. Costs $0.01 USDC.",
+            description: `Create a new token on the bonding curve. 
+
+💰 Cost: $0.01 USDC
+
+📝 Usage Examples:
+- Create a basic token: {"name": "My Token", "symbol": "MTK"}
+- Create with logo: {"name": "Cool Cat", "symbol": "CAT", "photoUrl": "https://example.com/logo.png"}
+- Create with website: {"name": "My Project", "symbol": "PROJ", "websiteUrl": "https://myproject.com"}
+
+💡 Tips:
+- Token symbol must be 3-10 characters, unique on the platform
+- Tokens start on a bonding curve and graduate to AMM at $100k market cap
+- You become the creator and earn 80% of trading fees
+- Use token_info to check your token after creation`,
             inputSchema: {
                 type: "object",
                 properties: {
@@ -104,7 +181,22 @@ export function getTools() {
         },
         {
             name: "buy_token",
-            description: "Buy tokens from the bonding curve. Amount: 0.05, 0.10, or 0.20 USDC (testnet) or 50, 100, or 200 USDC (mainnet). Includes 1% fee.",
+            description: `Buy tokens from the bonding curve.
+
+💰 Cost: Amount + 1% fee
+- Testnet: 0.05, 0.10, or 0.20 USDC
+- Mainnet: 50, 100, or 200 USDC
+
+📝 Usage Examples:
+- Buy by symbol: {"identifier": "FRIDA", "amount": "100"}
+- Buy by name: {"identifier": "My Token", "amount": "50"}
+- Buy by address: {"identifier": "0x1234...", "amount": "200"}
+
+💡 Tips:
+- Token identifier can be symbol (case-insensitive), name, or contract address
+- Use token_info first to check current price and market cap
+- Tokens on bonding curve have dynamic pricing based on supply
+- Use positions to see all your holdings after buying`,
             inputSchema: {
                 type: "object",
                 properties: {
@@ -126,7 +218,20 @@ export function getTools() {
         },
         {
             name: "sell_token",
-            description: "Sell tokens back to the bonding curve. Amount can be a number, percentage (e.g., '50%'), or 'all'. 1% fee deducted from proceeds.",
+            description: `Sell tokens back to the bonding curve.
+
+💰 Cost: 1% fee deducted from proceeds
+
+📝 Usage Examples:
+- Sell specific amount: {"identifier": "FRIDA", "amount": "1000"}
+- Sell percentage: {"identifier": "FRIDA", "amount": "50%"}
+- Sell all: {"identifier": "FRIDA", "amount": "all"}
+
+💡 Tips:
+- Amount can be a number, percentage (e.g., '50%'), or 'all'
+- Use token_info first to check your holdings
+- Selling reduces token supply and may affect price
+- Use positions to see updated holdings after selling`,
             inputSchema: {
                 type: "object",
                 properties: {
@@ -148,7 +253,26 @@ export function getTools() {
         },
         {
             name: "token_info",
-            description: "Get detailed information about a token including price, market cap, graduation progress, and your position (if you own tokens). Costs $0.0001 USDC.",
+            description: `Get detailed information about a token.
+
+💰 Cost: $0.0001 USDC
+
+📊 Returns:
+- Current price and market cap
+- Graduation progress (toward $100k for AMM)
+- Your position (if you own tokens)
+- Token metadata (name, symbol, logo, website)
+- Trading statistics
+
+📝 Usage Examples:
+- Get info by symbol: {"identifier": "FRIDA"}
+- Get info by name: {"identifier": "My Token"}
+- Get info by address: {"identifier": "0x1234..."}
+
+💡 Tips:
+- Use this before buying to check current price
+- Check graduation progress to see if token is close to AMM
+- Your position shows profit/loss if you own tokens`,
             inputSchema: {
                 type: "object",
                 properties: {
@@ -166,7 +290,20 @@ export function getTools() {
         },
         {
             name: "list_tokens",
-            description: "List all tokens with pagination and sorting. Costs $0.0001 USDC.",
+            description: `List all tokens with pagination and sorting.
+
+💰 Cost: $0.0001 USDC
+
+📝 Usage Examples:
+- List top tokens: {"sort": "mcap", "limit": 20}
+- List newest: {"sort": "created", "limit": 50}
+- List alphabetically: {"sort": "name", "page": 1, "limit": 100}
+
+💡 Tips:
+- Sort by 'mcap' to see highest market cap tokens first
+- Sort by 'created' to see newest tokens
+- Use pagination to browse through all tokens
+- Consider using the httpcat://tokens/list resource for cached data`,
             inputSchema: {
                 type: "object",
                 properties: {
@@ -195,7 +332,25 @@ export function getTools() {
         },
         {
             name: "positions",
-            description: "Get all your positions with comprehensive information including current value, profit/loss, ROI, transaction history, and portfolio summary. Costs $0.01 USDC.",
+            description: `Get all your token positions with comprehensive portfolio analysis.
+
+💰 Cost: $0.01 USDC
+
+📊 Returns:
+- All tokens you own with current value
+- Profit/loss for each position
+- ROI percentage
+- Transaction history
+- Portfolio summary (total value, total P/L)
+
+📝 Usage Example:
+- Get all positions: {} (no parameters needed)
+
+💡 Tips:
+- Use this regularly to track your portfolio performance
+- Shows both realized and unrealized gains
+- Transaction history helps track your trading activity
+- Portfolio summary gives quick overview of total value`,
             inputSchema: {
                 type: "object",
                 properties: {
@@ -208,7 +363,22 @@ export function getTools() {
         },
         {
             name: "check_balance",
-            description: "Check wallet balance (ETH and USDC). Free - no payment required.",
+            description: `Check wallet balance for ETH and USDC.
+
+💰 Cost: FREE - no payment required
+
+📊 Returns:
+- ETH balance (for gas fees)
+- USDC balance (for trading)
+
+📝 Usage Example:
+- Check balance: {} (no parameters needed)
+
+💡 Tips:
+- Check balance before trading to ensure sufficient funds
+- You need ETH for gas fees on all transactions
+- You need USDC for buying tokens and trading
+- Use this tool frequently to monitor your wallet`,
             inputSchema: {
                 type: "object",
                 properties: {
@@ -313,31 +483,31 @@ export function getTools() {
         },
         {
             name: "view_fees",
-            description: "View accumulated fees for a token. Shows total fees, creator share (80%), and platform share (20%). Free - no payment required.",
+            description: "View accumulated claims for a token or all your tokens. Shows total fees, creator share (80%), and platform share (20%). If no identifier provided, shows all tokens you created. Free - no payment required.",
             inputSchema: {
                 type: "object",
                 properties: {
                     identifier: {
                         type: "string",
-                        description: "Token identifier: address, name (use quotes if spaces), or symbol (case-insensitive)",
+                        description: "Optional token identifier: address, name (use quotes if spaces), or symbol (case-insensitive). If omitted, returns all your created tokens.",
                     },
                     privateKey: {
                         type: "string",
                         description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
                     },
                 },
-                required: ["identifier"],
+                required: [],
             },
         },
         {
             name: "claim_fees",
-            description: "Claim accumulated fees for a token. Creator receives 80% of fees, platform receives 20%. Requires gas fees.",
+            description: "Claim accumulated fees for a token. Creator receives 80% of fees, platform receives 20%. Requires gas fees. Use 'all' as identifier to claim all your tokens.",
             inputSchema: {
                 type: "object",
                 properties: {
                     identifier: {
                         type: "string",
-                        description: "Token identifier: address, name (use quotes if spaces), or symbol (case-insensitive)",
+                        description: "Token identifier: address, name (use quotes if spaces), symbol (case-insensitive), or 'all' to claim all your tokens.",
                     },
                     privateKey: {
                         type: "string",
@@ -383,160 +553,3940 @@ export function getTools() {
                 },
             },
         },
-    ];
-}
-// Generate a unique response ID
-function generateResponseId() {
-    return `resp_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-}
-export async function handleTool(name, args) {
-    const responseId = generateResponseId();
-    try {
-        let result;
-        switch (name) {
-            case "create_token": {
-                const params = args;
-                const client = await createClient(params.privateKey);
-                result = await createToken(client, {
-                    name: params.name,
-                    symbol: params.symbol,
-                    photoUrl: params.photoUrl,
-                    websiteUrl: params.websiteUrl,
-                });
-                break;
-            }
-            case "buy_token": {
-                const params = args;
-                const client = await createClient(params.privateKey);
-                const testMode = isTestMode(client);
-                result = await buyToken(client, params.identifier, params.amount, testMode, true // silent mode for MCP
-                );
-                break;
-            }
-            case "sell_token": {
-                const params = args;
-                const client = await createClient(params.privateKey);
-                // First get token info to check holdings
-                const info = await getTokenInfo(client, params.identifier, undefined, true // silent mode
-                );
-                if (!info.userPosition || info.userPosition.tokensOwned === "0") {
-                    throw new Error("You do not own any of this token");
-                }
-                const tokenAmount = parseTokenAmount(params.amount, info.userPosition.tokensOwned);
-                result = await sellToken(client, params.identifier, tokenAmount, true // silent mode
-                );
-                break;
-            }
-            case "token_info": {
-                const params = args;
-                const client = await createClient(params.privateKey);
-                result = await getTokenInfo(client, params.identifier, undefined, true // silent mode
-                );
-                break;
-            }
-            case "list_tokens": {
-                const params = args;
-                const client = await createClient(params.privateKey);
-                result = await listTokens(client, params.page || 1, params.limit || 20, params.sort || "mcap");
-                break;
-            }
-            case "positions": {
-                const params = args;
-                const client = await createClient(params.privateKey);
-                // Get user address from private key
-                const privateKey = resolvePrivateKey(params.privateKey);
-                if (!privateKey) {
-                    throw new Error("Private key required for positions command");
-                }
-                const account = privateKeyToAccount(privateKey);
-                const userAddress = account.address;
-                result = await getPositions(client, userAddress);
-                break;
-            }
-            case "check_balance": {
-                const params = args;
-                const resolvedKey = resolvePrivateKey(params.privateKey);
-                result = await checkBalance(resolvedKey);
-                break;
-            }
-            case "health_check": {
-                const params = args;
-                const client = await createClient(params.privateKey);
-                result = await checkHealth(client);
-                break;
-            }
-            case "chat_join": {
-                const params = args;
-                const client = await createClient(params.privateKey);
-                const session = await getOrCreateChatSession(client, params.tokenIdentifier, resolvePrivateKey(params.privateKey));
-                result = {
-                    leaseId: session.leaseId,
-                    leaseExpiresAt: session.leaseExpiresAt.toISOString(),
-                    wsUrl: session.wsUrl,
-                    lastMessages: session.messages.slice(-20), // Last 20 messages
-                };
-                break;
-            }
-            case "chat_send_message": {
-                const params = args;
-                const client = await createClient(params.privateKey);
-                const session = getChatSession(params.leaseId);
-                if (!session) {
-                    throw new Error(`No active chat session found for leaseId: ${params.leaseId}. Use chat_join first.`);
-                }
-                result = await sendMessage(session, params.message);
-                break;
-            }
-            case "chat_renew_lease": {
-                const params = args;
-                const client = await createClient(params.privateKey);
-                const session = await ensureValidSession(client, params.leaseId, resolvePrivateKey(params.privateKey));
-                result = {
-                    leaseId: session.leaseId,
-                    leaseExpiresAt: session.leaseExpiresAt.toISOString(),
-                };
-                break;
-            }
-            case "chat_get_recent_messages": {
-                const params = args;
-                const session = getChatSession(params.leaseId);
-                if (!session) {
-                    throw new Error(`No active chat session found for leaseId: ${params.leaseId}. Use chat_join first.`);
-                }
-                const messages = getRecentMessages(session, params.limit || 50);
-                result = { messages };
-                break;
-            }
-            case "view_fees": {
-                const params = args;
-                const client = await createClient(params.privateKey);
-                result = await viewFees(client, params.identifier, true); // silent mode
-                break;
-            }
-            case "claim_fees": {
-                const params = args;
-                const client = await createClient(params.privateKey);
-                // Get user address from private key
-                const privateKey = resolvePrivateKey(params.privateKey);
-                if (!privateKey) {
-                    throw new Error("Private key required for claim_fees command");
-                }
-                const account = privateKeyToAccount(privateKey);
-                const userAddress = account.address;
-                result = await claimFees(client, params.identifier, userAddress, true // silent mode
-                );
-                break;
-            }
-            case "get_transactions": {
-                const params = args;
-                const client = await createClient(params.privateKey);
-                result = await getTransactions(client, {
-                    userAddress: params.userAddress,
-                    tokenId: params.tokenId,
-                    type: params.type,
-                    limit: params.limit,
-                    offset: params.offset,
-                });
+        {
+            name: "swap_tokens",
+            description: "Swap tokens using universal swap with best route aggregation. Costs $0.10 USDC. Supports any ERC20 token (including CAT tokens).",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    tokenIn: {
+                        type: "string",
+                        description: "Token identifier to swap from: address, name (use quotes if spaces), or symbol (case-insensitive). Can be USDC, ETH, or any CAT token.",
+                    },
+                    tokenOut: {
+                        type: "string",
+                        description: "Token identifier to swap to: address, name (use quotes if spaces), or symbol (case-insensitive). Can be USDC, ETH, or any CAT token.",
+                    },
+                    amount: {
+                        type: "string",
+                        description: "Amount to swap (human-readable, e.g., '100' for 100 tokens, '0.5' for 0.5 ETH)",
+                    },
+                    slippageBps: {
+                        type: "number",
+                        description: "Slippage tolerance in basis points (default: 50, which is 0.5%). 100 bps = 1%",
+                        default: 50,
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["tokenIn", "tokenOut", "amount"],
+            },
+        },
+        {
+            name: "shielded_swap",
+            description: "MEV-protected swap via UniswapX Dutch auction. Costs $1.00 USDC. Provides protection against front-running and sandwich attacks.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    tokenIn: {
+                        type: "string",
+                        description: "Token identifier to swap from: address, name (use quotes if spaces), or symbol (case-insensitive). Can be USDC, ETH, or any CAT token.",
+                    },
+                    tokenOut: {
+                        type: "string",
+                        description: "Token identifier to swap to: address, name (use quotes if spaces), or symbol (case-insensitive). Can be USDC, ETH, or any CAT token.",
+                    },
+                    amount: {
+                        type: "string",
+                        description: "Amount to swap (human-readable, e.g., '100' for 100 tokens, '0.5' for 0.5 ETH)",
+                    },
+                    slippageBps: {
+                        type: "number",
+                        description: "Slippage tolerance in basis points (default: 50, which is 0.5%). 100 bps = 1%",
+                        default: 50,
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["tokenIn", "tokenOut", "amount"],
+            },
+        },
+        {
+            name: "gasless_swap_quote",
+            description: "Get gasless swap quotes from multiple providers. Free - no payment required. Returns quotes without executing the swap.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    tokenIn: {
+                        type: "string",
+                        description: "Token address to swap from (must be a contract address)",
+                    },
+                    tokenOut: {
+                        type: "string",
+                        description: "Token address to swap to (must be a contract address)",
+                    },
+                    amount: {
+                        type: "string",
+                        description: "Amount to swap in smallest units (e.g., for USDC with 6 decimals, '1000000' = 1 USDC)",
+                    },
+                    slippageBps: {
+                        type: "number",
+                        description: "Slippage tolerance in basis points (optional). 100 bps = 1%",
+                    },
+                    taker: {
+                        type: "string",
+                        description: "Taker address (wallet that will receive the tokens)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["tokenIn", "tokenOut", "amount", "taker"],
+            },
+        },
+        {
+            name: "gasless_swap_status",
+            description: "Check the status of a 0x gasless swap. Free - no payment required.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    tradeHash: {
+                        type: "string",
+                        description: "Trade hash from gasless swap",
+                    },
+                    chainId: {
+                        type: "number",
+                        description: "Optional chain ID (defaults to configured network)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["tradeHash"],
+            },
+        },
+        {
+            name: "gasless_swap_submit",
+            description: "Submit a signed 0x gasless swap trade. Costs $0.01 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    chainId: {
+                        type: "number",
+                        description: "Optional chain ID",
+                    },
+                    approval: {
+                        type: "object",
+                        description: "Optional approval object",
+                    },
+                    trade: {
+                        type: "object",
+                        description: "Trade object (required)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["trade"],
+            },
+        },
+        {
+            name: "gasless_swap_submit_our",
+            description: "Submit a gasless swap via our executor. Costs $0.01 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    tokenIn: {
+                        type: "string",
+                        description: "Token in address",
+                    },
+                    tokenOut: {
+                        type: "string",
+                        description: "Token out address",
+                    },
+                    totalAmount: {
+                        type: "string",
+                        description: "Total amount",
+                    },
+                    feeAmount: {
+                        type: "string",
+                        description: "Fee amount",
+                    },
+                    taker: {
+                        type: "string",
+                        description: "Taker address",
+                    },
+                    permit2Signature: {
+                        type: "string",
+                        description: "Permit2 signature",
+                    },
+                    permitNonce: {
+                        type: "number",
+                        description: "Permit nonce",
+                    },
+                    permitDeadline: {
+                        type: "number",
+                        description: "Permit deadline",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: [
+                    "tokenIn",
+                    "tokenOut",
+                    "totalAmount",
+                    "feeAmount",
+                    "taker",
+                    "permit2Signature",
+                    "permitNonce",
+                    "permitDeadline",
+                ],
+            },
+        },
+        {
+            name: "perps_markets",
+            description: "Get available perpetual futures markets. Costs $0.01 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    platform: {
+                        type: "string",
+                        description: "Optional platform filter",
+                    },
+                    symbol: {
+                        type: "string",
+                        description: "Optional symbol filter",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+            },
+        },
+        {
+            name: "perps_onboard",
+            description: "One-time setup to connect wallet to perps venues. Free - no payment required.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    wallet: {
+                        type: "string",
+                        description: "Wallet address",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["wallet"],
+            },
+        },
+        {
+            name: "perps_deposit",
+            description: "Deposit USDC to perps trading venues. Free - no payment required.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    amount: {
+                        type: "string",
+                        description: "Amount to deposit",
+                    },
+                    venue: {
+                        type: "string",
+                        description: "Optional venue",
+                    },
+                    chain: {
+                        type: "string",
+                        description: "Optional chain",
+                    },
+                    wallet: {
+                        type: "string",
+                        description: "Wallet address",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["amount", "wallet"],
+            },
+        },
+        {
+            name: "perps_trade",
+            description: "Open or close perpetual positions with auto-routing. Costs $0.05 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    market: {
+                        type: "string",
+                        description: "Market identifier",
+                    },
+                    side: {
+                        type: "string",
+                        enum: ["long", "short"],
+                        description: "Side: long or short",
+                    },
+                    sizeUsd: {
+                        type: "string",
+                        description: "Size in USD",
+                    },
+                    leverage: {
+                        type: "number",
+                        description: "Leverage multiplier",
+                    },
+                    orderType: {
+                        type: "string",
+                        description: "Optional order type",
+                    },
+                    price: {
+                        type: "string",
+                        description: "Optional price",
+                    },
+                    wallet: {
+                        type: "string",
+                        description: "Wallet address",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["market", "side", "sizeUsd", "leverage", "wallet"],
+            },
+        },
+        {
+            name: "perps_positions",
+            description: "View all open perpetual positions across venues. Costs $0.01 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    wallet: {
+                        type: "string",
+                        description: "Wallet address",
+                    },
+                    venue: {
+                        type: "string",
+                        description: "Optional venue filter",
+                    },
+                    asterApiKey: {
+                        type: "string",
+                        description: "Optional Aster API key",
+                    },
+                    asterApiSecret: {
+                        type: "string",
+                        description: "Optional Aster API secret",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["wallet"],
+            },
+        },
+        {
+            name: "predictions_markets",
+            description: "Browse prediction markets from Polymarket and Azuro. Costs $0.01 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    venue: {
+                        type: "string",
+                        description: "Optional venue filter",
+                    },
+                    category: {
+                        type: "string",
+                        description: "Optional category filter",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Optional limit",
+                    },
+                    sort: {
+                        type: "string",
+                        description: "Optional sort option",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+            },
+        },
+        {
+            name: "predictions_market",
+            description: "Get detailed information about a specific prediction market. Costs $0.01 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    marketId: {
+                        type: "string",
+                        description: "Market ID",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["marketId"],
+            },
+        },
+        {
+            name: "predictions_search",
+            description: "Search prediction markets by keyword. Costs $0.01 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: {
+                        type: "string",
+                        description: "Search query",
+                    },
+                    venue: {
+                        type: "string",
+                        description: "Optional venue filter",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Optional limit",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["query"],
+            },
+        },
+        {
+            name: "predictions_bet",
+            description: "Place a bet on a prediction market outcome. Costs $0.05 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    marketId: {
+                        type: "string",
+                        description: "Market ID",
+                    },
+                    outcomeId: {
+                        type: "string",
+                        description: "Outcome ID",
+                    },
+                    amountUsd: {
+                        type: "number",
+                        description: "Amount in USD",
+                    },
+                    wallet: {
+                        type: "string",
+                        description: "Wallet address",
+                    },
+                    polymarketApiKey: {
+                        type: "string",
+                        description: "Optional Polymarket API key",
+                    },
+                    polymarketApiSecret: {
+                        type: "string",
+                        description: "Optional Polymarket API secret",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["marketId", "outcomeId", "amountUsd", "wallet"],
+            },
+        },
+        {
+            name: "predictions_detect_arbs",
+            description: "Scan for arbitrage opportunities across prediction market venues. Free - no payment required.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    minSpreadPct: {
+                        type: "number",
+                        description: "Optional minimum spread percentage",
+                    },
+                    venues: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Optional venues array",
+                    },
+                    cryptoOnly: {
+                        type: "boolean",
+                        description: "Optional crypto-only filter",
+                    },
+                    maxResults: {
+                        type: "number",
+                        description: "Optional max results",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+            },
+        },
+        {
+            name: "predictions_calculate_hedge",
+            description: "Calculate optimal perp hedge for cross-venue arbitrage. Free - no payment required.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    marketA: {
+                        type: "object",
+                        description: "Market A object",
+                    },
+                    marketB: {
+                        type: "object",
+                        description: "Market B object",
+                    },
+                    positionSizeUsd: {
+                        type: "number",
+                        description: "Position size in USD",
+                    },
+                    currentPrice: {
+                        type: "number",
+                        description: "Current price",
+                    },
+                    fundingRate8h: {
+                        type: "number",
+                        description: "Optional funding rate (8h)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["marketA", "marketB", "positionSizeUsd", "currentPrice"],
+            },
+        },
+        {
+            name: "predictions_execute_arb",
+            description: "Execute complete arbitrage trade with optional hedge. Costs $0.20 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    marketA: {
+                        type: "object",
+                        description: "Market A object",
+                    },
+                    marketB: {
+                        type: "object",
+                        description: "Market B object",
+                    },
+                    positionSizeUsd: {
+                        type: "number",
+                        description: "Position size in USD",
+                    },
+                    autoHedge: {
+                        type: "boolean",
+                        description: "Optional auto-hedge flag",
+                    },
+                    maxSlippagePct: {
+                        type: "number",
+                        description: "Optional max slippage percentage",
+                    },
+                    currentPrice: {
+                        type: "number",
+                        description: "Optional current price",
+                    },
+                    wallet: {
+                        type: "string",
+                        description: "Wallet address",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["marketA", "marketB", "positionSizeUsd", "wallet"],
+            },
+        },
+        {
+            name: "predictions_detect_insiders",
+            description: "Detect sophisticated traders via wallet graph analysis. Costs $5.00 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    timeWindowMinutes: {
+                        type: "number",
+                        description: "Optional time window in minutes",
+                    },
+                    minTrades: {
+                        type: "number",
+                        description: "Optional minimum trades",
+                    },
+                    minSimilarity: {
+                        type: "number",
+                        description: "Optional minimum similarity (0-1)",
+                    },
+                    includeCommunities: {
+                        type: "boolean",
+                        description: "Optional include communities flag",
+                    },
+                    maxResults: {
+                        type: "number",
+                        description: "Optional max results",
+                    },
+                    assetFilter: {
+                        type: "string",
+                        description: "Optional asset filter",
+                    },
+                    trades: {
+                        type: "array",
+                        description: "Optional trades array",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+            },
+        },
+        {
+            name: "rpc_proxy",
+            description: "JSON-RPC proxy for Ethereum/Base blockchain calls. Costs $0.05 USDC per request. Supports all standard JSON-RPC methods.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    jsonrpc: {
+                        type: "string",
+                        description: 'JSON-RPC version (typically "2.0")',
+                        default: "2.0",
+                    },
+                    id: {
+                        type: "number",
+                        description: "Request ID (preserved in response)",
+                    },
+                    method: {
+                        type: "string",
+                        description: "RPC method name (e.g., 'eth_blockNumber', 'eth_getBalance', 'eth_call')",
+                    },
+                    params: {
+                        type: "array",
+                        description: "Method parameters (array or object)",
+                        items: {},
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["jsonrpc", "id", "method", "params"],
+            },
+        },
+        {
+            name: "call_x402_endpoint",
+            description: "Call an arbitrary x402-protected HTTP endpoint with automatic payment handling. Supports GET, POST, PUT, DELETE, PATCH methods.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    url: {
+                        type: "string",
+                        description: "Full URL of the x402 endpoint",
+                    },
+                    method: {
+                        type: "string",
+                        description: "HTTP method (GET, POST, PUT, DELETE, PATCH)",
+                        enum: ["GET", "POST", "PUT", "DELETE", "PATCH"],
+                        default: "POST",
+                    },
+                    body: {
+                        type: "object",
+                        description: "Request body (will be JSON stringified)",
+                    },
+                    headers: {
+                        type: "object",
+                        description: "Additional HTTP headers",
+                        additionalProperties: {
+                            type: "string",
+                        },
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["url"],
+            },
+        },
+        // Market Intelligence
+        {
+            name: "market_price",
+            description: "Get token price data. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    tokenIdentifier: {
+                        type: "string",
+                        description: "Token identifier: address, name, or symbol",
+                    },
+                    timeframe: {
+                        type: "string",
+                        enum: ["1h", "24h", "7d", "30d"],
+                        description: "Optional timeframe",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["tokenIdentifier"],
+            },
+        },
+        {
+            name: "market_ohlc",
+            description: "Get OHLC (Open, High, Low, Close) candle data. Costs $0.01 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    tokenIdentifier: {
+                        type: "string",
+                        description: "Token identifier: address, name, or symbol",
+                    },
+                    interval: {
+                        type: "string",
+                        enum: ["1m", "5m", "15m", "1h", "4h", "1d"],
+                        description: "Optional interval",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Optional limit (default: 100)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["tokenIdentifier"],
+            },
+        },
+        {
+            name: "market_liquidity",
+            description: "Get liquidity depth. Costs $0.01 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    tokenIdentifier: {
+                        type: "string",
+                        description: "Token identifier: address, name, or symbol",
+                    },
+                    depth: {
+                        type: "number",
+                        description: "Optional depth (default: 10)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["tokenIdentifier"],
+            },
+        },
+        {
+            name: "market_price_impact",
+            description: "Estimate price impact for a trade. Costs $0.01 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    tokenIdentifier: {
+                        type: "string",
+                        description: "Token identifier: address, name, or symbol",
+                    },
+                    amount: {
+                        type: "string",
+                        description: "Trade amount",
+                    },
+                    side: {
+                        type: "string",
+                        enum: ["buy", "sell"],
+                        description: "Trade side",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["tokenIdentifier", "amount", "side"],
+            },
+        },
+        {
+            name: "token_holders_top",
+            description: "Get top holders of a token. Costs $0.01 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    tokenIdentifier: {
+                        type: "string",
+                        description: "Token identifier: address, name, or symbol",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Optional limit (default: 10)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["tokenIdentifier"],
+            },
+        },
+        {
+            name: "token_distribution",
+            description: "Get token distribution analysis. Costs $0.01 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    tokenIdentifier: {
+                        type: "string",
+                        description: "Token identifier: address, name, or symbol",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["tokenIdentifier"],
+            },
+        },
+        {
+            name: "token_supply",
+            description: "Get token supply information. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    tokenIdentifier: {
+                        type: "string",
+                        description: "Token identifier: address, name, or symbol",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["tokenIdentifier"],
+            },
+        },
+        {
+            name: "token_unlocks",
+            description: "Get token unlock schedules. Costs $0.01 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    tokenIdentifier: {
+                        type: "string",
+                        description: "Token identifier: address, name, or symbol",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["tokenIdentifier"],
+            },
+        },
+        // Security
+        {
+            name: "security_token_scan",
+            description: "Comprehensive token safety scan. Costs $0.01 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    tokenAddress: {
+                        type: "string",
+                        description: "Token address (0x format)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["tokenAddress"],
+            },
+        },
+        {
+            name: "security_allowances",
+            description: "Check token allowances for a wallet. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    wallet: {
+                        type: "string",
+                        description: "Wallet address (0x format)",
+                    },
+                    token: {
+                        type: "string",
+                        description: "Token address (0x format)",
+                    },
+                    spender: {
+                        type: "string",
+                        description: "Optional spender address (0x format)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["wallet", "token"],
+            },
+        },
+        {
+            name: "security_revoke_allowance",
+            description: "Generate revoke allowance transaction. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    token: {
+                        type: "string",
+                        description: "Token address (0x format)",
+                    },
+                    spender: {
+                        type: "string",
+                        description: "Spender address (0x format)",
+                    },
+                    wallet: {
+                        type: "string",
+                        description: "Wallet address (0x format)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["token", "spender", "wallet"],
+            },
+        },
+        // Risk
+        {
+            name: "risk_policy",
+            description: "Get or set risk policy for a wallet. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    wallet: {
+                        type: "string",
+                        description: "Wallet address (0x format)",
+                    },
+                    maxPositionSize: {
+                        type: "string",
+                        description: "Optional max position size (for POST)",
+                    },
+                    maxLeverage: {
+                        type: "number",
+                        description: "Optional max leverage (for POST)",
+                    },
+                    allowedTokens: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Optional allowed tokens array (for POST)",
+                    },
+                    blockedTokens: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Optional blocked tokens array (for POST)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["wallet"],
+            },
+        },
+        {
+            name: "risk_evaluate",
+            description: "Evaluate risk policy against a proposed trade. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    wallet: {
+                        type: "string",
+                        description: "Wallet address (0x format)",
+                    },
+                    trade: {
+                        type: "object",
+                        description: "Trade object",
+                        properties: {
+                            type: {
+                                type: "string",
+                                enum: ["swap", "perps", "prediction"],
+                            },
+                            token: { type: "string" },
+                            amount: { type: "string" },
+                            leverage: { type: "number" },
+                        },
+                        required: ["type", "token", "amount"],
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["wallet", "trade"],
+            },
+        },
+        // Trading
+        {
+            name: "trade_preview",
+            description: "Preview trade without executing. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    tokenIn: {
+                        type: "string",
+                        description: "Token in address (0x format)",
+                    },
+                    tokenOut: {
+                        type: "string",
+                        description: "Token out address (0x format)",
+                    },
+                    amount: {
+                        type: "string",
+                        description: "Amount in wei",
+                    },
+                    slippageBps: {
+                        type: "number",
+                        description: "Optional slippage in basis points",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["tokenIn", "tokenOut", "amount"],
+            },
+        },
+        {
+            name: "tx_simulate",
+            description: "Simulate transaction with state analysis. Costs $0.01 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    transaction: {
+                        type: "object",
+                        description: "Transaction object",
+                        properties: {
+                            to: { type: "string" },
+                            data: { type: "string" },
+                            value: { type: "string" },
+                        },
+                        required: ["to", "data", "value"],
+                    },
+                    from: {
+                        type: "string",
+                        description: "Optional from address (0x format)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["transaction"],
+            },
+        },
+        // Opportunities
+        {
+            name: "opps_arbitrage",
+            description: "Discover arbitrage opportunities. Costs $0.01 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    minProfit: {
+                        type: "string",
+                        description: "Optional minimum profit",
+                    },
+                    tokens: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Optional tokens array",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+            },
+        },
+        {
+            name: "opps_funding",
+            description: "Discover funding opportunities. Costs $0.01 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    minRate: {
+                        type: "number",
+                        description: "Optional minimum rate",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+            },
+        },
+        {
+            name: "opps_yield",
+            description: "Discover yield opportunities. Costs $0.01 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    minApy: {
+                        type: "number",
+                        description: "Optional minimum APY",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+            },
+        },
+        {
+            name: "opps_liquidations",
+            description: "Discover liquidation opportunities. Costs $0.01 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    minProfit: {
+                        type: "string",
+                        description: "Optional minimum profit",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+            },
+        },
+        {
+            name: "opps_execute",
+            description: "Execute opportunity. Costs $0.05 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    opportunityId: {
+                        type: "string",
+                        description: "Opportunity ID",
+                    },
+                    wallet: {
+                        type: "string",
+                        description: "Wallet address (0x format)",
+                    },
+                    amount: {
+                        type: "string",
+                        description: "Optional amount",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["opportunityId", "wallet"],
+            },
+        },
+        // Portfolio
+        {
+            name: "portfolio_summary",
+            description: "Get portfolio summary. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    wallet: {
+                        type: "string",
+                        description: "Wallet address (0x format)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["wallet"],
+            },
+        },
+        {
+            name: "portfolio_pnl",
+            description: "Get portfolio P&L. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    wallet: {
+                        type: "string",
+                        description: "Wallet address (0x format)",
+                    },
+                    timeframe: {
+                        type: "string",
+                        enum: ["1d", "7d", "30d", "all"],
+                        description: "Optional timeframe",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["wallet"],
+            },
+        },
+        {
+            name: "history_trades",
+            description: "Get trade history. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    wallet: {
+                        type: "string",
+                        description: "Wallet address (0x format)",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Optional limit (default: 50)",
+                    },
+                    offset: {
+                        type: "number",
+                        description: "Optional offset (default: 0)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["wallet"],
+            },
+        },
+        {
+            name: "history_transactions",
+            description: "Get transaction history. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    wallet: {
+                        type: "string",
+                        description: "Wallet address (0x format)",
+                    },
+                    limit: {
+                        type: "number",
+                        description: "Optional limit (default: 50)",
+                    },
+                    offset: {
+                        type: "number",
+                        description: "Optional offset (default: 0)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["wallet"],
+            },
+        },
+        // Automation
+        {
+            name: "automation_alerts",
+            description: "List, create, or delete alerts. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    wallet: {
+                        type: "string",
+                        description: "Wallet address (0x format)",
+                    },
+                    type: {
+                        type: "string",
+                        enum: ["price", "volume", "mcap"],
+                        description: "Alert type (for POST)",
+                    },
+                    tokenIdentifier: {
+                        type: "string",
+                        description: "Token identifier (for POST)",
+                    },
+                    condition: {
+                        type: "string",
+                        enum: [">", "<", ">=", "<="],
+                        description: "Condition (for POST)",
+                    },
+                    value: {
+                        type: "string",
+                        description: "Value (for POST)",
+                    },
+                    webhookUrl: {
+                        type: "string",
+                        description: "Optional webhook URL (for POST)",
+                    },
+                    alertId: {
+                        type: "string",
+                        description: "Alert ID (for DELETE)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["wallet"],
+            },
+        },
+        {
+            name: "automation_webhooks",
+            description: "List or register webhooks. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    wallet: {
+                        type: "string",
+                        description: "Wallet address (0x format)",
+                    },
+                    url: {
+                        type: "string",
+                        description: "Webhook URL (for POST)",
+                    },
+                    events: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Events array (for POST)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["wallet"],
+            },
+        },
+        {
+            name: "automation_jobs",
+            description: "Run automation job. Costs $0.01 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    jobType: {
+                        type: "string",
+                        description: "Job type",
+                    },
+                    parameters: {
+                        type: "object",
+                        description: "Job parameters",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["jobType", "parameters"],
+            },
+        },
+        {
+            name: "automation_jobs_status",
+            description: "Get job status. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    jobId: {
+                        type: "string",
+                        description: "Job ID (UUID)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["jobId"],
+            },
+        },
+        // System
+        {
+            name: "system_status",
+            description: "Get system status. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+            },
+        },
+        {
+            name: "system_limits",
+            description: "Get rate limits. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+            },
+        },
+        {
+            name: "system_sources",
+            description: "Get data sources. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+            },
+        },
+        // Agent
+        {
+            name: "agent_context",
+            description: "Get agent context. Costs $0.01 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    agentId: {
+                        type: "string",
+                        description: "Optional agent ID",
+                    },
+                    includeHistory: {
+                        type: "boolean",
+                        description: "Optional include history flag",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+            },
+        },
+        // Tools - Address
+        {
+            name: "tools_address_validate",
+            description: "Validate Ethereum address format. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    address: {
+                        type: "string",
+                        description: "Address to validate",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["address"],
+            },
+        },
+        {
+            name: "tools_address_checksum",
+            description: "Convert address to EIP-55 checksum format. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    address: {
+                        type: "string",
+                        description: "Address to checksum",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["address"],
+            },
+        },
+        {
+            name: "tools_address_derive",
+            description: "Derive address from private key. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    privateKey: {
+                        type: "string",
+                        description: "Private key (0x-prefixed hex)",
+                    },
+                },
+                required: ["privateKey"],
+            },
+        },
+        {
+            name: "tools_address_balance",
+            description: "Get balance for address (ETH + tokens). Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    address: {
+                        type: "string",
+                        description: "Address (0x format)",
+                    },
+                    tokens: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Optional token addresses",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["address"],
+            },
+        },
+        // Tools - ABI
+        {
+            name: "tools_abi_encode",
+            description: "Encode function call from ABI and arguments. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    abi: {
+                        type: "array",
+                        description: "ABI JSON array",
+                    },
+                    functionName: {
+                        type: "string",
+                        description: "Function name",
+                    },
+                    args: {
+                        type: "array",
+                        description: "Function arguments",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["abi", "functionName", "args"],
+            },
+        },
+        {
+            name: "tools_abi_decode",
+            description: "Decode function result or event log. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    abi: {
+                        type: "array",
+                        description: "ABI JSON array",
+                    },
+                    data: {
+                        type: "string",
+                        description: "Data to decode (0x-prefixed hex)",
+                    },
+                    type: {
+                        type: "string",
+                        enum: ["function", "event"],
+                        description: "Type: function or event",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["abi", "data", "type"],
+            },
+        },
+        {
+            name: "tools_abi_parse",
+            description: "Parse ABI JSON and return structured format. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    abi: {
+                        type: "array",
+                        description: "ABI JSON array",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["abi"],
+            },
+        },
+        // Tools - Transaction
+        {
+            name: "tools_tx_build",
+            description: "Build complete transaction with auto-filled fields. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    to: {
+                        type: "string",
+                        description: "To address (0x format)",
+                    },
+                    data: {
+                        type: "string",
+                        description: "Optional data (0x-prefixed hex)",
+                    },
+                    value: {
+                        type: "string",
+                        description: "Optional value (wei)",
+                    },
+                    from: {
+                        type: "string",
+                        description: "Optional from address (0x format)",
+                    },
+                    gasLimit: {
+                        type: "string",
+                        description: "Optional gas limit (wei)",
+                    },
+                    gasPrice: {
+                        type: "string",
+                        description: "Optional gas price (wei)",
+                    },
+                    nonce: {
+                        type: "number",
+                        description: "Optional nonce",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["to"],
+            },
+        },
+        {
+            name: "tools_tx_encode",
+            description: "Encode transaction to RLP format. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    transaction: {
+                        type: "object",
+                        description: "Transaction object",
+                        properties: {
+                            to: { type: "string" },
+                            data: { type: "string" },
+                            value: { type: "string" },
+                            gasLimit: { type: "string" },
+                            gasPrice: { type: "string" },
+                            nonce: { type: "number" },
+                            chainId: { type: "number" },
+                        },
+                        required: ["to", "data", "value", "gasLimit", "gasPrice", "nonce", "chainId"],
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["transaction"],
+            },
+        },
+        {
+            name: "tools_tx_decode",
+            description: "Decode RLP transaction. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    rlp: {
+                        type: "string",
+                        description: "RLP data (0x-prefixed hex)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["rlp"],
+            },
+        },
+        {
+            name: "tools_tx_simulate",
+            description: "Enhanced transaction simulation with state analysis. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    transaction: {
+                        type: "object",
+                        description: "Transaction object",
+                        properties: {
+                            to: { type: "string" },
+                            data: { type: "string" },
+                            value: { type: "string" },
+                        },
+                        required: ["to", "data", "value"],
+                    },
+                    from: {
+                        type: "string",
+                        description: "Optional from address (0x format)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["transaction"],
+            },
+        },
+        {
+            name: "tools_tx_estimate_gas",
+            description: "Estimate gas for transaction. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    transaction: {
+                        type: "object",
+                        description: "Transaction object",
+                        properties: {
+                            to: { type: "string" },
+                            data: { type: "string" },
+                            value: { type: "string" },
+                        },
+                        required: ["to", "data", "value"],
+                    },
+                    from: {
+                        type: "string",
+                        description: "Optional from address (0x format)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["transaction"],
+            },
+        },
+        {
+            name: "tools_tx_prepare",
+            description: "Prepare transaction for signing. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    to: {
+                        type: "string",
+                        description: "To address (0x format)",
+                    },
+                    data: {
+                        type: "string",
+                        description: "Optional data (0x-prefixed hex)",
+                    },
+                    value: {
+                        type: "string",
+                        description: "Optional value (wei)",
+                    },
+                    from: {
+                        type: "string",
+                        description: "From address (0x format)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["to", "from"],
+            },
+        },
+        // Tools - Signature
+        {
+            name: "tools_signature_eip191",
+            description: "Prepare EIP-191 personal sign message. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    message: {
+                        type: "string",
+                        description: "Message to sign",
+                    },
+                    address: {
+                        type: "string",
+                        description: "Optional address for verification",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["message"],
+            },
+        },
+        {
+            name: "tools_signature_eip712",
+            description: "Prepare EIP-712 structured data signature. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    domain: {
+                        type: "object",
+                        description: "Domain object",
+                        properties: {
+                            name: { type: "string" },
+                            version: { type: "string" },
+                            chainId: { type: "number" },
+                            verifyingContract: { type: "string" },
+                        },
+                        required: ["name", "version", "chainId", "verifyingContract"],
+                    },
+                    types: {
+                        type: "object",
+                        description: "Types object",
+                    },
+                    message: {
+                        type: "object",
+                        description: "Message object",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["domain", "types", "message"],
+            },
+        },
+        {
+            name: "tools_signature_permit2",
+            description: "Prepare Permit2 signature message. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    token: {
+                        type: "string",
+                        description: "Token address (0x format)",
+                    },
+                    amount: {
+                        type: "string",
+                        description: "Amount (wei)",
+                    },
+                    spender: {
+                        type: "string",
+                        description: "Spender address (0x format)",
+                    },
+                    nonce: {
+                        type: "number",
+                        description: "Nonce",
+                    },
+                    deadline: {
+                        type: "number",
+                        description: "Deadline (Unix timestamp)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["token", "amount", "spender", "nonce", "deadline"],
+            },
+        },
+        // Sign Command - High-level signing operations
+        {
+            name: "sign_message",
+            description: "Sign a message using EIP-191 personal sign. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    message: {
+                        type: "string",
+                        description: "Message to sign",
+                    },
+                    verify: {
+                        type: "boolean",
+                        description: "Verify signature after signing",
+                        default: false,
+                    },
+                    format: {
+                        type: "string",
+                        enum: ["hex", "rsv", "compact"],
+                        description: "Signature format",
+                        default: "hex",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["message"],
+            },
+        },
+        {
+            name: "sign_file",
+            description: "Sign a file (hash + EIP-191 signature). Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    file: {
+                        type: "string",
+                        description: "File path to sign",
+                    },
+                    hashAlgorithm: {
+                        type: "string",
+                        enum: ["sha256", "keccak256"],
+                        description: "Hash algorithm",
+                        default: "sha256",
+                    },
+                    verify: {
+                        type: "boolean",
+                        description: "Verify signature after signing",
+                        default: false,
+                    },
+                    format: {
+                        type: "string",
+                        enum: ["hex", "rsv", "compact"],
+                        description: "Signature format",
+                        default: "hex",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["file"],
+            },
+        },
+        {
+            name: "sign_transaction",
+            description: "Sign a transaction (EIP-155). Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    transaction: {
+                        type: "object",
+                        description: "Transaction object",
+                        properties: {
+                            to: { type: "string", description: "To address (0x format)" },
+                            value: { type: "string", description: "Value in wei" },
+                            data: { type: "string", description: "Transaction data (0x-prefixed hex)" },
+                            gas: { type: "string", description: "Gas limit" },
+                            gasPrice: { type: "string", description: "Gas price" },
+                            nonce: { type: "number", description: "Nonce" },
+                        },
+                        required: ["to"],
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["transaction"],
+            },
+        },
+        {
+            name: "sign_eip712",
+            description: "Sign EIP-712 structured data. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    domain: {
+                        type: "object",
+                        description: "EIP-712 domain",
+                    },
+                    types: {
+                        type: "object",
+                        description: "EIP-712 types",
+                    },
+                    message: {
+                        type: "object",
+                        description: "EIP-712 message",
+                    },
+                    verify: {
+                        type: "boolean",
+                        description: "Verify signature after signing",
+                        default: false,
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["domain", "types", "message"],
+            },
+        },
+        {
+            name: "sign_permit2",
+            description: "Sign Permit2 token authorization. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    token: {
+                        type: "string",
+                        description: "Token address (0x format)",
+                    },
+                    amount: {
+                        type: "string",
+                        description: "Amount in wei",
+                    },
+                    spender: {
+                        type: "string",
+                        description: "Spender address (0x format)",
+                    },
+                    nonce: {
+                        type: "number",
+                        description: "Nonce (auto-generated if not provided)",
+                    },
+                    deadline: {
+                        type: "number",
+                        description: "Deadline Unix timestamp (auto-generated if not provided)",
+                    },
+                    verify: {
+                        type: "boolean",
+                        description: "Verify signature after signing",
+                        default: false,
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["token", "amount", "spender"],
+            },
+        },
+        {
+            name: "sign_batch",
+            description: "Batch sign multiple messages/files. Costs $0.001 USDC per item.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    messages: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Array of messages to sign",
+                    },
+                    files: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                path: { type: "string" },
+                                hashAlgorithm: {
+                                    type: "string",
+                                    enum: ["sha256", "keccak256"],
+                                    default: "sha256",
+                                },
+                            },
+                            required: ["path"],
+                        },
+                        description: "Array of files to sign",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+            },
+        },
+        {
+            name: "sign_verify",
+            description: "Verify a signature. FREE.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    signature: {
+                        type: "string",
+                        description: "Signature to verify (hex format)",
+                    },
+                    message: {
+                        type: "string",
+                        description: "Original message (string for EIP-191, JSON string for EIP-712)",
+                    },
+                    type: {
+                        type: "string",
+                        enum: ["eip191", "eip712"],
+                        description: "Signature type",
+                        default: "eip191",
+                    },
+                    domain: {
+                        type: "object",
+                        description: "EIP-712 domain (required for eip712 type)",
+                    },
+                    types: {
+                        type: "object",
+                        description: "EIP-712 types (required for eip712 type)",
+                    },
+                    primaryType: {
+                        type: "string",
+                        description: "EIP-712 primary type (required for eip712 type)",
+                    },
+                },
+                required: ["signature", "message"],
+            },
+        },
+        // Tools - Multicall
+        {
+            name: "tools_multicall_encode",
+            description: "Encode multicall operation. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    calls: {
+                        type: "array",
+                        description: "Calls array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                target: { type: "string" },
+                                data: { type: "string" },
+                            },
+                            required: ["target", "data"],
+                        },
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["calls"],
+            },
+        },
+        {
+            name: "tools_multicall_decode",
+            description: "Decode multicall results. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    data: {
+                        type: "string",
+                        description: "Data to decode (0x-prefixed hex)",
+                    },
+                    calls: {
+                        type: "array",
+                        description: "Calls array (same as encode input)",
+                        items: {
+                            type: "object",
+                            properties: {
+                                target: { type: "string" },
+                                data: { type: "string" },
+                            },
+                            required: ["target", "data"],
+                        },
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["data", "calls"],
+            },
+        },
+        // Tools - Nonce
+        {
+            name: "tools_nonce_get",
+            description: "Get current nonce for address. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    address: {
+                        type: "string",
+                        description: "Address (0x format)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["address"],
+            },
+        },
+        {
+            name: "tools_nonce_predict",
+            description: "Predict next nonce accounting for pending transactions. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    address: {
+                        type: "string",
+                        description: "Address (0x format)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["address"],
+            },
+        },
+        // Tools - Gas
+        {
+            name: "tools_gas_price",
+            description: "Get current gas price. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+            },
+        },
+        {
+            name: "tools_gas_estimate",
+            description: "Estimate gas for operation. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    transaction: {
+                        type: "object",
+                        description: "Transaction object",
+                        properties: {
+                            to: { type: "string" },
+                            data: { type: "string" },
+                            value: { type: "string" },
+                        },
+                        required: ["to", "data", "value"],
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["transaction"],
+            },
+        },
+        {
+            name: "tools_gas_optimize",
+            description: "Optimize gas settings for transaction. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    transaction: {
+                        type: "object",
+                        description: "Transaction object",
+                        properties: {
+                            to: { type: "string" },
+                            data: { type: "string" },
+                            value: { type: "string" },
+                        },
+                        required: ["to", "data", "value"],
+                    },
+                    priority: {
+                        type: "string",
+                        enum: ["low", "medium", "high"],
+                        description: "Optional priority",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["transaction"],
+            },
+        },
+        // Tools - Key
+        {
+            name: "tools_key_derive",
+            description: "Derive address from private key. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    privateKey: {
+                        type: "string",
+                        description: "Private key (0x-prefixed hex)",
+                    },
+                },
+                required: ["privateKey"],
+            },
+        },
+        {
+            name: "tools_key_validate",
+            description: "Validate private key format. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    privateKey: {
+                        type: "string",
+                        description: "Private key to validate",
+                    },
+                },
+                required: ["privateKey"],
+            },
+        },
+        // Tools - RPC
+        {
+            name: "tools_rpc_proxy",
+            description: "Enhanced JSON-RPC proxy. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    method: {
+                        type: "string",
+                        description: "RPC method name (e.g., 'eth_getBalance')",
+                    },
+                    params: {
+                        type: "array",
+                        description: "Method parameters",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["method", "params"],
+            },
+        },
+        {
+            name: "tools_rpc_batch",
+            description: "Batch multiple RPC calls. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    requests: {
+                        type: "array",
+                        description: "RPC requests array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                method: { type: "string" },
+                                params: { type: "array" },
+                                id: { type: "number" },
+                            },
+                            required: ["method", "params"],
+                        },
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["requests"],
+            },
+        },
+        {
+            name: "tools_rpc_health",
+            description: "Check RPC endpoint health. Costs $0.001 USDC.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+            },
+        },
+        // Additional Free Endpoints
+        {
+            name: "resolve_tokens",
+            description: "Batch lookup token metadata (name, symbol, decimals, totalSupply) for multiple tokens. Free - no payment required.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    tokens: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Token addresses (max 50, 0x format)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["tokens"],
+            },
+        },
+        {
+            name: "wallet_portfolio",
+            description: "Get all token balances for a wallet address. Free - no payment required.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    wallet: {
+                        type: "string",
+                        description: "Wallet address (0x format)",
+                    },
+                    tokens: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Optional token addresses (max 100, 0x format)",
+                    },
+                    includeMetadata: {
+                        type: "boolean",
+                        description: "Optional include metadata (default: true)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+                required: ["wallet"],
+            },
+        },
+        // Predictions Stream
+        {
+            name: "predictions_stream",
+            description: "Real-time market updates via Server-Sent Events (SSE). Returns connection info. Free - no payment required.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    venues: {
+                        type: "string",
+                        description: "Comma-separated venues (Polymarket,Azuro)",
+                    },
+                    sports: {
+                        type: "string",
+                        description: "Comma-separated sports for Azuro filtering",
+                    },
+                    min_volume: {
+                        type: "number",
+                        description: "Minimum 24h volume filter",
+                    },
+                    poll_interval: {
+                        type: "number",
+                        description: "Seconds between updates (2-60)",
+                    },
+                    realtime: {
+                        type: "boolean",
+                        description: "Use WebSocket feeds (default: false for poll-based)",
+                    },
+                    privateKey: {
+                        type: "string",
+                        description: "Optional private key (overrides config and env var). If not provided, uses HTTPCAT_PRIVATE_KEY env var or config file.",
+                    },
+                },
+            },
+        },
+    ];
+    // Filter based on admin commands if user is not admin
+    const isAdmin = isCurrentUserAdmin();
+    if (isAdmin) {
+        // Admin users see all tools
+        return allTools;
+    }
+    // Non-admin: filter tools based on HTTPCAT_ADMIN_COMMANDS
+    const adminCommands = getAdminCommands();
+    if (adminCommands.length === 0) {
+        // No admin commands configured, show all tools
+        return allTools;
+    }
+    const adminCommandSet = new Set(adminCommands.map((cmd) => cmd.trim().toLowerCase()));
+    return allTools.filter((tool) => {
+        const commandName = toolNameToCommandName(tool.name);
+        if (!commandName) {
+            // If we can't map it, show it (fail open)
+            return true;
+        }
+        // Hide tool if its command is in admin list
+        return !adminCommandSet.has(commandName.toLowerCase());
+    });
+}
+// Generate a unique response ID
+function generateResponseId() {
+    return `resp_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+}
+export async function handleTool(name, args) {
+    const responseId = generateResponseId();
+    try {
+        let result;
+        switch (name) {
+            case "create_token": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                result = await createToken(client, {
+                    name: params.name,
+                    symbol: params.symbol,
+                    photoUrl: params.photoUrl,
+                    websiteUrl: params.websiteUrl,
+                });
+                break;
+            }
+            case "buy_token": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const testMode = isTestMode(client);
+                result = await buyToken(client, params.identifier, params.amount, testMode, true // silent mode for MCP
+                );
+                break;
+            }
+            case "sell_token": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                // First get token info to check holdings
+                const info = await getTokenInfo(client, params.identifier, undefined, true // silent mode
+                );
+                if (!info.userPosition || info.userPosition.tokensOwned === "0") {
+                    throw new Error("You do not own any of this token");
+                }
+                const tokenAmount = parseTokenAmount(params.amount, info.userPosition.tokensOwned);
+                result = await sellToken(client, params.identifier, tokenAmount, true // silent mode
+                );
+                break;
+            }
+            case "token_info": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                result = await getTokenInfo(client, params.identifier, undefined, true // silent mode
+                );
+                break;
+            }
+            case "list_tokens": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                result = await listTokens(client, params.page || 1, params.limit || 20, params.sort || "mcap");
+                break;
+            }
+            case "positions": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                // Get user address from private key
+                const privateKey = resolvePrivateKey(params.privateKey);
+                if (!privateKey) {
+                    throw new Error("Private key required for positions command");
+                }
+                const account = privateKeyToAccount(privateKey);
+                const userAddress = account.address;
+                result = await getPositions(client, userAddress);
+                break;
+            }
+            case "check_balance": {
+                const params = args;
+                const resolvedKey = resolvePrivateKey(params.privateKey);
+                result = await checkBalance(resolvedKey);
+                break;
+            }
+            case "health_check": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                result = await checkHealth(client);
+                break;
+            }
+            case "chat_join": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const session = await getOrCreateChatSession(client, params.tokenIdentifier, resolvePrivateKey(params.privateKey));
+                result = {
+                    leaseId: session.leaseId,
+                    leaseExpiresAt: session.leaseExpiresAt.toISOString(),
+                    wsUrl: session.wsUrl,
+                    lastMessages: session.messages.slice(-20), // Last 20 messages
+                };
+                break;
+            }
+            case "chat_send_message": {
+                const params = args;
+                const session = getChatSession(params.leaseId);
+                if (!session) {
+                    throw new Error(`No active chat session found for leaseId: ${params.leaseId}. Use chat_join first.`);
+                }
+                result = await sendMessage(session, params.message);
+                break;
+            }
+            case "chat_renew_lease": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const session = await ensureValidSession(client, params.leaseId, resolvePrivateKey(params.privateKey));
+                result = {
+                    leaseId: session.leaseId,
+                    leaseExpiresAt: session.leaseExpiresAt.toISOString(),
+                };
+                break;
+            }
+            case "chat_get_recent_messages": {
+                const params = args;
+                const session = getChatSession(params.leaseId);
+                if (!session) {
+                    throw new Error(`No active chat session found for leaseId: ${params.leaseId}. Use chat_join first.`);
+                }
+                const messages = getRecentMessages(session, params.limit || 50);
+                result = { messages };
+                break;
+            }
+            case "view_fees": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const privateKey = resolvePrivateKey(params.privateKey);
+                if (!params.identifier) {
+                    // View all tokens
+                    if (!privateKey) {
+                        throw new Error("Private key required to view all your tokens");
+                    }
+                    const account = privateKeyToAccount(privateKey);
+                    const userAddress = account.address;
+                    const userTokens = await getUserCreatedTokens(client, userAddress);
+                    if (userTokens.length === 0) {
+                        result = { tokens: [], message: "No tokens created yet" };
+                    }
+                    else {
+                        const allFees = await getAllTokenFees(client, userTokens, true);
+                        result = {
+                            tokens: allFees.map((fees) => ({
+                                tokenId: fees.tokenId,
+                                tokenSymbol: fees.tokenSymbol,
+                                tokenName: fees.tokenName,
+                                feeToken: fees.feeToken,
+                                feePaired: fees.feePaired,
+                                creatorToken: fees.creatorToken,
+                                creatorPaired: fees.creatorPaired,
+                                error: 'error' in fees ? fees.error : undefined,
+                            })),
+                        };
+                    }
+                }
+                else {
+                    // View specific token
+                    result = await viewFees(client, params.identifier, true); // silent mode
+                }
+                break;
+            }
+            case "claim_fees": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                // Get user address from private key
+                const privateKey = resolvePrivateKey(params.privateKey);
+                if (!privateKey) {
+                    throw new Error("Private key required for claim_fees command");
+                }
+                const account = privateKeyToAccount(privateKey);
+                const userAddress = account.address;
+                if (params.identifier.toLowerCase() === 'all') {
+                    // Claim all tokens
+                    const userTokens = await getUserCreatedTokens(client, userAddress);
+                    if (userTokens.length === 0) {
+                        result = { tokens: [], message: "No tokens created yet" };
+                    }
+                    else {
+                        const results = await claimAllFees(client, userTokens, userAddress, true);
+                        result = {
+                            success: results.success,
+                            failed: results.failed,
+                        };
+                    }
+                }
+                else {
+                    // Claim specific token
+                    result = await claimFees(client, params.identifier, userAddress, true // silent mode
+                    );
+                }
+                break;
+            }
+            case "get_transactions": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                result = await getTransactions(client, {
+                    userAddress: params.userAddress,
+                    tokenId: params.tokenId,
+                    type: params.type,
+                    limit: params.limit,
+                    offset: params.offset,
+                });
+                break;
+            }
+            case "swap_tokens": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const privateKey = resolvePrivateKey(params.privateKey);
+                if (!privateKey) {
+                    throw new Error("Private key required for swap_tokens command");
+                }
+                result = await swap(client, params.tokenIn, params.tokenOut, params.amount, params.slippageBps || 50, true, // silent mode
+                privateKey);
+                break;
+            }
+            case "shielded_swap": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const privateKey = resolvePrivateKey(params.privateKey);
+                if (!privateKey) {
+                    throw new Error("Private key required for shielded_swap command");
+                }
+                result = await shieldedSwap(client, params.tokenIn, params.tokenOut, params.amount, params.slippageBps || 50, privateKey, true // silent mode
+                );
+                break;
+            }
+            case "gasless_swap_quote": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    tokenIn: params.tokenIn,
+                    tokenOut: params.tokenOut,
+                    amount: params.amount,
+                    taker: params.taker,
+                    ...(params.slippageBps !== undefined && {
+                        slippageBps: params.slippageBps,
+                    }),
+                };
+                const response = await client.invoke("swaps/gasless", input);
+                result = response.data;
+                break;
+            }
+            case "gasless_swap_status": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    tradeHash: params.tradeHash,
+                };
+                if (params.chainId !== undefined) {
+                    input.chainId = params.chainId;
+                }
+                const response = await client.invoke("swaps/gasless/status", input);
+                result = response.data;
+                break;
+            }
+            case "gasless_swap_submit": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    trade: params.trade,
+                };
+                if (params.chainId !== undefined) {
+                    input.chainId = params.chainId;
+                }
+                if (params.approval !== undefined) {
+                    input.approval = params.approval;
+                }
+                result = await submitGaslessSwap(client, input, true);
+                break;
+            }
+            case "gasless_swap_submit_our": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    tokenIn: params.tokenIn,
+                    tokenOut: params.tokenOut,
+                    totalAmount: params.totalAmount,
+                    feeAmount: params.feeAmount,
+                    taker: params.taker,
+                    permit2Signature: params.permit2Signature,
+                    permitNonce: params.permitNonce,
+                    permitDeadline: params.permitDeadline,
+                };
+                result = await submitGaslessSwapOur(client, input, true);
+                break;
+            }
+            case "rpc_proxy": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    jsonrpc: params.jsonrpc || "2.0",
+                    id: params.id,
+                    method: params.method,
+                    params: params.params,
+                };
+                const response = await client.invoke("rpc/proxy", input);
+                // The response should be in the format { output: { jsonrpc, id, result/error } }
+                result = response.data;
+                break;
+            }
+            case "call_x402_endpoint": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                result = await client.callX402Endpoint(params.url, {
+                    method: params.method || "POST",
+                    body: params.body,
+                    headers: params.headers,
+                });
+                break;
+            }
+            case "perps_markets": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {};
+                if (params.platform)
+                    input.platform = params.platform;
+                if (params.symbol)
+                    input.symbol = params.symbol;
+                result = await getPerpsMarkets(client, input, true);
+                break;
+            }
+            case "perps_onboard": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                result = await onboardPerps(client, params.wallet, true);
+                break;
+            }
+            case "perps_deposit": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    amount: params.amount,
+                    wallet: params.wallet,
+                };
+                if (params.venue)
+                    input.venue = params.venue;
+                if (params.chain)
+                    input.chain = params.chain;
+                result = await depositPerps(client, input, true);
+                break;
+            }
+            case "perps_trade": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    market: params.market,
+                    side: params.side,
+                    sizeUsd: params.sizeUsd,
+                    leverage: params.leverage,
+                    wallet: params.wallet,
+                };
+                if (params.orderType)
+                    input.orderType = params.orderType;
+                if (params.price)
+                    input.price = params.price;
+                result = await tradePerps(client, input, true);
+                break;
+            }
+            case "perps_positions": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    wallet: params.wallet,
+                };
+                if (params.venue)
+                    input.venue = params.venue;
+                if (params.asterApiKey)
+                    input.asterApiKey = params.asterApiKey;
+                if (params.asterApiSecret)
+                    input.asterApiSecret = params.asterApiSecret;
+                result = await getPerpsPositions(client, input, true);
+                break;
+            }
+            case "predictions_markets": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {};
+                if (params.venue)
+                    input.venue = params.venue;
+                if (params.category)
+                    input.category = params.category;
+                if (params.limit)
+                    input.limit = params.limit;
+                if (params.sort)
+                    input.sort = params.sort;
+                result = await getPredictionMarkets(client, input, true);
+                break;
+            }
+            case "predictions_market": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                result = await getPredictionMarket(client, params.marketId, true);
+                break;
+            }
+            case "predictions_search": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    query: params.query,
+                };
+                if (params.venue)
+                    input.venue = params.venue;
+                if (params.limit)
+                    input.limit = params.limit;
+                result = await searchPredictionMarkets(client, input, true);
+                break;
+            }
+            case "predictions_bet": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    marketId: params.marketId,
+                    outcomeId: params.outcomeId,
+                    amountUsd: params.amountUsd,
+                    wallet: params.wallet,
+                };
+                if (params.polymarketApiKey)
+                    input.polymarketApiKey = params.polymarketApiKey;
+                if (params.polymarketApiSecret)
+                    input.polymarketApiSecret = params.polymarketApiSecret;
+                result = await placePredictionBet(client, input, true);
+                break;
+            }
+            case "predictions_detect_arbs": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {};
+                if (params.minSpreadPct !== undefined)
+                    input.minSpreadPct = params.minSpreadPct;
+                if (params.venues)
+                    input.venues = params.venues;
+                if (params.cryptoOnly !== undefined)
+                    input.cryptoOnly = params.cryptoOnly;
+                if (params.maxResults !== undefined)
+                    input.maxResults = params.maxResults;
+                result = await detectPredictionArbs(client, input, true);
+                break;
+            }
+            case "predictions_calculate_hedge": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    marketA: params.marketA,
+                    marketB: params.marketB,
+                    positionSizeUsd: params.positionSizeUsd,
+                    currentPrice: params.currentPrice,
+                };
+                if (params.fundingRate8h !== undefined)
+                    input.fundingRate8h = params.fundingRate8h;
+                result = await calculatePredictionHedge(client, input, true);
+                break;
+            }
+            case "predictions_execute_arb": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    marketA: params.marketA,
+                    marketB: params.marketB,
+                    positionSizeUsd: params.positionSizeUsd,
+                    wallet: params.wallet,
+                };
+                if (params.autoHedge !== undefined)
+                    input.autoHedge = params.autoHedge;
+                if (params.maxSlippagePct !== undefined)
+                    input.maxSlippagePct = params.maxSlippagePct;
+                if (params.currentPrice !== undefined)
+                    input.currentPrice = params.currentPrice;
+                result = await executePredictionArb(client, input, true);
+                break;
+            }
+            case "predictions_detect_insiders": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {};
+                if (params.timeWindowMinutes !== undefined)
+                    input.timeWindowMinutes = params.timeWindowMinutes;
+                if (params.minTrades !== undefined)
+                    input.minTrades = params.minTrades;
+                if (params.minSimilarity !== undefined)
+                    input.minSimilarity = params.minSimilarity;
+                if (params.includeCommunities !== undefined)
+                    input.includeCommunities = params.includeCommunities;
+                if (params.maxResults !== undefined)
+                    input.maxResults = params.maxResults;
+                if (params.assetFilter)
+                    input.assetFilter = params.assetFilter;
+                if (params.trades)
+                    input.trades = params.trades;
+                result = await detectPredictionInsiders(client, input, true);
+                break;
+            }
+            // Market Intelligence
+            case "market_price": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { tokenIdentifier: params.tokenIdentifier };
+                if (params.timeframe)
+                    input.timeframe = params.timeframe;
+                const response = await client.invoke("market/price", input);
+                result = response.data;
+                break;
+            }
+            case "market_ohlc": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { tokenIdentifier: params.tokenIdentifier };
+                if (params.interval)
+                    input.interval = params.interval;
+                if (params.limit !== undefined)
+                    input.limit = params.limit;
+                const response = await client.invoke("market/ohlc", input);
+                result = response.data;
+                break;
+            }
+            case "market_liquidity": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { tokenIdentifier: params.tokenIdentifier };
+                if (params.depth !== undefined)
+                    input.depth = params.depth;
+                const response = await client.invoke("market/liquidity", input);
+                result = response.data;
+                break;
+            }
+            case "market_price_impact": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    tokenIdentifier: params.tokenIdentifier,
+                    amount: params.amount,
+                    side: params.side,
+                };
+                const response = await client.invoke("market/price-impact", input);
+                result = response.data;
+                break;
+            }
+            case "token_holders_top": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { tokenIdentifier: params.tokenIdentifier };
+                if (params.limit !== undefined)
+                    input.limit = params.limit;
+                const response = await client.invoke("token/holders/top", input);
+                result = response.data;
+                break;
+            }
+            case "token_distribution": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { tokenIdentifier: params.tokenIdentifier };
+                const response = await client.invoke("token/distribution", input);
+                result = response.data;
+                break;
+            }
+            case "token_supply": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { tokenIdentifier: params.tokenIdentifier };
+                const response = await client.invoke("token/supply", input);
+                result = response.data;
+                break;
+            }
+            case "token_unlocks": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { tokenIdentifier: params.tokenIdentifier };
+                const response = await client.invoke("token/unlocks", input);
+                result = response.data;
+                break;
+            }
+            // Security
+            case "security_token_scan": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { tokenAddress: params.tokenAddress };
+                const response = await client.invoke("security/token-scan", input);
+                result = response.data;
+                break;
+            }
+            case "security_allowances": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    wallet: params.wallet,
+                    token: params.token,
+                };
+                if (params.spender)
+                    input.spender = params.spender;
+                const response = await client.invoke("security/allowances", input);
+                result = response.data;
+                break;
+            }
+            case "security_revoke_allowance": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    token: params.token,
+                    spender: params.spender,
+                    wallet: params.wallet,
+                };
+                const response = await client.invoke("security/revoke-allowance", input);
+                result = response.data;
+                break;
+            }
+            // Risk
+            case "risk_policy": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { wallet: params.wallet };
+                // If any policy fields are provided, it's a POST (set policy)
+                if (params.maxPositionSize !== undefined ||
+                    params.maxLeverage !== undefined ||
+                    params.allowedTokens !== undefined ||
+                    params.blockedTokens !== undefined) {
+                    if (params.maxPositionSize !== undefined)
+                        input.maxPositionSize = params.maxPositionSize;
+                    if (params.maxLeverage !== undefined)
+                        input.maxLeverage = params.maxLeverage;
+                    if (params.allowedTokens !== undefined)
+                        input.allowedTokens = params.allowedTokens;
+                    if (params.blockedTokens !== undefined)
+                        input.blockedTokens = params.blockedTokens;
+                }
+                const response = await client.invoke("risk/policy", input);
+                result = response.data;
+                break;
+            }
+            case "risk_evaluate": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    wallet: params.wallet,
+                    trade: params.trade,
+                };
+                const response = await client.invoke("risk/evaluate", input);
+                result = response.data;
+                break;
+            }
+            // Trading
+            case "trade_preview": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    tokenIn: params.tokenIn,
+                    tokenOut: params.tokenOut,
+                    amount: params.amount,
+                };
+                if (params.slippageBps !== undefined)
+                    input.slippageBps = params.slippageBps;
+                const response = await client.invoke("trade/preview", input);
+                result = response.data;
+                break;
+            }
+            case "tx_simulate": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { transaction: params.transaction };
+                if (params.from)
+                    input.from = params.from;
+                const response = await client.invoke("tx/simulate", input);
+                result = response.data;
+                break;
+            }
+            // Opportunities
+            case "opps_arbitrage": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {};
+                if (params.minProfit !== undefined)
+                    input.minProfit = params.minProfit;
+                if (params.tokens !== undefined)
+                    input.tokens = params.tokens;
+                const response = await client.invoke("opps/arbitrage", input);
+                result = response.data;
+                break;
+            }
+            case "opps_funding": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {};
+                if (params.minRate !== undefined)
+                    input.minRate = params.minRate;
+                const response = await client.invoke("opps/funding", input);
+                result = response.data;
+                break;
+            }
+            case "opps_yield": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {};
+                if (params.minApy !== undefined)
+                    input.minApy = params.minApy;
+                const response = await client.invoke("opps/yield", input);
+                result = response.data;
+                break;
+            }
+            case "opps_liquidations": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {};
+                if (params.minProfit !== undefined)
+                    input.minProfit = params.minProfit;
+                const response = await client.invoke("opps/liquidations", input);
+                result = response.data;
+                break;
+            }
+            case "opps_execute": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    opportunityId: params.opportunityId,
+                    wallet: params.wallet,
+                };
+                if (params.amount !== undefined)
+                    input.amount = params.amount;
+                const response = await client.invoke("opps/execute", input);
+                result = response.data;
+                break;
+            }
+            // Portfolio
+            case "portfolio_summary": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { wallet: params.wallet };
+                const response = await client.invoke("portfolio/summary", input);
+                result = response.data;
+                break;
+            }
+            case "portfolio_pnl": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { wallet: params.wallet };
+                if (params.timeframe !== undefined)
+                    input.timeframe = params.timeframe;
+                const response = await client.invoke("portfolio/pnl", input);
+                result = response.data;
+                break;
+            }
+            case "history_trades": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { wallet: params.wallet };
+                if (params.limit !== undefined)
+                    input.limit = params.limit;
+                if (params.offset !== undefined)
+                    input.offset = params.offset;
+                const response = await client.invoke("history/trades", input);
+                result = response.data;
+                break;
+            }
+            case "history_transactions": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { wallet: params.wallet };
+                if (params.limit !== undefined)
+                    input.limit = params.limit;
+                if (params.offset !== undefined)
+                    input.offset = params.offset;
+                const response = await client.invoke("history/transactions", input);
+                result = response.data;
+                break;
+            }
+            // Automation
+            case "automation_alerts": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                // DELETE if alertId is provided
+                if (params.alertId) {
+                    const input = { alertId: params.alertId };
+                    const response = await client.invoke("automation/alerts", input);
+                    result = response.data;
+                }
+                // POST if type and other fields are provided
+                else if (params.type && params.tokenIdentifier && params.condition && params.value) {
+                    const input = {
+                        wallet: params.wallet,
+                        type: params.type,
+                        tokenIdentifier: params.tokenIdentifier,
+                        condition: params.condition,
+                        value: params.value,
+                    };
+                    if (params.webhookUrl)
+                        input.webhookUrl = params.webhookUrl;
+                    const response = await client.invoke("automation/alerts", input);
+                    result = response.data;
+                }
+                // GET (list alerts)
+                else {
+                    const input = { wallet: params.wallet };
+                    const response = await client.invoke("automation/alerts", input);
+                    result = response.data;
+                }
+                break;
+            }
+            case "automation_webhooks": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                // POST if url and events are provided
+                if (params.url && params.events) {
+                    const input = {
+                        wallet: params.wallet,
+                        url: params.url,
+                        events: params.events,
+                    };
+                    const response = await client.invoke("automation/webhooks", input);
+                    result = response.data;
+                }
+                // GET (list webhooks)
+                else {
+                    const input = { wallet: params.wallet };
+                    const response = await client.invoke("automation/webhooks", input);
+                    result = response.data;
+                }
+                break;
+            }
+            case "automation_jobs": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    jobType: params.jobType,
+                    parameters: params.parameters,
+                };
+                const response = await client.invoke("automation/jobs", input);
+                result = response.data;
+                break;
+            }
+            case "automation_jobs_status": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { jobId: params.jobId };
+                const response = await client.invoke("automation/jobs/status", input);
+                result = response.data;
+                break;
+            }
+            // System
+            case "system_status": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const response = await client.invoke("system/status", {});
+                result = response.data;
+                break;
+            }
+            case "system_limits": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const response = await client.invoke("system/limits", {});
+                result = response.data;
+                break;
+            }
+            case "system_sources": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const response = await client.invoke("system/sources", {});
+                result = response.data;
+                break;
+            }
+            // Agent
+            case "agent_context": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {};
+                if (params.agentId !== undefined)
+                    input.agentId = params.agentId;
+                if (params.includeHistory !== undefined)
+                    input.includeHistory = params.includeHistory;
+                const response = await client.invoke("agent/context", input);
+                result = response.data;
+                break;
+            }
+            // Tools - Address
+            case "tools_address_validate": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { address: params.address };
+                const response = await client.invoke("tools/address/validate", input);
+                result = response.data;
+                break;
+            }
+            case "tools_address_checksum": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { address: params.address };
+                const response = await client.invoke("tools/address/checksum", input);
+                result = response.data;
+                break;
+            }
+            case "tools_address_derive": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { privateKey: params.privateKey };
+                const response = await client.invoke("tools/address/derive", input);
+                result = response.data;
+                break;
+            }
+            case "tools_address_balance": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { address: params.address };
+                if (params.tokens !== undefined)
+                    input.tokens = params.tokens;
+                const response = await client.invoke("tools/address/balance", input);
+                result = response.data;
+                break;
+            }
+            // Tools - ABI
+            case "tools_abi_encode": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    abi: params.abi,
+                    functionName: params.functionName,
+                    args: params.args,
+                };
+                const response = await client.invoke("tools/abi/encode", input);
+                result = response.data;
+                break;
+            }
+            case "tools_abi_decode": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    abi: params.abi,
+                    data: params.data,
+                    type: params.type,
+                };
+                const response = await client.invoke("tools/abi/decode", input);
+                result = response.data;
+                break;
+            }
+            case "tools_abi_parse": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { abi: params.abi };
+                const response = await client.invoke("tools/abi/parse", input);
+                result = response.data;
+                break;
+            }
+            // Tools - Transaction
+            case "tools_tx_build": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { to: params.to };
+                if (params.data !== undefined)
+                    input.data = params.data;
+                if (params.value !== undefined)
+                    input.value = params.value;
+                if (params.from !== undefined)
+                    input.from = params.from;
+                if (params.gasLimit !== undefined)
+                    input.gasLimit = params.gasLimit;
+                if (params.gasPrice !== undefined)
+                    input.gasPrice = params.gasPrice;
+                if (params.nonce !== undefined)
+                    input.nonce = params.nonce;
+                const response = await client.invoke("tools/tx/build", input);
+                result = response.data;
+                break;
+            }
+            case "tools_tx_encode": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { transaction: params.transaction };
+                const response = await client.invoke("tools/tx/encode", input);
+                result = response.data;
+                break;
+            }
+            case "tools_tx_decode": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { rlp: params.rlp };
+                const response = await client.invoke("tools/tx/decode", input);
+                result = response.data;
+                break;
+            }
+            case "tools_tx_simulate": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { transaction: params.transaction };
+                if (params.from !== undefined)
+                    input.from = params.from;
+                const response = await client.invoke("tools/tx/simulate", input);
+                result = response.data;
+                break;
+            }
+            case "tools_tx_estimate_gas": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { transaction: params.transaction };
+                if (params.from !== undefined)
+                    input.from = params.from;
+                const response = await client.invoke("tools/tx/estimate-gas", input);
+                result = response.data;
+                break;
+            }
+            case "tools_tx_prepare": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { to: params.to, from: params.from };
+                if (params.data !== undefined)
+                    input.data = params.data;
+                if (params.value !== undefined)
+                    input.value = params.value;
+                const response = await client.invoke("tools/tx/prepare", input);
+                result = response.data;
+                break;
+            }
+            // Tools - Signature
+            case "tools_signature_eip191": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { message: params.message };
+                if (params.address !== undefined)
+                    input.address = params.address;
+                const response = await client.invoke("tools/signature/eip191", input);
+                result = response.data;
+                break;
+            }
+            case "tools_signature_eip712": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    domain: params.domain,
+                    types: params.types,
+                    message: params.message,
+                };
+                const response = await client.invoke("tools/signature/eip712", input);
+                result = response.data;
+                break;
+            }
+            case "tools_signature_permit2": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    token: params.token,
+                    amount: params.amount,
+                    spender: params.spender,
+                    nonce: params.nonce,
+                    deadline: params.deadline,
+                };
+                const response = await client.invoke("tools/signature/permit2", input);
+                result = response.data;
+                break;
+            }
+            // Sign Command - High-level signing operations
+            case "sign_message": {
+                const params = args;
+                const { privateKeyToAccount } = await import("viem/accounts");
+                const { recoverMessageAddress, hashMessage } = await import("viem");
+                const privateKey = resolvePrivateKey(params.privateKey);
+                if (!privateKey) {
+                    throw new Error("Private key required for signing");
+                }
+                const account = privateKeyToAccount(privateKey);
+                // Compute message hash locally (no API call needed)
+                const messageHash = hashMessage(params.message);
+                // Sign locally
+                const signature = await account.signMessage({ message: params.message });
+                const signerAddress = account.address;
+                let verified = false;
+                if (params.verify) {
+                    const recovered = await recoverMessageAddress({
+                        message: params.message,
+                        signature,
+                    });
+                    verified = recovered.toLowerCase() === signerAddress.toLowerCase();
+                }
+                result = {
+                    type: "eip191",
+                    message: params.message,
+                    messageHash: messageHash,
+                    signature,
+                    signer: signerAddress,
+                    verified,
+                };
+                break;
+            }
+            case "sign_file": {
+                const params = args;
+                const { privateKeyToAccount } = await import("viem/accounts");
+                const { recoverMessageAddress, hashMessage, keccak256 } = await import("viem");
+                const { readFileSync, existsSync } = await import("fs");
+                const { createHash } = await import("crypto");
+                const privateKey = resolvePrivateKey(params.privateKey);
+                if (!privateKey) {
+                    throw new Error("Private key required for signing");
+                }
+                const account = privateKeyToAccount(privateKey);
+                if (!existsSync(params.file)) {
+                    throw new Error(`File not found: ${params.file}`);
+                }
+                const fileContent = readFileSync(params.file);
+                const hashAlgo = params.hashAlgorithm || "sha256";
+                let fileHash;
+                if (hashAlgo === "sha256") {
+                    fileHash = createHash("sha256").update(fileContent).digest("hex");
+                }
+                else {
+                    const hexString = `0x${fileContent.toString("hex")}`;
+                    fileHash = keccak256(hexString).slice(2);
+                }
+                const fileHashHex = `0x${fileHash}`;
+                // Compute message hash locally (no API call needed)
+                const messageHash = hashMessage(fileHashHex);
+                // Sign locally
+                const signature = await account.signMessage({ message: fileHashHex });
+                const signerAddress = account.address;
+                let verified = false;
+                if (params.verify) {
+                    const recovered = await recoverMessageAddress({
+                        message: fileHashHex,
+                        signature,
+                    });
+                    verified = recovered.toLowerCase() === signerAddress.toLowerCase();
+                }
+                result = {
+                    type: "file",
+                    file: params.file,
+                    fileHash: fileHashHex,
+                    hashAlgorithm: hashAlgo,
+                    messageHash: messageHash,
+                    signature,
+                    signer: signerAddress,
+                    verified,
+                };
+                break;
+            }
+            case "sign_transaction": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                // Prepare transaction via backend
+                const prepareResult = await client.invoke("tools/tx/prepare", params.transaction);
+                result = {
+                    transaction: prepareResult.data.transaction,
+                    messageHash: prepareResult.data.messageHash,
+                    note: "Transaction prepared. Use send_transaction or another method to execute.",
+                };
+                break;
+            }
+            case "sign_eip712": {
+                const params = args;
+                const { privateKeyToAccount } = await import("viem/accounts");
+                const { recoverTypedDataAddress, hashTypedData } = await import("viem");
+                const privateKey = resolvePrivateKey(params.privateKey);
+                if (!privateKey) {
+                    throw new Error("Private key required for signing");
+                }
+                const account = privateKeyToAccount(privateKey);
+                // Compute message hash locally (no API call needed)
+                const primaryType = Object.keys(params.types).find((k) => k !== "EIP712Domain") || "Message";
+                const messageHash = hashTypedData({
+                    domain: params.domain,
+                    types: params.types,
+                    primaryType: primaryType,
+                    message: params.message,
+                });
+                // Sign locally
+                const signature = await account.signTypedData({
+                    domain: params.domain,
+                    types: params.types,
+                    primaryType,
+                    message: params.message,
+                });
+                const signerAddress = account.address;
+                let verified = false;
+                if (params.verify) {
+                    const recovered = await recoverTypedDataAddress({
+                        domain: params.domain,
+                        types: params.types,
+                        primaryType,
+                        message: params.message,
+                        signature,
+                    });
+                    verified = recovered.toLowerCase() === signerAddress.toLowerCase();
+                }
+                result = {
+                    type: "eip712",
+                    domain: params.domain,
+                    types: params.types,
+                    message: params.message,
+                    messageHash: messageHash,
+                    signature,
+                    signer: signerAddress,
+                    verified,
+                };
+                break;
+            }
+            case "sign_permit2": {
+                const params = args;
+                const { privateKeyToAccount } = await import("viem/accounts");
+                const { recoverTypedDataAddress, hashTypedData } = await import("viem");
+                const { getNetworkConfig } = await import("../utils/constants.js");
+                const { config } = await import("../config.js");
+                const privateKey = resolvePrivateKey(params.privateKey);
+                if (!privateKey) {
+                    throw new Error("Private key required for signing");
+                }
+                const account = privateKeyToAccount(privateKey);
+                // Get network for chain ID
+                const network = config.get("network") || "eip155:84532";
+                const { chain } = await getNetworkConfig(network);
+                // Auto-generate nonce and deadline if not provided
+                const nonce = params.nonce ?? Math.floor(Math.random() * 2 ** 32);
+                const deadline = params.deadline ?? Math.floor(Date.now() / 1000) + 3600;
+                // Construct Permit2 EIP-712 data locally (no API call needed)
+                const PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+                const domain = {
+                    name: "Permit2",
+                    chainId: chain.id,
+                    verifyingContract: PERMIT2_ADDRESS,
+                };
+                const types = {
+                    PermitSingle: [
+                        { name: "details", type: "PermitDetails" },
+                        { name: "spender", type: "address" },
+                        { name: "sigDeadline", type: "uint256" },
+                    ],
+                    PermitDetails: [
+                        { name: "token", type: "address" },
+                        { name: "amount", type: "uint160" },
+                        { name: "expiration", type: "uint48" },
+                        { name: "nonce", type: "uint48" },
+                    ],
+                };
+                const message = {
+                    details: {
+                        token: params.token,
+                        amount: BigInt(params.amount) > BigInt(2 ** 160 - 1) ? BigInt(2 ** 160 - 1) : BigInt(params.amount),
+                        expiration: BigInt(deadline),
+                        nonce: BigInt(nonce),
+                    },
+                    spender: params.spender,
+                    sigDeadline: BigInt(deadline),
+                };
+                // Compute message hash locally
+                const messageHash = hashTypedData({
+                    domain,
+                    types: types,
+                    primaryType: "PermitSingle",
+                    message: message,
+                });
+                // Sign locally
+                const signature = await account.signTypedData({
+                    domain,
+                    types: types,
+                    primaryType: "PermitSingle",
+                    message: message,
+                });
+                const signerAddress = account.address;
+                let verified = false;
+                if (params.verify) {
+                    const recovered = await recoverTypedDataAddress({
+                        domain,
+                        types: types,
+                        primaryType: "PermitSingle",
+                        message: message,
+                        signature,
+                    });
+                    verified = recovered.toLowerCase() === signerAddress.toLowerCase();
+                }
+                result = {
+                    type: "permit2",
+                    token: params.token,
+                    amount: params.amount,
+                    spender: params.spender,
+                    nonce,
+                    deadline,
+                    messageHash: messageHash,
+                    signature,
+                    signer: signerAddress,
+                    verified,
+                };
+                break;
+            }
+            case "sign_batch": {
+                const params = args;
+                const { privateKeyToAccount } = await import("viem/accounts");
+                const { hashMessage, keccak256 } = await import("viem");
+                const { readFileSync, existsSync } = await import("fs");
+                const { createHash } = await import("crypto");
+                const privateKey = resolvePrivateKey(params.privateKey);
+                if (!privateKey) {
+                    throw new Error("Private key required for signing");
+                }
+                const account = privateKeyToAccount(privateKey);
+                const results = [];
+                // Sign messages (no API calls needed)
+                if (params.messages) {
+                    for (const message of params.messages) {
+                        // Compute message hash locally
+                        const messageHash = hashMessage(message);
+                        const signature = await account.signMessage({ message });
+                        results.push({
+                            type: "message",
+                            message,
+                            messageHash: messageHash,
+                            signature,
+                            signer: account.address,
+                        });
+                    }
+                }
+                // Sign files (no API calls needed)
+                if (params.files) {
+                    for (const file of params.files) {
+                        if (!existsSync(file.path)) {
+                            results.push({
+                                type: "file",
+                                file: file.path,
+                                error: "File not found",
+                            });
+                            continue;
+                        }
+                        const fileContent = readFileSync(file.path);
+                        const hashAlgo = file.hashAlgorithm || "sha256";
+                        let fileHash;
+                        if (hashAlgo === "sha256") {
+                            fileHash = createHash("sha256").update(fileContent).digest("hex");
+                        }
+                        else {
+                            const hexString = `0x${fileContent.toString("hex")}`;
+                            fileHash = keccak256(hexString).slice(2);
+                        }
+                        const fileHashHex = `0x${fileHash}`;
+                        // Compute message hash locally
+                        const messageHash = hashMessage(fileHashHex);
+                        const signature = await account.signMessage({ message: fileHashHex });
+                        results.push({
+                            type: "file",
+                            file: file.path,
+                            fileHash: fileHashHex,
+                            hashAlgorithm: hashAlgo,
+                            messageHash: messageHash,
+                            signature,
+                            signer: account.address,
+                        });
+                    }
+                }
+                result = {
+                    count: results.length,
+                    signatures: results,
+                };
+                break;
+            }
+            case "sign_verify": {
+                const params = args;
+                const { recoverMessageAddress, recoverTypedDataAddress } = await import("viem");
+                let recoveredAddress;
+                let verified = false;
+                if (params.type === "eip712") {
+                    if (!params.domain || !params.types || !params.primaryType) {
+                        throw new Error("EIP-712 verification requires domain, types, and primaryType");
+                    }
+                    const messageObj = typeof params.message === "string" ? JSON.parse(params.message) : params.message;
+                    recoveredAddress = await recoverTypedDataAddress({
+                        domain: params.domain,
+                        types: params.types,
+                        primaryType: params.primaryType,
+                        message: messageObj,
+                        signature: params.signature,
+                    });
+                    verified = true;
+                }
+                else {
+                    // EIP-191
+                    recoveredAddress = await recoverMessageAddress({
+                        message: params.message,
+                        signature: params.signature,
+                    });
+                    verified = true;
+                }
+                result = {
+                    verified,
+                    recoveredAddress,
+                    signature: params.signature,
+                    message: params.message,
+                    type: params.type || "eip191",
+                };
+                break;
+            }
+            // Tools - Multicall
+            case "tools_multicall_encode": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { calls: params.calls };
+                const response = await client.invoke("tools/multicall/encode", input);
+                result = response.data;
+                break;
+            }
+            case "tools_multicall_decode": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    data: params.data,
+                    calls: params.calls,
+                };
+                const response = await client.invoke("tools/multicall/decode", input);
+                result = response.data;
+                break;
+            }
+            // Tools - Nonce
+            case "tools_nonce_get": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { address: params.address };
+                const response = await client.invoke("tools/nonce/get", input);
+                result = response.data;
+                break;
+            }
+            case "tools_nonce_predict": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { address: params.address };
+                const response = await client.invoke("tools/nonce/predict", input);
+                result = response.data;
+                break;
+            }
+            // Tools - Gas
+            case "tools_gas_price": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const response = await client.invoke("tools/gas/price", {});
+                result = response.data;
+                break;
+            }
+            case "tools_gas_estimate": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { transaction: params.transaction };
+                const response = await client.invoke("tools/gas/estimate", input);
+                result = response.data;
+                break;
+            }
+            case "tools_gas_optimize": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { transaction: params.transaction };
+                if (params.priority !== undefined)
+                    input.priority = params.priority;
+                const response = await client.invoke("tools/gas/optimize", input);
+                result = response.data;
+                break;
+            }
+            // Tools - Key
+            case "tools_key_derive": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { privateKey: params.privateKey };
+                const response = await client.invoke("tools/key/derive", input);
+                result = response.data;
+                break;
+            }
+            case "tools_key_validate": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { privateKey: params.privateKey };
+                const response = await client.invoke("tools/key/validate", input);
+                result = response.data;
+                break;
+            }
+            // Tools - RPC
+            case "tools_rpc_proxy": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {
+                    method: params.method,
+                    params: params.params,
+                };
+                const response = await client.invoke("tools/rpc/proxy", input);
+                result = response.data;
+                break;
+            }
+            case "tools_rpc_batch": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { requests: params.requests };
+                const response = await client.invoke("tools/rpc/batch", input);
+                result = response.data;
+                break;
+            }
+            case "tools_rpc_health": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const response = await client.invoke("tools/rpc/health", {});
+                result = response.data;
+                break;
+            }
+            // Additional Free Endpoints
+            case "resolve_tokens": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { tokens: params.tokens };
+                const response = await client.invoke("entrypoints/resolve_tokens/invoke", input);
+                result = response.data;
+                break;
+            }
+            case "wallet_portfolio": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = { wallet: params.wallet };
+                if (params.tokens !== undefined)
+                    input.tokens = params.tokens;
+                if (params.includeMetadata !== undefined)
+                    input.includeMetadata = params.includeMetadata;
+                const response = await client.invoke("entrypoints/wallet_portfolio/invoke", input);
+                result = response.data;
+                break;
+            }
+            // Predictions Stream
+            case "predictions_stream": {
+                const params = args;
+                const client = await createClient(params.privateKey);
+                const input = {};
+                if (params.venues !== undefined)
+                    input.venues = params.venues;
+                if (params.sports !== undefined)
+                    input.sports = params.sports;
+                if (params.min_volume !== undefined)
+                    input.min_volume = params.min_volume;
+                if (params.poll_interval !== undefined)
+                    input.poll_interval = params.poll_interval;
+                if (params.realtime !== undefined)
+                    input.realtime = params.realtime;
+                // Note: SSE endpoints return connection info, not streaming directly
+                const response = await client.invoke("predictions/stream", input);
+                result = {
+                    ...response.data,
+                    note: "This is an SSE endpoint. Use the connection URL provided to establish a Server-Sent Events connection.",
+                };
                 break;
             }
             default: