mcp-crypto-price 5.0.0 → 5.0.1

package/dist/tools/asset-info.js

@@ -33,6 +33,19 @@ export async function handleGetAssetInfo(args) {
                         text: `Could not find cryptocurrency with symbol ${upperSymbol}`,
                     },
                 ],
+                structuredContent: {
+                    id: '',
+                    rank: null,
+                    symbol: upperSymbol,
+                    name: '',
+                    priceUsd: '',
+                    changePercent24Hr: null,
+                    marketCapUsd: null,
+                    volumeUsd24Hr: null,
+                    supply: null,
+                    maxSupply: null,
+                    vwap24Hr: null,
+                },
             };
         }
         return {
@@ -62,6 +75,19 @@ export async function handleGetAssetInfo(args) {
                         text: `Invalid input: ${error.issues.map((e) => e.message).join(', ')}`,
                     },
                 ],
+                structuredContent: {
+                    id: '',
+                    rank: null,
+                    symbol: '',
+                    name: '',
+                    priceUsd: '',
+                    changePercent24Hr: null,
+                    marketCapUsd: null,
+                    volumeUsd24Hr: null,
+                    supply: null,
+                    maxSupply: null,
+                    vwap24Hr: null,
+                },
             };
         }
         return {
@@ -73,6 +99,19 @@ export async function handleGetAssetInfo(args) {
                         : `Failed to retrieve asset info: ${String(error)}`,
                 },
             ],
+            structuredContent: {
+                id: '',
+                rank: null,
+                symbol: '',
+                name: '',
+                priceUsd: '',
+                changePercent24Hr: null,
+                marketCapUsd: null,
+                volumeUsd24Hr: null,
+                supply: null,
+                maxSupply: null,
+                vwap24Hr: null,
+            },
         };
     }
 }

package/dist/tools/candlestick.js

@@ -51,6 +51,12 @@ export async function handleGetCandlestickData(args) {
                         text: `Could not find cryptocurrency with symbol ${upperSymbol}`,
                     },
                 ],
+                structuredContent: {
+                    name: '',
+                    symbol: upperSymbol,
+                    exchange,
+                    candles: [],
+                },
             };
         }
         const now = Date.now();
@@ -62,6 +68,12 @@ export async function handleGetCandlestickData(args) {
                 content: [
                     { type: 'text', text: 'Failed to retrieve candlestick data' },
                 ],
+                structuredContent: {
+                    name: asset.name,
+                    symbol: asset.symbol,
+                    exchange,
+                    candles: [],
+                },
             };
         }
         if (!candlesData.data.length) {
@@ -72,6 +84,12 @@ export async function handleGetCandlestickData(args) {
                         text: `No candlestick data available for ${asset.name} (${asset.symbol}) on ${exchange} with quote ${quote.toUpperCase()}`,
                     },
                 ],
+                structuredContent: {
+                    name: asset.name,
+                    symbol: asset.symbol,
+                    exchange,
+                    candles: [],
+                },
             };
         }
         return {
@@ -106,6 +124,12 @@ export async function handleGetCandlestickData(args) {
                         text: `Invalid input: ${error.issues.map((e) => e.message).join(', ')}`,
                     },
                 ],
+                structuredContent: {
+                    name: '',
+                    symbol: '',
+                    exchange: '',
+                    candles: [],
+                },
             };
         }
         return {
@@ -117,6 +141,12 @@ export async function handleGetCandlestickData(args) {
                         : `Failed to retrieve candlestick data: ${String(error)}`,
                 },
             ],
+            structuredContent: {
+                name: '',
+                symbol: '',
+                exchange: '',
+                candles: [],
+            },
         };
     }
 }

package/dist/tools/compare.js

@@ -34,6 +34,7 @@ export async function handleCompareCrypto(args) {
                         text: 'Please provide 2-5 cryptocurrency symbols to compare (e.g. "BTC,ETH,SOL")',
                     },
                 ],
+                structuredContent: { assets: [], notFound: symbolList },
             };
         }
         const results = [];
@@ -55,6 +56,7 @@ export async function handleCompareCrypto(args) {
                         text: `Could not find any of the specified cryptocurrencies: ${symbolList.join(', ')}`,
                     },
                 ],
+                structuredContent: { assets: [], notFound },
             };
         }
         let output = formatComparison(results);
@@ -87,6 +89,7 @@ export async function handleCompareCrypto(args) {
                         text: `Invalid input: ${error.issues.map((e) => e.message).join(', ')}`,
                     },
                 ],
+                structuredContent: { assets: [], notFound: [] },
             };
         }
         return {
@@ -98,6 +101,7 @@ export async function handleCompareCrypto(args) {
                         : `Failed to compare cryptocurrencies: ${String(error)}`,
                 },
             ],
+            structuredContent: { assets: [], notFound: [] },
         };
     }
 }

package/dist/tools/exchanges.js

@@ -39,6 +39,7 @@ export async function handleGetExchanges(args) {
                             text: `Could not find exchange "${exchangeId}". Try an ID like 'binance', 'coinbase', or 'kraken'.`,
                         },
                     ],
+                    structuredContent: { exchanges: [] },
                 };
             }
             return {
@@ -62,6 +63,7 @@ export async function handleGetExchanges(args) {
         if (!exchanges) {
             return {
                 content: [{ type: 'text', text: 'Failed to retrieve exchanges' }],
+                structuredContent: { exchanges: [] },
             };
         }
         return {
@@ -91,6 +93,7 @@ export async function handleGetExchanges(args) {
                         : `Failed to retrieve exchanges: ${String(error)}`,
                 },
             ],
+            structuredContent: { exchanges: [] },
         };
     }
 }

package/dist/tools/global-metrics.js

@@ -17,11 +17,23 @@ export async function handleGetGlobalMetrics(args) {
                 content: [
                     { type: 'text', text: 'Failed to retrieve global market data' },
                 ],
+                structuredContent: {
+                    totalMarketCap: 0,
+                    totalVolume: 0,
+                    btcDominance: '',
+                    activeCryptocurrencies: 0,
+                },
             };
         }
         if (!assetsData.data.length) {
             return {
                 content: [{ type: 'text', text: 'No market data available' }],
+                structuredContent: {
+                    totalMarketCap: 0,
+                    totalVolume: 0,
+                    btcDominance: '',
+                    activeCryptocurrencies: 0,
+                },
             };
         }
         const totalMarketCap = assetsData.data.reduce((sum, a) => sum + parseFloat(a.marketCapUsd || '0'), 0);
@@ -51,6 +63,12 @@ export async function handleGetGlobalMetrics(args) {
                         text: `Invalid input: ${error.issues.map((e) => e.message).join(', ')}`,
                     },
                 ],
+                structuredContent: {
+                    totalMarketCap: 0,
+                    totalVolume: 0,
+                    btcDominance: '',
+                    activeCryptocurrencies: 0,
+                },
             };
         }
         return {
@@ -62,6 +80,12 @@ export async function handleGetGlobalMetrics(args) {
                         : `Failed to retrieve global market data: ${String(error)}`,
                 },
             ],
+            structuredContent: {
+                totalMarketCap: 0,
+                totalVolume: 0,
+                btcDominance: '',
+                activeCryptocurrencies: 0,
+            },
         };
     }
 }

package/dist/tools/historical.js

@@ -41,6 +41,17 @@ export async function handleGetHistoricalAnalysis(args) {
                         text: `Could not find cryptocurrency with symbol ${upperSymbol}`,
                     },
                 ],
+                structuredContent: {
+                    name: '',
+                    symbol: upperSymbol,
+                    periodHigh: 0,
+                    periodLow: 0,
+                    priceChangePercent: '',
+                    currentPrice: 0,
+                    startingPrice: 0,
+                    priceRange: 0,
+                    rangePercentage: '',
+                },
             };
         }
         // Round timestamps to the nearest minute so the cache key stays stable
@@ -52,6 +63,17 @@ export async function handleGetHistoricalAnalysis(args) {
         if (!historyData) {
             return {
                 content: [{ type: 'text', text: 'Failed to retrieve historical data' }],
+                structuredContent: {
+                    name: asset.name,
+                    symbol: asset.symbol,
+                    periodHigh: 0,
+                    periodLow: 0,
+                    priceChangePercent: '',
+                    currentPrice: 0,
+                    startingPrice: 0,
+                    priceRange: 0,
+                    rangePercentage: '',
+                },
             };
         }
         if (!historyData.data.length) {
@@ -62,6 +84,17 @@ export async function handleGetHistoricalAnalysis(args) {
                         text: 'No historical data available for the selected time period',
                     },
                 ],
+                structuredContent: {
+                    name: asset.name,
+                    symbol: asset.symbol,
+                    periodHigh: 0,
+                    periodLow: 0,
+                    priceChangePercent: '',
+                    currentPrice: 0,
+                    startingPrice: 0,
+                    priceRange: 0,
+                    rangePercentage: '',
+                },
             };
         }
         const currentPrice = parseFloat(asset.priceUsd);
@@ -101,6 +134,17 @@ export async function handleGetHistoricalAnalysis(args) {
                         : `Failed to retrieve historical data: ${String(error)}`,
                 },
             ],
+            structuredContent: {
+                name: '',
+                symbol: '',
+                periodHigh: 0,
+                periodLow: 0,
+                priceChangePercent: '',
+                currentPrice: 0,
+                startingPrice: 0,
+                priceRange: 0,
+                rangePercentage: '',
+            },
         };
     }
 }

package/dist/tools/market.js

@@ -33,12 +33,28 @@ export async function handleGetMarketAnalysis(args) {
                         text: `Could not find cryptocurrency with symbol ${upperSymbol}`,
                     },
                 ],
+                structuredContent: {
+                    name: '',
+                    symbol: upperSymbol,
+                    priceUsd: '',
+                    volumeUsd24Hr: null,
+                    vwap24Hr: null,
+                    topMarkets: [],
+                },
             };
         }
         const marketsData = await getMarkets(asset.id);
         if (!marketsData) {
             return {
                 content: [{ type: 'text', text: 'Failed to retrieve market data' }],
+                structuredContent: {
+                    name: asset.name,
+                    symbol: asset.symbol,
+                    priceUsd: asset.priceUsd,
+                    volumeUsd24Hr: asset.volumeUsd24Hr,
+                    vwap24Hr: asset.vwap24Hr,
+                    topMarkets: [],
+                },
             };
         }
         const totalVolume = marketsData.data.reduce((sum, market) => sum + parseFloat(market.volumeUsd24Hr), 0);
@@ -76,6 +92,14 @@ export async function handleGetMarketAnalysis(args) {
                         : `Failed to retrieve data: ${String(error)}`,
                 },
             ],
+            structuredContent: {
+                name: '',
+                symbol: '',
+                priceUsd: '',
+                volumeUsd24Hr: null,
+                vwap24Hr: null,
+                topMarkets: [],
+            },
         };
     }
 }

package/dist/tools/price-conversion.js

@@ -38,12 +38,26 @@ export async function handleGetPriceConversion(args) {
                         text: `Could not find cryptocurrency with symbol ${upperSymbol}`,
                     },
                 ],
+                structuredContent: {
+                    fromSymbol: upperSymbol,
+                    amount,
+                    toCurrency: upperCurrency,
+                    conversionRate: 0,
+                    convertedAmount: 0,
+                },
             };
         }
         const rates = await getRates();
         if (!rates) {
             return {
                 content: [{ type: 'text', text: 'Failed to retrieve exchange rates' }],
+                structuredContent: {
+                    fromSymbol: upperSymbol,
+                    amount,
+                    toCurrency: upperCurrency,
+                    conversionRate: 0,
+                    convertedAmount: 0,
+                },
             };
         }
         const rate = rates.find((r) => r.symbol.toLowerCase() === upperCurrency);
@@ -55,6 +69,13 @@ export async function handleGetPriceConversion(args) {
                         text: `Could not find exchange rate for currency "${currency}". Available currencies include: usd, eur, gbp, jpy, etc.`,
                     },
                 ],
+                structuredContent: {
+                    fromSymbol: upperSymbol,
+                    amount,
+                    toCurrency: upperCurrency,
+                    conversionRate: 0,
+                    convertedAmount: 0,
+                },
             };
         }
         const priceUsd = parseFloat(asset.priceUsd);
@@ -86,6 +107,13 @@ export async function handleGetPriceConversion(args) {
                         text: `Invalid input: ${error.issues.map((e) => e.message).join(', ')}`,
                     },
                 ],
+                structuredContent: {
+                    fromSymbol: '',
+                    amount: 0,
+                    toCurrency: '',
+                    conversionRate: 0,
+                    convertedAmount: 0,
+                },
             };
         }
         return {
@@ -97,6 +125,13 @@ export async function handleGetPriceConversion(args) {
                         : `Failed to convert price: ${String(error)}`,
                 },
             ],
+            structuredContent: {
+                fromSymbol: '',
+                amount: 0,
+                toCurrency: '',
+                conversionRate: 0,
+                convertedAmount: 0,
+            },
         };
     }
 }

package/dist/tools/price.js

@@ -29,6 +29,15 @@ export async function handleGetPrice(args) {
                         text: `Could not find cryptocurrency with symbol ${upperSymbol}`,
                     },
                 ],
+                structuredContent: {
+                    name: '',
+                    symbol: upperSymbol,
+                    priceUsd: '',
+                    changePercent24Hr: null,
+                    volumeUsd24Hr: null,
+                    marketCapUsd: null,
+                    rank: null,
+                },
             };
         }
         return {
@@ -54,6 +63,15 @@ export async function handleGetPrice(args) {
                         : `Failed to retrieve cryptocurrency data: ${String(error)}`,
                 },
             ],
+            structuredContent: {
+                name: '',
+                symbol: '',
+                priceUsd: '',
+                changePercent24Hr: null,
+                volumeUsd24Hr: null,
+                marketCapUsd: null,
+                rank: null,
+            },
         };
     }
 }

package/dist/tools/rates.js

@@ -29,6 +29,7 @@ export async function handleGetRates(args) {
                             text: `Could not find rate for slug "${slug}". Try a slug like 'us-dollar', 'euro', or 'bitcoin'.`,
                         },
                     ],
+                    structuredContent: { rates: [] },
                 };
             }
             return {
@@ -50,6 +51,7 @@ export async function handleGetRates(args) {
         if (!rates) {
             return {
                 content: [{ type: 'text', text: 'Failed to retrieve currency rates' }],
+                structuredContent: { rates: [] },
             };
         }
         return {
@@ -75,6 +77,7 @@ export async function handleGetRates(args) {
                         : `Failed to retrieve rates: ${String(error)}`,
                 },
             ],
+            structuredContent: { rates: [] },
         };
     }
 }

package/dist/tools/search-assets.js

@@ -30,6 +30,7 @@ export async function handleSearchAssets(args) {
         if (!results) {
             return {
                 content: [{ type: 'text', text: 'Failed to search for assets' }],
+                structuredContent: { results: [] },
             };
         }
         if (results.length === 0) {
@@ -40,6 +41,7 @@ export async function handleSearchAssets(args) {
                         text: `No cryptocurrencies found matching "${query}"`,
                     },
                 ],
+                structuredContent: { results: [] },
             };
         }
         return {
@@ -65,6 +67,7 @@ export async function handleSearchAssets(args) {
                         text: `Invalid input: ${error.issues.map((e) => e.message).join(', ')}`,
                     },
                 ],
+                structuredContent: { results: [] },
             };
         }
         return {
@@ -76,6 +79,7 @@ export async function handleSearchAssets(args) {
                         : `Failed to search for assets: ${String(error)}`,
                 },
             ],
+            structuredContent: { results: [] },
         };
     }
 }

package/dist/tools/technical-analysis.js

@@ -39,6 +39,16 @@ export async function handleGetTechnicalAnalysis(args) {
                         text: `Could not find cryptocurrency with symbol ${upperSymbol}`,
                     },
                 ],
+                structuredContent: {
+                    name: '',
+                    symbol: upperSymbol,
+                    currentPrice: '',
+                    sma: null,
+                    ema: null,
+                    rsi: null,
+                    macd: null,
+                    vwap: null,
+                },
             };
         }
         const ta = await getTechnicalAnalysis(asset.id);
@@ -50,6 +60,16 @@ export async function handleGetTechnicalAnalysis(args) {
                         text: `Failed to retrieve technical analysis for ${asset.name} (${asset.symbol})`,
                     },
                 ],
+                structuredContent: {
+                    name: asset.name,
+                    symbol: asset.symbol,
+                    currentPrice: asset.priceUsd,
+                    sma: null,
+                    ema: null,
+                    rsi: null,
+                    macd: null,
+                    vwap: null,
+                },
             };
         }
         const rsiValue = ta.rsi ? parseFloat(ta.rsi.value) : null;
@@ -103,6 +123,16 @@ export async function handleGetTechnicalAnalysis(args) {
                         : `Failed to retrieve technical analysis: ${String(error)}`,
                 },
             ],
+            structuredContent: {
+                name: '',
+                symbol: '',
+                currentPrice: '',
+                sma: null,
+                ema: null,
+                rsi: null,
+                macd: null,
+                vwap: null,
+            },
         };
     }
 }

package/dist/tools/top-assets.js

@@ -27,12 +27,14 @@ export async function handleGetTopAssets(args) {
         if (!assetsData) {
             return {
                 content: [{ type: 'text', text: 'Failed to retrieve assets data' }],
+                structuredContent: { assets: [] },
             };
         }
         const topAssets = assetsData.data.slice(0, limit);
         if (!topAssets.length) {
             return {
                 content: [{ type: 'text', text: 'No assets data available' }],
+                structuredContent: { assets: [] },
             };
         }
         return {
@@ -60,6 +62,7 @@ export async function handleGetTopAssets(args) {
                         : `Failed to retrieve assets data: ${String(error)}`,
                 },
             ],
+            structuredContent: { assets: [] },
         };
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-crypto-price",
-  "version": "5.0.0",
+  "version": "5.0.1",
   "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": {