mcp-crypto-price 2.1.4 → 2.2.0

package/dist/config/index.js

@@ -1,7 +1,28 @@
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, resolve } from 'path';
+function readVersion() {
+    try {
+        // ESM context — import.meta.url is available
+        const dir = dirname(fileURLToPath(import.meta.url));
+        const pkg = JSON.parse(readFileSync(resolve(dir, '../../package.json'), 'utf-8'));
+        return pkg.version;
+    }
+    catch {
+        // CJS context (e.g. Smithery esbuild bundle) — import.meta is empty
+        try {
+            const pkg = JSON.parse(readFileSync(resolve(__dirname, '../../package.json'), 'utf-8'));
+            return pkg.version;
+        }
+        catch {
+            return '0.0.0';
+        }
+    }
+}
 export const COINCAP_API_V2_BASE = "https://api.coincap.io/v2";
 export const COINCAP_API_V3_BASE = "https://rest.coincap.io/v3";
 export const SERVER_CONFIG = {
     name: "mcp-crypto-price",
-    version: "2.1.0",
+    version: readVersion(),
 };
 export const CACHE_TTL = 60000; // 1 minute cache

package/dist/index.js

@@ -5,7 +5,7 @@ import { z } from "zod";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { SERVER_CONFIG } from './config/index.js';
-import { handleGetPrice, handleGetMarketAnalysis, handleGetHistoricalAnalysis, GetPriceArgumentsSchema, GetMarketAnalysisSchema, GetHistoricalAnalysisSchema, } from './tools/index.js';
+import { handleGetPrice, handleGetMarketAnalysis, handleGetHistoricalAnalysis, handleGetTopAssets, GetPriceArgumentsSchema, GetMarketAnalysisSchema, GetHistoricalAnalysisSchema, GetTopAssetsSchema, } from './tools/index.js';
 export const configSchema = z.object({
     coincapApiKey: z
         .string()
@@ -44,6 +44,33 @@ export function createServer({ config, }) {
         const result = await handleGetHistoricalAnalysis(args);
         return result;
     });
+    server.registerTool("get-top-assets", {
+        title: "Get Top Assets",
+        description: "Get top cryptocurrencies ranked by market cap",
+        inputSchema: GetTopAssetsSchema.shape,
+    }, async (args, _extra) => {
+        const result = await handleGetTopAssets(args);
+        return result;
+    });
+    // Register a no-op resource so the server advertises resources capability
+    // during the MCP initialize handshake. Without this, clients may receive
+    // -32601 "Method not found" errors for resources/list.
+    server.registerResource("server-info", "info://server", {
+        title: "Server Info",
+        description: "Basic server information",
+        mimeType: "application/json",
+    }, async (uri) => ({
+        contents: [
+            {
+                uri: uri.href,
+                mimeType: "application/json",
+                text: JSON.stringify({
+                    name: SERVER_CONFIG.name,
+                    version: SERVER_CONFIG.version,
+                }),
+            },
+        ],
+    }));
     return server.server;
 }
 export default createServer;

package/dist/services/__tests__/coincap.test.js

@@ -23,7 +23,13 @@ describe('CoinCap Service', () => {
                         rank: '1',
                         symbol: 'BTC',
                         name: 'Bitcoin',
-                        priceUsd: '50000.00'
+                        priceUsd: '50000.00',
+                        changePercent24Hr: '2.50',
+                        volumeUsd24Hr: '30000000000',
+                        marketCapUsd: '950000000000',
+                        supply: '19000000',
+                        maxSupply: '21000000',
+                        vwap24Hr: '49500.00',
                     }
                 ]
             };
@@ -59,7 +65,10 @@ describe('CoinCap Service', () => {
                     {
                         exchangeId: 'binance',
                         baseSymbol: 'BTC',
-                        priceUsd: '50000.00'
+                        quoteSymbol: 'USDT',
+                        priceUsd: '50000.00',
+                        volumeUsd24Hr: '5000000000',
+                        percentExchangeVolume: '25.00',
                     }
                 ]
             };

package/dist/services/__tests__/formatters.test.js

@@ -23,6 +23,24 @@ describe('Formatters', () => {
             expect(formatted).toContain('Market Cap: $1000.00B');
             expect(formatted).toContain('Rank: #1');
         });
+        it('should use adaptive precision for low-value coins', () => {
+            const asset = {
+                id: 'shiba-inu',
+                rank: '15',
+                symbol: 'SHIB',
+                name: 'Shiba Inu',
+                priceUsd: '0.00001234',
+                changePercent24Hr: '2.50',
+                volumeUsd24Hr: '500000000',
+                marketCapUsd: '7000000000',
+                supply: '589000000000000',
+                maxSupply: '',
+                vwap24Hr: '0.00001200'
+            };
+            const formatted = formatPriceInfo(asset);
+            expect(formatted).toContain('Price: $0.00001234');
+            expect(formatted).not.toContain('Price: $0.00\n');
+        });
     });
     describe('formatMarketAnalysis', () => {
         it('should format market analysis correctly', () => {

package/dist/services/coincap.js

@@ -1,4 +1,5 @@
 import { COINCAP_API_V2_BASE, COINCAP_API_V3_BASE, CACHE_TTL } from '../config/index.js';
+import { AssetsResponseSchema, HistoricalDataSchema, MarketsResponseSchema } from './schemas.js';
 const cache = new Map();
 // Expose cache clear function for testing
 export function clearCache() {
@@ -27,7 +28,7 @@ function setCacheData(key, data) {
  * 2. If v3 fails or no API key is provided, falls back to v2
  * 3. If both fail, throws an error
  */
-async function makeCoinCapRequest(endpoint) {
+async function makeCoinCapRequest(endpoint, schema) {
     // Check cache first
     const cacheKey = endpoint;
     const cachedData = getCachedData(cacheKey);
@@ -45,7 +46,8 @@ async function makeCoinCapRequest(endpoint) {
                 }
             });
             if (v3Response.ok) {
-                const data = await v3Response.json();
+                const raw = await v3Response.json();
+                const data = schema ? schema.parse(raw) : raw;
                 setCacheData(cacheKey, data);
                 return data;
             }
@@ -67,7 +69,8 @@ async function makeCoinCapRequest(endpoint) {
         }
         const v2Response = await fetch(`${COINCAP_API_V2_BASE}${endpoint}`, { headers });
         if (v2Response.ok) {
-            const data = await v2Response.json();
+            const raw = await v2Response.json();
+            const data = schema ? schema.parse(raw) : raw;
             setCacheData(cacheKey, data);
             return data;
         }
@@ -89,16 +92,29 @@ async function makeCoinCapRequest(endpoint) {
 }
 export async function getAssets() {
     try {
-        return await makeCoinCapRequest('/assets');
+        return await makeCoinCapRequest('/assets', AssetsResponseSchema);
     }
     catch (error) {
         console.error("Failed to get assets:", error);
         return null;
     }
 }
+export async function searchAsset(symbol) {
+    try {
+        const upperSymbol = symbol.toUpperCase();
+        const data = await makeCoinCapRequest(`/assets?search=${encodeURIComponent(symbol)}`, AssetsResponseSchema);
+        const asset = data.data.find((a) => a.symbol.toUpperCase() === upperSymbol) ??
+            data.data.find((a) => a.name.toUpperCase() === upperSymbol);
+        return asset ?? null;
+    }
+    catch (error) {
+        console.error(`Failed to search for asset ${symbol}:`, error);
+        return null;
+    }
+}
 export async function getMarkets(assetId) {
     try {
-        return await makeCoinCapRequest(`/assets/${assetId}/markets`);
+        return await makeCoinCapRequest(`/assets/${assetId}/markets`, MarketsResponseSchema);
     }
     catch (error) {
         console.error(`Failed to get markets for asset ${assetId}:`, error);
@@ -107,7 +123,7 @@ export async function getMarkets(assetId) {
 }
 export async function getHistoricalData(assetId, interval, start, end) {
     try {
-        return await makeCoinCapRequest(`/assets/${assetId}/history?interval=${interval}&start=${start}&end=${end}`);
+        return await makeCoinCapRequest(`/assets/${assetId}/history?interval=${interval}&start=${start}&end=${end}`, HistoricalDataSchema);
     }
     catch (error) {
         console.error(`Failed to get historical data for asset ${assetId}:`, error);

package/dist/services/formatters.js

@@ -1,8 +1,17 @@
+function formatPrice(value) {
+    if (value >= 1)
+        return value.toFixed(2);
+    if (value >= 0.01)
+        return value.toFixed(4);
+    if (value >= 0.0001)
+        return value.toFixed(6);
+    return value.toFixed(8);
+}
 export function formatPriceInfo(asset) {
-    const price = parseFloat(asset.priceUsd).toFixed(2);
-    const change = parseFloat(asset.changePercent24Hr).toFixed(2);
-    const volume = (parseFloat(asset.volumeUsd24Hr) / 1000000).toFixed(2);
-    const marketCap = (parseFloat(asset.marketCapUsd) / 1000000000).toFixed(2);
+    const price = formatPrice(parseFloat(asset.priceUsd));
+    const change = parseFloat(asset.changePercent24Hr || '0').toFixed(2);
+    const volume = (parseFloat(asset.volumeUsd24Hr || '0') / 1000000).toFixed(2);
+    const marketCap = (parseFloat(asset.marketCapUsd || '0') / 1000000000).toFixed(2);
     return [
         `${asset.name} (${asset.symbol})`,
         `Price: $${price}`,
@@ -20,17 +29,26 @@ export function formatMarketAnalysis(asset, markets) {
     const marketInfo = topMarkets.map(market => {
         const volumePercent = (parseFloat(market.volumeUsd24Hr) / totalVolume * 100).toFixed(2);
         const volume = (parseFloat(market.volumeUsd24Hr) / 1000000).toFixed(2);
-        return `${market.exchangeId}: $${market.priceUsd} (Volume: $${volume}M, ${volumePercent}% of total)`;
+        return `${market.exchangeId}: $${formatPrice(parseFloat(market.priceUsd))} (Volume: $${volume}M, ${volumePercent}% of total)`;
     }).join('\n');
     return [
         `Market Analysis for ${asset.name} (${asset.symbol})`,
-        `Current Price: $${parseFloat(asset.priceUsd).toFixed(2)}`,
-        `24h Volume: $${(parseFloat(asset.volumeUsd24Hr) / 1000000).toFixed(2)}M`,
-        `VWAP (24h): $${parseFloat(asset.vwap24Hr || '0').toFixed(2)}`,
+        `Current Price: $${formatPrice(parseFloat(asset.priceUsd))}`,
+        `24h Volume: $${(parseFloat(asset.volumeUsd24Hr || '0') / 1000000).toFixed(2)}M`,
+        `VWAP (24h): $${formatPrice(parseFloat(asset.vwap24Hr || '0'))}`,
         '\nTop 5 Markets by Volume:',
         marketInfo
     ].join('\n');
 }
+export function formatTopAssets(assets) {
+    const lines = assets.map((asset) => {
+        const price = formatPrice(parseFloat(asset.priceUsd));
+        const change = parseFloat(asset.changePercent24Hr || '0').toFixed(2);
+        const marketCap = (parseFloat(asset.marketCapUsd || '0') / 1000000000).toFixed(2);
+        return `#${asset.rank} ${asset.name} (${asset.symbol}): $${price} (24h: ${change}%, MCap: $${marketCap}B)`;
+    });
+    return ['Top Cryptocurrencies by Market Cap', '', ...lines].join('\n');
+}
 export function formatHistoricalAnalysis(asset, history) {
     const currentPrice = parseFloat(asset.priceUsd);
     const oldestPrice = parseFloat(history[0].priceUsd);
@@ -39,13 +57,13 @@ export function formatHistoricalAnalysis(asset, history) {
     const priceChange = ((currentPrice - oldestPrice) / oldestPrice * 100).toFixed(2);
     return [
         `Historical Analysis for ${asset.name} (${asset.symbol})`,
-        `Period High: $${highestPrice.toFixed(2)}`,
-        `Period Low: $${lowestPrice.toFixed(2)}`,
+        `Period High: $${formatPrice(highestPrice)}`,
+        `Period Low: $${formatPrice(lowestPrice)}`,
         `Price Change: ${priceChange}%`,
-        `Current Price: $${currentPrice.toFixed(2)}`,
-        `Starting Price: $${oldestPrice.toFixed(2)}`,
+        `Current Price: $${formatPrice(currentPrice)}`,
+        `Starting Price: $${formatPrice(oldestPrice)}`,
         '\nVolatility Analysis:',
-        `Price Range: $${(highestPrice - lowestPrice).toFixed(2)}`,
+        `Price Range: $${formatPrice(highestPrice - lowestPrice)}`,
         `Range Percentage: ${((highestPrice - lowestPrice) / lowestPrice * 100).toFixed(2)}%`
     ].join('\n');
 }

package/dist/services/schemas.js

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export const CryptoAssetSchema = z.object({
+    id: z.string(),
+    rank: z.string(),
+    symbol: z.string(),
+    name: z.string(),
+    priceUsd: z.string(),
+    changePercent24Hr: z.string().nullable(),
+    volumeUsd24Hr: z.string().nullable(),
+    marketCapUsd: z.string().nullable(),
+    supply: z.string().nullable(),
+    maxSupply: z.string().nullable(),
+    vwap24Hr: z.string().nullable(),
+});
+export const AssetsResponseSchema = z.object({
+    data: z.array(CryptoAssetSchema),
+});
+export const HistoryPointSchema = z.object({
+    time: z.number(),
+    priceUsd: z.string(),
+    circulatingSupply: z.string().optional(),
+    date: z.string(),
+});
+export const HistoricalDataSchema = z.object({
+    data: z.array(HistoryPointSchema),
+});
+export const MarketSchema = z.object({
+    exchangeId: z.string(),
+    baseSymbol: z.string(),
+    quoteSymbol: z.string(),
+    priceUsd: z.string(),
+    volumeUsd24Hr: z.string(),
+    percentExchangeVolume: z.string().nullable().optional(),
+});
+export const MarketsResponseSchema = z.object({
+    data: z.array(MarketSchema),
+});

package/dist/tools/__tests__/historical.test.js

@@ -0,0 +1,61 @@
+import { jest } from '@jest/globals';
+jest.unstable_mockModule('../../services/coincap.js', () => ({
+    searchAsset: jest.fn(),
+    getAssets: jest.fn(),
+    getMarkets: jest.fn(),
+    getHistoricalData: jest.fn(),
+    clearCache: jest.fn(),
+}));
+const { searchAsset, getHistoricalData } = await import('../../services/coincap.js');
+const { handleGetHistoricalAnalysis } = await import('../historical.js');
+const mockSearchAsset = searchAsset;
+const mockGetHistoricalData = getHistoricalData;
+const mockAsset = {
+    id: 'bitcoin', rank: '1', symbol: 'BTC', name: 'Bitcoin',
+    priceUsd: '50000.00', changePercent24Hr: '2.50',
+    volumeUsd24Hr: '30000000000', marketCapUsd: '950000000000',
+    supply: '19000000', maxSupply: '21000000', vwap24Hr: '49500.00',
+};
+describe('handleGetHistoricalAnalysis', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should return formatted historical analysis', async () => {
+        mockSearchAsset.mockResolvedValueOnce(mockAsset);
+        mockGetHistoricalData.mockResolvedValueOnce({
+            data: [
+                { time: 1609459200000, priceUsd: '45000.00', circulatingSupply: '18900000', date: '2021-01-01' },
+                { time: 1609545600000, priceUsd: '47000.00', circulatingSupply: '18900000', date: '2021-01-02' },
+            ],
+        });
+        const result = await handleGetHistoricalAnalysis({ symbol: 'BTC' });
+        expect(result.content[0].text).toContain('Historical Analysis for Bitcoin');
+        expect(result.content[0].text).toContain('Period High');
+    });
+    it('should return not-found message for unknown symbol', async () => {
+        mockSearchAsset.mockResolvedValueOnce(null);
+        const result = await handleGetHistoricalAnalysis({ symbol: 'ZZZZZ' });
+        expect(result.content[0].text).toContain('Could not find cryptocurrency with symbol ZZZZZ');
+    });
+    it('should return error when historical data is null', async () => {
+        mockSearchAsset.mockResolvedValueOnce(mockAsset);
+        mockGetHistoricalData.mockResolvedValueOnce(null);
+        const result = await handleGetHistoricalAnalysis({ symbol: 'BTC' });
+        expect(result.content[0].text).toBe('Failed to retrieve historical data');
+    });
+    it('should return message for empty history array', async () => {
+        mockSearchAsset.mockResolvedValueOnce(mockAsset);
+        mockGetHistoricalData.mockResolvedValueOnce({ data: [] });
+        const result = await handleGetHistoricalAnalysis({ symbol: 'BTC' });
+        expect(result.content[0].text).toBe('No historical data available for the selected time period');
+    });
+    it('should clamp days to schema bounds', async () => {
+        // days > 30 should fail schema validation
+        await expect(handleGetHistoricalAnalysis({ symbol: 'BTC', days: 100 })).rejects.toThrow();
+        // days < 1 should fail schema validation
+        await expect(handleGetHistoricalAnalysis({ symbol: 'BTC', days: 0 })).rejects.toThrow();
+    });
+    it('should throw on missing symbol', async () => {
+        await expect(handleGetHistoricalAnalysis({})).rejects.toThrow();
+    });
+});

package/dist/tools/__tests__/market.test.js

@@ -0,0 +1,50 @@
+import { jest } from '@jest/globals';
+jest.unstable_mockModule('../../services/coincap.js', () => ({
+    searchAsset: jest.fn(),
+    getAssets: jest.fn(),
+    getMarkets: jest.fn(),
+    getHistoricalData: jest.fn(),
+    clearCache: jest.fn(),
+}));
+const { searchAsset, getMarkets } = await import('../../services/coincap.js');
+const { handleGetMarketAnalysis } = await import('../market.js');
+const mockSearchAsset = searchAsset;
+const mockGetMarkets = getMarkets;
+const mockAsset = {
+    id: 'bitcoin', rank: '1', symbol: 'BTC', name: 'Bitcoin',
+    priceUsd: '50000.00', changePercent24Hr: '2.50',
+    volumeUsd24Hr: '30000000000', marketCapUsd: '950000000000',
+    supply: '19000000', maxSupply: '21000000', vwap24Hr: '49500.00',
+};
+describe('handleGetMarketAnalysis', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should return formatted market analysis for a valid symbol', async () => {
+        mockSearchAsset.mockResolvedValueOnce(mockAsset);
+        mockGetMarkets.mockResolvedValueOnce({
+            data: [{
+                    exchangeId: 'binance', baseSymbol: 'BTC', quoteSymbol: 'USDT',
+                    priceUsd: '50000.00', volumeUsd24Hr: '5000000000',
+                    percentExchangeVolume: '25.00',
+                }],
+        });
+        const result = await handleGetMarketAnalysis({ symbol: 'BTC' });
+        expect(result.content[0].text).toContain('Market Analysis for Bitcoin');
+        expect(result.content[0].text).toContain('binance');
+    });
+    it('should return not-found message for unknown symbol', async () => {
+        mockSearchAsset.mockResolvedValueOnce(null);
+        const result = await handleGetMarketAnalysis({ symbol: 'ZZZZZ' });
+        expect(result.content[0].text).toContain('Could not find cryptocurrency with symbol ZZZZZ');
+    });
+    it('should return error when markets data is null', async () => {
+        mockSearchAsset.mockResolvedValueOnce(mockAsset);
+        mockGetMarkets.mockResolvedValueOnce(null);
+        const result = await handleGetMarketAnalysis({ symbol: 'BTC' });
+        expect(result.content[0].text).toBe('Failed to retrieve market data');
+    });
+    it('should throw on missing symbol', async () => {
+        await expect(handleGetMarketAnalysis({})).rejects.toThrow();
+    });
+});

package/dist/tools/__tests__/price.test.js

@@ -0,0 +1,40 @@
+import { jest } from '@jest/globals';
+jest.unstable_mockModule('../../services/coincap.js', () => ({
+    searchAsset: jest.fn(),
+    getAssets: jest.fn(),
+    getMarkets: jest.fn(),
+    getHistoricalData: jest.fn(),
+    clearCache: jest.fn(),
+}));
+const { searchAsset } = await import('../../services/coincap.js');
+const { handleGetPrice } = await import('../price.js');
+const mockSearchAsset = searchAsset;
+describe('handleGetPrice', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should return formatted price for a valid symbol', async () => {
+        mockSearchAsset.mockResolvedValueOnce({
+            id: 'bitcoin', rank: '1', symbol: 'BTC', name: 'Bitcoin',
+            priceUsd: '50000.00', changePercent24Hr: '2.50',
+            volumeUsd24Hr: '30000000000', marketCapUsd: '950000000000',
+            supply: '19000000', maxSupply: '21000000', vwap24Hr: '49500.00',
+        });
+        const result = await handleGetPrice({ symbol: 'BTC' });
+        expect(result.content[0].text).toContain('Bitcoin (BTC)');
+        expect(result.content[0].text).toContain('50000.00');
+    });
+    it('should return not-found message for unknown symbol', async () => {
+        mockSearchAsset.mockResolvedValueOnce(null);
+        const result = await handleGetPrice({ symbol: 'ZZZZZ' });
+        expect(result.content[0].text).toContain('Could not find cryptocurrency with symbol ZZZZZ');
+    });
+    it('should return error message on exception', async () => {
+        mockSearchAsset.mockRejectedValueOnce(new Error('Network failure'));
+        const result = await handleGetPrice({ symbol: 'BTC' });
+        expect(result.content[0].text).toContain('Network failure');
+    });
+    it('should throw on missing symbol', async () => {
+        await expect(handleGetPrice({})).rejects.toThrow();
+    });
+});

package/dist/tools/__tests__/top-assets.test.js

@@ -0,0 +1,54 @@
+import { jest } from '@jest/globals';
+jest.unstable_mockModule('../../services/coincap.js', () => ({
+    searchAsset: jest.fn(),
+    getAssets: jest.fn(),
+    getMarkets: jest.fn(),
+    getHistoricalData: jest.fn(),
+    clearCache: jest.fn(),
+}));
+const { getAssets } = await import('../../services/coincap.js');
+const { handleGetTopAssets } = await import('../top-assets.js');
+const mockGetAssets = getAssets;
+const mockAssets = [
+    {
+        id: 'bitcoin', rank: '1', symbol: 'BTC', name: 'Bitcoin',
+        priceUsd: '50000.00', changePercent24Hr: '2.50',
+        volumeUsd24Hr: '30000000000', marketCapUsd: '950000000000',
+        supply: '19000000', maxSupply: '21000000', vwap24Hr: '49500.00',
+    },
+    {
+        id: 'ethereum', rank: '2', symbol: 'ETH', name: 'Ethereum',
+        priceUsd: '3000.00', changePercent24Hr: '1.20',
+        volumeUsd24Hr: '15000000000', marketCapUsd: '350000000000',
+        supply: '120000000', maxSupply: null, vwap24Hr: '2950.00',
+    },
+];
+describe('handleGetTopAssets', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('should return formatted top assets', async () => {
+        mockGetAssets.mockResolvedValueOnce({ data: mockAssets });
+        const result = await handleGetTopAssets({});
+        expect(result.content[0].text).toContain('Top Cryptocurrencies by Market Cap');
+        expect(result.content[0].text).toContain('Bitcoin (BTC)');
+        expect(result.content[0].text).toContain('Ethereum (ETH)');
+    });
+    it('should respect limit parameter', async () => {
+        mockGetAssets.mockResolvedValueOnce({ data: mockAssets });
+        const result = await handleGetTopAssets({ limit: 1 });
+        expect(result.content[0].text).toContain('Bitcoin');
+        expect(result.content[0].text).not.toContain('Ethereum');
+    });
+    it('should return error when assets data is null', async () => {
+        mockGetAssets.mockResolvedValueOnce(null);
+        const result = await handleGetTopAssets({});
+        expect(result.content[0].text).toBe('Failed to retrieve assets data');
+    });
+    it('should reject limit > 50', async () => {
+        await expect(handleGetTopAssets({ limit: 100 })).rejects.toThrow();
+    });
+    it('should reject limit < 1', async () => {
+        await expect(handleGetTopAssets({ limit: 0 })).rejects.toThrow();
+    });
+});

package/dist/tools/historical.js

@@ -1,8 +1,8 @@
 import { z } from 'zod';
-import { getAssets, getHistoricalData } from '../services/coincap.js';
+import { searchAsset, getHistoricalData } from '../services/coincap.js';
 import { formatHistoricalAnalysis } from '../services/formatters.js';
 export const GetHistoricalAnalysisSchema = z.object({
-    symbol: z.string().min(1),
+    symbol: z.string().min(1).describe("Cryptocurrency symbol or name (e.g. BTC or Bitcoin)"),
     interval: z.enum(['m5', 'm15', 'm30', 'h1', 'h2', 'h6', 'h12', 'd1']).default('h1'),
     days: z.number().min(1).max(30).default(7),
 });
@@ -10,19 +10,16 @@ export async function handleGetHistoricalAnalysis(args) {
     const { symbol, interval, days } = GetHistoricalAnalysisSchema.parse(args);
     const upperSymbol = symbol.toUpperCase();
     try {
-        const assetsData = await getAssets();
-        if (!assetsData) {
-            return {
-                content: [{ type: "text", text: "Failed to retrieve cryptocurrency data" }],
-            };
-        }
-        const asset = assetsData.data.find((a) => a.symbol.toUpperCase() === upperSymbol);
+        const asset = await searchAsset(upperSymbol);
         if (!asset) {
             return {
                 content: [{ type: "text", text: `Could not find cryptocurrency with symbol ${upperSymbol}` }],
             };
         }
-        const end = Date.now();
+        // Round timestamps to the nearest minute so the cache key stays stable
+        // across calls made within the same 60-second TTL window
+        const now = Date.now();
+        const end = now - (now % 60000);
         const start = end - (days * 24 * 60 * 60 * 1000);
         const historyData = await getHistoricalData(asset.id, interval, start, end);
         if (!historyData) {

package/dist/tools/index.js

@@ -1,3 +1,4 @@
 export * from './price.js';
 export * from './market.js';
 export * from './historical.js';
+export * from './top-assets.js';

package/dist/tools/market.js

@@ -1,20 +1,14 @@
 import { z } from 'zod';
-import { getAssets, getMarkets } from '../services/coincap.js';
+import { searchAsset, getMarkets } from '../services/coincap.js';
 import { formatMarketAnalysis } from '../services/formatters.js';
 export const GetMarketAnalysisSchema = z.object({
-    symbol: z.string().min(1),
+    symbol: z.string().min(1).describe("Cryptocurrency symbol or name (e.g. BTC or Bitcoin)"),
 });
 export async function handleGetMarketAnalysis(args) {
     const { symbol } = GetMarketAnalysisSchema.parse(args);
     const upperSymbol = symbol.toUpperCase();
     try {
-        const assetsData = await getAssets();
-        if (!assetsData) {
-            return {
-                content: [{ type: "text", text: "Failed to retrieve cryptocurrency data" }],
-            };
-        }
-        const asset = assetsData.data.find((a) => a.symbol.toUpperCase() === upperSymbol);
+        const asset = await searchAsset(upperSymbol);
         if (!asset) {
             return {
                 content: [{ type: "text", text: `Could not find cryptocurrency with symbol ${upperSymbol}` }],

package/dist/tools/price.js

@@ -1,28 +1,17 @@
 import { z } from 'zod';
-import { getAssets } from '../services/coincap.js';
+import { searchAsset } from '../services/coincap.js';
 import { formatPriceInfo } from '../services/formatters.js';
 export const GetPriceArgumentsSchema = z.object({
-    symbol: z.string().min(1),
+    symbol: z.string().min(1).describe("Cryptocurrency symbol or name (e.g. BTC or Bitcoin)"),
 });
 export async function handleGetPrice(args) {
     const { symbol } = GetPriceArgumentsSchema.parse(args);
     const upperSymbol = symbol.toUpperCase();
     try {
-        const assetsData = await getAssets();
-        if (!assetsData) {
-            return {
-                content: [{ type: "text", text: "Failed to retrieve cryptocurrency data" }],
-            };
-        }
-        const asset = assetsData.data.find((a) => a.symbol.toUpperCase() === upperSymbol);
+        const asset = await searchAsset(upperSymbol);
         if (!asset) {
             return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Could not find cryptocurrency with symbol ${upperSymbol}`,
-                    },
-                ],
+                content: [{ type: "text", text: `Could not find cryptocurrency with symbol ${upperSymbol}` }],
             };
         }
         return {

package/dist/tools/top-assets.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+import { getAssets } from '../services/coincap.js';
+import { formatTopAssets } from '../services/formatters.js';
+export const GetTopAssetsSchema = z.object({
+    limit: z.number().min(1).max(50).default(10),
+});
+export async function handleGetTopAssets(args) {
+    const { limit } = GetTopAssetsSchema.parse(args);
+    try {
+        const assetsData = await getAssets();
+        if (!assetsData) {
+            return {
+                content: [{ type: "text", text: "Failed to retrieve assets data" }],
+            };
+        }
+        const topAssets = assetsData.data.slice(0, limit);
+        if (!topAssets.length) {
+            return {
+                content: [{ type: "text", text: "No assets data available" }],
+            };
+        }
+        return {
+            content: [{ type: "text", text: formatTopAssets(topAssets) }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: error instanceof Error ? error.message : `Failed to retrieve assets data: ${String(error)}`
+                }],
+        };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-crypto-price",
-  "version": "2.1.4",
+  "version": "2.2.0",
   "description": "A Model Context Protocol (MCP) server that provides real-time cryptocurrency data and analysis through CoinCap's API. Features include price tracking, market analysis, and historical trends.",
   "license": "MIT",
   "author": {
@@ -39,12 +39,13 @@
   "devDependencies": {
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
-    "@semantic-release/github": "^12.0.2",
+    "@semantic-release/github": "^12.0.6",
+    "@semantic-release/npm": "^13.1.4",
     "@types/jest": "^30.0.0",
     "@types/node": "^24.10.1",
     "conventional-changelog-conventionalcommits": "^9.1.0",
     "jest": "^30.2.0",
-    "semantic-release": "^25.0.2",
+    "semantic-release": "^25.0.3",
     "shx": "^0.3.4",
     "ts-jest": "^29.2.5",
     "typescript": "^5.7.3"