helius-mcp 0.5.3 → 1.2.0

package/dist/tools/plans.js

@@ -1,274 +1,133 @@
 import { z } from 'zod';
-// Helius plan details (as of 2024)
-const HELIUS_PLANS = {
+import { fetchDoc, extractSections } from '../utils/docs.js';
+import { mcpError } from '../utils/errors.js';
+import { getJwt } from '../utils/config.js';
+import { listProjects } from 'helius-sdk/auth/listProjects';
+import { getProject } from 'helius-sdk/auth/getProject';
+import { MCP_USER_AGENT } from '../http.js';
+/**
+ * Static plan metadata — NOT the source of truth for pricing or billing data.
+ *
+ * Remaining uses (no billing data should be served from here):
+ * 1. Plan name lookup in auth.ts getAccountStatus
+ * 2. Feature-gate booleans in recommend.ts derivePlanLimitations()
+ * 3. Validation of minimumPlan keys in validate-catalog.ts
+ *
+ * All user-facing billing data (prices, credits, rate limits) is fetched live
+ * from the billing docs via fetchDoc('billing').
+ */
+export const HELIUS_PLANS = {
     free: {
         name: 'Free',
-        price: '$0/month',
-        credits: '1M/month',
-        additionalCredits: 'N/A',
-        rateLimit: {
-            rpc: '10 RPS',
-            sendTransaction: '1/sec',
-            getProgramAccounts: '5/sec',
-            das: '2/sec',
-        },
-        connections: {
-            websocket: 5,
-            enhancedWebsocket: 0,
-        },
-        features: {
-            webhooks: true,
-            standardWebSockets: true,
-            enhancedWebSockets: false,
-            laserstream: false,
-            stakedConnections: true,
-            archivalData: true,
-        },
-        support: 'Community (Discord)',
-        sla: 'N/A',
+        features: { webhooks: true, standardWebSockets: true, enhancedWebSockets: false, laserstream: false, stakedConnections: true, archivalData: true },
     },
     developer: {
         name: 'Developer',
-        price: '$49/month',
-        credits: '10M/month',
-        additionalCredits: '$5 per million',
-        rateLimit: {
-            rpc: '50 RPS',
-            sendTransaction: '5/sec',
-            getProgramAccounts: '25/sec',
-            das: '10/sec',
-        },
-        connections: {
-            websocket: 150,
-            enhancedWebsocket: 0,
-        },
-        features: {
-            webhooks: true,
-            standardWebSockets: true,
-            enhancedWebSockets: false,
-            laserstream: 'Devnet only',
-            stakedConnections: true,
-            archivalData: true,
-        },
-        support: 'Chat support',
-        sla: '24-hour response',
+        features: { webhooks: true, standardWebSockets: true, enhancedWebSockets: false, laserstream: 'Devnet only', stakedConnections: true, archivalData: true },
     },
     business: {
         name: 'Business',
-        price: '$499/month',
-        credits: '100M/month',
-        additionalCredits: '$5 per million',
-        rateLimit: {
-            rpc: '200 RPS',
-            sendTransaction: '50/sec',
-            getProgramAccounts: '50/sec',
-            das: '50/sec',
-        },
-        connections: {
-            websocket: 250,
-            enhancedWebsocket: 100,
-        },
-        features: {
-            webhooks: true,
-            standardWebSockets: true,
-            enhancedWebSockets: true,
-            laserstream: 'Devnet only',
-            stakedConnections: true,
-            archivalData: true,
-        },
-        support: 'Priority chat',
-        sla: '12-hour response',
+        features: { webhooks: true, standardWebSockets: true, enhancedWebSockets: true, laserstream: 'Devnet only', stakedConnections: true, archivalData: true },
     },
     professional: {
         name: 'Professional',
-        price: '$999/month',
-        credits: '200M/month',
-        additionalCredits: '$5 per million',
-        rateLimit: {
-            rpc: '500 RPS (+100 RPS for $100/mo)',
-            sendTransaction: '100/sec',
-            getProgramAccounts: '75/sec',
-            das: '100/sec',
-        },
-        connections: {
-            websocket: 250,
-            enhancedWebsocket: 100,
-        },
-        features: {
-            webhooks: true,
-            standardWebSockets: true,
-            enhancedWebSockets: true,
-            laserstream: 'Full access (mainnet + devnet, data add-ons $500+/mo)',
-            stakedConnections: true,
-            archivalData: true,
-        },
-        support: 'Dedicated Slack + Telegram',
-        sla: '8-hour response',
+        features: { webhooks: true, standardWebSockets: true, enhancedWebSockets: true, laserstream: 'Full access (mainnet + devnet)', stakedConnections: true, archivalData: true },
     },
 };
-function formatPlanDetails(planKey) {
-    const plan = HELIUS_PLANS[planKey];
-    const lines = [
-        `## ${plan.name} Plan`,
-        '',
-        `**Price:** ${plan.price}`,
-        `**Credits:** ${plan.credits}`,
-        `**Additional Credits:** ${plan.additionalCredits}`,
-        '',
-        '### Rate Limits',
-        `- RPC Requests: ${plan.rateLimit.rpc}`,
-        `- sendTransaction: ${plan.rateLimit.sendTransaction}`,
-        `- getProgramAccounts: ${plan.rateLimit.getProgramAccounts}`,
-        `- DAS Requests: ${plan.rateLimit.das}`,
-        '',
-        '### Connection Limits',
-        `- Standard WebSocket Connections: ${plan.connections.websocket}`,
-        `- Enhanced WebSocket Connections: ${plan.connections.enhancedWebsocket}`,
-        '',
-        '### Features',
-        `- Webhooks: ${plan.features.webhooks ? 'Yes' : 'No'}`,
-        `- Standard WebSockets: ${plan.features.standardWebSockets ? 'Yes' : 'No'}`,
-        `- Enhanced WebSockets: ${typeof plan.features.enhancedWebSockets === 'string' ? plan.features.enhancedWebSockets : plan.features.enhancedWebSockets ? 'Yes' : 'No'}`,
-        `- Laserstream: ${typeof plan.features.laserstream === 'string' ? plan.features.laserstream : plan.features.laserstream ? 'Yes' : 'No'}`,
-        `- Staked Connections: ${plan.features.stakedConnections ? 'Yes' : 'No'}`,
-        `- Archival Data: ${plan.features.archivalData ? 'Yes' : 'No'}`,
-    ];
-    if ('soc2Compliance' in plan.features) {
-        lines.push(`- SOC 2 Compliance: Yes`);
+const BILLING_FETCH_ERROR = 'Could not fetch live billing data. Try:\n' +
+    '- `lookupHeliusDocs({ topic: \'billing\' })` for full billing documentation\n' +
+    '- Visit https://www.helius.dev/docs/billing directly';
+/**
+ * Detect the user's current Helius plan from their JWT session.
+ * Returns the plan key (e.g. "developer") or undefined if unavailable.
+ * Best-effort — never throws.
+ */
+export async function detectCurrentPlan() {
+    const jwt = getJwt();
+    if (!jwt)
+        return undefined;
+    try {
+        const projects = await listProjects(jwt, MCP_USER_AGENT);
+        if (projects.length > 0) {
+            const details = await getProject(jwt, projects[0].id, MCP_USER_AGENT);
+            const raw = details.subscriptionPlanDetails?.currentPlan?.trim().toLowerCase();
+            if (raw && raw in HELIUS_PLANS)
+                return raw;
+        }
     }
-    if ('customInfrastructure' in plan.features) {
-        lines.push(`- Custom Infrastructure: Yes`);
+    catch {
+        // Best-effort — don't block the response
     }
-    lines.push('', '### Support');
-    lines.push(`- Channel: ${plan.support}`);
-    lines.push(`- SLA: ${plan.sla}`);
-    return lines.join('\n');
+    return undefined;
 }
 export function registerPlanTools(server) {
-    server.tool('getHeliusPlanInfo', 'Get detailed Helius plan information including pricing, credits, rate limits, and feature availability. Shows what features are available on each tier (Free, Developer, Business, Professional). Useful for understanding WebSocket limits, Laserstream access, and API rate limits per plan.', {
-        plan: z.enum(['free', 'developer', 'business', 'professional', 'all']).optional().default('all').describe('Specific plan to show details for, or "all" for comparison')
+    server.tool('getHeliusPlanInfo', 'BEST FOR: pricing and plan questions. PREFER compareHeliusPlans for side-by-side category comparisons, getRateLimitInfo for per-method credit costs. Get Helius plan pricing, credits, rate limits, and feature availability. Fetches live from billing docs.', {
+        plan: z.enum(['free', 'developer', 'business', 'professional', 'all']).optional().default('all').describe('Specific plan to show details for, or "all" for comparison'),
     }, async ({ plan }) => {
+        let billingDoc;
         try {
-            if (plan === 'all') {
-                const lines = [
-                    '# Helius Plans Overview',
-                    '',
-                    '| Feature | Free | Developer | Business | Professional |',
-                    '|---------|------|-----------|----------|--------------|',
-                    '| **Price** | $0/mo | $49/mo | $499/mo | $999/mo |',
-                    '| **Credits** | 1M | 10M | 100M | 200M |',
-                    '| **RPC RPS** | 10 | 50 | 200 | 500 |',
-                    '| **sendTransaction** | 1/s | 5/s | 50/s | 100/s |',
-                    '| **DAS Requests** | 2/s | 10/s | 50/s | 100/s |',
-                    '| **WS Connections** | 5 | 150 | 250 | 250 |',
-                    '| **Enhanced WS** | No | No | Yes (100) | Yes (100) |',
-                    '| **Laserstream** | No | Devnet | Devnet | Full |',
-                    '| **Support SLA** | — | 24hr | 12hr | 8hr |',
-                    '',
-                    '---',
-                    '',
-                    '## Key Differences',
-                    '',
-                    '### WebSocket Connection Limits',
-                    '- **Free:** 5 simultaneous connections',
-                    '- **Developer:** 150 connections',
-                    '- **Business/Professional:** 250 standard, 100 enhanced each',
-                    '',
-                    '### Enhanced WebSockets',
-                    '- **Available on:** Business, Professional',
-                    '- **Connection limit:** 100 (Business/Pro)',
-                    '- **Speed:** 1.5-2x faster than standard WebSockets',
-                    '- **Filtering:** Up to 50,000 addresses per filter',
-                    '- **Subscriptions:** transactionSubscribe, accountSubscribe',
-                    '- **Timeout:** 10 min inactivity (ping every 30-60s)',
-                    '- **Cost:** 1 credit to open, 3 credits per 0.1 MB streamed',
-                    '',
-                    '### Laserstream (gRPC)',
-                    '- **Developer/Business:** Devnet only',
-                    '- **Professional:** Full access (mainnet + devnet)',
-                    '- **Data add-ons:** Starting at $500/mo for Professional',
-                    '- **Features:** 24h historical replay, lowest latency',
-                    '',
-                    '### Credit Costs (from docs)',
-                    '- **0 credits**: Helius Sender',
-                    '- **1 credit**: Standard RPC, sendTransaction, Priority Fee API, webhook events',
-                    '- **3 credits**: per 0.1 MB streamed (LaserStream, Enhanced WS)',
-                    '- **10 credits**: getProgramAccounts, historical data (getBlock, getTransaction, etc.), DAS API',
-                    '- **100 credits**: Enhanced Transactions, Wallet API, getValidityProof (ZK), webhook management',
-                    '- **Additional credits**: $5 per million (all paid plans)',
-                    '',
-                    '**Docs:** https://www.helius.dev/pricing',
-                ];
-                return { content: [{ type: 'text', text: lines.join('\n') }] };
-            }
-            const planDetails = formatPlanDetails(plan);
-            return { content: [{ type: 'text', text: planDetails }] };
+            billingDoc = await fetchDoc('billing');
+        }
+        catch {
+            return mcpError(BILLING_FETCH_ERROR);
+        }
+        // Required: plans table
+        const plansTable = extractSections(billingDoc, ['standard plans', 'standard pricing'], { includeLooseMatches: false });
+        if (!plansTable) {
+            return mcpError(BILLING_FETCH_ERROR);
+        }
+        // Optional sections
+        const credits = extractSections(billingDoc, ['credits system', 'credit costs'], { includeLooseMatches: false });
+        const addOns = extractSections(billingDoc, ['data add-ons', 'add-ons'], { includeLooseMatches: false });
+        const rateLimits = extractSections(billingDoc, ['rate limits', 'standard rate limits'], { includeLooseMatches: false });
+        const sections = [];
+        const currentPlanKey = await detectCurrentPlan();
+        if (currentPlanKey) {
+            const displayName = HELIUS_PLANS[currentPlanKey]?.name ?? currentPlanKey;
+            sections.push(`**Your current plan: ${displayName}**`, '');
         }
-        catch (err) {
-            const errorMsg = err instanceof Error ? err.message : String(err);
-            return { content: [{ type: 'text', text: `Error: ${errorMsg}` }], isError: true };
+        if (plan !== 'all') {
+            const planInfo = HELIUS_PLANS[plan];
+            const displayName = planInfo ? planInfo.name : plan;
+            sections.push(`## ${displayName} Plan`, `See the "${plan}" column in the tables below.`, '');
         }
+        sections.push(plansTable);
+        if (credits)
+            sections.push('', credits);
+        if (addOns)
+            sections.push('', addOns);
+        if (rateLimits)
+            sections.push('', rateLimits);
+        sections.push('', '---', '', '## Actions', '', '- To upgrade, use the `upgradePlan` tool with a plan name (developer, business, professional)', '- To preview pricing before upgrading, use the `previewUpgrade` tool', '', 'Source: https://www.helius.dev/docs/billing (fetched live)');
+        return { content: [{ type: 'text', text: sections.join('\n') }] };
     });
-    server.tool('compareHeliusPlans', 'Compare specific Helius plans side-by-side for a specific feature category (rate limits, features, connections, or pricing).', {
-        category: z.enum(['rates', 'features', 'connections', 'pricing', 'support']).describe('Category to compare'),
-        plans: z.array(z.enum(['free', 'developer', 'business', 'professional'])).optional().describe('Plans to compare (default: all)')
-    }, async ({ category, plans }) => {
-        const plansToCompare = plans || ['free', 'developer', 'business', 'professional'];
+    server.tool('compareHeliusPlans', 'BEST FOR: side-by-side plan comparison in a specific category. Compare Helius plans for rate limits, features, or pricing. Fetches live from billing docs.', {
+        category: z.enum(['rates', 'features', 'pricing']).describe('Category to compare'),
+    }, async ({ category }) => {
+        let billingDoc;
+        try {
+            billingDoc = await fetchDoc('billing');
+        }
+        catch {
+            return mcpError(BILLING_FETCH_ERROR);
+        }
+        const sectionMap = {
+            rates: ['rate limits', 'standard rate limits', 'special rate limits'],
+            features: ['standard plans', 'standard pricing'],
+            pricing: ['credits system', 'credit costs', 'data add-ons'],
+        };
+        const extracted = extractSections(billingDoc, sectionMap[category], { includeLooseMatches: false });
+        if (!extracted) {
+            return mcpError(BILLING_FETCH_ERROR);
+        }
         const lines = [];
-        switch (category) {
-            case 'rates':
-                lines.push('# Rate Limits Comparison', '');
-                lines.push('| Plan | RPC RPS | sendTx | getProgramAccounts | DAS |');
-                lines.push('|------|---------|--------|-------------------|-----|');
-                for (const p of plansToCompare) {
-                    const plan = HELIUS_PLANS[p];
-                    lines.push(`| ${plan.name} | ${plan.rateLimit.rpc} | ${plan.rateLimit.sendTransaction} | ${plan.rateLimit.getProgramAccounts} | ${plan.rateLimit.das} |`);
-                }
-                break;
-            case 'features':
-                lines.push('# Features Comparison', '');
-                lines.push('| Plan | Enhanced WS | Laserstream | Staked | Archival |');
-                lines.push('|------|-------------|-------------|--------|----------|');
-                for (const p of plansToCompare) {
-                    const plan = HELIUS_PLANS[p];
-                    const ews = typeof plan.features.enhancedWebSockets === 'string' ? plan.features.enhancedWebSockets : plan.features.enhancedWebSockets ? 'Yes' : 'No';
-                    const ls = typeof plan.features.laserstream === 'string' ? plan.features.laserstream : plan.features.laserstream ? 'Yes' : 'No';
-                    lines.push(`| ${plan.name} | ${ews} | ${ls} | Yes | Yes |`);
-                }
-                break;
-            case 'connections':
-                lines.push('# Connection Limits Comparison', '');
-                lines.push('| Plan | Standard WS | Enhanced WS |');
-                lines.push('|------|-------------|-------------|');
-                for (const p of plansToCompare) {
-                    const plan = HELIUS_PLANS[p];
-                    lines.push(`| ${plan.name} | ${plan.connections.websocket} | ${plan.connections.enhancedWebsocket} |`);
-                }
-                lines.push('', '**Notes:**');
-                lines.push('- Enhanced WS requires Business+ plan');
-                lines.push('- Opening a connection costs 1 credit');
-                lines.push('- Enhanced WS data: 3 credits per 0.1 MB streamed');
-                lines.push('- 10-minute inactivity timeout (ping every 30-60s)');
-                break;
-            case 'pricing':
-                lines.push('# Pricing Comparison', '');
-                lines.push('| Plan | Price | Credits | Extra Credits |');
-                lines.push('|------|-------|---------|---------------|');
-                for (const p of plansToCompare) {
-                    const plan = HELIUS_PLANS[p];
-                    lines.push(`| ${plan.name} | ${plan.price} | ${plan.credits} | ${plan.additionalCredits} |`);
-                }
-                break;
-            case 'support':
-                lines.push('# Support Comparison', '');
-                lines.push('| Plan | Channel | SLA |');
-                lines.push('|------|---------|-----|');
-                for (const p of plansToCompare) {
-                    const plan = HELIUS_PLANS[p];
-                    lines.push(`| ${plan.name} | ${plan.support} | ${plan.sla} |`);
-                }
-                break;
+        const currentPlanKey = await detectCurrentPlan();
+        if (currentPlanKey) {
+            const displayName = HELIUS_PLANS[currentPlanKey]?.name ?? currentPlanKey;
+            lines.push(`**Your current plan: ${displayName}**`, '');
         }
+        lines.push(extracted);
+        lines.push('', '---', 'Source: https://www.helius.dev/docs/billing (fetched live)');
         return { content: [{ type: 'text', text: lines.join('\n') }] };
     });
 }

package/dist/tools/product-catalog.d.ts

@@ -0,0 +1,10 @@
+export interface CatalogProduct {
+    name: string;
+    mcpTools: string[];
+    creditCostPerCall: string;
+    minimumPlan: string;
+    docKey: string;
+    referenceFile?: string;
+    description: string;
+}
+export declare const PRODUCT_CATALOG: Record<string, CatalogProduct>;

package/dist/tools/product-catalog.js

@@ -0,0 +1,123 @@
+// ─── Product Catalog ───
+//
+// Centralized product definitions — each Helius product defined once with its
+// invariant properties. The recommend tool groups products by minimumPlan into
+// tiers and uses the description field to give AI consumers rich context.
+export const PRODUCT_CATALOG = {
+    'das-api': {
+        name: 'DAS API',
+        mcpTools: ['getAssetsByOwner', 'getAssetsByGroup', 'searchAssets', 'getAsset', 'getTokenBalances', 'getTokenAccounts'],
+        creditCostPerCall: '10 credits',
+        minimumPlan: 'free',
+        docKey: 'das',
+        referenceFile: 'references/das.md',
+        description: 'Query tokens, NFTs, collections, and digital assets. Fetches wallet token holdings with names, symbols, and prices. Browse NFT collections, search assets by creator/authority/owner.',
+    },
+    'standard-rpc': {
+        name: 'Standard RPC',
+        mcpTools: ['getBalance', 'getAccountInfo', 'getBlock', 'getNetworkStatus'],
+        creditCostPerCall: '1-10 credits',
+        minimumPlan: 'free',
+        docKey: 'rpc',
+        description: 'Core Solana RPC for native SOL balances, account data, block info, and network status. Foundation for any Solana app.',
+    },
+    'enhanced-transactions': {
+        name: 'Enhanced Transactions API',
+        mcpTools: ['parseTransactions', 'getTransactionHistory'],
+        creditCostPerCall: '100 credits',
+        minimumPlan: 'free',
+        docKey: 'enhanced-transactions',
+        referenceFile: 'references/enhanced-transactions.md',
+        description: 'Parse any transaction into human-readable format with types (SWAP, TRANSFER, NFT_SALE), descriptions, token transfers, and fees. Powers transaction history views and trade verification.',
+    },
+    'wallet-api': {
+        name: 'Wallet API',
+        mcpTools: ['getWalletBalances', 'getWalletHistory', 'getWalletTransfers', 'getWalletIdentity', 'batchWalletIdentity', 'getWalletFundedBy'],
+        creditCostPerCall: '100 credits',
+        minimumPlan: 'developer',
+        docKey: 'wallet-api',
+        referenceFile: 'references/wallet-api.md',
+        description: 'Portfolio balances with USD prices sorted by value, transfer history with sender/receiver, entity identification (exchanges, protocols, whales), and wallet funding source tracking. Purpose-built for wallet-centric features \u2014 more data in fewer calls than DAS + RPC.',
+    },
+    'webhooks': {
+        name: 'Webhooks',
+        mcpTools: ['createWebhook', 'getAllWebhooks', 'updateWebhook', 'deleteWebhook'],
+        creditCostPerCall: '100 credits to create, 1 credit per event',
+        minimumPlan: 'free',
+        docKey: 'webhooks',
+        referenceFile: 'references/webhooks.md',
+        description: 'HTTP POST notifications when monitored addresses have on-chain activity. Event-driven architecture without polling. Monitor up to 100k addresses per webhook. Filter by 150+ transaction types (SWAP, NFT_SALE, TRANSFER, etc.).',
+    },
+    'enhanced-websockets': {
+        name: 'Enhanced WebSockets',
+        mcpTools: ['transactionSubscribe', 'accountSubscribe', 'getEnhancedWebSocketInfo'],
+        creditCostPerCall: '3 credits per 0.1 MB streamed',
+        minimumPlan: 'business',
+        docKey: 'enhanced-websockets',
+        referenceFile: 'references/websockets.md',
+        description: 'Real-time transaction and account streaming over persistent WebSocket connections. 1.5-2x faster than standard WebSockets with advanced filtering (up to 50k addresses per filter). Powers live dashboards and real-time UIs.',
+    },
+    'helius-sender': {
+        name: 'Helius Sender',
+        mcpTools: ['getSenderInfo'],
+        creditCostPerCall: '0 credits',
+        minimumPlan: 'free',
+        docKey: 'sender',
+        referenceFile: 'references/sender.md',
+        description: 'Submit transactions with SWQoS routing, staked connections, and Jito tip integration for optimal landing rates. Essential for trading bots, token launches, and any app that sends transactions.',
+    },
+    'priority-fee': {
+        name: 'Priority Fee API',
+        mcpTools: ['getPriorityFeeEstimate'],
+        creditCostPerCall: '1 credit',
+        minimumPlan: 'free',
+        docKey: 'priority-fee',
+        referenceFile: 'references/priority-fees.md',
+        description: 'Real-time fee estimates for transaction prioritization during network congestion. Returns recommended fees at multiple priority levels (Min, Low, Medium, High, VeryHigh).',
+    },
+    'standard-websockets': {
+        name: 'Standard WebSockets',
+        mcpTools: ['transactionSubscribe'],
+        creditCostPerCall: '3 credits per 0.1 MB streamed',
+        minimumPlan: 'free',
+        docKey: 'websocket',
+        referenceFile: 'references/websockets.md',
+        description: 'Persistent connection for real-time transaction and account updates using standard Solana WebSocket subscriptions. Good for confirmation tracking and basic streaming.',
+    },
+    'laserstream-devnet': {
+        name: 'Laserstream (Devnet)',
+        mcpTools: ['laserstreamSubscribe', 'getLaserstreamInfo'],
+        creditCostPerCall: '3 credits per 0.1 MB streamed',
+        minimumPlan: 'developer',
+        docKey: 'laserstream',
+        referenceFile: 'references/laserstream.md',
+        description: 'High-performance gRPC streaming for development and testing. Subscribe to slots, accounts, transactions, blocks, or entries. Test streaming pipelines with production-grade infrastructure on devnet.',
+    },
+    'laserstream-mainnet': {
+        name: 'Laserstream (Mainnet)',
+        mcpTools: ['laserstreamSubscribe', 'getLaserstreamInfo'],
+        creditCostPerCall: '3 credits per 0.1 MB streamed',
+        minimumPlan: 'professional',
+        docKey: 'laserstream',
+        referenceFile: 'references/laserstream.md',
+        description: 'Lowest-latency gRPC streaming with 24h historical replay for production indexers, trading infrastructure, and data pipelines. Subscribe to all transactions, accounts, blocks, or entries on mainnet.',
+    },
+    'token-transfers': {
+        name: 'Token Transfers',
+        mcpTools: ['transferSol', 'transferToken'],
+        creditCostPerCall: '~3-13 credits + on-chain fees',
+        minimumPlan: 'free',
+        docKey: 'sender',
+        referenceFile: 'references/sender.md',
+        description: 'Send native SOL or SPL tokens from the MCP keypair to any Solana address. Uses Helius Sender for optimal landing rates. Requires a configured keypair.',
+    },
+    'token-holders': {
+        name: 'Token Holders',
+        mcpTools: ['getTokenHolders'],
+        creditCostPerCall: '20 credits',
+        minimumPlan: 'free',
+        docKey: 'das',
+        referenceFile: 'references/das.md',
+        description: 'Top 20 holders of any SPL token. Check token distribution, find whale wallets, verify decentralization. Useful for token launches and analytics.',
+    },
+};

package/dist/tools/recommend.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare const KNOWN_TOOLS: Set<string>;
+export declare const PLAN_RANK: Record<string, number>;
+export declare function registerRecommendTools(server: McpServer): void;