helius-mcp 1.3.0 → 2.1.0

package/dist/router/instructions.d.ts

@@ -0,0 +1 @@
+export declare const ROUTER_INSTRUCTIONS = "Helius MCP exposes 10 public tools total: 9 routed domain tools plus `expandResult`.\n\nChoose tools by user intent, not by name similarity.\n\nRouting:\n- Account setup, API keys, signup, plans, billing: `heliusAccount`\n- Wallet-centric balances, holdings, identity, wallet history: `heliusWallet`\n- Assets, NFTs, collections, token holders: `heliusAsset`\n- Parsed transactions or wallet transaction history: `heliusTransaction`\n- Raw chain state, token accounts, stake reads, blocks, network status, priority fees, transaction simulation: `heliusChain`\n- Webhook CRUD or live subscription configuration: `heliusStreaming`\n- Docs, guides, pricing references, troubleshooting, source, blog, SIMDs: `heliusKnowledge`\n- SOL/token transfers or staking mutations: `heliusWrite`\n- Compressed account, proof, balance, compression history: `heliusCompression`\n\nRules:\n- Use the chosen routed tool plus the Helius action name in `action`.\n- Wallet holdings use `heliusWallet.getTokenBalances`; raw token accounts use `heliusChain.getTokenAccounts`.\n- Parsed transaction details use `heliusTransaction.parseTransactions`; wallet activity listing uses `heliusTransaction.getTransactionHistory`; per-transfer rows (token + SOL with mint/direction/counterparty filters) use `heliusTransaction.getTransfersByAddress`.\n- Streaming or webhook setup guides live under `heliusKnowledge`; actual webhook/subscription config lives under `heliusStreaming`.\n- Pricing and plan selection start with `heliusAccount.getHeliusPlanInfo`; per-method credit costs or rate limits use `heliusKnowledge.getRateLimitInfo` or `heliusKnowledge.getHeliusCreditsInfo`.\n- Read queries stay on domain tools; sends and staking mutations use `heliusWrite`.\n- Heavy content is summary-first. Use `expandResult` with the returned `resultId` for sections, ranges, pages, or continuation.\n- Set `_feedback` to a short reason for the call or takeaway from the previous result. Avoid placeholders like `first_call`.\n- Set `_feedbackTool` to the current `publicTool.action`, e.g. `heliusWallet.getBalance`. Always send `_model`.";

package/dist/router/instructions.js

@@ -0,0 +1,25 @@
+export const ROUTER_INSTRUCTIONS = `Helius MCP exposes 10 public tools total: 9 routed domain tools plus \`expandResult\`.
+
+Choose tools by user intent, not by name similarity.
+
+Routing:
+- Account setup, API keys, signup, plans, billing: \`heliusAccount\`
+- Wallet-centric balances, holdings, identity, wallet history: \`heliusWallet\`
+- Assets, NFTs, collections, token holders: \`heliusAsset\`
+- Parsed transactions or wallet transaction history: \`heliusTransaction\`
+- Raw chain state, token accounts, stake reads, blocks, network status, priority fees, transaction simulation: \`heliusChain\`
+- Webhook CRUD or live subscription configuration: \`heliusStreaming\`
+- Docs, guides, pricing references, troubleshooting, source, blog, SIMDs: \`heliusKnowledge\`
+- SOL/token transfers or staking mutations: \`heliusWrite\`
+- Compressed account, proof, balance, compression history: \`heliusCompression\`
+
+Rules:
+- Use the chosen routed tool plus the Helius action name in \`action\`.
+- Wallet holdings use \`heliusWallet.getTokenBalances\`; raw token accounts use \`heliusChain.getTokenAccounts\`.
+- Parsed transaction details use \`heliusTransaction.parseTransactions\`; wallet activity listing uses \`heliusTransaction.getTransactionHistory\`; per-transfer rows (token + SOL with mint/direction/counterparty filters) use \`heliusTransaction.getTransfersByAddress\`.
+- Streaming or webhook setup guides live under \`heliusKnowledge\`; actual webhook/subscription config lives under \`heliusStreaming\`.
+- Pricing and plan selection start with \`heliusAccount.getHeliusPlanInfo\`; per-method credit costs or rate limits use \`heliusKnowledge.getRateLimitInfo\` or \`heliusKnowledge.getHeliusCreditsInfo\`.
+- Read queries stay on domain tools; sends and staking mutations use \`heliusWrite\`.
+- Heavy content is summary-first. Use \`expandResult\` with the returned \`resultId\` for sections, ranges, pages, or continuation.
+- Set \`_feedback\` to a short reason for the call or takeaway from the previous result. Avoid placeholders like \`first_call\`.
+- Set \`_feedbackTool\` to the current \`publicTool.action\`, e.g. \`heliusWallet.getBalance\`. Always send \`_model\`.`;

package/dist/router/register.d.ts

@@ -0,0 +1,2 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerRouterTools(server: McpServer): void;

package/dist/router/register.js

@@ -0,0 +1,15 @@
+import { dispatchRoutedTool, expandStoredResult } from './dispatch.js';
+import { withTelemetryHandler } from './telemetry.js';
+import { EXPAND_RESULT_SCHEMA, HELIUS_ACCOUNT_SCHEMA, HELIUS_ASSET_SCHEMA, HELIUS_CHAIN_SCHEMA, HELIUS_COMPRESSION_SCHEMA, HELIUS_KNOWLEDGE_SCHEMA, HELIUS_STREAMING_SCHEMA, HELIUS_TRANSACTION_SCHEMA, HELIUS_WALLET_SCHEMA, HELIUS_WRITE_SCHEMA, } from './schemas.js';
+export function registerRouterTools(server) {
+    server.tool('heliusAccount', 'Account setup, API keys, signup, plans, and billing. Use for pricing or account state, not per-method rate limits.', HELIUS_ACCOUNT_SCHEMA, withTelemetryHandler('heliusAccount', (params, extra) => dispatchRoutedTool('heliusAccount', params, extra)));
+    server.tool('heliusWallet', 'Wallet-centric balances, holdings, identity, and wallet history. Use for portfolio views, not raw token accounts.', HELIUS_WALLET_SCHEMA, withTelemetryHandler('heliusWallet', (params, extra) => dispatchRoutedTool('heliusWallet', params, extra)));
+    server.tool('heliusAsset', 'Assets, NFTs, collections, proofs, and token holders. Use for DAS ownership or metadata, not transaction history.', HELIUS_ASSET_SCHEMA, withTelemetryHandler('heliusAsset', (params, extra) => dispatchRoutedTool('heliusAsset', params, extra)));
+    server.tool('heliusTransaction', 'Parsed transactions and wallet transaction history. Use for activity analysis, not raw account state.', HELIUS_TRANSACTION_SCHEMA, withTelemetryHandler('heliusTransaction', (params, extra) => dispatchRoutedTool('heliusTransaction', params, extra)));
+    server.tool('heliusChain', 'Raw chain state, token accounts, stake reads, blocks, network status, priority fees, and transaction simulation. Use for token accounts or blocks, not wallet portfolio summaries.', HELIUS_CHAIN_SCHEMA, withTelemetryHandler('heliusChain', (params, extra) => dispatchRoutedTool('heliusChain', params, extra)));
+    server.tool('heliusStreaming', 'Webhook CRUD and live subscription configuration. Use for actual webhook/subscription setup, not how-to guides.', HELIUS_STREAMING_SCHEMA, withTelemetryHandler('heliusStreaming', (params, extra) => dispatchRoutedTool('heliusStreaming', params, extra)));
+    server.tool('heliusKnowledge', 'Docs, guides, pricing references, troubleshooting, source, blog, and SIMD research. Use for guides, rate limits, or errors, not live mutations.', HELIUS_KNOWLEDGE_SCHEMA, withTelemetryHandler('heliusKnowledge', (params, extra) => dispatchRoutedTool('heliusKnowledge', params, extra)));
+    server.tool('heliusWrite', 'Mutating SOL/token transfer and staking actions. Use for sends or staking, not read-only queries.', HELIUS_WRITE_SCHEMA, withTelemetryHandler('heliusWrite', (params, extra) => dispatchRoutedTool('heliusWrite', params, extra)));
+    server.tool('heliusCompression', 'Compressed account, proof, balance, and compression history queries. Use for zk-compression state, not standard DAS assets.', HELIUS_COMPRESSION_SCHEMA, withTelemetryHandler('heliusCompression', (params, extra) => dispatchRoutedTool('heliusCompression', params, extra)));
+    server.tool('expandResult', 'Expand a prior summary-first result by resultId, section, range, page, or continuation.', EXPAND_RESULT_SCHEMA, withTelemetryHandler('expandResult', (params, extra) => expandStoredResult(params, extra)));
+}

package/dist/router/required-params.d.ts

@@ -0,0 +1,9 @@
+import type { ActionName } from './actions.js';
+/**
+ * Map of actions to their required top-level parameters.
+ *
+ * Only actions with unambiguous required fields are listed here.
+ * Actions with "one-of" requirements (e.g. getAsset needs `id` OR `ids`)
+ * or no required params are omitted — those rely on bespoke handler validation.
+ */
+export declare const ACTION_REQUIRED_PARAMS: Partial<Record<ActionName, string[]>>;

package/dist/router/required-params.js

@@ -0,0 +1,68 @@
+/**
+ * Map of actions to their required top-level parameters.
+ *
+ * Only actions with unambiguous required fields are listed here.
+ * Actions with "one-of" requirements (e.g. getAsset needs `id` OR `ids`)
+ * or no required params are omitted — those rely on bespoke handler validation.
+ */
+export const ACTION_REQUIRED_PARAMS = {
+    // Wallet
+    getBalance: ['address'],
+    getTokenBalances: ['address'],
+    getWalletBalances: ['address'],
+    getWalletBalanceAt: ['address', 'mint'],
+    getWalletHistory: ['address'],
+    getWalletTransfers: ['address'],
+    getWalletIdentity: ['address'],
+    batchWalletIdentity: ['addresses'],
+    getWalletFundedBy: ['address'],
+    // Transaction
+    parseTransactions: ['signatures'],
+    getTransactionHistory: ['address'],
+    getTransfersByAddress: ['address'],
+    // Asset
+    getAssetsByOwner: ['address'],
+    getAssetsByGroup: ['groupKey', 'groupValue'],
+    getAssetProof: ['id'],
+    getAssetProofBatch: ['ids'],
+    getSignaturesForAsset: ['id'],
+    getNftEditions: ['mint'],
+    // Chain
+    getTokenHolders: ['mint'],
+    getProgramAccounts: ['programId'],
+    getBlock: ['slot'],
+    simulateTransaction: ['transaction'],
+    getWithdrawableAmount: ['stakeAccount'],
+    // Streaming
+    createWebhook: ['webhookURL', 'accountAddresses'],
+    getWebhookByID: ['webhookID'],
+    updateWebhook: ['webhookID'],
+    deleteWebhook: ['webhookID'],
+    accountSubscribe: ['account'],
+    // Knowledge
+    troubleshootError: ['errorCode'],
+    recommendStack: ['description'],
+    getSIMD: ['number'],
+    searchSolanaDocs: ['query'],
+    readSolanaSourceFile: ['path'],
+    compareHeliusPlans: ['category'],
+    // Write
+    transferSol: ['recipientAddress'],
+    transferToken: ['recipientAddress', 'mintAddress'],
+    stakeSOL: ['amount'],
+    unstakeSOL: ['stakeAccount'],
+    withdrawStake: ['stakeAccount'],
+    // Compression
+    getCompressedAccountsByOwner: ['owner'],
+    getCompressedBalanceByOwner: ['owner'],
+    getCompressedMintTokenHolders: ['mint'],
+    getCompressedTokenAccountsByOwner: ['owner'],
+    getCompressedTokenAccountsByDelegate: ['delegate'],
+    getCompressedTokenBalancesByOwnerV2: ['owner'],
+    getCompressedAccountProof: ['hash'],
+    getCompressionSignaturesForAccount: ['hash'],
+    getCompressionSignaturesForAddress: ['address'],
+    getCompressionSignaturesForOwner: ['owner'],
+    getCompressionSignaturesForTokenOwner: ['owner'],
+    getTransactionWithCompressionInfo: ['signature'],
+};

package/dist/router/responses.d.ts

@@ -0,0 +1,29 @@
+import type { DetailLevel, ResponseFamily } from './types.js';
+export type RouterResponse = {
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+    _meta?: Record<string, unknown>;
+};
+export declare function getFamilyLimit(family: ResponseFamily, detail: DetailLevel): number;
+export declare function toPlainText(response: {
+    content?: Array<{
+        type?: string;
+        text?: string;
+    }>;
+    structuredContent?: unknown;
+}): string;
+export declare function compactErrorText(text: string, maxChars?: number): string;
+export declare function cleanText(text: string): string;
+export declare function truncateText(text: string, limit: number): string;
+export declare function buildTextVariant(family: ResponseFamily, detail: DetailLevel, text: string): string;
+export declare function estimateRenderedSize(text: string): number;
+export declare function collectSectionHints(text: string): string[];
+export declare function applySectionSelection(text: string, section?: string): string;
+export declare function applyItemSelection(text: string, item?: number): string;
+export declare function applyRangeSelection(text: string, range?: string): string;
+export declare function mcpText(text: string, meta?: Record<string, unknown>): RouterResponse;
+export declare function mcpErrorCompact(text: string, meta?: Record<string, unknown>): RouterResponse;
+export declare function mcpResultHandle(summary: string, resultId: string, availableExpansions: string[], meta?: Record<string, unknown>): RouterResponse;

package/dist/router/responses.js

@@ -0,0 +1,186 @@
+import { extractSections } from '../utils/docs.js';
+const FAMILY_LIMITS = {
+    scalar: { summary: 800, standard: 1200, full: 1200 },
+    mutationReceipt: { summary: 1000, standard: 1500, full: 1500 },
+    record: { summary: 1500, standard: 3000, full: 8000 },
+    list: { summary: 2500, standard: 4500, full: 12000 },
+    history: { summary: 2500, standard: 4500, full: 12000 },
+    document: { summary: 2500, standard: 5000, full: 12000 },
+    streamingConfig: { summary: 2500, standard: 5000, full: 12000 },
+    catalog: { summary: 2500, standard: 5000, full: 12000 },
+};
+export function getFamilyLimit(family, detail) {
+    return FAMILY_LIMITS[family][detail];
+}
+export function toPlainText(response) {
+    const text = response.content
+        ?.filter((item) => item.type === 'text' || item.type === undefined)
+        .map((item) => item.text ?? '')
+        .join('\n\n')
+        .trim();
+    if (text) {
+        return text;
+    }
+    if (response.structuredContent !== undefined) {
+        return JSON.stringify(response.structuredContent, null, 2);
+    }
+    return '';
+}
+export function compactErrorText(text, maxChars = 1200) {
+    const withoutMeta = text
+        .replace(/^```json[\s\S]*?```\n*/i, '')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+    return truncateText(withoutMeta, maxChars);
+}
+export function cleanText(text) {
+    return text
+        .replace(/\r\n/g, '\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+}
+export function truncateText(text, limit) {
+    if (text.length <= limit) {
+        return text;
+    }
+    const truncated = text.slice(0, limit);
+    const boundary = Math.max(truncated.lastIndexOf('\n## '), truncated.lastIndexOf('\n### '), truncated.lastIndexOf('\n---\n'), truncated.lastIndexOf('\n\n'));
+    const cut = boundary > limit * 0.55 ? boundary : limit;
+    return `${truncated.slice(0, cut).trim()}\n\n[truncated]`;
+}
+function stripExampleCode(text) {
+    const markers = ['**Example Code:**', '**Example:**', '```typescript', '```ts', '```javascript', '```js'];
+    let cut = text.length;
+    for (const marker of markers) {
+        const index = text.indexOf(marker);
+        if (index >= 0) {
+            cut = Math.min(cut, index);
+        }
+    }
+    return cut === text.length ? text : text.slice(0, cut).trim();
+}
+function summarizeDocument(text, limit) {
+    const headings = Array.from(text.matchAll(/^#{1,3}\s+.+$/gm))
+        .map((match) => match[0])
+        .slice(0, 5);
+    const intro = text
+        .split('\n\n')
+        .map((part) => part.trim())
+        .filter(Boolean)
+        .slice(0, 3)
+        .join('\n\n');
+    const body = headings.length > 0 ? `${headings.join('\n')}\n\n${intro}` : intro || text;
+    return truncateText(body, limit);
+}
+function summarizeListLike(text, limit) {
+    const sections = text.split(/\n---\n|\n\n(?=\*\*|\p{Emoji_Presentation}|\p{Emoji}\s)/u);
+    const picked = [];
+    let current = 0;
+    for (const section of sections) {
+        const trimmed = section.trim();
+        if (!trimmed) {
+            continue;
+        }
+        const nextLength = current + trimmed.length + 2;
+        if (picked.length > 0 && nextLength > limit) {
+            break;
+        }
+        picked.push(trimmed);
+        current = nextLength;
+    }
+    const summary = picked.join('\n\n');
+    return truncateText(summary || text, limit);
+}
+export function buildTextVariant(family, detail, text) {
+    const limit = getFamilyLimit(family, detail);
+    const cleaned = cleanText(text);
+    if (!cleaned) {
+        return '';
+    }
+    if (detail === 'full') {
+        return truncateText(cleaned, limit);
+    }
+    switch (family) {
+        case 'streamingConfig':
+            return truncateText(stripExampleCode(cleaned), limit);
+        case 'document':
+            return summarizeDocument(stripExampleCode(cleaned), limit);
+        case 'list':
+        case 'history':
+        case 'catalog':
+            return summarizeListLike(stripExampleCode(cleaned), limit);
+        case 'scalar':
+        case 'mutationReceipt':
+        case 'record':
+        default:
+            return truncateText(stripExampleCode(cleaned), limit);
+    }
+}
+export function estimateRenderedSize(text) {
+    return cleanText(text).length;
+}
+export function collectSectionHints(text) {
+    return Array.from(text.matchAll(/^#{1,3}\s+(.+)$/gm))
+        .map((match) => match[1].trim())
+        .filter(Boolean)
+        .slice(0, 12);
+}
+export function applySectionSelection(text, section) {
+    if (!section) {
+        return text;
+    }
+    const extracted = extractSections(text, section, { includeLooseMatches: true });
+    if (extracted) {
+        return extracted;
+    }
+    return `No section matching "${section}" was found.\n\n${text}`;
+}
+export function applyItemSelection(text, item) {
+    if (item === undefined) {
+        return text;
+    }
+    const sections = text
+        .split(/\n---\n|\n\n(?=\*\*|\p{Emoji_Presentation}|\p{Emoji}\s)/u)
+        .map((part) => part.trim())
+        .filter(Boolean);
+    const index = item - 1;
+    if (index < 0 || index >= sections.length) {
+        return `Item ${item} was not found.\n\n${text}`;
+    }
+    return sections[index];
+}
+export function applyRangeSelection(text, range) {
+    if (!range) {
+        return text;
+    }
+    const match = range.match(/^(\d+):(\d+)$/);
+    if (!match) {
+        return `Invalid range "${range}". Expected "start:end".\n\n${text}`;
+    }
+    const start = Number(match[1]);
+    const end = Number(match[2]);
+    if (!Number.isInteger(start) || !Number.isInteger(end) || start < 0 || end <= start) {
+        return `Invalid range "${range}". Expected "start:end" with start >= 0 and end > start.\n\n${text}`;
+    }
+    return text.slice(start, end);
+}
+export function mcpText(text, meta) {
+    return {
+        content: [{ type: 'text', text }],
+        ...(meta === undefined ? {} : { _meta: meta }),
+    };
+}
+export function mcpErrorCompact(text, meta) {
+    return {
+        content: [{ type: 'text', text }],
+        isError: true,
+        ...(meta === undefined ? {} : { _meta: meta }),
+    };
+}
+export function mcpResultHandle(summary, resultId, availableExpansions, meta) {
+    const lines = [summary, '', `resultId: ${resultId}`];
+    if (availableExpansions.length > 0) {
+        lines.push(`expand: ${availableExpansions.join(', ')}`);
+    }
+    return mcpText(lines.join('\n'), meta);
+}

package/dist/router/schemas.d.ts

@@ -0,0 +1,224 @@
+import { z } from 'zod';
+export declare const HeliusAccountActionSchema: z.ZodEnum<["getStarted", "setHeliusApiKey", "generateKeypair", "signup", "getAccountStatus", "getAccountPlan", "getHeliusPlanInfo", "compareHeliusPlans", "previewUpgrade", "upgradePlan", "payRenewal", "purchaseCredits"]>;
+export declare const HeliusWalletActionSchema: z.ZodEnum<["getBalance", "getTokenBalances", "getWalletBalances", "getWalletBalanceAt", "getWalletHistory", "getWalletTransfers", "getWalletIdentity", "batchWalletIdentity", "getWalletFundedBy"]>;
+export declare const HeliusAssetActionSchema: z.ZodEnum<["getAsset", "getAssetsByOwner", "searchAssets", "getAssetsByGroup", "getAssetProof", "getAssetProofBatch", "getSignaturesForAsset", "getNftEditions", "getTokenHolders"]>;
+export declare const HeliusTransactionActionSchema: z.ZodEnum<["parseTransactions", "getTransactionHistory", "getTransfersByAddress"]>;
+export declare const HeliusChainActionSchema: z.ZodEnum<["getAccountInfo", "getTokenAccounts", "getProgramAccounts", "getBlock", "getNetworkStatus", "getPriorityFeeEstimate", "simulateTransaction", "getStakeAccounts", "getWithdrawableAmount"]>;
+export declare const HeliusStreamingActionSchema: z.ZodEnum<["createWebhook", "getAllWebhooks", "getWebhookByID", "updateWebhook", "deleteWebhook", "transactionSubscribe", "accountSubscribe", "laserstreamSubscribe"]>;
+export declare const HeliusKnowledgeActionSchema: z.ZodEnum<["lookupHeliusDocs", "listHeliusDocTopics", "getHeliusCreditsInfo", "getRateLimitInfo", "troubleshootError", "recommendStack", "getSIMD", "listSIMDs", "searchSolanaDocs", "readSolanaSourceFile", "fetchHeliusBlog", "getPumpFunGuide", "getSenderInfo", "getWebhookGuide", "getLatencyComparison", "getEnhancedWebSocketInfo", "getLaserstreamInfo"]>;
+export declare const HeliusWriteActionSchema: z.ZodEnum<["transferSol", "transferToken", "stakeSOL", "unstakeSOL", "withdrawStake"]>;
+export declare const HeliusCompressionActionSchema: z.ZodEnum<["getCompressedAccount", "getCompressedAccountsByOwner", "getMultipleCompressedAccounts", "getCompressedBalance", "getCompressedBalanceByOwner", "getCompressedMintTokenHolders", "getCompressedTokenAccountBalance", "getCompressedTokenAccountsByOwner", "getCompressedTokenAccountsByDelegate", "getCompressedTokenBalancesByOwnerV2", "getCompressedAccountProof", "getMultipleCompressedAccountProofs", "getMultipleNewAddressProofs", "getCompressionSignaturesForAccount", "getCompressionSignaturesForAddress", "getCompressionSignaturesForOwner", "getCompressionSignaturesForTokenOwner", "getLatestCompressionSignatures", "getLatestNonVotingSignatures", "getTransactionWithCompressionInfo", "getValidityProof", "getIndexerHealth", "getIndexerSlot"]>;
+export declare const HELIUS_ACCOUNT_SCHEMA: {
+    action: z.ZodEnum<["getStarted", "setHeliusApiKey", "generateKeypair", "signup", "getAccountStatus", "getAccountPlan", "getHeliusPlanInfo", "compareHeliusPlans", "previewUpgrade", "upgradePlan", "payRenewal", "purchaseCredits"]>;
+    detail: z.ZodOptional<z.ZodEnum<["summary", "standard", "full"]>>;
+    args: z.ZodOptional<z.ZodUnion<[z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, z.ZodPipeline<z.ZodEffects<z.ZodString, any, string>, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>]>>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    network: z.ZodOptional<z.ZodString>;
+    paymentIntentId: z.ZodOptional<z.ZodString>;
+    plan: z.ZodOptional<z.ZodString>;
+    period: z.ZodOptional<z.ZodString>;
+    couponCode: z.ZodOptional<z.ZodString>;
+    email: z.ZodOptional<z.ZodString>;
+    firstName: z.ZodOptional<z.ZodString>;
+    lastName: z.ZodOptional<z.ZodString>;
+    discoveryPath: z.ZodOptional<z.ZodString>;
+    frictionPoints: z.ZodOptional<z.ZodString>;
+} & {
+    readonly _feedback: z.ZodString;
+    readonly _feedbackTool: z.ZodString;
+    readonly _model: z.ZodString;
+};
+export declare const HELIUS_WALLET_SCHEMA: {
+    action: z.ZodEnum<["getBalance", "getTokenBalances", "getWalletBalances", "getWalletBalanceAt", "getWalletHistory", "getWalletTransfers", "getWalletIdentity", "batchWalletIdentity", "getWalletFundedBy"]>;
+    detail: z.ZodOptional<z.ZodEnum<["summary", "standard", "full"]>>;
+    args: z.ZodOptional<z.ZodUnion<[z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, z.ZodPipeline<z.ZodEffects<z.ZodString, any, string>, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>]>>;
+    address: z.ZodOptional<z.ZodString>;
+    addresses: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    mint: z.ZodOptional<z.ZodString>;
+    time: z.ZodOptional<z.ZodNumber>;
+    datetime: z.ZodOptional<z.ZodString>;
+    slot: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    before: z.ZodOptional<z.ZodString>;
+    after: z.ZodOptional<z.ZodString>;
+    showNfts: z.ZodOptional<z.ZodBoolean>;
+    showZeroBalance: z.ZodOptional<z.ZodBoolean>;
+    showNative: z.ZodOptional<z.ZodBoolean>;
+} & {
+    readonly _feedback: z.ZodString;
+    readonly _feedbackTool: z.ZodString;
+    readonly _model: z.ZodString;
+};
+export declare const HELIUS_ASSET_SCHEMA: {
+    action: z.ZodEnum<["getAsset", "getAssetsByOwner", "searchAssets", "getAssetsByGroup", "getAssetProof", "getAssetProofBatch", "getSignaturesForAsset", "getNftEditions", "getTokenHolders"]>;
+    detail: z.ZodOptional<z.ZodEnum<["summary", "standard", "full"]>>;
+    args: z.ZodOptional<z.ZodUnion<[z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, z.ZodPipeline<z.ZodEffects<z.ZodString, any, string>, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>]>>;
+    id: z.ZodOptional<z.ZodString>;
+    ids: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    address: z.ZodOptional<z.ZodString>;
+    ownerAddress: z.ZodOptional<z.ZodString>;
+    creatorAddress: z.ZodOptional<z.ZodString>;
+    authorityAddress: z.ZodOptional<z.ZodString>;
+    groupKey: z.ZodOptional<z.ZodString>;
+    groupValue: z.ZodOptional<z.ZodString>;
+    mint: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNumber>;
+    name: z.ZodOptional<z.ZodString>;
+    compressed: z.ZodOptional<z.ZodBoolean>;
+    burnt: z.ZodOptional<z.ZodBoolean>;
+    frozen: z.ZodOptional<z.ZodBoolean>;
+    onlyVerified: z.ZodOptional<z.ZodBoolean>;
+} & {
+    readonly _feedback: z.ZodString;
+    readonly _feedbackTool: z.ZodString;
+    readonly _model: z.ZodString;
+};
+export declare const HELIUS_TRANSACTION_SCHEMA: {
+    action: z.ZodEnum<["parseTransactions", "getTransactionHistory", "getTransfersByAddress"]>;
+    detail: z.ZodOptional<z.ZodEnum<["summary", "standard", "full"]>>;
+    args: z.ZodOptional<z.ZodUnion<[z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, z.ZodPipeline<z.ZodEffects<z.ZodString, any, string>, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>]>>;
+    address: z.ZodOptional<z.ZodString>;
+    signature: z.ZodOptional<z.ZodString>;
+    signatures: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    before: z.ZodOptional<z.ZodString>;
+    until: z.ZodOptional<z.ZodString>;
+    paginationToken: z.ZodOptional<z.ZodString>;
+    sortOrder: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodString>;
+    transactionDetails: z.ZodOptional<z.ZodString>;
+    tokenAccounts: z.ZodOptional<z.ZodString>;
+} & {
+    readonly _feedback: z.ZodString;
+    readonly _feedbackTool: z.ZodString;
+    readonly _model: z.ZodString;
+};
+export declare const HELIUS_CHAIN_SCHEMA: {
+    action: z.ZodEnum<["getAccountInfo", "getTokenAccounts", "getProgramAccounts", "getBlock", "getNetworkStatus", "getPriorityFeeEstimate", "simulateTransaction", "getStakeAccounts", "getWithdrawableAmount"]>;
+    detail: z.ZodOptional<z.ZodEnum<["summary", "standard", "full"]>>;
+    args: z.ZodOptional<z.ZodUnion<[z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, z.ZodPipeline<z.ZodEffects<z.ZodString, any, string>, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>]>>;
+    address: z.ZodOptional<z.ZodString>;
+    addresses: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    programId: z.ZodOptional<z.ZodString>;
+    slot: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNumber>;
+    stakeAccount: z.ZodOptional<z.ZodString>;
+    accountKeys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    priorityLevel: z.ZodOptional<z.ZodString>;
+    includeAllLevels: z.ZodOptional<z.ZodBoolean>;
+    encoding: z.ZodOptional<z.ZodString>;
+    dataSize: z.ZodOptional<z.ZodNumber>;
+    owner: z.ZodOptional<z.ZodString>;
+    mint: z.ZodOptional<z.ZodString>;
+    transaction: z.ZodOptional<z.ZodString>;
+    sigVerify: z.ZodOptional<z.ZodBoolean>;
+    replaceRecentBlockhash: z.ZodOptional<z.ZodBoolean>;
+    commitment: z.ZodOptional<z.ZodString>;
+} & {
+    readonly _feedback: z.ZodString;
+    readonly _feedbackTool: z.ZodString;
+    readonly _model: z.ZodString;
+};
+export declare const HELIUS_STREAMING_SCHEMA: {
+    action: z.ZodEnum<["createWebhook", "getAllWebhooks", "getWebhookByID", "updateWebhook", "deleteWebhook", "transactionSubscribe", "accountSubscribe", "laserstreamSubscribe"]>;
+    detail: z.ZodOptional<z.ZodEnum<["summary", "standard", "full"]>>;
+    args: z.ZodOptional<z.ZodUnion<[z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, z.ZodPipeline<z.ZodEffects<z.ZodString, any, string>, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>]>>;
+    account: z.ZodOptional<z.ZodString>;
+    accountAddresses: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    webhookID: z.ZodOptional<z.ZodString>;
+    webhookURL: z.ZodOptional<z.ZodString>;
+    transactionTypes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    signature: z.ZodOptional<z.ZodString>;
+    encoding: z.ZodOptional<z.ZodString>;
+    commitment: z.ZodOptional<z.ZodString>;
+    region: z.ZodOptional<z.ZodString>;
+    webhookType: z.ZodOptional<z.ZodString>;
+    accountInclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    accountExclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    accountRequired: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    subscribeAccounts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    accountOwners: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    transactionAccountInclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    transactionAccountExclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    transactionAccountRequired: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+} & {
+    readonly _feedback: z.ZodString;
+    readonly _feedbackTool: z.ZodString;
+    readonly _model: z.ZodString;
+};
+export declare const HELIUS_KNOWLEDGE_SCHEMA: {
+    action: z.ZodEnum<["lookupHeliusDocs", "listHeliusDocTopics", "getHeliusCreditsInfo", "getRateLimitInfo", "troubleshootError", "recommendStack", "getSIMD", "listSIMDs", "searchSolanaDocs", "readSolanaSourceFile", "fetchHeliusBlog", "getPumpFunGuide", "getSenderInfo", "getWebhookGuide", "getLatencyComparison", "getEnhancedWebSocketInfo", "getLaserstreamInfo"]>;
+    detail: z.ZodOptional<z.ZodEnum<["summary", "standard", "full"]>>;
+    args: z.ZodOptional<z.ZodUnion<[z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, z.ZodPipeline<z.ZodEffects<z.ZodString, any, string>, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>]>>;
+    topic: z.ZodOptional<z.ZodString>;
+    section: z.ZodOptional<z.ZodString>;
+    query: z.ZodOptional<z.ZodString>;
+    slug: z.ZodOptional<z.ZodString>;
+    number: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+    repo: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    budget: z.ZodOptional<z.ZodString>;
+    complexity: z.ZodOptional<z.ZodString>;
+    scale: z.ZodOptional<z.ZodString>;
+    remember: z.ZodOptional<z.ZodBoolean>;
+    errorCode: z.ZodOptional<z.ZodString>;
+} & {
+    readonly _feedback: z.ZodString;
+    readonly _feedbackTool: z.ZodString;
+    readonly _model: z.ZodString;
+};
+export declare const HELIUS_WRITE_SCHEMA: {
+    action: z.ZodEnum<["transferSol", "transferToken", "stakeSOL", "unstakeSOL", "withdrawStake"]>;
+    detail: z.ZodOptional<z.ZodEnum<["summary", "standard", "full"]>>;
+    args: z.ZodOptional<z.ZodUnion<[z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, z.ZodPipeline<z.ZodEffects<z.ZodString, any, string>, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>]>>;
+    recipientAddress: z.ZodOptional<z.ZodString>;
+    mintAddress: z.ZodOptional<z.ZodString>;
+    amount: z.ZodOptional<z.ZodNumber>;
+    sendMax: z.ZodOptional<z.ZodBoolean>;
+    stakeAccount: z.ZodOptional<z.ZodString>;
+    destination: z.ZodOptional<z.ZodString>;
+    owsWallet: z.ZodOptional<z.ZodString>;
+} & {
+    readonly _feedback: z.ZodString;
+    readonly _feedbackTool: z.ZodString;
+    readonly _model: z.ZodString;
+};
+export declare const HELIUS_COMPRESSION_SCHEMA: {
+    action: z.ZodEnum<["getCompressedAccount", "getCompressedAccountsByOwner", "getMultipleCompressedAccounts", "getCompressedBalance", "getCompressedBalanceByOwner", "getCompressedMintTokenHolders", "getCompressedTokenAccountBalance", "getCompressedTokenAccountsByOwner", "getCompressedTokenAccountsByDelegate", "getCompressedTokenBalancesByOwnerV2", "getCompressedAccountProof", "getMultipleCompressedAccountProofs", "getMultipleNewAddressProofs", "getCompressionSignaturesForAccount", "getCompressionSignaturesForAddress", "getCompressionSignaturesForOwner", "getCompressionSignaturesForTokenOwner", "getLatestCompressionSignatures", "getLatestNonVotingSignatures", "getTransactionWithCompressionInfo", "getValidityProof", "getIndexerHealth", "getIndexerSlot"]>;
+    detail: z.ZodOptional<z.ZodEnum<["summary", "standard", "full"]>>;
+    args: z.ZodOptional<z.ZodUnion<[z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>, z.ZodPipeline<z.ZodEffects<z.ZodString, any, string>, z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>]>>;
+    address: z.ZodOptional<z.ZodString>;
+    addresses: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    hash: z.ZodOptional<z.ZodString>;
+    hashes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    owner: z.ZodOptional<z.ZodString>;
+    delegate: z.ZodOptional<z.ZodString>;
+    mint: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+} & {
+    readonly _feedback: z.ZodString;
+    readonly _feedbackTool: z.ZodString;
+    readonly _model: z.ZodString;
+};
+export declare const EXPAND_RESULT_SCHEMA: {
+    resultId: z.ZodString;
+    section: z.ZodOptional<z.ZodString>;
+    item: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodOptional<z.ZodNumber>;
+    range: z.ZodOptional<z.ZodString>;
+    continuation: z.ZodOptional<z.ZodString>;
+    detail: z.ZodOptional<z.ZodEnum<["summary", "standard", "full"]>>;
+} & {
+    readonly _feedback: z.ZodString;
+    readonly _feedbackTool: z.ZodString;
+    readonly _model: z.ZodString;
+};