helius-mcp 0.2.4 → 0.4.1

package/README.md

@@ -1,150 +1,42 @@
 # Helius MCP Server
 
-Official Model Context Protocol (MCP) server for Helius - Complete Solana blockchain data access for Claude.
+MCP server for Helius - Solana blockchain data access for Claude.
 
-## Features
+## Setup
 
-**29 Tools Covering:**
-- ✅ Digital Asset Standard (DAS) API - NFTs, tokens, compressed NFTs
-- ✅ RPC Methods - Balances, accounts, signatures
-- ✅ Enhanced Transactions - Human-readable parsing
-- ✅ Priority Fees - Real-time fee estimation
-- ✅ Webhooks - Event monitoring and notifications
-- ✅ Enhanced WebSockets - Real-time streaming (1.5-2× faster)
-- ✅ Laserstream gRPC - Lowest latency streaming with 24h replay
-
-**Network Support:**
-- Mainnet Beta
-- Devnet
-
-## Installation
+```bash
+claude mcp add helius npx helius-mcp@latest
+```
 
+Set your API key:
 ```bash
-npm install -g @helius-labs/mcp-server
+export HELIUS_API_KEY=your-api-key
 ```
 
-## Quick Start
+## Tools (29)
 
-### 1. Get Helius API Key
+**DAS API (12):** getAsset, getAssetBatch, getAssetsByOwner, getAssetsByGroup, getAssetsByCreator, getAssetsByAuthority, searchAssets, getAssetProof, getAssetProofBatch, getSignaturesForAsset, getNftEditions, getTokenAccounts
 
-Sign up at [helius.dev](https://www.helius.dev) and create an API key.
+**RPC (4):** getBalance, getAccountInfo, getMultipleAccounts, getSignaturesForAddress
 
-### 2. Configure Claude Desktop
+**Transactions (1):** parseTransactions
 
-Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
+**Priority Fees (1):** getPriorityFeeEstimate
 
-```json
-{
-  "mcpServers": {
-    "helius": {
-      "command": "helius-mcp",
-      "env": {
-        "HELIUS_API_KEY": "your-api-key-here",
-        "HELIUS_NETWORK": "mainnet-beta"
-      }
-    }
-  }
-}
-```
+**Webhooks (5):** getAllWebhooks, getWebhookByID, createWebhook, updateWebhook, deleteWebhook
 
-### 3. Restart Claude Desktop
+**Enhanced WebSockets (3):** transactionSubscribe, accountSubscribe, getEnhancedWebSocketInfo
 
-The Helius tools will now be available in Claude.
+**Laserstream gRPC (2):** laserstreamSubscribe, getLaserstreamInfo
 
-## Usage Examples
+**Config (1):** setHeliusApiKey
 
-**Check wallet balance:**
-```
-What's the SOL balance for vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg?
-```
-
-**Get NFT information:**
-```
-Show me details for NFT FKZJkqv2YbXmcGWbp2RJfhVmpE6PnSaq6dMj1DKXgj1m
-```
+## Networks
 
-**Monitor transactions:**
-```
-Set up a webhook to track transactions for wallet ABC...XYZ
-```
+Mainnet Beta and Devnet. Set via `HELIUS_NETWORK` env var.
 
-**Real-time streaming:**
-```
-Show me how to subscribe to Raydium swap transactions
-```
+## Docs
 
-## Available Tools
-
-### Config (1 tool)
-- `setHeliusApiKey` - Configure API key and network
-
-### DAS API (12 tools)
-- `getAsset` - NFT/token details
-- `getAssetBatch` - Batch fetch assets
-- `getAssetsByOwner` - Wallet's assets
-- `getAssetsByGroup` - Collection NFTs
-- `getAssetsByCreator` - Creator's assets
-- `getAssetsByAuthority` - Authority's assets
-- `searchAssets` - Advanced search
-- `getAssetProof` - cNFT Merkle proof
-- `getAssetProofBatch` - Batch proofs
-- `getSignaturesForAsset` - cNFT transaction history
-- `getNftEditions` - Edition NFTs
-- `getTokenAccounts` - Token account queries
-
-### RPC Methods (4 tools)
-- `getBalance` - SOL balance
-- `getAccountInfo` - Account details
-- `getMultipleAccounts` - Batch account lookups
-- `getSignaturesForAddress` - Transaction signatures
-
-### Enhanced Transactions (1 tool)
-- `parseTransactions` - Human-readable parsing
-
-### Priority Fees (1 tool)
-- `getPriorityFeeEstimate` - Optimal fees
-
-### Webhooks (5 tools)
-- `getAllWebhooks` - List webhooks
-- `getWebhookByID` - Webhook details
-- `createWebhook` - Create webhook
-- `updateWebhook` - Update webhook
-- `deleteWebhook` - Delete webhook
-
-### Enhanced WebSockets (3 tools)
-- `transactionSubscribe` - Real-time transaction streaming
-- `accountSubscribe` - Real-time account monitoring
-- `getEnhancedWebSocketInfo` - WebSocket service info
-
-### Laserstream gRPC (2 tools)
-- `laserstreamSubscribe` - High-performance gRPC streaming
-- `getLaserstreamInfo` - Laserstream service info
-
-## Plan Requirements
-
-### Enhanced WebSockets
-- Free/Developer: ❌ Not available
-- Business: ✅ 250 connections
-- Professional: ✅ 250 connections
-
-### Laserstream gRPC
-- Free: ❌ Not available
-- Developer: ✅ Devnet only
-- Business: ✅ Devnet only
-- Professional: ✅ Mainnet + Devnet
-
-## Documentation
-
-- [Helius API Documentation](https://docs.helius.dev)
+- [Helius API](https://docs.helius.dev)
 - [Enhanced WebSockets](https://docs.helius.dev/enhanced-websockets)
-- [Laserstream gRPC](https://docs.helius.dev/laserstream)
-- [MCP Protocol](https://modelcontextprotocol.io)
-
-## Support
-
-- GitHub Issues: [helius-labs/helius-mcp-server](https://github.com/helius-labs/helius-mcp-server/issues)
-- Discord: [Helius Discord](https://discord.gg/aYYStRz3YX)
-
-## License
-
-MIT
+- [Laserstream](https://docs.helius.dev/laserstream)

package/dist/index.js

@@ -4,26 +4,18 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { registerTools } from './tools/index.js';
 import { setApiKey } from './utils/helius.js';
 const server = new McpServer({
-    name: 'helius-claude-plugin',
-    version: '0.2.4'
+    name: 'helius-mcp',
+    version: '0.3.0'
 });
-// Register all tools
 registerTools(server);
-// Start the server
 async function main() {
-    // Auto-configure API key from environment if available
     if (process.env.HELIUS_API_KEY) {
         setApiKey(process.env.HELIUS_API_KEY);
-        console.error('✅ Helius API key loaded from environment');
-    }
-    else {
-        console.error('ℹ️  No API key found. Use setHeliusApiKey tool or set HELIUS_API_KEY environment variable');
     }
     const transport = new StdioServerTransport();
     await server.connect(transport);
-    console.error('🚀 Helius MCP Server v0.2.4 running (29 tools)');
 }
 main().catch((error) => {
-    console.error('Failed to start server:', error);
+    console.error('Failed to start:', error);
     process.exit(1);
 });

package/dist/tools/accounts.js

@@ -1,197 +1,307 @@
 import { z } from 'zod';
-import { getHeliusClient, hasApiKey } from '../utils/helius.js';
+import { getHeliusClient, hasApiKey, getRpcUrl } from '../utils/helius.js';
 import { formatAddress, formatSol } from '../utils/formatters.js';
 import { noApiKeyResponse } from './shared.js';
+function formatParsedAccountData(account) {
+    const lines = [];
+    const parsedData = account.data;
+    if (parsedData?.program) {
+        lines.push(`  Program: ${parsedData.program}`);
+    }
+    if (parsedData?.parsed?.type) {
+        lines.push(`  Account Type: ${parsedData.parsed.type}`);
+    }
+    if (parsedData?.parsed?.info) {
+        for (const [key, value] of Object.entries(parsedData.parsed.info)) {
+            const display = typeof value === 'object' ? JSON.stringify(value) : String(value);
+            lines.push(`  ${key}: ${display}`);
+        }
+    }
+    return lines;
+}
 export function registerAccountTools(server) {
-    // Get multiple account balances at once
-    server.tool('getMultipleAccounts', 'Get account info for multiple addresses in a single call (up to 100 addresses). More efficient than calling getBalance repeatedly. Returns SOL balance, owner, executable status, and rent epoch for each account.', {
-        addresses: z.array(z.string()).describe('Array of Solana addresses (max 100)'),
-        commitment: z.enum(['processed', 'confirmed', 'finalized']).optional().default('confirmed')
-    }, async ({ addresses, commitment }) => {
+    // Get Account Info (single or batch) — uses direct JSON-RPC
+    server.tool('getAccountInfo', 'Get detailed Solana account information for one or more accounts. For a single account: returns owner program, lamport balance, data size, executable status, and rent epoch. For batch: pass up to 100 addresses in "addresses" for fast bulk lookups. Use jsonParsed encoding (default) on token mint addresses to see Token-2022 extensions, authorities, and supply data. Use this to inspect any on-chain account.', {
+        address: z.string().optional().describe('Single account address (base58 encoded). Use this OR addresses, not both.'),
+        addresses: z.array(z.string()).optional().describe('Array of account addresses for batch lookup (up to 100). Use this OR address, not both.'),
+        encoding: z.enum(['base58', 'base64', 'jsonParsed']).optional().default('jsonParsed').describe('Data encoding format')
+    }, async ({ address, addresses, encoding }) => {
         if (!hasApiKey())
             return noApiKeyResponse();
-        if (addresses.length > 100) {
+        const url = getRpcUrl();
+        // Validate: must provide exactly one of address or addresses
+        if (!address && (!addresses || addresses.length === 0)) {
             return {
                 content: [{
                         type: 'text',
-                        text: '**Error**\n\nMaximum 100 addresses allowed per request'
-                    }],
-                isError: true
+                        text: `**Error:** Provide either \`address\` (single account) or \`addresses\` (batch of up to 100).`
+                    }]
             };
         }
-        try {
-            const helius = getHeliusClient();
-            const connection = helius.connection;
-            if (!connection || !connection.getMultipleAccountsInfo) {
+        if (address && addresses && addresses.length > 0) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `**Error:** Provide either \`address\` or \`addresses\`, not both.`
+                    }]
+            };
+        }
+        // --- Batch mode ---
+        if (addresses && addresses.length > 0) {
+            if (addresses.length > 100) {
                 return {
                     content: [{
                             type: 'text',
-                            text: '**Error**\n\nMultiple account lookup not available'
-                        }],
-                    isError: true
+                            text: `**Error:** Maximum 100 accounts per request. You provided ${addresses.length}.`
+                        }]
                 };
             }
-            const accountsInfo = await connection.getMultipleAccountsInfo(addresses, { commitment });
-            const lines = [
-                `**Account Info (${addresses.length} addresses)**`,
-                ``
-            ];
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    jsonrpc: '2.0',
+                    id: 'get-multiple-accounts',
+                    method: 'getMultipleAccounts',
+                    params: [addresses, { encoding }]
+                })
+            });
+            const data = await response.json();
+            if (data.error) {
+                return {
+                    content: [{
+                            type: 'text',
+                            text: `**Error**\n\n${data.error.message}`
+                        }]
+                };
+            }
+            const accounts = data.result?.value || [];
+            const lines = [`**Multiple Accounts** (${addresses.length} requested)`, ''];
             addresses.forEach((addr, i) => {
-                const info = accountsInfo[i];
-                if (!info) {
-                    lines.push(`${i + 1}. ${formatAddress(addr)} - Account does not exist`);
-                    return;
+                const account = accounts[i];
+                if (!account) {
+                    lines.push(`**${formatAddress(addr)}:** Not found`);
                 }
-                lines.push(`${i + 1}. ${formatAddress(addr)}`);
-                lines.push(`   Balance: ${formatSol(info.lamports)}`);
-                lines.push(`   Owner: ${formatAddress(info.owner.toBase58())}`);
-                if (info.executable) {
-                    lines.push(`   ⚡ Executable program`);
+                else {
+                    lines.push(`**${formatAddress(addr)}**`);
+                    lines.push(`  Balance: ${formatSol(account.lamports)}`);
+                    lines.push(`  Owner: ${account.owner}`);
+                    lines.push(`  Executable: ${account.executable ? 'Yes' : 'No'}`);
+                    if (account.space !== undefined) {
+                        lines.push(`  Data Size: ${account.space} bytes`);
+                    }
+                    // Show parsed data (Token-2022 extensions, mint info, etc.)
+                    const parsedLines = formatParsedAccountData(account);
+                    lines.push(...parsedLines);
                 }
-                lines.push(``);
+                lines.push('');
             });
             return {
-                content: [{ type: 'text', text: lines.join('\n') }]
+                content: [{
+                        type: 'text',
+                        text: lines.join('\n')
+                    }]
+            };
+        }
+        // --- Single account mode ---
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 'get-account-info',
+                method: 'getAccountInfo',
+                params: [address, { encoding }]
+            })
+        });
+        const data = await response.json();
+        if (data.error) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `**Error**\n\n${data.error.message}`
+                    }]
             };
         }
-        catch (error) {
+        const account = data.result?.value;
+        if (!account) {
             return {
-                content: [{ type: 'text', text: `**Error**\n\n${error.message}` }],
-                isError: true
+                content: [{
+                        type: 'text',
+                        text: `**Account ${formatAddress(address)}**\n\nAccount not found or has no data.`
+                    }]
             };
         }
+        const lines = [
+            `**Account ${formatAddress(address)}**`,
+            '',
+            `**Balance:** ${formatSol(account.lamports)} (${account.lamports.toLocaleString()} lamports)`,
+            `**Owner:** ${account.owner}`,
+            `**Executable:** ${account.executable ? 'Yes' : 'No'}`,
+        ];
+        if (account.space !== undefined) {
+            lines.push(`**Data Size:** ${account.space} bytes`);
+        }
+        // Show parsed data details when using jsonParsed
+        const parsedLines = formatParsedAccountData(account);
+        if (parsedLines.length > 0) {
+            lines.push('', '**Parsed Data:**');
+            lines.push(...parsedLines);
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: lines.join('\n')
+                }]
+        };
     });
-    // Get program accounts
-    server.tool('getProgramAccounts', 'Query all accounts owned by a program. Use filters to narrow results (e.g., token accounts for a specific mint, PDAs with certain data). Returns account addresses and data. Warning: Can be slow for programs with many accounts.', {
-        programId: z.string().describe('Program address to query'),
-        filters: z.array(z.object({
-            memcmp: z.object({
-                offset: z.number(),
-                bytes: z.string()
-            }).optional(),
-            dataSize: z.number().optional()
-        })).optional().describe('Optional filters to narrow results'),
-        limit: z.number().optional().default(10).describe('Max accounts to return')
-    }, async ({ programId, filters, limit }) => {
+    // Get Token Accounts
+    server.tool('getTokenAccounts', 'Query token accounts with advanced filters. Can filter by mint address, owner address, or both. Returns token account addresses and balances.', {
+        owner: z.string().optional().describe('Filter by owner wallet address'),
+        mint: z.string().optional().describe('Filter by token mint address'),
+        page: z.number().optional().default(1).describe('Page number (starts at 1)'),
+        limit: z.number().optional().default(20).describe('Results per page (max 1000)')
+    }, async ({ owner, mint, page, limit }) => {
         if (!hasApiKey())
             return noApiKeyResponse();
-        try {
-            const helius = getHeliusClient();
-            const connection = helius.connection;
-            if (!connection || !connection.getProgramAccounts) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: '**Error**\n\nProgram account lookup not available'
-                        }],
-                    isError: true
-                };
-            }
-            const config = {};
-            if (filters && filters.length > 0) {
-                config.filters = filters;
-            }
-            const accounts = await connection.getProgramAccounts(programId, config);
-            if (!accounts || accounts.length === 0) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `**No Accounts Found**\n\nProgram: ${formatAddress(programId)}`
-                        }]
-                };
-            }
-            const lines = [
-                `**Program Accounts**`,
-                ``,
-                `Program: ${formatAddress(programId)}`,
-                `Total: ${accounts.length} accounts`,
-                ``
-            ];
-            const displayAccounts = accounts.slice(0, limit);
-            displayAccounts.forEach((account, i) => {
-                const pubkey = account.pubkey.toBase58();
-                const lamports = account.account.lamports;
-                const dataLength = account.account.data.length;
-                lines.push(`${i + 1}. ${formatAddress(pubkey)}`);
-                lines.push(`   Balance: ${formatSol(lamports)}`);
-                lines.push(`   Data: ${dataLength} bytes`);
-            });
-            if (accounts.length > limit) {
-                lines.push(``);
-                lines.push(`💡 Showing first ${limit} of ${accounts.length} accounts`);
-            }
+        const helius = getHeliusClient();
+        if (!owner && !mint) {
             return {
-                content: [{ type: 'text', text: lines.join('\n') }]
+                content: [{
+                        type: 'text',
+                        text: `**Error:** You must provide at least one of: owner or mint address.`
+                    }]
             };
         }
-        catch (error) {
+        const params = { page, limit };
+        if (owner)
+            params.owner = owner;
+        if (mint)
+            params.mint = mint;
+        const response = await helius.getTokenAccounts(params);
+        const items = (response.token_accounts || []);
+        if (items.length === 0) {
+            const filterDesc = owner && mint
+                ? `owner=${formatAddress(owner)}, mint=${formatAddress(mint)}`
+                : owner
+                    ? `owner=${formatAddress(owner)}`
+                    : `mint=${formatAddress(mint)}`;
             return {
-                content: [{ type: 'text', text: `**Error**\n\n${error.message}` }],
-                isError: true
+                content: [{
+                        type: 'text',
+                        text: `**Token Accounts** (${filterDesc})\n\nNo token accounts found.`
+                    }]
             };
         }
+        const lines = [`**Token Accounts** (${response.total || items.length} total, page ${page})`, ''];
+        items.forEach((account) => {
+            const flags = [];
+            if (account.frozen)
+                flags.push('Frozen');
+            if (account.delegated_amount && account.delegated_amount > 0)
+                flags.push('Delegated');
+            const flagStr = flags.length > 0 ? ` [${flags.join(', ')}]` : '';
+            lines.push(`- **Account:** ${formatAddress(account.address)}${flagStr}`);
+            lines.push(`  Mint: ${formatAddress(account.mint)}`);
+            lines.push(`  Owner: ${formatAddress(account.owner)}`);
+            lines.push(`  Amount: ${account.amount.toLocaleString()}`);
+            if (account.delegated_amount && account.delegated_amount > 0) {
+                lines.push(`  Delegated: ${account.delegated_amount.toLocaleString()}`);
+            }
+            lines.push('');
+        });
+        return {
+            content: [{
+                    type: 'text',
+                    text: lines.join('\n')
+                }]
+        };
     });
-    // Get account info
-    server.tool('getAccountInfo', 'Get detailed information about a single Solana account including balance, owner, data, executable status, and rent epoch. Use this for inspecting program accounts, PDAs, or any on-chain account.', {
-        address: z.string().describe('Solana address to query'),
-        encoding: z.enum(['base58', 'base64', 'jsonParsed']).optional().default('base64')
-    }, async ({ address, encoding }) => {
+    // Get Program Accounts (V2 with pagination)
+    server.tool('getProgramAccounts', 'Get all accounts owned by a specific program. Returns account addresses, balances, and data sizes. Use dataSize to filter by account data length (e.g. 165 for token accounts). Useful for finding all accounts created by a program like a DEX, lending protocol, or custom program.', {
+        programId: z.string().describe('Program ID (base58 encoded) — the owner program of the accounts to find'),
+        limit: z.number().optional().default(20).describe('Maximum accounts to return (default 20, max 100)'),
+        encoding: z.enum(['base58', 'base64', 'jsonParsed']).optional().default('base64').describe('Data encoding format'),
+        dataSize: z.number().optional().describe('Filter by exact account data size in bytes (e.g. 165 for SPL token accounts)'),
+        paginationKey: z.string().optional().describe('Pagination cursor from a previous response to fetch the next page')
+    }, async ({ programId, limit, encoding, dataSize, paginationKey }) => {
         if (!hasApiKey())
             return noApiKeyResponse();
+        const url = getRpcUrl();
+        const cappedLimit = Math.min(limit, 10_000);
+        const filters = [];
+        if (dataSize !== undefined) {
+            filters.push({ dataSize });
+        }
+        const rpcParams = {
+            encoding,
+            dataSlice: { offset: 0, length: 0 },
+            limit: cappedLimit
+        };
+        if (filters.length > 0)
+            rpcParams.filters = filters;
+        if (paginationKey)
+            rpcParams.paginationKey = paginationKey;
+        const requestBody = {
+            jsonrpc: '2.0',
+            id: 'get-program-accounts-v2',
+            method: 'getProgramAccountsV2',
+            params: [programId, rpcParams]
+        };
+        let data;
         try {
-            const helius = getHeliusClient();
-            const connection = helius.connection;
-            if (!connection || !connection.getAccountInfo) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: '**Error**\n\nAccount info lookup not available'
-                        }],
-                    isError: true
-                };
-            }
-            const accountInfo = await connection.getAccountInfo(address, { encoding });
-            if (!accountInfo) {
-                return {
-                    content: [{
-                            type: 'text',
-                            text: `**Account Not Found**\n\n${formatAddress(address)}\n\nThis account does not exist or has been closed.`
-                        }]
-                };
-            }
-            const lines = [
-                `**Account Info**`,
-                ``,
-                `Address: ${formatAddress(address)}`,
-                `Balance: ${formatSol(accountInfo.lamports)}`,
-                `Owner: ${formatAddress(accountInfo.owner.toBase58())}`,
-                `Data Length: ${accountInfo.data.length} bytes`,
-                `Rent Epoch: ${accountInfo.rentEpoch}`,
-                ``
-            ];
-            if (accountInfo.executable) {
-                lines.push(`⚡ **Executable Program**`);
-                lines.push(``);
-            }
-            if (encoding === 'jsonParsed' && accountInfo.data.parsed) {
-                lines.push(`**Parsed Data:**`);
-                lines.push('```json');
-                lines.push(JSON.stringify(accountInfo.data.parsed, null, 2));
-                lines.push('```');
-            }
-            else if (accountInfo.data.length > 0 && accountInfo.data.length <= 100) {
-                lines.push(`**Data (first 100 bytes):**`);
-                lines.push(`${accountInfo.data.toString('hex').slice(0, 200)}...`);
-            }
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(requestBody)
+            });
+            data = await response.json();
+        }
+        catch (err) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: `**Error fetching program accounts:** ${err instanceof Error ? err.message : String(err)}`
+                    }]
+            };
+        }
+        if (data.error) {
             return {
-                content: [{ type: 'text', text: lines.join('\n') }]
+                content: [{
+                        type: 'text',
+                        text: `**Error**\n\n${data.error.message}`
+                    }]
             };
         }
-        catch (error) {
+        const accounts = data.result?.accounts || [];
+        if (accounts.length === 0) {
             return {
-                content: [{ type: 'text', text: `**Error**\n\n${error.message}` }],
-                isError: true
+                content: [{
+                        type: 'text',
+                        text: `**Program Accounts for ${formatAddress(programId)}**\n\nNo accounts found.`
+                    }]
             };
         }
+        const totalLabel = data.result?.totalResults
+            ? `${data.result.totalResults.toLocaleString()} total`
+            : `${accounts.length} returned`;
+        const lines = [`**Program Accounts for ${formatAddress(programId)}** (${totalLabel})`, ''];
+        accounts.forEach((item) => {
+            lines.push(`- **${formatAddress(item.pubkey)}**`);
+            lines.push(`  Balance: ${formatSol(item.account.lamports)}`);
+            if (item.account.space !== undefined) {
+                lines.push(`  Data Size: ${item.account.space} bytes`);
+            }
+            lines.push(`  Executable: ${item.account.executable ? 'Yes' : 'No'}`);
+        });
+        if (data.result?.paginationKey) {
+            lines.push('', `**Next Page:** Pass \`paginationKey: "${data.result.paginationKey}"\` to fetch the next page.`);
+        }
+        return {
+            content: [{
+                    type: 'text',
+                    text: lines.join('\n')
+                }]
+        };
     });
 }