Upload 2537 files

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+crypto-indicators-mcp/node_modules/ccxt/dist/ccxt.browser.js filter=lfs diff=lfs merge=lfs -text
+crypto-indicators-mcp/node_modules/technicalindicators/images/home.png filter=lfs diff=lfs merge=lfs -text
+crypto-indicators-mcp/node_modules/technicalindicators/images/screener.png filter=lfs diff=lfs merge=lfs -text
+crypto-indicators-mcp/node_modules/technicalindicators/images/trade.png filter=lfs diff=lfs merge=lfs -text
+crypto-indicators-mcp/node_modules/technicalindicators/tf_model/group1-shard1of1 filter=lfs diff=lfs merge=lfs -text

crypto-indicators-mcp/.gitignore

@@ -0,0 +1,3 @@
+node_modules
+.env
+deprecated

crypto-indicators-mcp/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 kukapay
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

crypto-indicators-mcp/README.md

@@ -0,0 +1,177 @@
+# Crypto Indicators MCP Server
+
+An MCP server providing a range of cryptocurrency technical analysis indicators and strategies, empowering AI trading agents to efficiently analyze market trends and develop robust quantitative strategies.
+
+[![License](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+[![Node.js](https://img.shields.io/badge/Node.js-18.x-green.svg)](https://nodejs.org/)
+![Status](https://img.shields.io/badge/status-active-brightgreen.svg)
+
+## Features
+
+- **Technical Indicators**: 50+ indicators across trend, momentum, volatility, and volume categories.
+- **Trading Strategies**: Corresponding strategies outputting signals: `-1` (SELL), `0` (HOLD), `1` (BUY).
+- **Flexible Data Source**: Defaults to Binance, configurable to any `ccxt`-supported exchange.
+- **Modular Design**: Indicators and strategies are categorized for easy maintenance.
+
+## Installation
+
+### Prerequisites
+
+- [Node.js](https://nodejs.org/) (v18.x or higher)
+- npm (v8.x or higher)
+
+### Steps
+
+1. **Clone the Repository**:
+   ```bash
+   git clone https://github.com/kukapay/crypto-indicators-mcp.git
+   cd crypto-indicators-mcp
+   ```
+
+2. **Install Dependencies**:
+   ```bash
+   npm install
+   ```
+
+3. **Configure MCP Client**:
+   To use this server with an MCP client like Claude Desktop, add the following to your config file (or equivalent):
+   ```json
+    {
+      "mcpServers": {
+        "crypto-indicators-mcp": {
+          "command": "node",
+          "args": ["path/to/crypto-indicators-mcp/index.js"],
+          "env": {
+            "EXCHANGE_NAME": "binance"
+          }
+        }
+      }
+    }   
+    ```
+
+## Available Tools
+
+### Trend Indicators
+- `calculate_absolute_price_oscillator`: Measures the difference between two EMAs to identify trend strength (APO).
+- `calculate_aroon`: Identifies trend changes and strength using high/low price extremes (Aroon).
+- `calculate_balance_of_power`: Gauges buying vs. selling pressure based on price movement (BOP).
+- `calculate_chande_forecast_oscillator`: Predicts future price movements relative to past trends (CFO).
+- `calculate_commodity_channel_index`: Detects overbought/oversold conditions and trend reversals (CCI).
+- `calculate_double_exponential_moving_average`: Smooths price data with reduced lag for trend detection (DEMA).
+- `calculate_exponential_moving_average`: Weights recent prices more heavily for trend analysis (EMA).
+- `calculate_mass_index`: Identifies potential reversals by measuring range expansion (MI).
+- `calculate_moving_average_convergence_divergence`: Tracks momentum and trend direction via EMA differences (MACD).
+- `calculate_moving_max`: Computes the maximum price over a rolling period (MMAX).
+- `calculate_moving_min`: Computes the minimum price over a rolling period (MMIN).
+- `calculate_moving_sum`: Calculates the sum of prices over a rolling period (MSUM).
+- `calculate_parabolic_sar`: Provides stop-and-reverse points for trend following (PSAR).
+- `calculate_qstick`: Measures buying/selling pressure based on open-close differences (Qstick).
+- `calculate_kdj`: Combines stochastic and momentum signals for trend analysis (KDJ).
+- `calculate_rolling_moving_average`: Applies a rolling EMA for smoother trend tracking (RMA).
+- `calculate_simple_moving_average`: Averages prices over a period to identify trends (SMA).
+- `calculate_since_change`: Tracks the time since the last significant price change.
+- `calculate_triple_exponential_moving_average`: Reduces lag further than DEMA for trend clarity (TEMA).
+- `calculate_triangular_moving_average`: Weights middle prices more for smoother trends (TRIMA).
+- `calculate_triple_exponential_average`: Measures momentum with triple smoothing (TRIX).
+- `calculate_typical_price`: Averages high, low, and close prices for a balanced trend view.
+- `calculate_volume_weighted_moving_average`: Incorporates volume into moving averages for trend strength (VWMA).
+- `calculate_vortex`: Identifies trend direction and strength using true range (Vortex).
+
+### Momentum Indicators
+- `calculate_awesome_oscillator`: Measures market momentum using midline crossovers (AO).
+- `calculate_chaikin_oscillator`: Tracks accumulation/distribution momentum (CMO).
+- `calculate_ichimoku_cloud`: Provides a comprehensive view of support, resistance, and momentum (Ichimoku).
+- `calculate_percentage_price_oscillator`: Normalizes MACD as a percentage for momentum (PPO).
+- `calculate_percentage_volume_oscillator`: Measures volume momentum via EMA differences (PVO).
+- `calculate_price_rate_of_change`: Tracks price momentum as a percentage change (ROC).
+- `calculate_relative_strength_index`: Identifies overbought/oversold conditions via momentum (RSI).
+- `calculate_stochastic_oscillator`: Compares closing prices to ranges for momentum signals (STOCH).
+- `calculate_williams_r`: Measures momentum relative to recent high-low ranges (Williams %R).
+
+### Volatility Indicators
+- `calculate_acceleration_bands`: Frames price action with dynamic volatility bands (AB).
+- `calculate_average_true_range`: Measures market volatility based on price ranges (ATR).
+- `calculate_bollinger_bands`: Encloses price action with volatility-based bands (BB).
+- `calculate_bollinger_bands_width`: Quantifies volatility via band width changes (BBW).
+- `calculate_chandelier_exit`: Sets trailing stop-losses based on volatility (CE).
+- `calculate_donchian_channel`: Tracks volatility with high/low price channels (DC).
+- `calculate_keltner_channel`: Combines ATR and EMA for volatility bands (KC).
+- `calculate_moving_standard_deviation`: Measures price deviation for volatility (MSTD).
+- `calculate_projection_oscillator`: Assesses volatility relative to projected prices (PO).
+- `calculate_true_range`: Calculates daily price range for volatility analysis (TR).
+- `calculate_ulcer_index`: Quantifies downside volatility and drawdowns (UI).
+
+### Volume Indicators
+- `calculate_accumulation_distribution`: Tracks volume flow to confirm price trends (AD).
+- `calculate_chaikin_money_flow`: Measures buying/selling pressure with volume (CMF).
+- `calculate_ease_of_movement`: Assesses how easily prices move with volume (EMV).
+- `calculate_force_index`: Combines price and volume for momentum strength (FI).
+- `calculate_money_flow_index`: Identifies overbought/oversold via price-volume (MFI).
+- `calculate_negative_volume_index`: Tracks price changes on lower volume days (NVI).
+- `calculate_on_balance_volume`: Accumulates volume to predict price movements (OBV).
+- `calculate_volume_price_trend`: Combines volume and price for trend confirmation (VPT).
+- `calculate_volume_weighted_average_price`: Averages prices weighted by volume (VWAP).
+
+### Trend Strategies
+- `calculate_absolute_price_oscillator_strategy`: Generates buy/sell signals from APO crossovers (APO Strategy).
+- `calculate_aroon_strategy`: Signals trend reversals using Aroon crossovers (Aroon Strategy).
+- `calculate_balance_of_power_strategy`: Issues signals based on BOP thresholds (BOP Strategy).
+- `calculate_chande_forecast_oscillator_strategy`: Predicts reversals with CFO signals (CFO Strategy).
+- `calculate_kdj_strategy`: Combines KDJ lines for trend-based signals (KDJ Strategy).
+- `calculate_macd_strategy`: Uses MACD crossovers for trading signals (MACD Strategy).
+- `calculate_parabolic_sar_strategy`: Signals trend direction with PSAR shifts (PSAR Strategy).
+- `calculate_typical_price_strategy`: Generates signals from typical price trends.
+- `calculate_volume_weighted_moving_average_strategy`: Issues signals based on VWMA crossovers (VWMA Strategy).
+- `calculate_vortex_strategy`: Signals trend direction with Vortex crossovers (Vortex Strategy).
+
+### Momentum Strategies
+- `calculate_momentum_strategy`: Issues signals based on momentum direction.
+- `calculate_awesome_oscillator_strategy`: Signals momentum shifts with AO crossovers (AO Strategy).
+- `calculate_ichimoku_cloud_strategy`: Generates signals from Ichimoku cloud positions (Ichimoku Strategy).
+- `calculate_rsi2_strategy`: Signals overbought/oversold with RSI thresholds (RSI Strategy).
+- `calculate_stochastic_oscillator_strategy`: Uses stochastic crossovers for signals (STOCH Strategy).
+- `calculate_williams_r_strategy`: Signals momentum reversals with Williams %R (Williams %R Strategy).
+
+### Volatility Strategies
+- `calculate_acceleration_bands_strategy`: Signals breakouts with acceleration bands (AB Strategy).
+- `calculate_bollinger_bands_strategy`: Issues signals from Bollinger Band breaches (BB Strategy).
+- `calculate_projection_oscillator_strategy`: Signals volatility shifts with PO (PO Strategy).
+
+### Volume Strategies
+- `calculate_chaikin_money_flow_strategy`: Signals volume pressure with CMF (CMF Strategy).
+- `calculate_ease_of_movement_strategy`: Issues signals based on EMV trends (EMV Strategy).
+- `calculate_force_index_strategy`: Signals momentum with force index shifts (FI Strategy).
+- `calculate_money_flow_index_strategy`: Signals overbought/oversold with MFI (MFI Strategy).
+- `calculate_negative_volume_index_strategy`: Signals trends with NVI changes (NVI Strategy).
+- `calculate_volume_weighted_average_price_strategy`: Issues signals from VWAP crossovers (VWAP Strategy).
+
+## Usage Examples
+
+### Example 1: Calculate MACD Indicator
+
+**Input (Natural Language Prompt)**:
+```
+Calculate the MACD for BTC/USDT on a 1-hour timeframe with fast period 12, slow period 26, signal period 9, and fetch 100 data points.
+```
+
+**Output**:
+```
+{"macd": [...], "signal": [...], "histogram": [...]}
+```
+
+### Example 2: Calculate RSI Strategy
+
+**Input (Natural Language Prompt)**:
+```
+Give me the RSI strategy signals for ETH/USDT on a 4-hour timeframe with a period of 14 and 50 data points.
+```
+
+**Output**:
+```
+[-1, 0, 1, 0, ...]
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+

crypto-indicators-mcp/index.js

@@ -0,0 +1,33 @@
+const { McpServer } = require("@modelcontextprotocol/sdk/server/mcp.js");
+const { StdioServerTransport } = require("@modelcontextprotocol/sdk/server/stdio.js");
+
+// Initialize MCP server
+const server = new McpServer({
+  name: "crypto-indicators-mcp",
+  version: "1.0.0",
+});
+
+// Load tools from separate files
+require("./indicators/trendIndicators")(server);
+require("./indicators/momentumIndicators")(server);
+require("./indicators/volatilityIndicators")(server);
+require("./indicators/volumeIndicators")(server);
+
+// Load strategies from separate files
+require("./strategies/trendStrategies")(server);
+require("./strategies/momentumStrategies")(server);
+require("./strategies/volatilityStrategies")(server);
+require("./strategies/volumeStrategies")(server);
+
+// Function to start the server using async/await
+async function startServer() {
+  const transport = new StdioServerTransport();
+  try {
+    await server.connect(transport);
+  } catch (err) {
+    console.error("Failed to start server:", err);
+  }
+}
+
+// Start the server
+startServer();

crypto-indicators-mcp/indicators/momentumIndicators.js

@@ -0,0 +1,198 @@
+const { z } = require("zod");
+const {
+  awesomeOscillator, chaikinOscillator, ichimokuCloud, percentagePriceOscillator,
+  percentageVolumeOscillator, priceRateOfChange, relativeStrengthIndex,
+  stochasticOscillator, williamsR,
+} = require("indicatorts");
+const fetchOhlcvData = require("../utils/fetchOhlcvData");
+
+module.exports = (server) => {
+  server.tool(
+    "calculate_awesome_oscillator",
+    "Calculate the Awesome Oscillator (AO) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      fastPeriod: z.number().default(5).describe("Fast period for AO"),
+      slowPeriod: z.number().default(34).describe("Slow period for AO"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, fastPeriod, slowPeriod, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = awesomeOscillator(asset.highs, asset.lows, { fastPeriod, slowPeriod });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_chaikin_oscillator",
+    "Calculate the Chaikin Oscillator (CMO) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      fastPeriod: z.number().default(3).describe("Fast period for CMO"),
+      slowPeriod: z.number().default(10).describe("Slow period for CMO"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, fastPeriod, slowPeriod, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = chaikinOscillator(asset.highs, asset.lows, asset.closings, asset.volumes, { fastPeriod, slowPeriod });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_ichimoku_cloud",
+    "Calculate the Ichimoku Cloud for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      conversionPeriod: z.number().default(9).describe("Conversion line period"),
+      basePeriod: z.number().default(26).describe("Base line period"),
+      spanPeriod: z.number().default(52).describe("Leading span period"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, conversionPeriod, basePeriod, spanPeriod, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = ichimokuCloud(asset.highs, asset.lows, asset.closings, { conversionPeriod, basePeriod, spanPeriod });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_percentage_price_oscillator",
+    "Calculate the Percentage Price Oscillator (PPO) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      fastPeriod: z.number().default(12).describe("Fast period for PPO"),
+      slowPeriod: z.number().default(26).describe("Slow period for PPO"),
+      signalPeriod: z.number().default(9).describe("Signal period for PPO"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, fastPeriod, slowPeriod, signalPeriod, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = percentagePriceOscillator(asset.closings, { fastPeriod, slowPeriod, signalPeriod });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_percentage_volume_oscillator",
+    "Calculate the Percentage Volume Oscillator (PVO) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      fastPeriod: z.number().default(12).describe("Fast period for PVO"),
+      slowPeriod: z.number().default(26).describe("Slow period for PVO"),
+      signalPeriod: z.number().default(9).describe("Signal period for PVO"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, fastPeriod, slowPeriod, signalPeriod, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = percentageVolumeOscillator(asset.volumes, { fastPeriod, slowPeriod, signalPeriod });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_price_rate_of_change",
+    "Calculate the Price Rate of Change (ROC) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for ROC"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = priceRateOfChange(asset.closings, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_relative_strength_index",
+    "Calculate the Relative Strength Index (RSI) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for RSI"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = relativeStrengthIndex(asset.closings, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_stochastic_oscillator",
+    "Calculate the Stochastic Oscillator (STOCH) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for STOCH"),
+      signalPeriod: z.number().default(3).describe("Signal period for STOCH"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, signalPeriod, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = stochasticOscillator(asset.highs, asset.lows, asset.closings, { period, signalPeriod });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_williams_r",
+    "Calculate the Williams R (WILLR) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for WILLR"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = williamsR(asset.highs, asset.lows, asset.closings, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+};

crypto-indicators-mcp/indicators/trendIndicators.js

@@ -0,0 +1,494 @@
+const { z } = require("zod");
+const {
+  absolutePriceOscillator, aroon, balanceOfPower, chandeForecastOscillator,
+  commodityChannelIndex, doubleExponentialMovingAverage, exponentialMovingAverage,
+  massIndex, movingAverageConvergenceDivergence, movingMax, movingMin, movingSum,
+  parabolicSar, qstick, kdj, rollingMovingAverage, simpleMovingAverage, sinceChange,
+  tripleExponentialMovingAverage, triangularMovingAverage, tripleExponentialAverage,
+  typicalPrice, volumeWeightedMovingAverage, vortex,
+} = require("indicatorts");
+const fetchOhlcvData = require("../utils/fetchOhlcvData");
+
+module.exports = (server) => {
+  server.tool(
+    "calculate_absolute_price_oscillator",
+    "Calculate the Absolute Price Oscillator (APO) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      fastPeriod: z.number().default(12).describe("Fast period for APO"),
+      slowPeriod: z.number().default(26).describe("Slow period for APO"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, fastPeriod, slowPeriod, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = absolutePriceOscillator(asset.closings, { fastPeriod, slowPeriod });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_aroon",
+    "Calculate the Aroon Indicator for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for Aroon"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = aroon(asset.highs, asset.lows, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_balance_of_power",
+    "Calculate the Balance of Power (BOP) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = balanceOfPower(asset.openings, asset.highs, asset.lows, asset.closings);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_chande_forecast_oscillator",
+    "Calculate the Chande Forecast Oscillator (CFO) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for CFO"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = chandeForecastOscillator(asset.closings, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_commodity_channel_index",
+    "Calculate the Commodity Channel Index (CCI) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(20).describe("Period length for CCI"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = commodityChannelIndex(asset.highs, asset.lows, asset.closings, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_double_exponential_moving_average",
+    "Calculate the Double Exponential Moving Average (DEMA) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(10).describe("Period length for DEMA"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = doubleExponentialMovingAverage(asset.closings, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_exponential_moving_average",
+    "Calculate the Exponential Moving Average (EMA) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(10).describe("Period length for EMA"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = exponentialMovingAverage(asset.closings, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_mass_index",
+    "Calculate the Mass Index (MI) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(25).describe("Period length for MI"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = massIndex(asset.highs, asset.lows, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_moving_average_convergence_divergence",
+    "Calculate the MACD for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      fastPeriod: z.number().default(12).describe("Fast period for MACD"),
+      slowPeriod: z.number().default(26).describe("Slow period for MACD"),
+      signalPeriod: z.number().default(9).describe("Signal period for MACD"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, fastPeriod, slowPeriod, signalPeriod, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = movingAverageConvergenceDivergence(asset.closings, { fastPeriod, slowPeriod, signalPeriod });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_moving_max",
+    "Calculate the Moving Max (MMAX) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(10).describe("Period length for MMAX"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = movingMax(asset.closings, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_moving_min",
+    "Calculate the Moving Min (MMIN) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(10).describe("Period length for MMIN"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = movingMin(asset.closings, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_moving_sum",
+    "Calculate the Moving Sum (MSUM) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(10).describe("Period length for MSUM"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = movingSum(asset.closings, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_parabolic_sar",
+    "Calculate the Parabolic SAR (PSAR) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      accelerationFactorStep: z.number().default(0.02).describe("Acceleration factor step for PSAR"),
+      accelerationFactorMax: z.number().default(0.2).describe("Maximum acceleration factor for PSAR"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, accelerationFactorStep, accelerationFactorMax, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = parabolicSar(asset.highs, asset.lows, { accelerationFactorStep, accelerationFactorMax });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_qstick",
+    "Calculate the Qstick Indicator for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for Qstick"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = qstick(asset.openings, asset.closings, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_kdj",
+    "Calculate the Random Index (KDJ) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(9).describe("Period length for KDJ"),
+      signalPeriod: z.number().default(3).describe("Signal period for KDJ"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, signalPeriod, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = kdj(asset.highs, asset.lows, asset.closings, { period, signalPeriod });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_rolling_moving_average",
+    "Calculate the Rolling Moving Average (RMA) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(10).describe("Period length for RMA"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = rollingMovingAverage(asset.closings, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_simple_moving_average",
+    "Calculate the Simple Moving Average (SMA) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(10).describe("Period length for SMA"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = simpleMovingAverage(asset.closings, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_since_change",
+    "Calculate the Since Change for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = sinceChange(asset.closings);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_triple_exponential_moving_average",
+    "Calculate the Triple Exponential Moving Average (TEMA) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(10).describe("Period length for TEMA"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = tripleExponentialMovingAverage(asset.closings, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_triangular_moving_average",
+    "Calculate the Triangular Moving Average (TRIMA) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(10).describe("Period length for TRIMA"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = triangularMovingAverage(asset.closings, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_triple_exponential_average",
+    "Calculate the Triple Exponential Average (TRIX) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(15).describe("Period length for TRIX"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = tripleExponentialAverage(asset.closings, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_typical_price",
+    "Calculate the Typical Price for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = typicalPrice(asset.highs, asset.lows, asset.closings);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_volume_weighted_moving_average",
+    "Calculate the Volume Weighted Moving Average (VWMA) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for VWMA"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = volumeWeightedMovingAverage(asset.closings, asset.volumes, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_vortex",
+    "Calculate the Vortex Indicator for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for Vortex"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = vortex(asset.highs, asset.lows, asset.closings, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+};

crypto-indicators-mcp/indicators/volatilityIndicators.js

@@ -0,0 +1,232 @@
+const { z } = require("zod");
+const {
+  accelerationBands, averageTrueRange, bollingerBands, bollingerBandsWidth,
+  chandelierExit, donchianChannel, keltnerChannel, movingStandardDeviation,
+  projectionOscillator, trueRange, ulcerIndex,
+} = require("indicatorts");
+const fetchOhlcvData = require("../utils/fetchOhlcvData");
+
+module.exports = (server) => {
+  server.tool(
+    "calculate_acceleration_bands",
+    "Calculate the Acceleration Bands (AB) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(20).describe("Period length for AB"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = accelerationBands(asset.highs, asset.lows, asset.closings, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_average_true_range",
+    "Calculate the Average True Range (ATR) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for ATR"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = averageTrueRange(asset.highs, asset.lows, asset.closings, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_bollinger_bands",
+    "Calculate the Bollinger Bands (BB) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(20).describe("Period length for BB"),
+      stdDev: z.number().default(2).describe("Standard deviation multiplier"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, stdDev, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = bollingerBands(asset.closings, { period, stdDev });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_bollinger_bands_width",
+    "Calculate the Bollinger Bands Width (BBW) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(20).describe("Period length for BBW"),
+      stdDev: z.number().default(2).describe("Standard deviation multiplier"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, stdDev, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = bollingerBandsWidth(asset.closings, { period, stdDev });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_chandelier_exit",
+    "Calculate the Chandelier Exit (CE) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(22).describe("Period length for CE"),
+      multiplier: z.number().default(3).describe("Multiplier for CE"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, multiplier, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = chandelierExit(asset.highs, asset.lows, asset.closings, { period, multiplier });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_donchian_channel",
+    "Calculate the Donchian Channel (DC) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(20).describe("Period length for DC"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = donchianChannel(asset.highs, asset.lows, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_keltner_channel",
+    "Calculate the Keltner Channel (KC) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(20).describe("Period length for KC"),
+      multiplier: z.number().default(2).describe("Multiplier for KC"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, multiplier, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = keltnerChannel(asset.highs, asset.lows, asset.closings, { period, multiplier });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_moving_standard_deviation",
+    "Calculate the Moving Standard Deviation (MSTD) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(20).describe("Period length for MSTD"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = movingStandardDeviation(asset.closings, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_projection_oscillator",
+    "Calculate the Projection Oscillator (PO) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for PO"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = projectionOscillator(asset.highs, asset.lows, asset.closings, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_true_range",
+    "Calculate the True Range (TR) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = trueRange(asset.highs, asset.lows, asset.closings);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_ulcer_index",
+    "Calculate the Ulcer Index (UI) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for UI"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = ulcerIndex(asset.closings, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+};

crypto-indicators-mcp/indicators/volumeIndicators.js

@@ -0,0 +1,184 @@
+const { z } = require("zod");
+const {
+  accumulationDistribution, chaikinMoneyFlow, easeOfMovement, forceIndex,
+  moneyFlowIndex, negativeVolumeIndex, onBalanceVolume, volumePriceTrend,
+  volumeWeightedAveragePrice,
+} = require("indicatorts");
+const fetchOhlcvData = require("../utils/fetchOhlcvData");
+
+module.exports = (server) => {
+  server.tool(
+    "calculate_accumulation_distribution",
+    "Calculate the Accumulation/Distribution (AD) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = accumulationDistribution(asset.highs, asset.lows, asset.closings, asset.volumes);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_chaikin_money_flow",
+    "Calculate the Chaikin Money Flow (CMF) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(20).describe("Period length for CMF"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = chaikinMoneyFlow(asset.highs, asset.lows, asset.closings, asset.volumes, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_ease_of_movement",
+    "Calculate the Ease of Movement (EMV) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for EMV"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = easeOfMovement(asset.highs, asset.lows, asset.volumes, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_force_index",
+    "Calculate the Force Index (FI) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(13).describe("Period length for FI"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = forceIndex(asset.closings, asset.volumes, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_money_flow_index",
+    "Calculate the Money Flow Index (MFI) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for MFI"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = moneyFlowIndex(asset.highs, asset.lows, asset.closings, asset.volumes, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_negative_volume_index",
+    "Calculate the Negative Volume Index (NVI) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = negativeVolumeIndex(asset.closings, asset.volumes);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_on_balance_volume",
+    "Calculate the On-Balance Volume (OBV) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = onBalanceVolume(asset.closings, asset.volumes);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_volume_price_trend",
+    "Calculate the Volume Price Trend (VPT) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = volumePriceTrend(asset.closings, asset.volumes);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_volume_weighted_average_price",
+    "Calculate the Volume Weighted Average Price (VWAP) for a given trading pair using Binance OHLCV data",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = volumeWeightedAveragePrice(asset.highs, asset.lows, asset.closings, asset.volumes);
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+};

crypto-indicators-mcp/node_modules/.package-lock.json

@@ -0,0 +1,1435 @@
+{
+  "name": "crypto-indicators-mcp",
+  "version": "1.0.1",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "node_modules/@modelcontextprotocol/sdk": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmmirror.com/@modelcontextprotocol/sdk/-/sdk-1.7.0.tgz",
+      "integrity": "sha512-IYPe/FLpvF3IZrd/f5p5ffmWhMc3aEMuM2wGJASDqC2Ge7qatVCdbfPx3n/5xFeb19xN0j/911M2AaFuircsWA==",
+      "license": "MIT",
+      "dependencies": {
+        "content-type": "^1.0.5",
+        "cors": "^2.8.5",
+        "eventsource": "^3.0.2",
+        "express": "^5.0.1",
+        "express-rate-limit": "^7.5.0",
+        "pkce-challenge": "^4.1.0",
+        "raw-body": "^3.0.0",
+        "zod": "^3.23.8",
+        "zod-to-json-schema": "^3.24.1"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "6.14.13",
+      "resolved": "https://registry.npmmirror.com/@types/node/-/node-6.14.13.tgz",
+      "integrity": "sha512-J1F0XJ/9zxlZel5ZlbeSuHW2OpabrUAqpFuC2sm2I3by8sERQ8+KCjNKUcq8QHuzpGMWiJpo9ZxeHrqrP2KzQw==",
+      "license": "MIT"
+    },
+    "node_modules/accepts": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/accepts/-/accepts-2.0.0.tgz",
+      "integrity": "sha512-5cvg6CtKwfgdmVqY1WIiXKc3Q1bkRqGLi+2W/6ao+6Y7gu/RCwRuAhGEzh5B4KlszSuTLgZYuqFqo5bImjNKng==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-types": "^3.0.0",
+        "negotiator": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmmirror.com/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmmirror.com/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmmirror.com/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "license": "MIT"
+    },
+    "node_modules/body-parser": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmmirror.com/body-parser/-/body-parser-2.1.0.tgz",
+      "integrity": "sha512-/hPxh61E+ll0Ujp24Ilm64cykicul1ypfwjVttduAiEdtnJFvLePSrIPk+HMImtNv5270wOGCb1Tns2rybMkoQ==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "^3.1.2",
+        "content-type": "^1.0.5",
+        "debug": "^4.4.0",
+        "http-errors": "^2.0.0",
+        "iconv-lite": "^0.5.2",
+        "on-finished": "^2.4.1",
+        "qs": "^6.14.0",
+        "raw-body": "^3.0.0",
+        "type-is": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/body-parser/node_modules/debug": {
+      "version": "4.4.0",
+      "resolved": "https://registry.npmmirror.com/debug/-/debug-4.4.0.tgz",
+      "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/body-parser/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmmirror.com/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/body-parser/node_modules/qs": {
+      "version": "6.14.0",
+      "resolved": "https://registry.npmmirror.com/qs/-/qs-6.14.0.tgz",
+      "integrity": "sha512-YWWTjgABSKcvs/nWBi9PycY/JiPJqOD4JA6o9Sej2AtvSGarXxKC3OQSk4pAarbdQlKAh5D4FCQkJNkW+GAn3w==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "side-channel": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmmirror.com/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmmirror.com/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmmirror.com/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/call-bound": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmmirror.com/call-bound/-/call-bound-1.0.4.tgz",
+      "integrity": "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "get-intrinsic": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/ccxt": {
+      "version": "1.95.43",
+      "resolved": "https://registry.npmmirror.com/ccxt/-/ccxt-1.95.43.tgz",
+      "integrity": "sha512-LKu1ECf56mmCGY8vlpoZrgQ1DQ8A+uc01mza/1vvgZ+q4Azrp2XXYjKXsGSDvbR47xziEGY6S1QxFoQwAE4k/w==",
+      "hasInstallScript": true,
+      "license": "MIT",
+      "dependencies": {
+        "replace-in-file": "^6.3.5",
+        "ws": "^8.8.1"
+      },
+      "engines": {
+        "node": ">=10.4.0"
+      }
+    },
+    "node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmmirror.com/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/cliui": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmmirror.com/cliui/-/cliui-8.0.1.tgz",
+      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
+      "license": "ISC",
+      "dependencies": {
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.1",
+        "wrap-ansi": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmmirror.com/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmmirror.com/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "license": "MIT"
+    },
+    "node_modules/concat-map": {
+      "version": "0.0.1",
+      "resolved": "https://registry.npmmirror.com/concat-map/-/concat-map-0.0.1.tgz",
+      "integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
+      "license": "MIT"
+    },
+    "node_modules/content-disposition": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmmirror.com/content-disposition/-/content-disposition-1.0.0.tgz",
+      "integrity": "sha512-Au9nRL8VNUut/XSzbQA38+M78dzP4D+eqg3gfJHMIHHYa3bg067xj1KxMUWj+VULbiZMowKngFFbKczUrNJ1mg==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "5.2.1"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmmirror.com/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie": {
+      "version": "0.7.1",
+      "resolved": "https://registry.npmmirror.com/cookie/-/cookie-0.7.1.tgz",
+      "integrity": "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie-signature": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmmirror.com/cookie-signature/-/cookie-signature-1.2.2.tgz",
+      "integrity": "sha512-D76uU73ulSXrD1UXF4KE2TMxVVwhsnCgfAyTg9k8P6KGZjlXKrOLe4dJQKI3Bxi5wjesZoFXJWElNWBjPZMbhg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6.6.0"
+      }
+    },
+    "node_modules/cors": {
+      "version": "2.8.5",
+      "resolved": "https://registry.npmmirror.com/cors/-/cors-2.8.5.tgz",
+      "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==",
+      "license": "MIT",
+      "dependencies": {
+        "object-assign": "^4",
+        "vary": "^1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.3.6",
+      "resolved": "https://registry.npmmirror.com/debug/-/debug-4.3.6.tgz",
+      "integrity": "sha512-O/09Bd4Z1fBrU4VzkhFqVgpPzaGbw6Sm9FEkBT1A/YBXQFGuuSxa1dN2nxgxS34JmKXqYx8CZAwEVoJFImUXIg==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "2.1.2"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/destroy": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmmirror.com/destroy/-/destroy-1.2.0.tgz",
+      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmmirror.com/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmmirror.com/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
+      "license": "MIT"
+    },
+    "node_modules/emoji-regex": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmmirror.com/emoji-regex/-/emoji-regex-8.0.0.tgz",
+      "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
+      "license": "MIT"
+    },
+    "node_modules/encodeurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/encodeurl/-/encodeurl-2.0.0.tgz",
+      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmmirror.com/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmmirror.com/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmmirror.com/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmmirror.com/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmmirror.com/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
+      "license": "MIT"
+    },
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmmirror.com/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/eventsource": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmmirror.com/eventsource/-/eventsource-3.0.5.tgz",
+      "integrity": "sha512-LT/5J605bx5SNyE+ITBDiM3FxffBiq9un7Vx0EwMDM3vg8sWKx/tO2zC+LMqZ+smAM0F2hblaDZUVZF0te2pSw==",
+      "license": "MIT",
+      "dependencies": {
+        "eventsource-parser": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/eventsource-parser": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmmirror.com/eventsource-parser/-/eventsource-parser-3.0.0.tgz",
+      "integrity": "sha512-T1C0XCUimhxVQzW4zFipdx0SficT651NnkR0ZSH3yQwh+mFMdLfgjABVi4YtMTtaL4s168593DaoaRLMqryavA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/express": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmmirror.com/express/-/express-5.0.1.tgz",
+      "integrity": "sha512-ORF7g6qGnD+YtUG9yx4DFoqCShNMmUKiXuT5oWMHiOvt/4WFbHC6yCwQMTSBMno7AqntNCAzzcnnjowRkTL9eQ==",
+      "license": "MIT",
+      "dependencies": {
+        "accepts": "^2.0.0",
+        "body-parser": "^2.0.1",
+        "content-disposition": "^1.0.0",
+        "content-type": "~1.0.4",
+        "cookie": "0.7.1",
+        "cookie-signature": "^1.2.1",
+        "debug": "4.3.6",
+        "depd": "2.0.0",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "finalhandler": "^2.0.0",
+        "fresh": "2.0.0",
+        "http-errors": "2.0.0",
+        "merge-descriptors": "^2.0.0",
+        "methods": "~1.1.2",
+        "mime-types": "^3.0.0",
+        "on-finished": "2.4.1",
+        "once": "1.4.0",
+        "parseurl": "~1.3.3",
+        "proxy-addr": "~2.0.7",
+        "qs": "6.13.0",
+        "range-parser": "~1.2.1",
+        "router": "^2.0.0",
+        "safe-buffer": "5.2.1",
+        "send": "^1.1.0",
+        "serve-static": "^2.1.0",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "type-is": "^2.0.0",
+        "utils-merge": "1.0.1",
+        "vary": "~1.1.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/express-rate-limit": {
+      "version": "7.5.0",
+      "resolved": "https://registry.npmmirror.com/express-rate-limit/-/express-rate-limit-7.5.0.tgz",
+      "integrity": "sha512-eB5zbQh5h+VenMPM3fh+nw1YExi5nMr6HUCR62ELSP11huvxm/Uir1H1QEyTkk5QX6A58pX6NmaTMceKZ0Eodg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/express-rate-limit"
+      },
+      "peerDependencies": {
+        "express": "^4.11 || 5 || ^5.0.0-beta.1"
+      }
+    },
+    "node_modules/finalhandler": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmmirror.com/finalhandler/-/finalhandler-2.1.0.tgz",
+      "integrity": "sha512-/t88Ty3d5JWQbWYgaOGCCYfXRwV1+be02WqYYlL6h0lEiUAMPM8o8qKGO01YIkOHzka2up08wvgYD0mDiI+q3Q==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.4.0",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "on-finished": "^2.4.1",
+        "parseurl": "^1.3.3",
+        "statuses": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/finalhandler/node_modules/debug": {
+      "version": "4.4.0",
+      "resolved": "https://registry.npmmirror.com/debug/-/debug-4.4.0.tgz",
+      "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/finalhandler/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmmirror.com/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmmirror.com/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fresh": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/fresh/-/fresh-2.0.0.tgz",
+      "integrity": "sha512-Rx/WycZ60HOaqLKAi6cHRKKI7zxWbJ31MhntmtwMoaTeF7XFH9hhBp8vITaMidfljRQ6eYWCKkaTK+ykVJHP2A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/fs.realpath": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmmirror.com/fs.realpath/-/fs.realpath-1.0.0.tgz",
+      "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
+      "license": "ISC"
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmmirror.com/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-caller-file": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmmirror.com/get-caller-file/-/get-caller-file-2.0.5.tgz",
+      "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==",
+      "license": "ISC",
+      "engines": {
+        "node": "6.* || 8.* || >= 10.*"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmmirror.com/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmmirror.com/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "license": "MIT",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/glob": {
+      "version": "7.2.3",
+      "resolved": "https://registry.npmmirror.com/glob/-/glob-7.2.3.tgz",
+      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
+      "license": "ISC",
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.1.1",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmmirror.com/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmmirror.com/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmmirror.com/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmmirror.com/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/http-errors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/http-errors/-/http-errors-2.0.0.tgz",
+      "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
+      "license": "MIT",
+      "dependencies": {
+        "depd": "2.0.0",
+        "inherits": "2.0.4",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "toidentifier": "1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmmirror.com/iconv-lite/-/iconv-lite-0.5.2.tgz",
+      "integrity": "sha512-kERHXvpSaB4aU3eANwidg79K8FlrN77m8G9V+0vOR3HYaRifrlwMEpT7ZBJqLSEIHnEgJTHcWK82wwLwwKwtag==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/indicatorts": {
+      "version": "2.2.2",
+      "resolved": "https://registry.npmmirror.com/indicatorts/-/indicatorts-2.2.2.tgz",
+      "integrity": "sha512-oJRe83n2zj826Mlp2RKQVfurqbq5dEHzAWgZidiYkS0mrx3GCbXlNj59YtwZvekRmNwi/d4NdeHGHd8Nspl6Xg==",
+      "license": "MIT"
+    },
+    "node_modules/inflight": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmmirror.com/inflight/-/inflight-1.0.6.tgz",
+      "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
+      "license": "ISC",
+      "dependencies": {
+        "once": "^1.3.0",
+        "wrappy": "1"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmmirror.com/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC"
+    },
+    "node_modules/ipaddr.js": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmmirror.com/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/is-fullwidth-code-point": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmmirror.com/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",
+      "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/is-promise": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmmirror.com/is-promise/-/is-promise-4.0.0.tgz",
+      "integrity": "sha512-hvpoI6korhJMnej285dSg6nu1+e6uxs7zG3BYAm5byqDsgJNWwxzM6z6iZiAgQR4TJ30JmBTOwqZUw3WlyH3AQ==",
+      "license": "MIT"
+    },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmmirror.com/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/media-typer": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmmirror.com/media-typer/-/media-typer-1.1.0.tgz",
+      "integrity": "sha512-aisnrDP4GNe06UcKFnV5bfMNPBUw4jsLGaWwWfnH3v02GnBuXX2MCVn5RbrWo0j3pczUilYblq7fQ7Nw2t5XKw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/merge-descriptors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/merge-descriptors/-/merge-descriptors-2.0.0.tgz",
+      "integrity": "sha512-Snk314V5ayFLhp3fkUREub6WtjBfPdCPY1Ln8/8munuLuiYhsABgBVWsozAG+MWMbVEvcdcpbi9R7ww22l9Q3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/methods": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmmirror.com/methods/-/methods-1.1.2.tgz",
+      "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.54.0",
+      "resolved": "https://registry.npmmirror.com/mime-db/-/mime-db-1.54.0.tgz",
+      "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmmirror.com/mime-types/-/mime-types-3.0.0.tgz",
+      "integrity": "sha512-XqoSHeCGjVClAmoGFG3lVFqQFRIrTVw2OH3axRqAcfaw+gHWIfnASS92AV+Rl/mk0MupgZTRHQOjxY6YVnzK5w==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "^1.53.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmmirror.com/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmmirror.com/ms/-/ms-2.1.2.tgz",
+      "integrity": "sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==",
+      "license": "MIT"
+    },
+    "node_modules/negotiator": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmmirror.com/negotiator/-/negotiator-1.0.0.tgz",
+      "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmmirror.com/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/object-inspect": {
+      "version": "1.13.4",
+      "resolved": "https://registry.npmmirror.com/object-inspect/-/object-inspect-1.13.4.tgz",
+      "integrity": "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/on-finished": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmmirror.com/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+      "license": "MIT",
+      "dependencies": {
+        "ee-first": "1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/once": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmmirror.com/once/-/once-1.4.0.tgz",
+      "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
+      "license": "ISC",
+      "dependencies": {
+        "wrappy": "1"
+      }
+    },
+    "node_modules/parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmmirror.com/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/path-is-absolute": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmmirror.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
+      "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/path-to-regexp": {
+      "version": "8.2.0",
+      "resolved": "https://registry.npmmirror.com/path-to-regexp/-/path-to-regexp-8.2.0.tgz",
+      "integrity": "sha512-TdrF7fW9Rphjq4RjrW0Kp2AW0Ahwu9sRGTkS6bvDi0SCwZlEZYmcfDbEsTz8RVk0EHIS/Vd1bv3JhG+1xZuAyQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/pkce-challenge": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmmirror.com/pkce-challenge/-/pkce-challenge-4.1.0.tgz",
+      "integrity": "sha512-ZBmhE1C9LcPoH9XZSdwiPtbPHZROwAnMy+kIFQVrnMCxY4Cudlz3gBOpzilgc0jOgRaiT3sIWfpMomW2ar2orQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.20.0"
+      }
+    },
+    "node_modules/proxy-addr": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmmirror.com/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "license": "MIT",
+      "dependencies": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/qs": {
+      "version": "6.13.0",
+      "resolved": "https://registry.npmmirror.com/qs/-/qs-6.13.0.tgz",
+      "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "side-channel": "^1.0.6"
+      },
+      "engines": {
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/range-parser": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmmirror.com/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/raw-body": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmmirror.com/raw-body/-/raw-body-3.0.0.tgz",
+      "integrity": "sha512-RmkhL8CAyCRPXCE28MMH0z2PNWQBNk2Q09ZdxM9IOOXwxwZbN+qbWaatPkdkWIKL2ZVDImrN/pK5HTRz2PcS4g==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.6.3",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/raw-body/node_modules/iconv-lite": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmmirror.com/iconv-lite/-/iconv-lite-0.6.3.tgz",
+      "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/replace-in-file": {
+      "version": "6.3.5",
+      "resolved": "https://registry.npmmirror.com/replace-in-file/-/replace-in-file-6.3.5.tgz",
+      "integrity": "sha512-arB9d3ENdKva2fxRnSjwBEXfK1npgyci7ZZuwysgAp7ORjHSyxz6oqIjTEv8R0Ydl4Ll7uOAZXL4vbkhGIizCg==",
+      "license": "MIT",
+      "dependencies": {
+        "chalk": "^4.1.2",
+        "glob": "^7.2.0",
+        "yargs": "^17.2.1"
+      },
+      "bin": {
+        "replace-in-file": "bin/cli.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/require-directory": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmmirror.com/require-directory/-/require-directory-2.1.1.tgz",
+      "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/router": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmmirror.com/router/-/router-2.1.0.tgz",
+      "integrity": "sha512-/m/NSLxeYEgWNtyC+WtNHCF7jbGxOibVWKnn+1Psff4dJGOfoXP+MuC/f2CwSmyiHdOIzYnYFp4W6GxWfekaLA==",
+      "license": "MIT",
+      "dependencies": {
+        "is-promise": "^4.0.0",
+        "parseurl": "^1.3.3",
+        "path-to-regexp": "^8.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmmirror.com/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmmirror.com/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "license": "MIT"
+    },
+    "node_modules/send": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmmirror.com/send/-/send-1.1.0.tgz",
+      "integrity": "sha512-v67WcEouB5GxbTWL/4NeToqcZiAWEq90N888fczVArY8A79J0L4FD7vj5hm3eUMua5EpoQ59wa/oovY6TLvRUA==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.3.5",
+        "destroy": "^1.2.0",
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "etag": "^1.8.1",
+        "fresh": "^0.5.2",
+        "http-errors": "^2.0.0",
+        "mime-types": "^2.1.35",
+        "ms": "^2.1.3",
+        "on-finished": "^2.4.1",
+        "range-parser": "^1.2.1",
+        "statuses": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/send/node_modules/fresh": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmmirror.com/fresh/-/fresh-0.5.2.tgz",
+      "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/send/node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmmirror.com/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/send/node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmmirror.com/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/send/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmmirror.com/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/serve-static": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmmirror.com/serve-static/-/serve-static-2.1.0.tgz",
+      "integrity": "sha512-A3We5UfEjG8Z7VkDv6uItWw6HY2bBSBJT1KtVESn6EOoOr2jAxNhxWCLY3jDE2WcuHXByWju74ck3ZgLwL8xmA==",
+      "license": "MIT",
+      "dependencies": {
+        "encodeurl": "^2.0.0",
+        "escape-html": "^1.0.3",
+        "parseurl": "^1.3.3",
+        "send": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmmirror.com/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
+      "license": "ISC"
+    },
+    "node_modules/side-channel": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmmirror.com/side-channel/-/side-channel-1.1.0.tgz",
+      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3",
+        "side-channel-list": "^1.0.0",
+        "side-channel-map": "^1.0.1",
+        "side-channel-weakmap": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-list": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmmirror.com/side-channel-list/-/side-channel-list-1.0.0.tgz",
+      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-map": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmmirror.com/side-channel-map/-/side-channel-map-1.0.1.tgz",
+      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-weakmap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmmirror.com/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3",
+        "side-channel-map": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/statuses": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmmirror.com/statuses/-/statuses-2.0.1.tgz",
+      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/string-width": {
+      "version": "4.2.3",
+      "resolved": "https://registry.npmmirror.com/string-width/-/string-width-4.2.3.tgz",
+      "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
+      "license": "MIT",
+      "dependencies": {
+        "emoji-regex": "^8.0.0",
+        "is-fullwidth-code-point": "^3.0.0",
+        "strip-ansi": "^6.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/strip-ansi": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmmirror.com/strip-ansi/-/strip-ansi-6.0.1.tgz",
+      "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmmirror.com/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/technicalindicators": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmmirror.com/technicalindicators/-/technicalindicators-3.1.0.tgz",
+      "integrity": "sha512-f16mOc+Y05hNy/of+UbGxhxQQmxUztCiluhsqC5QLUYz4WowUgKde9m6nIjK1Kay0wGHigT0IkOabpp0+22UfA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "^6.0.96"
+      }
+    },
+    "node_modules/toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmmirror.com/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/trading-indicator": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmmirror.com/trading-indicator/-/trading-indicator-2.0.4.tgz",
+      "integrity": "sha512-j4ns8c4/JZXE8jJJsQ2d0ZFyRQbB3x9J+Dpfgwb4towW3TE+AFKVgsD8eGUrHJft7+hWoWKAJDhH7ljynJrYHw==",
+      "license": "ISC",
+      "dependencies": {
+        "ccxt": "^1.95.36",
+        "technicalindicators": "^3.0.0"
+      }
+    },
+    "node_modules/type-is": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmmirror.com/type-is/-/type-is-2.0.0.tgz",
+      "integrity": "sha512-gd0sGezQYCbWSbkZr75mln4YBidWUN60+devscpLF5mtRDUpiaTvKpBNrdaCvel1NdR2k6vclXybU5fBd2i+nw==",
+      "license": "MIT",
+      "dependencies": {
+        "content-type": "^1.0.5",
+        "media-typer": "^1.1.0",
+        "mime-types": "^3.0.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/undici": {
+      "version": "7.5.0",
+      "resolved": "https://registry.npmmirror.com/undici/-/undici-7.5.0.tgz",
+      "integrity": "sha512-NFQG741e8mJ0fLQk90xKxFdaSM7z4+IQpAgsFI36bCDY9Z2+aXXZjVy2uUksMouWfMI9+w5ejOq5zYYTBCQJDQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=20.18.1"
+      }
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmmirror.com/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/utils-merge": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmmirror.com/utils-merge/-/utils-merge-1.0.1.tgz",
+      "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmmirror.com/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/wrap-ansi": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmmirror.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz",
+      "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==",
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.0.0",
+        "string-width": "^4.1.0",
+        "strip-ansi": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/wrap-ansi?sponsor=1"
+      }
+    },
+    "node_modules/wrappy": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmmirror.com/wrappy/-/wrappy-1.0.2.tgz",
+      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
+      "license": "ISC"
+    },
+    "node_modules/ws": {
+      "version": "8.18.1",
+      "resolved": "https://registry.npmmirror.com/ws/-/ws-8.18.1.tgz",
+      "integrity": "sha512-RKW2aJZMXeMxVpnZ6bck+RswznaxmzdULiBr6KY7XkTnW8uvt0iT9H5DkHUChXrc+uurzwa0rVI16n/Xzjdz1w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/y18n": {
+      "version": "5.0.8",
+      "resolved": "https://registry.npmmirror.com/y18n/-/y18n-5.0.8.tgz",
+      "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/yargs": {
+      "version": "17.7.2",
+      "resolved": "https://registry.npmmirror.com/yargs/-/yargs-17.7.2.tgz",
+      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
+      "license": "MIT",
+      "dependencies": {
+        "cliui": "^8.0.1",
+        "escalade": "^3.1.1",
+        "get-caller-file": "^2.0.5",
+        "require-directory": "^2.1.1",
+        "string-width": "^4.2.3",
+        "y18n": "^5.0.5",
+        "yargs-parser": "^21.1.1"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/yargs-parser": {
+      "version": "21.1.1",
+      "resolved": "https://registry.npmmirror.com/yargs-parser/-/yargs-parser-21.1.1.tgz",
+      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+      "license": "ISC",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/zod": {
+      "version": "3.24.2",
+      "resolved": "https://registry.npmmirror.com/zod/-/zod-3.24.2.tgz",
+      "integrity": "sha512-lY7CDW43ECgW9u1TcT3IoXHflywfVqDYze4waEz812jR/bZ8FHDsl7pFQoSZTz5N+2NqRXs8GBwnAwo3ZNxqhQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/zod-to-json-schema": {
+      "version": "3.24.5",
+      "resolved": "https://registry.npmmirror.com/zod-to-json-schema/-/zod-to-json-schema-3.24.5.tgz",
+      "integrity": "sha512-/AuWwMP+YqiPbsJx5D6TfgRTc4kTLjsh5SOcd4bLsfUg2RcEXrFMJl1DGgdHy2aCfsIA/cr/1JM0xcB2GZji8g==",
+      "license": "ISC",
+      "peerDependencies": {
+        "zod": "^3.24.1"
+      }
+    }
+  }
+}

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Anthropic, PBC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/README.md

@@ -0,0 +1,493 @@
+# MCP TypeScript SDK ![NPM Version](https://img.shields.io/npm/v/%40modelcontextprotocol%2Fsdk) ![MIT licensed](https://img.shields.io/npm/l/%40modelcontextprotocol%2Fsdk)
+
+## Table of Contents
+- [Overview](#overview)
+- [Installation](#installation)
+- [Quickstart](#quickstart)
+- [What is MCP?](#what-is-mcp)
+- [Core Concepts](#core-concepts)
+  - [Server](#server)
+  - [Resources](#resources)
+  - [Tools](#tools)
+  - [Prompts](#prompts)
+- [Running Your Server](#running-your-server)
+  - [stdio](#stdio)
+  - [HTTP with SSE](#http-with-sse)
+  - [Testing and Debugging](#testing-and-debugging)
+- [Examples](#examples)
+  - [Echo Server](#echo-server)
+  - [SQLite Explorer](#sqlite-explorer)
+- [Advanced Usage](#advanced-usage)
+  - [Low-Level Server](#low-level-server)
+  - [Writing MCP Clients](#writing-mcp-clients)
+  - [Server Capabilities](#server-capabilities)
+
+## Overview
+
+The Model Context Protocol allows applications to provide context for LLMs in a standardized way, separating the concerns of providing context from the actual LLM interaction. This TypeScript SDK implements the full MCP specification, making it easy to:
+
+- Build MCP clients that can connect to any MCP server
+- Create MCP servers that expose resources, prompts and tools
+- Use standard transports like stdio and SSE
+- Handle all MCP protocol messages and lifecycle events
+
+## Installation
+
+```bash
+npm install @modelcontextprotocol/sdk
+```
+
+## Quick Start
+
+Let's create a simple MCP server that exposes a calculator tool and some data:
+
+```typescript
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+// Create an MCP server
+const server = new McpServer({
+  name: "Demo",
+  version: "1.0.0"
+});
+
+// Add an addition tool
+server.tool("add",
+  { a: z.number(), b: z.number() },
+  async ({ a, b }) => ({
+    content: [{ type: "text", text: String(a + b) }]
+  })
+);
+
+// Add a dynamic greeting resource
+server.resource(
+  "greeting",
+  new ResourceTemplate("greeting://{name}", { list: undefined }),
+  async (uri, { name }) => ({
+    contents: [{
+      uri: uri.href,
+      text: `Hello, ${name}!`
+    }]
+  })
+);
+
+// Start receiving messages on stdin and sending messages on stdout
+const transport = new StdioServerTransport();
+await server.connect(transport);
+```
+
+## What is MCP?
+
+The [Model Context Protocol (MCP)](https://modelcontextprotocol.io) lets you build servers that expose data and functionality to LLM applications in a secure, standardized way. Think of it like a web API, but specifically designed for LLM interactions. MCP servers can:
+
+- Expose data through **Resources** (think of these sort of like GET endpoints; they are used to load information into the LLM's context)
+- Provide functionality through **Tools** (sort of like POST endpoints; they are used to execute code or otherwise produce a side effect)
+- Define interaction patterns through **Prompts** (reusable templates for LLM interactions)
+- And more!
+
+## Core Concepts
+
+### Server
+
+The McpServer is your core interface to the MCP protocol. It handles connection management, protocol compliance, and message routing:
+
+```typescript
+const server = new McpServer({
+  name: "My App",
+  version: "1.0.0"
+});
+```
+
+### Resources
+
+Resources are how you expose data to LLMs. They're similar to GET endpoints in a REST API - they provide data but shouldn't perform significant computation or have side effects:
+
+```typescript
+// Static resource
+server.resource(
+  "config",
+  "config://app",
+  async (uri) => ({
+    contents: [{
+      uri: uri.href,
+      text: "App configuration here"
+    }]
+  })
+);
+
+// Dynamic resource with parameters
+server.resource(
+  "user-profile",
+  new ResourceTemplate("users://{userId}/profile", { list: undefined }),
+  async (uri, { userId }) => ({
+    contents: [{
+      uri: uri.href,
+      text: `Profile data for user ${userId}`
+    }]
+  })
+);
+```
+
+### Tools
+
+Tools let LLMs take actions through your server. Unlike resources, tools are expected to perform computation and have side effects:
+
+```typescript
+// Simple tool with parameters
+server.tool(
+  "calculate-bmi",
+  {
+    weightKg: z.number(),
+    heightM: z.number()
+  },
+  async ({ weightKg, heightM }) => ({
+    content: [{
+      type: "text",
+      text: String(weightKg / (heightM * heightM))
+    }]
+  })
+);
+
+// Async tool with external API call
+server.tool(
+  "fetch-weather",
+  { city: z.string() },
+  async ({ city }) => {
+    const response = await fetch(`https://api.weather.com/${city}`);
+    const data = await response.text();
+    return {
+      content: [{ type: "text", text: data }]
+    };
+  }
+);
+```
+
+### Prompts
+
+Prompts are reusable templates that help LLMs interact with your server effectively:
+
+```typescript
+server.prompt(
+  "review-code",
+  { code: z.string() },
+  ({ code }) => ({
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `Please review this code:\n\n${code}`
+      }
+    }]
+  })
+);
+```
+
+## Running Your Server
+
+MCP servers in TypeScript need to be connected to a transport to communicate with clients. How you start the server depends on the choice of transport:
+
+### stdio
+
+For command-line tools and direct integrations:
+
+```typescript
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+const server = new McpServer({
+  name: "example-server",
+  version: "1.0.0"
+});
+
+// ... set up server resources, tools, and prompts ...
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+```
+
+### HTTP with SSE
+
+For remote servers, start a web server with a Server-Sent Events (SSE) endpoint, and a separate endpoint for the client to send its messages to:
+
+```typescript
+import express from "express";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+
+const server = new McpServer({
+  name: "example-server",
+  version: "1.0.0"
+});
+
+// ... set up server resources, tools, and prompts ...
+
+const app = express();
+
+app.get("/sse", async (req, res) => {
+  const transport = new SSEServerTransport("/messages", res);
+  await server.connect(transport);
+});
+
+app.post("/messages", async (req, res) => {
+  // Note: to support multiple simultaneous connections, these messages will
+  // need to be routed to a specific matching transport. (This logic isn't
+  // implemented here, for simplicity.)
+  await transport.handlePostMessage(req, res);
+});
+
+app.listen(3001);
+```
+
+### Testing and Debugging
+
+To test your server, you can use the [MCP Inspector](https://github.com/modelcontextprotocol/inspector). See its README for more information.
+
+## Examples
+
+### Echo Server
+
+A simple server demonstrating resources, tools, and prompts:
+
+```typescript
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+
+const server = new McpServer({
+  name: "Echo",
+  version: "1.0.0"
+});
+
+server.resource(
+  "echo",
+  new ResourceTemplate("echo://{message}", { list: undefined }),
+  async (uri, { message }) => ({
+    contents: [{
+      uri: uri.href,
+      text: `Resource echo: ${message}`
+    }]
+  })
+);
+
+server.tool(
+  "echo",
+  { message: z.string() },
+  async ({ message }) => ({
+    content: [{ type: "text", text: `Tool echo: ${message}` }]
+  })
+);
+
+server.prompt(
+  "echo",
+  { message: z.string() },
+  ({ message }) => ({
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: `Please process this message: ${message}`
+      }
+    }]
+  })
+);
+```
+
+### SQLite Explorer
+
+A more complex example showing database integration:
+
+```typescript
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import sqlite3 from "sqlite3";
+import { promisify } from "util";
+import { z } from "zod";
+
+const server = new McpServer({
+  name: "SQLite Explorer",
+  version: "1.0.0"
+});
+
+// Helper to create DB connection
+const getDb = () => {
+  const db = new sqlite3.Database("database.db");
+  return {
+    all: promisify<string, any[]>(db.all.bind(db)),
+    close: promisify(db.close.bind(db))
+  };
+};
+
+server.resource(
+  "schema",
+  "schema://main",
+  async (uri) => {
+    const db = getDb();
+    try {
+      const tables = await db.all(
+        "SELECT sql FROM sqlite_master WHERE type='table'"
+      );
+      return {
+        contents: [{
+          uri: uri.href,
+          text: tables.map((t: {sql: string}) => t.sql).join("\n")
+        }]
+      };
+    } finally {
+      await db.close();
+    }
+  }
+);
+
+server.tool(
+  "query",
+  { sql: z.string() },
+  async ({ sql }) => {
+    const db = getDb();
+    try {
+      const results = await db.all(sql);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(results, null, 2)
+        }]
+      };
+    } catch (err: unknown) {
+      const error = err as Error;
+      return {
+        content: [{
+          type: "text",
+          text: `Error: ${error.message}`
+        }],
+        isError: true
+      };
+    } finally {
+      await db.close();
+    }
+  }
+);
+```
+
+## Advanced Usage
+
+### Low-Level Server
+
+For more control, you can use the low-level Server class directly:
+
+```typescript
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+const server = new Server(
+  {
+    name: "example-server",
+    version: "1.0.0"
+  },
+  {
+    capabilities: {
+      prompts: {}
+    }
+  }
+);
+
+server.setRequestHandler(ListPromptsRequestSchema, async () => {
+  return {
+    prompts: [{
+      name: "example-prompt",
+      description: "An example prompt template",
+      arguments: [{
+        name: "arg1",
+        description: "Example argument",
+        required: true
+      }]
+    }]
+  };
+});
+
+server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+  if (request.params.name !== "example-prompt") {
+    throw new Error("Unknown prompt");
+  }
+  return {
+    description: "Example prompt",
+    messages: [{
+      role: "user",
+      content: {
+        type: "text",
+        text: "Example prompt text"
+      }
+    }]
+  };
+});
+
+const transport = new StdioServerTransport();
+await server.connect(transport);
+```
+
+### Writing MCP Clients
+
+The SDK provides a high-level client interface:
+
+```typescript
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+
+const transport = new StdioClientTransport({
+  command: "node",
+  args: ["server.js"]
+});
+
+const client = new Client(
+  {
+    name: "example-client",
+    version: "1.0.0"
+  },
+  {
+    capabilities: {
+      prompts: {},
+      resources: {},
+      tools: {}
+    }
+  }
+);
+
+await client.connect(transport);
+
+// List prompts
+const prompts = await client.listPrompts();
+
+// Get a prompt
+const prompt = await client.getPrompt("example-prompt", {
+  arg1: "value"
+});
+
+// List resources
+const resources = await client.listResources();
+
+// Read a resource
+const resource = await client.readResource("file:///example.txt");
+
+// Call a tool
+const result = await client.callTool({
+  name: "example-tool",
+  arguments: {
+    arg1: "value"
+  }
+});
+```
+
+## Documentation
+
+- [Model Context Protocol documentation](https://modelcontextprotocol.io)
+- [MCP Specification](https://spec.modelcontextprotocol.io)
+- [Example Servers](https://github.com/modelcontextprotocol/servers)
+
+## Contributing
+
+Issues and pull requests are welcome on GitHub at https://github.com/modelcontextprotocol/typescript-sdk.
+
+## License
+
+This project is licensed under the MIT License—see the [LICENSE](LICENSE) file for details.

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/cli.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli.d.ts.map

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":""}

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/cli.js

@@ -0,0 +1,131 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ws_1 = __importDefault(require("ws"));
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+global.WebSocket = ws_1.default;
+const express_1 = __importDefault(require("express"));
+const index_js_1 = require("./client/index.js");
+const sse_js_1 = require("./client/sse.js");
+const stdio_js_1 = require("./client/stdio.js");
+const websocket_js_1 = require("./client/websocket.js");
+const index_js_2 = require("./server/index.js");
+const sse_js_2 = require("./server/sse.js");
+const stdio_js_2 = require("./server/stdio.js");
+const types_js_1 = require("./types.js");
+async function runClient(url_or_command, args) {
+    const client = new index_js_1.Client({
+        name: "mcp-typescript test client",
+        version: "0.1.0",
+    }, {
+        capabilities: {
+            sampling: {},
+        },
+    });
+    let clientTransport;
+    let url = undefined;
+    try {
+        url = new URL(url_or_command);
+    }
+    catch (_a) {
+        // Ignore
+    }
+    if ((url === null || url === void 0 ? void 0 : url.protocol) === "http:" || (url === null || url === void 0 ? void 0 : url.protocol) === "https:") {
+        clientTransport = new sse_js_1.SSEClientTransport(new URL(url_or_command));
+    }
+    else if ((url === null || url === void 0 ? void 0 : url.protocol) === "ws:" || (url === null || url === void 0 ? void 0 : url.protocol) === "wss:") {
+        clientTransport = new websocket_js_1.WebSocketClientTransport(new URL(url_or_command));
+    }
+    else {
+        clientTransport = new stdio_js_1.StdioClientTransport({
+            command: url_or_command,
+            args,
+        });
+    }
+    console.log("Connected to server.");
+    await client.connect(clientTransport);
+    console.log("Initialized.");
+    await client.request({ method: "resources/list" }, types_js_1.ListResourcesResultSchema);
+    await client.close();
+    console.log("Closed.");
+}
+async function runServer(port) {
+    if (port !== null) {
+        const app = (0, express_1.default)();
+        let servers = [];
+        app.get("/sse", async (req, res) => {
+            console.log("Got new SSE connection");
+            const transport = new sse_js_2.SSEServerTransport("/message", res);
+            const server = new index_js_2.Server({
+                name: "mcp-typescript test server",
+                version: "0.1.0",
+            }, {
+                capabilities: {},
+            });
+            servers.push(server);
+            server.onclose = () => {
+                console.log("SSE connection closed");
+                servers = servers.filter((s) => s !== server);
+            };
+            await server.connect(transport);
+        });
+        app.post("/message", async (req, res) => {
+            console.log("Received message");
+            const sessionId = req.query.sessionId;
+            const transport = servers
+                .map((s) => s.transport)
+                .find((t) => t.sessionId === sessionId);
+            if (!transport) {
+                res.status(404).send("Session not found");
+                return;
+            }
+            await transport.handlePostMessage(req, res);
+        });
+        app.listen(port, () => {
+            console.log(`Server running on http://localhost:${port}/sse`);
+        });
+    }
+    else {
+        const server = new index_js_2.Server({
+            name: "mcp-typescript test server",
+            version: "0.1.0",
+        }, {
+            capabilities: {
+                prompts: {},
+                resources: {},
+                tools: {},
+                logging: {},
+            },
+        });
+        const transport = new stdio_js_2.StdioServerTransport();
+        await server.connect(transport);
+        console.log("Server running on stdio");
+    }
+}
+const args = process.argv.slice(2);
+const command = args[0];
+switch (command) {
+    case "client":
+        if (args.length < 2) {
+            console.error("Usage: client <server_url_or_command> [args...]");
+            process.exit(1);
+        }
+        runClient(args[1], args.slice(2)).catch((error) => {
+            console.error(error);
+            process.exit(1);
+        });
+        break;
+    case "server": {
+        const port = args[1] ? parseInt(args[1]) : null;
+        runServer(port).catch((error) => {
+            console.error(error);
+            process.exit(1);
+        });
+        break;
+    }
+    default:
+        console.error("Unrecognized command:", command);
+}
+//# sourceMappingURL=cli.js.map

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../../src/cli.ts"],"names":[],"mappings":"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"}

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/auth.d.ts

@@ -0,0 +1,116 @@
+import type { OAuthClientMetadata, OAuthClientInformation, OAuthTokens, OAuthMetadata, OAuthClientInformationFull } from "../shared/auth.js";
+/**
+ * Implements an end-to-end OAuth client to be used with one MCP server.
+ *
+ * This client relies upon a concept of an authorized "session," the exact
+ * meaning of which is application-defined. Tokens, authorization codes, and
+ * code verifiers should not cross different sessions.
+ */
+export interface OAuthClientProvider {
+    /**
+     * The URL to redirect the user agent to after authorization.
+     */
+    get redirectUrl(): string | URL;
+    /**
+     * Metadata about this OAuth client.
+     */
+    get clientMetadata(): OAuthClientMetadata;
+    /**
+     * Loads information about this OAuth client, as registered already with the
+     * server, or returns `undefined` if the client is not registered with the
+     * server.
+     */
+    clientInformation(): OAuthClientInformation | undefined | Promise<OAuthClientInformation | undefined>;
+    /**
+     * If implemented, this permits the OAuth client to dynamically register with
+     * the server. Client information saved this way should later be read via
+     * `clientInformation()`.
+     *
+     * This method is not required to be implemented if client information is
+     * statically known (e.g., pre-registered).
+     */
+    saveClientInformation?(clientInformation: OAuthClientInformationFull): void | Promise<void>;
+    /**
+     * Loads any existing OAuth tokens for the current session, or returns
+     * `undefined` if there are no saved tokens.
+     */
+    tokens(): OAuthTokens | undefined | Promise<OAuthTokens | undefined>;
+    /**
+     * Stores new OAuth tokens for the current session, after a successful
+     * authorization.
+     */
+    saveTokens(tokens: OAuthTokens): void | Promise<void>;
+    /**
+     * Invoked to redirect the user agent to the given URL to begin the authorization flow.
+     */
+    redirectToAuthorization(authorizationUrl: URL): void | Promise<void>;
+    /**
+     * Saves a PKCE code verifier for the current session, before redirecting to
+     * the authorization flow.
+     */
+    saveCodeVerifier(codeVerifier: string): void | Promise<void>;
+    /**
+     * Loads the PKCE code verifier for the current session, necessary to validate
+     * the authorization result.
+     */
+    codeVerifier(): string | Promise<string>;
+}
+export type AuthResult = "AUTHORIZED" | "REDIRECT";
+export declare class UnauthorizedError extends Error {
+    constructor(message?: string);
+}
+/**
+ * Orchestrates the full auth flow with a server.
+ *
+ * This can be used as a single entry point for all authorization functionality,
+ * instead of linking together the other lower-level functions in this module.
+ */
+export declare function auth(provider: OAuthClientProvider, { serverUrl, authorizationCode }: {
+    serverUrl: string | URL;
+    authorizationCode?: string;
+}): Promise<AuthResult>;
+/**
+ * Looks up RFC 8414 OAuth 2.0 Authorization Server Metadata.
+ *
+ * If the server returns a 404 for the well-known endpoint, this function will
+ * return `undefined`. Any other errors will be thrown as exceptions.
+ */
+export declare function discoverOAuthMetadata(serverUrl: string | URL, opts?: {
+    protocolVersion?: string;
+}): Promise<OAuthMetadata | undefined>;
+/**
+ * Begins the authorization flow with the given server, by generating a PKCE challenge and constructing the authorization URL.
+ */
+export declare function startAuthorization(serverUrl: string | URL, { metadata, clientInformation, redirectUrl, }: {
+    metadata?: OAuthMetadata;
+    clientInformation: OAuthClientInformation;
+    redirectUrl: string | URL;
+}): Promise<{
+    authorizationUrl: URL;
+    codeVerifier: string;
+}>;
+/**
+ * Exchanges an authorization code for an access token with the given server.
+ */
+export declare function exchangeAuthorization(serverUrl: string | URL, { metadata, clientInformation, authorizationCode, codeVerifier, }: {
+    metadata?: OAuthMetadata;
+    clientInformation: OAuthClientInformation;
+    authorizationCode: string;
+    codeVerifier: string;
+}): Promise<OAuthTokens>;
+/**
+ * Exchange a refresh token for an updated access token.
+ */
+export declare function refreshAuthorization(serverUrl: string | URL, { metadata, clientInformation, refreshToken, }: {
+    metadata?: OAuthMetadata;
+    clientInformation: OAuthClientInformation;
+    refreshToken: string;
+}): Promise<OAuthTokens>;
+/**
+ * Performs OAuth 2.0 Dynamic Client Registration according to RFC 7591.
+ */
+export declare function registerClient(serverUrl: string | URL, { metadata, clientMetadata, }: {
+    metadata?: OAuthMetadata;
+    clientMetadata: OAuthClientMetadata;
+}): Promise<OAuthClientInformationFull>;
+//# sourceMappingURL=auth.d.ts.map

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/auth.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.d.ts","sourceRoot":"","sources":["../../../src/client/auth.ts"],"names":[],"mappings":"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"}

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/auth.js

@@ -0,0 +1,251 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnauthorizedError = void 0;
+exports.auth = auth;
+exports.discoverOAuthMetadata = discoverOAuthMetadata;
+exports.startAuthorization = startAuthorization;
+exports.exchangeAuthorization = exchangeAuthorization;
+exports.refreshAuthorization = refreshAuthorization;
+exports.registerClient = registerClient;
+const pkce_challenge_1 = __importDefault(require("pkce-challenge"));
+const types_js_1 = require("../types.js");
+const auth_js_1 = require("../shared/auth.js");
+class UnauthorizedError extends Error {
+    constructor(message) {
+        super(message !== null && message !== void 0 ? message : "Unauthorized");
+    }
+}
+exports.UnauthorizedError = UnauthorizedError;
+/**
+ * Orchestrates the full auth flow with a server.
+ *
+ * This can be used as a single entry point for all authorization functionality,
+ * instead of linking together the other lower-level functions in this module.
+ */
+async function auth(provider, { serverUrl, authorizationCode }) {
+    const metadata = await discoverOAuthMetadata(serverUrl);
+    // Handle client registration if needed
+    let clientInformation = await Promise.resolve(provider.clientInformation());
+    if (!clientInformation) {
+        if (authorizationCode !== undefined) {
+            throw new Error("Existing OAuth client information is required when exchanging an authorization code");
+        }
+        if (!provider.saveClientInformation) {
+            throw new Error("OAuth client information must be saveable for dynamic registration");
+        }
+        const fullInformation = await registerClient(serverUrl, {
+            metadata,
+            clientMetadata: provider.clientMetadata,
+        });
+        await provider.saveClientInformation(fullInformation);
+        clientInformation = fullInformation;
+    }
+    // Exchange authorization code for tokens
+    if (authorizationCode !== undefined) {
+        const codeVerifier = await provider.codeVerifier();
+        const tokens = await exchangeAuthorization(serverUrl, {
+            metadata,
+            clientInformation,
+            authorizationCode,
+            codeVerifier,
+        });
+        await provider.saveTokens(tokens);
+        return "AUTHORIZED";
+    }
+    const tokens = await provider.tokens();
+    // Handle token refresh or new authorization
+    if (tokens === null || tokens === void 0 ? void 0 : tokens.refresh_token) {
+        try {
+            // Attempt to refresh the token
+            const newTokens = await refreshAuthorization(serverUrl, {
+                metadata,
+                clientInformation,
+                refreshToken: tokens.refresh_token,
+            });
+            await provider.saveTokens(newTokens);
+            return "AUTHORIZED";
+        }
+        catch (error) {
+            console.error("Could not refresh OAuth tokens:", error);
+        }
+    }
+    // Start new authorization flow
+    const { authorizationUrl, codeVerifier } = await startAuthorization(serverUrl, {
+        metadata,
+        clientInformation,
+        redirectUrl: provider.redirectUrl
+    });
+    await provider.saveCodeVerifier(codeVerifier);
+    await provider.redirectToAuthorization(authorizationUrl);
+    return "REDIRECT";
+}
+/**
+ * Looks up RFC 8414 OAuth 2.0 Authorization Server Metadata.
+ *
+ * If the server returns a 404 for the well-known endpoint, this function will
+ * return `undefined`. Any other errors will be thrown as exceptions.
+ */
+async function discoverOAuthMetadata(serverUrl, opts) {
+    var _a;
+    const url = new URL("/.well-known/oauth-authorization-server", serverUrl);
+    let response;
+    try {
+        response = await fetch(url, {
+            headers: {
+                "MCP-Protocol-Version": (_a = opts === null || opts === void 0 ? void 0 : opts.protocolVersion) !== null && _a !== void 0 ? _a : types_js_1.LATEST_PROTOCOL_VERSION
+            }
+        });
+    }
+    catch (error) {
+        // CORS errors come back as TypeError
+        if (error instanceof TypeError) {
+            response = await fetch(url);
+        }
+        else {
+            throw error;
+        }
+    }
+    if (response.status === 404) {
+        return undefined;
+    }
+    if (!response.ok) {
+        throw new Error(`HTTP ${response.status} trying to load well-known OAuth metadata`);
+    }
+    return auth_js_1.OAuthMetadataSchema.parse(await response.json());
+}
+/**
+ * Begins the authorization flow with the given server, by generating a PKCE challenge and constructing the authorization URL.
+ */
+async function startAuthorization(serverUrl, { metadata, clientInformation, redirectUrl, }) {
+    const responseType = "code";
+    const codeChallengeMethod = "S256";
+    let authorizationUrl;
+    if (metadata) {
+        authorizationUrl = new URL(metadata.authorization_endpoint);
+        if (!metadata.response_types_supported.includes(responseType)) {
+            throw new Error(`Incompatible auth server: does not support response type ${responseType}`);
+        }
+        if (!metadata.code_challenge_methods_supported ||
+            !metadata.code_challenge_methods_supported.includes(codeChallengeMethod)) {
+            throw new Error(`Incompatible auth server: does not support code challenge method ${codeChallengeMethod}`);
+        }
+    }
+    else {
+        authorizationUrl = new URL("/authorize", serverUrl);
+    }
+    // Generate PKCE challenge
+    const challenge = await (0, pkce_challenge_1.default)();
+    const codeVerifier = challenge.code_verifier;
+    const codeChallenge = challenge.code_challenge;
+    authorizationUrl.searchParams.set("response_type", responseType);
+    authorizationUrl.searchParams.set("client_id", clientInformation.client_id);
+    authorizationUrl.searchParams.set("code_challenge", codeChallenge);
+    authorizationUrl.searchParams.set("code_challenge_method", codeChallengeMethod);
+    authorizationUrl.searchParams.set("redirect_uri", String(redirectUrl));
+    return { authorizationUrl, codeVerifier };
+}
+/**
+ * Exchanges an authorization code for an access token with the given server.
+ */
+async function exchangeAuthorization(serverUrl, { metadata, clientInformation, authorizationCode, codeVerifier, }) {
+    const grantType = "authorization_code";
+    let tokenUrl;
+    if (metadata) {
+        tokenUrl = new URL(metadata.token_endpoint);
+        if (metadata.grant_types_supported &&
+            !metadata.grant_types_supported.includes(grantType)) {
+            throw new Error(`Incompatible auth server: does not support grant type ${grantType}`);
+        }
+    }
+    else {
+        tokenUrl = new URL("/token", serverUrl);
+    }
+    // Exchange code for tokens
+    const params = new URLSearchParams({
+        grant_type: grantType,
+        client_id: clientInformation.client_id,
+        code: authorizationCode,
+        code_verifier: codeVerifier,
+    });
+    if (clientInformation.client_secret) {
+        params.set("client_secret", clientInformation.client_secret);
+    }
+    const response = await fetch(tokenUrl, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+        },
+        body: params,
+    });
+    if (!response.ok) {
+        throw new Error(`Token exchange failed: HTTP ${response.status}`);
+    }
+    return auth_js_1.OAuthTokensSchema.parse(await response.json());
+}
+/**
+ * Exchange a refresh token for an updated access token.
+ */
+async function refreshAuthorization(serverUrl, { metadata, clientInformation, refreshToken, }) {
+    const grantType = "refresh_token";
+    let tokenUrl;
+    if (metadata) {
+        tokenUrl = new URL(metadata.token_endpoint);
+        if (metadata.grant_types_supported &&
+            !metadata.grant_types_supported.includes(grantType)) {
+            throw new Error(`Incompatible auth server: does not support grant type ${grantType}`);
+        }
+    }
+    else {
+        tokenUrl = new URL("/token", serverUrl);
+    }
+    // Exchange refresh token
+    const params = new URLSearchParams({
+        grant_type: grantType,
+        client_id: clientInformation.client_id,
+        refresh_token: refreshToken,
+    });
+    if (clientInformation.client_secret) {
+        params.set("client_secret", clientInformation.client_secret);
+    }
+    const response = await fetch(tokenUrl, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+        },
+        body: params,
+    });
+    if (!response.ok) {
+        throw new Error(`Token refresh failed: HTTP ${response.status}`);
+    }
+    return auth_js_1.OAuthTokensSchema.parse(await response.json());
+}
+/**
+ * Performs OAuth 2.0 Dynamic Client Registration according to RFC 7591.
+ */
+async function registerClient(serverUrl, { metadata, clientMetadata, }) {
+    let registrationUrl;
+    if (metadata) {
+        if (!metadata.registration_endpoint) {
+            throw new Error("Incompatible auth server: does not support dynamic client registration");
+        }
+        registrationUrl = new URL(metadata.registration_endpoint);
+    }
+    else {
+        registrationUrl = new URL("/register", serverUrl);
+    }
+    const response = await fetch(registrationUrl, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(clientMetadata),
+    });
+    if (!response.ok) {
+        throw new Error(`Dynamic client registration failed: HTTP ${response.status}`);
+    }
+    return auth_js_1.OAuthClientInformationFullSchema.parse(await response.json());
+}
+//# sourceMappingURL=auth.js.map

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/auth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auth.js","sourceRoot":"","sources":["../../../src/client/auth.ts"],"names":[],"mappings":"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"}

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/index.d.ts

@@ -0,0 +1,784 @@
+import { Protocol, ProtocolOptions, RequestOptions } from "../shared/protocol.js";
+import { Transport } from "../shared/transport.js";
+import { CallToolRequest, CallToolResultSchema, ClientCapabilities, ClientNotification, ClientRequest, ClientResult, CompatibilityCallToolResultSchema, CompleteRequest, GetPromptRequest, Implementation, ListPromptsRequest, ListResourcesRequest, ListResourceTemplatesRequest, ListToolsRequest, LoggingLevel, Notification, ReadResourceRequest, Request, Result, ServerCapabilities, SubscribeRequest, UnsubscribeRequest } from "../types.js";
+export type ClientOptions = ProtocolOptions & {
+    /**
+     * Capabilities to advertise as being supported by this client.
+     */
+    capabilities?: ClientCapabilities;
+};
+/**
+ * An MCP client on top of a pluggable transport.
+ *
+ * The client will automatically begin the initialization flow with the server when connect() is called.
+ *
+ * To use with custom types, extend the base Request/Notification/Result types and pass them as type parameters:
+ *
+ * ```typescript
+ * // Custom schemas
+ * const CustomRequestSchema = RequestSchema.extend({...})
+ * const CustomNotificationSchema = NotificationSchema.extend({...})
+ * const CustomResultSchema = ResultSchema.extend({...})
+ *
+ * // Type aliases
+ * type CustomRequest = z.infer<typeof CustomRequestSchema>
+ * type CustomNotification = z.infer<typeof CustomNotificationSchema>
+ * type CustomResult = z.infer<typeof CustomResultSchema>
+ *
+ * // Create typed client
+ * const client = new Client<CustomRequest, CustomNotification, CustomResult>({
+ *   name: "CustomClient",
+ *   version: "1.0.0"
+ * })
+ * ```
+ */
+export declare class Client<RequestT extends Request = Request, NotificationT extends Notification = Notification, ResultT extends Result = Result> extends Protocol<ClientRequest | RequestT, ClientNotification | NotificationT, ClientResult | ResultT> {
+    private _clientInfo;
+    private _serverCapabilities?;
+    private _serverVersion?;
+    private _capabilities;
+    private _instructions?;
+    /**
+     * Initializes this client with the given name and version information.
+     */
+    constructor(_clientInfo: Implementation, options?: ClientOptions);
+    /**
+     * Registers new capabilities. This can only be called before connecting to a transport.
+     *
+     * The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization).
+     */
+    registerCapabilities(capabilities: ClientCapabilities): void;
+    protected assertCapability(capability: keyof ServerCapabilities, method: string): void;
+    connect(transport: Transport): Promise<void>;
+    /**
+     * After initialization has completed, this will be populated with the server's reported capabilities.
+     */
+    getServerCapabilities(): ServerCapabilities | undefined;
+    /**
+     * After initialization has completed, this will be populated with information about the server's name and version.
+     */
+    getServerVersion(): Implementation | undefined;
+    /**
+     * After initialization has completed, this may be populated with information about the server's instructions.
+     */
+    getInstructions(): string | undefined;
+    protected assertCapabilityForMethod(method: RequestT["method"]): void;
+    protected assertNotificationCapability(method: NotificationT["method"]): void;
+    protected assertRequestHandlerCapability(method: string): void;
+    ping(options?: RequestOptions): Promise<{
+        _meta?: import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough"> | undefined;
+    }>;
+    complete(params: CompleteRequest["params"], options?: RequestOptions): Promise<import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+        _meta: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+    }, {
+        completion: import("zod").ZodObject<{
+            values: import("zod").ZodArray<import("zod").ZodString, "many">;
+            total: import("zod").ZodOptional<import("zod").ZodNumber>;
+            hasMore: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            values: import("zod").ZodArray<import("zod").ZodString, "many">;
+            total: import("zod").ZodOptional<import("zod").ZodNumber>;
+            hasMore: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            values: import("zod").ZodArray<import("zod").ZodString, "many">;
+            total: import("zod").ZodOptional<import("zod").ZodNumber>;
+            hasMore: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod").ZodTypeAny, "passthrough">>;
+    }>, import("zod").ZodTypeAny, "passthrough">>;
+    setLoggingLevel(level: LoggingLevel, options?: RequestOptions): Promise<{
+        _meta?: import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough"> | undefined;
+    }>;
+    getPrompt(params: GetPromptRequest["params"], options?: RequestOptions): Promise<import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+        _meta: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+    }, {
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        messages: import("zod").ZodArray<import("zod").ZodObject<{
+            role: import("zod").ZodEnum<["user", "assistant"]>;
+            content: import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"text">;
+                text: import("zod").ZodString;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodLiteral<"text">;
+                text: import("zod").ZodString;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodLiteral<"text">;
+                text: import("zod").ZodString;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"image">;
+                data: import("zod").ZodString;
+                mimeType: import("zod").ZodString;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodLiteral<"image">;
+                data: import("zod").ZodString;
+                mimeType: import("zod").ZodString;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodLiteral<"image">;
+                data: import("zod").ZodString;
+                mimeType: import("zod").ZodString;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"resource">;
+                resource: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">>]>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodLiteral<"resource">;
+                resource: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">>]>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodLiteral<"resource">;
+                resource: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">>]>;
+            }, import("zod").ZodTypeAny, "passthrough">>]>;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            role: import("zod").ZodEnum<["user", "assistant"]>;
+            content: import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"text">;
+                text: import("zod").ZodString;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodLiteral<"text">;
+                text: import("zod").ZodString;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodLiteral<"text">;
+                text: import("zod").ZodString;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"image">;
+                data: import("zod").ZodString;
+                mimeType: import("zod").ZodString;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodLiteral<"image">;
+                data: import("zod").ZodString;
+                mimeType: import("zod").ZodString;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodLiteral<"image">;
+                data: import("zod").ZodString;
+                mimeType: import("zod").ZodString;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"resource">;
+                resource: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">>]>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodLiteral<"resource">;
+                resource: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">>]>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodLiteral<"resource">;
+                resource: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">>]>;
+            }, import("zod").ZodTypeAny, "passthrough">>]>;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            role: import("zod").ZodEnum<["user", "assistant"]>;
+            content: import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"text">;
+                text: import("zod").ZodString;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodLiteral<"text">;
+                text: import("zod").ZodString;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodLiteral<"text">;
+                text: import("zod").ZodString;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"image">;
+                data: import("zod").ZodString;
+                mimeType: import("zod").ZodString;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodLiteral<"image">;
+                data: import("zod").ZodString;
+                mimeType: import("zod").ZodString;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodLiteral<"image">;
+                data: import("zod").ZodString;
+                mimeType: import("zod").ZodString;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"resource">;
+                resource: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">>]>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodLiteral<"resource">;
+                resource: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">>]>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodLiteral<"resource">;
+                resource: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    text: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                }, {
+                    blob: import("zod").ZodString;
+                }>, import("zod").ZodTypeAny, "passthrough">>]>;
+            }, import("zod").ZodTypeAny, "passthrough">>]>;
+        }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+    }>, import("zod").ZodTypeAny, "passthrough">>;
+    listPrompts(params?: ListPromptsRequest["params"], options?: RequestOptions): Promise<import("zod").objectOutputType<import("zod").objectUtil.extendShape<import("zod").objectUtil.extendShape<{
+        _meta: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+    }, {
+        nextCursor: import("zod").ZodOptional<import("zod").ZodString>;
+    }>, {
+        prompts: import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            arguments: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                required: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                name: import("zod").ZodString;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                required: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                name: import("zod").ZodString;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                required: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, import("zod").ZodTypeAny, "passthrough">>, "many">>;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            arguments: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                required: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                name: import("zod").ZodString;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                required: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                name: import("zod").ZodString;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                required: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, import("zod").ZodTypeAny, "passthrough">>, "many">>;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            arguments: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+                name: import("zod").ZodString;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                required: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                name: import("zod").ZodString;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                required: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                name: import("zod").ZodString;
+                description: import("zod").ZodOptional<import("zod").ZodString>;
+                required: import("zod").ZodOptional<import("zod").ZodBoolean>;
+            }, import("zod").ZodTypeAny, "passthrough">>, "many">>;
+        }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+    }>, import("zod").ZodTypeAny, "passthrough">>;
+    listResources(params?: ListResourcesRequest["params"], options?: RequestOptions): Promise<import("zod").objectOutputType<import("zod").objectUtil.extendShape<import("zod").objectUtil.extendShape<{
+        _meta: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+    }, {
+        nextCursor: import("zod").ZodOptional<import("zod").ZodString>;
+    }>, {
+        resources: import("zod").ZodArray<import("zod").ZodObject<{
+            uri: import("zod").ZodString;
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            uri: import("zod").ZodString;
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            uri: import("zod").ZodString;
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+    }>, import("zod").ZodTypeAny, "passthrough">>;
+    listResourceTemplates(params?: ListResourceTemplatesRequest["params"], options?: RequestOptions): Promise<import("zod").objectOutputType<import("zod").objectUtil.extendShape<import("zod").objectUtil.extendShape<{
+        _meta: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+    }, {
+        nextCursor: import("zod").ZodOptional<import("zod").ZodString>;
+    }>, {
+        resourceTemplates: import("zod").ZodArray<import("zod").ZodObject<{
+            uriTemplate: import("zod").ZodString;
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            uriTemplate: import("zod").ZodString;
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            uriTemplate: import("zod").ZodString;
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+        }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+    }>, import("zod").ZodTypeAny, "passthrough">>;
+    readResource(params: ReadResourceRequest["params"], options?: RequestOptions): Promise<import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+        _meta: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+    }, {
+        contents: import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+            uri: import("zod").ZodString;
+            mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+        }, {
+            text: import("zod").ZodString;
+        }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+            uri: import("zod").ZodString;
+            mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+        }, {
+            text: import("zod").ZodString;
+        }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+            uri: import("zod").ZodString;
+            mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+        }, {
+            text: import("zod").ZodString;
+        }>, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+            uri: import("zod").ZodString;
+            mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+        }, {
+            blob: import("zod").ZodString;
+        }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+            uri: import("zod").ZodString;
+            mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+        }, {
+            blob: import("zod").ZodString;
+        }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+            uri: import("zod").ZodString;
+            mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+        }, {
+            blob: import("zod").ZodString;
+        }>, import("zod").ZodTypeAny, "passthrough">>]>, "many">;
+    }>, import("zod").ZodTypeAny, "passthrough">>;
+    subscribeResource(params: SubscribeRequest["params"], options?: RequestOptions): Promise<{
+        _meta?: import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough"> | undefined;
+    }>;
+    unsubscribeResource(params: UnsubscribeRequest["params"], options?: RequestOptions): Promise<{
+        _meta?: import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough"> | undefined;
+    }>;
+    callTool(params: CallToolRequest["params"], resultSchema?: typeof CallToolResultSchema | typeof CompatibilityCallToolResultSchema, options?: RequestOptions): Promise<import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+        _meta: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+    }, {
+        content: import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"text">;
+            text: import("zod").ZodString;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            type: import("zod").ZodLiteral<"text">;
+            text: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            type: import("zod").ZodLiteral<"text">;
+            text: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"image">;
+            data: import("zod").ZodString;
+            mimeType: import("zod").ZodString;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            type: import("zod").ZodLiteral<"image">;
+            data: import("zod").ZodString;
+            mimeType: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            type: import("zod").ZodLiteral<"image">;
+            data: import("zod").ZodString;
+            mimeType: import("zod").ZodString;
+        }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"resource">;
+            resource: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                uri: import("zod").ZodString;
+                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            }, {
+                text: import("zod").ZodString;
+            }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                uri: import("zod").ZodString;
+                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            }, {
+                text: import("zod").ZodString;
+            }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                uri: import("zod").ZodString;
+                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            }, {
+                text: import("zod").ZodString;
+            }>, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                uri: import("zod").ZodString;
+                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            }, {
+                blob: import("zod").ZodString;
+            }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                uri: import("zod").ZodString;
+                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            }, {
+                blob: import("zod").ZodString;
+            }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                uri: import("zod").ZodString;
+                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            }, {
+                blob: import("zod").ZodString;
+            }>, import("zod").ZodTypeAny, "passthrough">>]>;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            type: import("zod").ZodLiteral<"resource">;
+            resource: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                uri: import("zod").ZodString;
+                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            }, {
+                text: import("zod").ZodString;
+            }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                uri: import("zod").ZodString;
+                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            }, {
+                text: import("zod").ZodString;
+            }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                uri: import("zod").ZodString;
+                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            }, {
+                text: import("zod").ZodString;
+            }>, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                uri: import("zod").ZodString;
+                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            }, {
+                blob: import("zod").ZodString;
+            }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                uri: import("zod").ZodString;
+                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            }, {
+                blob: import("zod").ZodString;
+            }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                uri: import("zod").ZodString;
+                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            }, {
+                blob: import("zod").ZodString;
+            }>, import("zod").ZodTypeAny, "passthrough">>]>;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            type: import("zod").ZodLiteral<"resource">;
+            resource: import("zod").ZodUnion<[import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                uri: import("zod").ZodString;
+                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            }, {
+                text: import("zod").ZodString;
+            }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                uri: import("zod").ZodString;
+                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            }, {
+                text: import("zod").ZodString;
+            }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                uri: import("zod").ZodString;
+                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            }, {
+                text: import("zod").ZodString;
+            }>, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                uri: import("zod").ZodString;
+                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            }, {
+                blob: import("zod").ZodString;
+            }>, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+                uri: import("zod").ZodString;
+                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            }, {
+                blob: import("zod").ZodString;
+            }>, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<import("zod").objectUtil.extendShape<{
+                uri: import("zod").ZodString;
+                mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+            }, {
+                blob: import("zod").ZodString;
+            }>, import("zod").ZodTypeAny, "passthrough">>]>;
+        }, import("zod").ZodTypeAny, "passthrough">>]>, "many">;
+        isError: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodBoolean>>;
+    }>, import("zod").ZodTypeAny, "passthrough"> | import("zod").objectOutputType<import("zod").objectUtil.extendShape<{
+        _meta: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+    }, {
+        toolResult: import("zod").ZodUnknown;
+    }>, import("zod").ZodTypeAny, "passthrough">>;
+    listTools(params?: ListToolsRequest["params"], options?: RequestOptions): Promise<import("zod").objectOutputType<import("zod").objectUtil.extendShape<import("zod").objectUtil.extendShape<{
+        _meta: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+    }, {
+        nextCursor: import("zod").ZodOptional<import("zod").ZodString>;
+    }>, {
+        tools: import("zod").ZodArray<import("zod").ZodObject<{
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            inputSchema: import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"object">;
+                properties: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodLiteral<"object">;
+                properties: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodLiteral<"object">;
+                properties: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+            }, import("zod").ZodTypeAny, "passthrough">>;
+        }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            inputSchema: import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"object">;
+                properties: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodLiteral<"object">;
+                properties: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodLiteral<"object">;
+                properties: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+            }, import("zod").ZodTypeAny, "passthrough">>;
+        }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            inputSchema: import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"object">;
+                properties: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodLiteral<"object">;
+                properties: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodLiteral<"object">;
+                properties: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+            }, import("zod").ZodTypeAny, "passthrough">>;
+        }, import("zod").ZodTypeAny, "passthrough">>, "many">;
+    }>, import("zod").ZodTypeAny, "passthrough">>;
+    sendRootsListChanged(): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"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"}

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/index.js

@@ -0,0 +1,229 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Client = void 0;
+const protocol_js_1 = require("../shared/protocol.js");
+const types_js_1 = require("../types.js");
+/**
+ * An MCP client on top of a pluggable transport.
+ *
+ * The client will automatically begin the initialization flow with the server when connect() is called.
+ *
+ * To use with custom types, extend the base Request/Notification/Result types and pass them as type parameters:
+ *
+ * ```typescript
+ * // Custom schemas
+ * const CustomRequestSchema = RequestSchema.extend({...})
+ * const CustomNotificationSchema = NotificationSchema.extend({...})
+ * const CustomResultSchema = ResultSchema.extend({...})
+ *
+ * // Type aliases
+ * type CustomRequest = z.infer<typeof CustomRequestSchema>
+ * type CustomNotification = z.infer<typeof CustomNotificationSchema>
+ * type CustomResult = z.infer<typeof CustomResultSchema>
+ *
+ * // Create typed client
+ * const client = new Client<CustomRequest, CustomNotification, CustomResult>({
+ *   name: "CustomClient",
+ *   version: "1.0.0"
+ * })
+ * ```
+ */
+class Client extends protocol_js_1.Protocol {
+    /**
+     * Initializes this client with the given name and version information.
+     */
+    constructor(_clientInfo, options) {
+        var _a;
+        super(options);
+        this._clientInfo = _clientInfo;
+        this._capabilities = (_a = options === null || options === void 0 ? void 0 : options.capabilities) !== null && _a !== void 0 ? _a : {};
+    }
+    /**
+     * Registers new capabilities. This can only be called before connecting to a transport.
+     *
+     * The new capabilities will be merged with any existing capabilities previously given (e.g., at initialization).
+     */
+    registerCapabilities(capabilities) {
+        if (this.transport) {
+            throw new Error("Cannot register capabilities after connecting to transport");
+        }
+        this._capabilities = (0, protocol_js_1.mergeCapabilities)(this._capabilities, capabilities);
+    }
+    assertCapability(capability, method) {
+        var _a;
+        if (!((_a = this._serverCapabilities) === null || _a === void 0 ? void 0 : _a[capability])) {
+            throw new Error(`Server does not support ${capability} (required for ${method})`);
+        }
+    }
+    async connect(transport) {
+        await super.connect(transport);
+        try {
+            const result = await this.request({
+                method: "initialize",
+                params: {
+                    protocolVersion: types_js_1.LATEST_PROTOCOL_VERSION,
+                    capabilities: this._capabilities,
+                    clientInfo: this._clientInfo,
+                },
+            }, types_js_1.InitializeResultSchema);
+            if (result === undefined) {
+                throw new Error(`Server sent invalid initialize result: ${result}`);
+            }
+            if (!types_js_1.SUPPORTED_PROTOCOL_VERSIONS.includes(result.protocolVersion)) {
+                throw new Error(`Server's protocol version is not supported: ${result.protocolVersion}`);
+            }
+            this._serverCapabilities = result.capabilities;
+            this._serverVersion = result.serverInfo;
+            this._instructions = result.instructions;
+            await this.notification({
+                method: "notifications/initialized",
+            });
+        }
+        catch (error) {
+            // Disconnect if initialization fails.
+            void this.close();
+            throw error;
+        }
+    }
+    /**
+     * After initialization has completed, this will be populated with the server's reported capabilities.
+     */
+    getServerCapabilities() {
+        return this._serverCapabilities;
+    }
+    /**
+     * After initialization has completed, this will be populated with information about the server's name and version.
+     */
+    getServerVersion() {
+        return this._serverVersion;
+    }
+    /**
+     * After initialization has completed, this may be populated with information about the server's instructions.
+     */
+    getInstructions() {
+        return this._instructions;
+    }
+    assertCapabilityForMethod(method) {
+        var _a, _b, _c, _d, _e;
+        switch (method) {
+            case "logging/setLevel":
+                if (!((_a = this._serverCapabilities) === null || _a === void 0 ? void 0 : _a.logging)) {
+                    throw new Error(`Server does not support logging (required for ${method})`);
+                }
+                break;
+            case "prompts/get":
+            case "prompts/list":
+                if (!((_b = this._serverCapabilities) === null || _b === void 0 ? void 0 : _b.prompts)) {
+                    throw new Error(`Server does not support prompts (required for ${method})`);
+                }
+                break;
+            case "resources/list":
+            case "resources/templates/list":
+            case "resources/read":
+            case "resources/subscribe":
+            case "resources/unsubscribe":
+                if (!((_c = this._serverCapabilities) === null || _c === void 0 ? void 0 : _c.resources)) {
+                    throw new Error(`Server does not support resources (required for ${method})`);
+                }
+                if (method === "resources/subscribe" &&
+                    !this._serverCapabilities.resources.subscribe) {
+                    throw new Error(`Server does not support resource subscriptions (required for ${method})`);
+                }
+                break;
+            case "tools/call":
+            case "tools/list":
+                if (!((_d = this._serverCapabilities) === null || _d === void 0 ? void 0 : _d.tools)) {
+                    throw new Error(`Server does not support tools (required for ${method})`);
+                }
+                break;
+            case "completion/complete":
+                if (!((_e = this._serverCapabilities) === null || _e === void 0 ? void 0 : _e.prompts)) {
+                    throw new Error(`Server does not support prompts (required for ${method})`);
+                }
+                break;
+            case "initialize":
+                // No specific capability required for initialize
+                break;
+            case "ping":
+                // No specific capability required for ping
+                break;
+        }
+    }
+    assertNotificationCapability(method) {
+        var _a;
+        switch (method) {
+            case "notifications/roots/list_changed":
+                if (!((_a = this._capabilities.roots) === null || _a === void 0 ? void 0 : _a.listChanged)) {
+                    throw new Error(`Client does not support roots list changed notifications (required for ${method})`);
+                }
+                break;
+            case "notifications/initialized":
+                // No specific capability required for initialized
+                break;
+            case "notifications/cancelled":
+                // Cancellation notifications are always allowed
+                break;
+            case "notifications/progress":
+                // Progress notifications are always allowed
+                break;
+        }
+    }
+    assertRequestHandlerCapability(method) {
+        switch (method) {
+            case "sampling/createMessage":
+                if (!this._capabilities.sampling) {
+                    throw new Error(`Client does not support sampling capability (required for ${method})`);
+                }
+                break;
+            case "roots/list":
+                if (!this._capabilities.roots) {
+                    throw new Error(`Client does not support roots capability (required for ${method})`);
+                }
+                break;
+            case "ping":
+                // No specific capability required for ping
+                break;
+        }
+    }
+    async ping(options) {
+        return this.request({ method: "ping" }, types_js_1.EmptyResultSchema, options);
+    }
+    async complete(params, options) {
+        return this.request({ method: "completion/complete", params }, types_js_1.CompleteResultSchema, options);
+    }
+    async setLoggingLevel(level, options) {
+        return this.request({ method: "logging/setLevel", params: { level } }, types_js_1.EmptyResultSchema, options);
+    }
+    async getPrompt(params, options) {
+        return this.request({ method: "prompts/get", params }, types_js_1.GetPromptResultSchema, options);
+    }
+    async listPrompts(params, options) {
+        return this.request({ method: "prompts/list", params }, types_js_1.ListPromptsResultSchema, options);
+    }
+    async listResources(params, options) {
+        return this.request({ method: "resources/list", params }, types_js_1.ListResourcesResultSchema, options);
+    }
+    async listResourceTemplates(params, options) {
+        return this.request({ method: "resources/templates/list", params }, types_js_1.ListResourceTemplatesResultSchema, options);
+    }
+    async readResource(params, options) {
+        return this.request({ method: "resources/read", params }, types_js_1.ReadResourceResultSchema, options);
+    }
+    async subscribeResource(params, options) {
+        return this.request({ method: "resources/subscribe", params }, types_js_1.EmptyResultSchema, options);
+    }
+    async unsubscribeResource(params, options) {
+        return this.request({ method: "resources/unsubscribe", params }, types_js_1.EmptyResultSchema, options);
+    }
+    async callTool(params, resultSchema = types_js_1.CallToolResultSchema, options) {
+        return this.request({ method: "tools/call", params }, resultSchema, options);
+    }
+    async listTools(params, options) {
+        return this.request({ method: "tools/list", params }, types_js_1.ListToolsResultSchema, options);
+    }
+    async sendRootsListChanged() {
+        return this.notification({ method: "notifications/roots/list_changed" });
+    }
+}
+exports.Client = Client;
+//# sourceMappingURL=index.js.map

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"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"}

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/sse.d.ts

@@ -0,0 +1,70 @@
+import { type ErrorEvent, type EventSourceInit } from "eventsource";
+import { Transport } from "../shared/transport.js";
+import { JSONRPCMessage } from "../types.js";
+import { OAuthClientProvider } from "./auth.js";
+export declare class SseError extends Error {
+    readonly code: number | undefined;
+    readonly event: ErrorEvent;
+    constructor(code: number | undefined, message: string | undefined, event: ErrorEvent);
+}
+/**
+ * Configuration options for the `SSEClientTransport`.
+ */
+export type SSEClientTransportOptions = {
+    /**
+     * An OAuth client provider to use for authentication.
+     *
+     * When an `authProvider` is specified and the SSE connection is started:
+     * 1. The connection is attempted with any existing access token from the `authProvider`.
+     * 2. If the access token has expired, the `authProvider` is used to refresh the token.
+     * 3. If token refresh fails or no access token exists, and auth is required, `OAuthClientProvider.redirectToAuthorization` is called, and an `UnauthorizedError` will be thrown from `connect`/`start`.
+     *
+     * After the user has finished authorizing via their user agent, and is redirected back to the MCP client application, call `SSEClientTransport.finishAuth` with the authorization code before retrying the connection.
+     *
+     * If an `authProvider` is not provided, and auth is required, an `UnauthorizedError` will be thrown.
+     *
+     * `UnauthorizedError` might also be thrown when sending any message over the SSE transport, indicating that the session has expired, and needs to be re-authed and reconnected.
+     */
+    authProvider?: OAuthClientProvider;
+    /**
+     * Customizes the initial SSE request to the server (the request that begins the stream).
+     *
+     * NOTE: Setting this property will prevent an `Authorization` header from
+     * being automatically attached to the SSE request, if an `authProvider` is
+     * also given. This can be worked around by setting the `Authorization` header
+     * manually.
+     */
+    eventSourceInit?: EventSourceInit;
+    /**
+     * Customizes recurring POST requests to the server.
+     */
+    requestInit?: RequestInit;
+};
+/**
+ * Client transport for SSE: this will connect to a server using Server-Sent Events for receiving
+ * messages and make separate POST requests for sending messages.
+ */
+export declare class SSEClientTransport implements Transport {
+    private _eventSource?;
+    private _endpoint?;
+    private _abortController?;
+    private _url;
+    private _eventSourceInit?;
+    private _requestInit?;
+    private _authProvider?;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: (message: JSONRPCMessage) => void;
+    constructor(url: URL, opts?: SSEClientTransportOptions);
+    private _authThenStart;
+    private _commonHeaders;
+    private _startOrAuth;
+    start(): Promise<void>;
+    /**
+     * Call this method after the user has finished authorizing via their user agent and is redirected back to the MCP client application. This will exchange the authorization code for an access token, enabling the next connection attempt to successfully auth.
+     */
+    finishAuth(authorizationCode: string): Promise<void>;
+    close(): Promise<void>;
+    send(message: JSONRPCMessage): Promise<void>;
+}
+//# sourceMappingURL=sse.d.ts.map

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/sse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.d.ts","sourceRoot":"","sources":["../../../src/client/sse.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,UAAU,EAAE,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AACjF,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAwB,MAAM,aAAa,CAAC;AACnE,OAAO,EAAoB,mBAAmB,EAAqB,MAAM,WAAW,CAAC;AAErF,qBAAa,QAAS,SAAQ,KAAK;aAEf,IAAI,EAAE,MAAM,GAAG,SAAS;aAExB,KAAK,EAAE,UAAU;gBAFjB,IAAI,EAAE,MAAM,GAAG,SAAS,EACxC,OAAO,EAAE,MAAM,GAAG,SAAS,EACX,KAAK,EAAE,UAAU;CAIpC;AAED;;GAEG;AACH,MAAM,MAAM,yBAAyB,GAAG;IACtC;;;;;;;;;;;;;OAaG;IACH,YAAY,CAAC,EAAE,mBAAmB,CAAC;IAEnC;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,eAAe,CAAC;IAElC;;OAEG;IACH,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B,CAAC;AAEF;;;GAGG;AACH,qBAAa,kBAAmB,YAAW,SAAS;IAClD,OAAO,CAAC,YAAY,CAAC,CAAc;IACnC,OAAO,CAAC,SAAS,CAAC,CAAM;IACxB,OAAO,CAAC,gBAAgB,CAAC,CAAkB;IAC3C,OAAO,CAAC,IAAI,CAAM;IAClB,OAAO,CAAC,gBAAgB,CAAC,CAAkB;IAC3C,OAAO,CAAC,YAAY,CAAC,CAAc;IACnC,OAAO,CAAC,aAAa,CAAC,CAAsB;IAE5C,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;gBAG5C,GAAG,EAAE,GAAG,EACR,IAAI,CAAC,EAAE,yBAAyB;YAQpB,cAAc;YAoBd,cAAc;IAY5B,OAAO,CAAC,YAAY;IAmEd,KAAK;IAUX;;OAEG;IACG,UAAU,CAAC,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAWpD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAMtB,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CAuCnD"}

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/sse.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SSEClientTransport = exports.SseError = void 0;
+const eventsource_1 = require("eventsource");
+const types_js_1 = require("../types.js");
+const auth_js_1 = require("./auth.js");
+class SseError extends Error {
+    constructor(code, message, event) {
+        super(`SSE error: ${message}`);
+        this.code = code;
+        this.event = event;
+    }
+}
+exports.SseError = SseError;
+/**
+ * Client transport for SSE: this will connect to a server using Server-Sent Events for receiving
+ * messages and make separate POST requests for sending messages.
+ */
+class SSEClientTransport {
+    constructor(url, opts) {
+        this._url = url;
+        this._eventSourceInit = opts === null || opts === void 0 ? void 0 : opts.eventSourceInit;
+        this._requestInit = opts === null || opts === void 0 ? void 0 : opts.requestInit;
+        this._authProvider = opts === null || opts === void 0 ? void 0 : opts.authProvider;
+    }
+    async _authThenStart() {
+        var _a;
+        if (!this._authProvider) {
+            throw new auth_js_1.UnauthorizedError("No auth provider");
+        }
+        let result;
+        try {
+            result = await (0, auth_js_1.auth)(this._authProvider, { serverUrl: this._url });
+        }
+        catch (error) {
+            (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error);
+            throw error;
+        }
+        if (result !== "AUTHORIZED") {
+            throw new auth_js_1.UnauthorizedError();
+        }
+        return await this._startOrAuth();
+    }
+    async _commonHeaders() {
+        const headers = {};
+        if (this._authProvider) {
+            const tokens = await this._authProvider.tokens();
+            if (tokens) {
+                headers["Authorization"] = `Bearer ${tokens.access_token}`;
+            }
+        }
+        return headers;
+    }
+    _startOrAuth() {
+        return new Promise((resolve, reject) => {
+            var _a;
+            this._eventSource = new eventsource_1.EventSource(this._url.href, (_a = this._eventSourceInit) !== null && _a !== void 0 ? _a : {
+                fetch: (url, init) => this._commonHeaders().then((headers) => fetch(url, {
+                    ...init,
+                    headers: {
+                        ...headers,
+                        Accept: "text/event-stream"
+                    }
+                })),
+            });
+            this._abortController = new AbortController();
+            this._eventSource.onerror = (event) => {
+                var _a;
+                if (event.code === 401 && this._authProvider) {
+                    this._authThenStart().then(resolve, reject);
+                    return;
+                }
+                const error = new SseError(event.code, event.message, event);
+                reject(error);
+                (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error);
+            };
+            this._eventSource.onopen = () => {
+                // The connection is open, but we need to wait for the endpoint to be received.
+            };
+            this._eventSource.addEventListener("endpoint", (event) => {
+                var _a;
+                const messageEvent = event;
+                try {
+                    this._endpoint = new URL(messageEvent.data, this._url);
+                    if (this._endpoint.origin !== this._url.origin) {
+                        throw new Error(`Endpoint origin does not match connection origin: ${this._endpoint.origin}`);
+                    }
+                }
+                catch (error) {
+                    reject(error);
+                    (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error);
+                    void this.close();
+                    return;
+                }
+                resolve();
+            });
+            this._eventSource.onmessage = (event) => {
+                var _a, _b;
+                const messageEvent = event;
+                let message;
+                try {
+                    message = types_js_1.JSONRPCMessageSchema.parse(JSON.parse(messageEvent.data));
+                }
+                catch (error) {
+                    (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error);
+                    return;
+                }
+                (_b = this.onmessage) === null || _b === void 0 ? void 0 : _b.call(this, message);
+            };
+        });
+    }
+    async start() {
+        if (this._eventSource) {
+            throw new Error("SSEClientTransport already started! If using Client class, note that connect() calls start() automatically.");
+        }
+        return await this._startOrAuth();
+    }
+    /**
+     * Call this method after the user has finished authorizing via their user agent and is redirected back to the MCP client application. This will exchange the authorization code for an access token, enabling the next connection attempt to successfully auth.
+     */
+    async finishAuth(authorizationCode) {
+        if (!this._authProvider) {
+            throw new auth_js_1.UnauthorizedError("No auth provider");
+        }
+        const result = await (0, auth_js_1.auth)(this._authProvider, { serverUrl: this._url, authorizationCode });
+        if (result !== "AUTHORIZED") {
+            throw new auth_js_1.UnauthorizedError("Failed to authorize");
+        }
+    }
+    async close() {
+        var _a, _b, _c;
+        (_a = this._abortController) === null || _a === void 0 ? void 0 : _a.abort();
+        (_b = this._eventSource) === null || _b === void 0 ? void 0 : _b.close();
+        (_c = this.onclose) === null || _c === void 0 ? void 0 : _c.call(this);
+    }
+    async send(message) {
+        var _a, _b, _c;
+        if (!this._endpoint) {
+            throw new Error("Not connected");
+        }
+        try {
+            const commonHeaders = await this._commonHeaders();
+            const headers = new Headers({ ...commonHeaders, ...(_a = this._requestInit) === null || _a === void 0 ? void 0 : _a.headers });
+            headers.set("content-type", "application/json");
+            const init = {
+                ...this._requestInit,
+                method: "POST",
+                headers,
+                body: JSON.stringify(message),
+                signal: (_b = this._abortController) === null || _b === void 0 ? void 0 : _b.signal,
+            };
+            const response = await fetch(this._endpoint, init);
+            if (!response.ok) {
+                if (response.status === 401 && this._authProvider) {
+                    const result = await (0, auth_js_1.auth)(this._authProvider, { serverUrl: this._url });
+                    if (result !== "AUTHORIZED") {
+                        throw new auth_js_1.UnauthorizedError();
+                    }
+                    // Purposely _not_ awaited, so we don't call onerror twice
+                    return this.send(message);
+                }
+                const text = await response.text().catch(() => null);
+                throw new Error(`Error POSTing to endpoint (HTTP ${response.status}): ${text}`);
+            }
+        }
+        catch (error) {
+            (_c = this.onerror) === null || _c === void 0 ? void 0 : _c.call(this, error);
+            throw error;
+        }
+    }
+}
+exports.SSEClientTransport = SSEClientTransport;
+//# sourceMappingURL=sse.js.map

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/sse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse.js","sourceRoot":"","sources":["../../../src/client/sse.ts"],"names":[],"mappings":"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"}

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/stdio.d.ts

@@ -0,0 +1,69 @@
+import { IOType } from "node:child_process";
+import { Stream } from "node:stream";
+import { Transport } from "../shared/transport.js";
+import { JSONRPCMessage } from "../types.js";
+export type StdioServerParameters = {
+    /**
+     * The executable to run to start the server.
+     */
+    command: string;
+    /**
+     * Command line arguments to pass to the executable.
+     */
+    args?: string[];
+    /**
+     * The environment to use when spawning the process.
+     *
+     * If not specified, the result of getDefaultEnvironment() will be used.
+     */
+    env?: Record<string, string>;
+    /**
+     * How to handle stderr of the child process. This matches the semantics of Node's `child_process.spawn`.
+     *
+     * The default is "inherit", meaning messages to stderr will be printed to the parent process's stderr.
+     */
+    stderr?: IOType | Stream | number;
+    /**
+     * The working directory to use when spawning the process.
+     *
+     * If not specified, the current working directory will be inherited.
+     */
+    cwd?: string;
+};
+/**
+ * Environment variables to inherit by default, if an environment is not explicitly given.
+ */
+export declare const DEFAULT_INHERITED_ENV_VARS: string[];
+/**
+ * Returns a default environment object including only environment variables deemed safe to inherit.
+ */
+export declare function getDefaultEnvironment(): Record<string, string>;
+/**
+ * Client transport for stdio: this will connect to a server by spawning a process and communicating with it over stdin/stdout.
+ *
+ * This transport is only available in Node.js environments.
+ */
+export declare class StdioClientTransport implements Transport {
+    private _process?;
+    private _abortController;
+    private _readBuffer;
+    private _serverParams;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: (message: JSONRPCMessage) => void;
+    constructor(server: StdioServerParameters);
+    /**
+     * Starts the server process and prepares to communicate with it.
+     */
+    start(): Promise<void>;
+    /**
+     * The stderr stream of the child process, if `StdioServerParameters.stderr` was set to "pipe" or "overlapped".
+     *
+     * This is only available after the process has been started.
+     */
+    get stderr(): Stream | null;
+    private processReadBuffer;
+    close(): Promise<void>;
+    send(message: JSONRPCMessage): Promise<void>;
+}
+//# sourceMappingURL=stdio.d.ts.map

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/stdio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.d.ts","sourceRoot":"","sources":["../../../src/client/stdio.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,MAAM,EAAS,MAAM,oBAAoB,CAAC;AAEjE,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C,MAAM,MAAM,qBAAqB,GAAG;IAClC;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAEhB;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAE7B;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;IAElC;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,0BAA0B,UAgBmB,CAAC;AAE3D;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAkB9D;AAED;;;;GAIG;AACH,qBAAa,oBAAqB,YAAW,SAAS;IACpD,OAAO,CAAC,QAAQ,CAAC,CAAe;IAChC,OAAO,CAAC,gBAAgB,CAA0C;IAClE,OAAO,CAAC,WAAW,CAAgC;IACnD,OAAO,CAAC,aAAa,CAAwB;IAE7C,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;gBAElC,MAAM,EAAE,qBAAqB;IAIzC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAwD5B;;;;OAIG;IACH,IAAI,MAAM,IAAI,MAAM,GAAG,IAAI,CAE1B;IAED,OAAO,CAAC,iBAAiB;IAenB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAM5B,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CAc7C"}

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/stdio.js

@@ -0,0 +1,157 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StdioClientTransport = exports.DEFAULT_INHERITED_ENV_VARS = void 0;
+exports.getDefaultEnvironment = getDefaultEnvironment;
+const node_child_process_1 = require("node:child_process");
+const node_process_1 = __importDefault(require("node:process"));
+const stdio_js_1 = require("../shared/stdio.js");
+/**
+ * Environment variables to inherit by default, if an environment is not explicitly given.
+ */
+exports.DEFAULT_INHERITED_ENV_VARS = node_process_1.default.platform === "win32"
+    ? [
+        "APPDATA",
+        "HOMEDRIVE",
+        "HOMEPATH",
+        "LOCALAPPDATA",
+        "PATH",
+        "PROCESSOR_ARCHITECTURE",
+        "SYSTEMDRIVE",
+        "SYSTEMROOT",
+        "TEMP",
+        "USERNAME",
+        "USERPROFILE",
+    ]
+    : /* list inspired by the default env inheritance of sudo */
+        ["HOME", "LOGNAME", "PATH", "SHELL", "TERM", "USER"];
+/**
+ * Returns a default environment object including only environment variables deemed safe to inherit.
+ */
+function getDefaultEnvironment() {
+    const env = {};
+    for (const key of exports.DEFAULT_INHERITED_ENV_VARS) {
+        const value = node_process_1.default.env[key];
+        if (value === undefined) {
+            continue;
+        }
+        if (value.startsWith("()")) {
+            // Skip functions, which are a security risk.
+            continue;
+        }
+        env[key] = value;
+    }
+    return env;
+}
+/**
+ * Client transport for stdio: this will connect to a server by spawning a process and communicating with it over stdin/stdout.
+ *
+ * This transport is only available in Node.js environments.
+ */
+class StdioClientTransport {
+    constructor(server) {
+        this._abortController = new AbortController();
+        this._readBuffer = new stdio_js_1.ReadBuffer();
+        this._serverParams = server;
+    }
+    /**
+     * Starts the server process and prepares to communicate with it.
+     */
+    async start() {
+        if (this._process) {
+            throw new Error("StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.");
+        }
+        return new Promise((resolve, reject) => {
+            var _a, _b, _c, _d, _e, _f;
+            this._process = (0, node_child_process_1.spawn)(this._serverParams.command, (_a = this._serverParams.args) !== null && _a !== void 0 ? _a : [], {
+                env: (_b = this._serverParams.env) !== null && _b !== void 0 ? _b : getDefaultEnvironment(),
+                stdio: ["pipe", "pipe", (_c = this._serverParams.stderr) !== null && _c !== void 0 ? _c : "inherit"],
+                shell: false,
+                signal: this._abortController.signal,
+                windowsHide: node_process_1.default.platform === "win32" && isElectron(),
+                cwd: this._serverParams.cwd,
+            });
+            this._process.on("error", (error) => {
+                var _a, _b;
+                if (error.name === "AbortError") {
+                    // Expected when close() is called.
+                    (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this);
+                    return;
+                }
+                reject(error);
+                (_b = this.onerror) === null || _b === void 0 ? void 0 : _b.call(this, error);
+            });
+            this._process.on("spawn", () => {
+                resolve();
+            });
+            this._process.on("close", (_code) => {
+                var _a;
+                this._process = undefined;
+                (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this);
+            });
+            (_d = this._process.stdin) === null || _d === void 0 ? void 0 : _d.on("error", (error) => {
+                var _a;
+                (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error);
+            });
+            (_e = this._process.stdout) === null || _e === void 0 ? void 0 : _e.on("data", (chunk) => {
+                this._readBuffer.append(chunk);
+                this.processReadBuffer();
+            });
+            (_f = this._process.stdout) === null || _f === void 0 ? void 0 : _f.on("error", (error) => {
+                var _a;
+                (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error);
+            });
+        });
+    }
+    /**
+     * The stderr stream of the child process, if `StdioServerParameters.stderr` was set to "pipe" or "overlapped".
+     *
+     * This is only available after the process has been started.
+     */
+    get stderr() {
+        var _a, _b;
+        return (_b = (_a = this._process) === null || _a === void 0 ? void 0 : _a.stderr) !== null && _b !== void 0 ? _b : null;
+    }
+    processReadBuffer() {
+        var _a, _b;
+        while (true) {
+            try {
+                const message = this._readBuffer.readMessage();
+                if (message === null) {
+                    break;
+                }
+                (_a = this.onmessage) === null || _a === void 0 ? void 0 : _a.call(this, message);
+            }
+            catch (error) {
+                (_b = this.onerror) === null || _b === void 0 ? void 0 : _b.call(this, error);
+            }
+        }
+    }
+    async close() {
+        this._abortController.abort();
+        this._process = undefined;
+        this._readBuffer.clear();
+    }
+    send(message) {
+        return new Promise((resolve) => {
+            var _a;
+            if (!((_a = this._process) === null || _a === void 0 ? void 0 : _a.stdin)) {
+                throw new Error("Not connected");
+            }
+            const json = (0, stdio_js_1.serializeMessage)(message);
+            if (this._process.stdin.write(json)) {
+                resolve();
+            }
+            else {
+                this._process.stdin.once("drain", resolve);
+            }
+        });
+    }
+}
+exports.StdioClientTransport = StdioClientTransport;
+function isElectron() {
+    return "type" in node_process_1.default;
+}
+//# sourceMappingURL=stdio.js.map

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/stdio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.js","sourceRoot":"","sources":["../../../src/client/stdio.ts"],"names":[],"mappings":"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"}

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/websocket.d.ts

@@ -0,0 +1,17 @@
+import { Transport } from "../shared/transport.js";
+import { JSONRPCMessage } from "../types.js";
+/**
+ * Client transport for WebSocket: this will connect to a server over the WebSocket protocol.
+ */
+export declare class WebSocketClientTransport implements Transport {
+    private _socket?;
+    private _url;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: (message: JSONRPCMessage) => void;
+    constructor(url: URL);
+    start(): Promise<void>;
+    close(): Promise<void>;
+    send(message: JSONRPCMessage): Promise<void>;
+}
+//# sourceMappingURL=websocket.d.ts.map

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/websocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.d.ts","sourceRoot":"","sources":["../../../src/client/websocket.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACnD,OAAO,EAAE,cAAc,EAAwB,MAAM,aAAa,CAAC;AAInE;;GAEG;AACH,qBAAa,wBAAyB,YAAW,SAAS;IACxD,OAAO,CAAC,OAAO,CAAC,CAAY;IAC5B,OAAO,CAAC,IAAI,CAAM;IAElB,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;gBAElC,GAAG,EAAE,GAAG;IAIpB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAyChB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAI5B,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CAW7C"}

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/websocket.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketClientTransport = void 0;
+const types_js_1 = require("../types.js");
+const SUBPROTOCOL = "mcp";
+/**
+ * Client transport for WebSocket: this will connect to a server over the WebSocket protocol.
+ */
+class WebSocketClientTransport {
+    constructor(url) {
+        this._url = url;
+    }
+    start() {
+        if (this._socket) {
+            throw new Error("WebSocketClientTransport already started! If using Client class, note that connect() calls start() automatically.");
+        }
+        return new Promise((resolve, reject) => {
+            this._socket = new WebSocket(this._url, SUBPROTOCOL);
+            this._socket.onerror = (event) => {
+                var _a;
+                const error = "error" in event
+                    ? event.error
+                    : new Error(`WebSocket error: ${JSON.stringify(event)}`);
+                reject(error);
+                (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error);
+            };
+            this._socket.onopen = () => {
+                resolve();
+            };
+            this._socket.onclose = () => {
+                var _a;
+                (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this);
+            };
+            this._socket.onmessage = (event) => {
+                var _a, _b;
+                let message;
+                try {
+                    message = types_js_1.JSONRPCMessageSchema.parse(JSON.parse(event.data));
+                }
+                catch (error) {
+                    (_a = this.onerror) === null || _a === void 0 ? void 0 : _a.call(this, error);
+                    return;
+                }
+                (_b = this.onmessage) === null || _b === void 0 ? void 0 : _b.call(this, message);
+            };
+        });
+    }
+    async close() {
+        var _a;
+        (_a = this._socket) === null || _a === void 0 ? void 0 : _a.close();
+    }
+    send(message) {
+        return new Promise((resolve, reject) => {
+            var _a;
+            if (!this._socket) {
+                reject(new Error("Not connected"));
+                return;
+            }
+            (_a = this._socket) === null || _a === void 0 ? void 0 : _a.send(JSON.stringify(message));
+            resolve();
+        });
+    }
+}
+exports.WebSocketClientTransport = WebSocketClientTransport;
+//# sourceMappingURL=websocket.js.map

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/client/websocket.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.js","sourceRoot":"","sources":["../../../src/client/websocket.ts"],"names":[],"mappings":";;;AACA,0CAAmE;AAEnE,MAAM,WAAW,GAAG,KAAK,CAAC;AAE1B;;GAEG;AACH,MAAa,wBAAwB;IAQnC,YAAY,GAAQ;QAClB,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC;IAClB,CAAC;IAED,KAAK;QACH,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CACb,mHAAmH,CACpH,CAAC;QACJ,CAAC;QAED,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,CAAC,OAAO,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;YAErD,IAAI,CAAC,OAAO,CAAC,OAAO,GAAG,CAAC,KAAK,EAAE,EAAE;;gBAC/B,MAAM,KAAK,GACT,OAAO,IAAI,KAAK;oBACd,CAAC,CAAE,KAAK,CAAC,KAAe;oBACxB,CAAC,CAAC,IAAI,KAAK,CAAC,oBAAoB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;gBAC7D,MAAM,CAAC,KAAK,CAAC,CAAC;gBACd,MAAA,IAAI,CAAC,OAAO,qDAAG,KAAK,CAAC,CAAC;YACxB,CAAC,CAAC;YAEF,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,GAAG,EAAE;gBACzB,OAAO,EAAE,CAAC;YACZ,CAAC,CAAC;YAEF,IAAI,CAAC,OAAO,CAAC,OAAO,GAAG,GAAG,EAAE;;gBAC1B,MAAA,IAAI,CAAC,OAAO,oDAAI,CAAC;YACnB,CAAC,CAAC;YAEF,IAAI,CAAC,OAAO,CAAC,SAAS,GAAG,CAAC,KAAmB,EAAE,EAAE;;gBAC/C,IAAI,OAAuB,CAAC;gBAC5B,IAAI,CAAC;oBACH,OAAO,GAAG,+BAAoB,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;gBAC/D,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,MAAA,IAAI,CAAC,OAAO,qDAAG,KAAc,CAAC,CAAC;oBAC/B,OAAO;gBACT,CAAC;gBAED,MAAA,IAAI,CAAC,SAAS,qDAAG,OAAO,CAAC,CAAC;YAC5B,CAAC,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAED,KAAK,CAAC,KAAK;;QACT,MAAA,IAAI,CAAC,OAAO,0CAAE,KAAK,EAAE,CAAC;IACxB,CAAC;IAED,IAAI,CAAC,OAAuB;QAC1B,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;;YACrC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC;gBAClB,MAAM,CAAC,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC,CAAC;gBACnC,OAAO;YACT,CAAC;YAED,MAAA,IAAI,CAAC,OAAO,0CAAE,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC;YAC5C,OAAO,EAAE,CAAC;QACZ,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AApED,4DAoEC"}

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/inMemory.d.ts

@@ -0,0 +1,21 @@
+import { Transport } from "./shared/transport.js";
+import { JSONRPCMessage } from "./types.js";
+/**
+ * In-memory transport for creating clients and servers that talk to each other within the same process.
+ */
+export declare class InMemoryTransport implements Transport {
+    private _otherTransport?;
+    private _messageQueue;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    onmessage?: (message: JSONRPCMessage) => void;
+    sessionId?: string;
+    /**
+     * Creates a pair of linked in-memory transports that can communicate with each other. One should be passed to a Client and one to a Server.
+     */
+    static createLinkedPair(): [InMemoryTransport, InMemoryTransport];
+    start(): Promise<void>;
+    close(): Promise<void>;
+    send(message: JSONRPCMessage): Promise<void>;
+}
+//# sourceMappingURL=inMemory.d.ts.map

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/inMemory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inMemory.d.ts","sourceRoot":"","sources":["../../src/inMemory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE5C;;GAEG;AACH,qBAAa,iBAAkB,YAAW,SAAS;IACjD,OAAO,CAAC,eAAe,CAAC,CAAoB;IAC5C,OAAO,CAAC,aAAa,CAAwB;IAE7C,OAAO,CAAC,EAAE,MAAM,IAAI,CAAC;IACrB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACjC,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,IAAI,CAAC;IAC9C,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,MAAM,CAAC,gBAAgB,IAAI,CAAC,iBAAiB,EAAE,iBAAiB,CAAC;IAQ3D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAUtB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAOtB,IAAI,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;CAWnD"}

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/inMemory.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryTransport = void 0;
+/**
+ * In-memory transport for creating clients and servers that talk to each other within the same process.
+ */
+class InMemoryTransport {
+    constructor() {
+        this._messageQueue = [];
+    }
+    /**
+     * Creates a pair of linked in-memory transports that can communicate with each other. One should be passed to a Client and one to a Server.
+     */
+    static createLinkedPair() {
+        const clientTransport = new InMemoryTransport();
+        const serverTransport = new InMemoryTransport();
+        clientTransport._otherTransport = serverTransport;
+        serverTransport._otherTransport = clientTransport;
+        return [clientTransport, serverTransport];
+    }
+    async start() {
+        var _a;
+        // Process any messages that were queued before start was called
+        while (this._messageQueue.length > 0) {
+            const message = this._messageQueue.shift();
+            if (message) {
+                (_a = this.onmessage) === null || _a === void 0 ? void 0 : _a.call(this, message);
+            }
+        }
+    }
+    async close() {
+        var _a;
+        const other = this._otherTransport;
+        this._otherTransport = undefined;
+        await (other === null || other === void 0 ? void 0 : other.close());
+        (_a = this.onclose) === null || _a === void 0 ? void 0 : _a.call(this);
+    }
+    async send(message) {
+        if (!this._otherTransport) {
+            throw new Error("Not connected");
+        }
+        if (this._otherTransport.onmessage) {
+            this._otherTransport.onmessage(message);
+        }
+        else {
+            this._otherTransport._messageQueue.push(message);
+        }
+    }
+}
+exports.InMemoryTransport = InMemoryTransport;
+//# sourceMappingURL=inMemory.js.map

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/inMemory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inMemory.js","sourceRoot":"","sources":["../../src/inMemory.ts"],"names":[],"mappings":";;;AAGA;;GAEG;AACH,MAAa,iBAAiB;IAA9B;QAEU,kBAAa,GAAqB,EAAE,CAAC;IA8C/C,CAAC;IAvCC;;OAEG;IACH,MAAM,CAAC,gBAAgB;QACrB,MAAM,eAAe,GAAG,IAAI,iBAAiB,EAAE,CAAC;QAChD,MAAM,eAAe,GAAG,IAAI,iBAAiB,EAAE,CAAC;QAChD,eAAe,CAAC,eAAe,GAAG,eAAe,CAAC;QAClD,eAAe,CAAC,eAAe,GAAG,eAAe,CAAC;QAClD,OAAO,CAAC,eAAe,EAAE,eAAe,CAAC,CAAC;IAC5C,CAAC;IAED,KAAK,CAAC,KAAK;;QACT,gEAAgE;QAChE,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACrC,MAAM,OAAO,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;YAC3C,IAAI,OAAO,EAAE,CAAC;gBACZ,MAAA,IAAI,CAAC,SAAS,qDAAG,OAAO,CAAC,CAAC;YAC5B,CAAC;QACH,CAAC;IACH,CAAC;IAED,KAAK,CAAC,KAAK;;QACT,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC;QACnC,IAAI,CAAC,eAAe,GAAG,SAAS,CAAC;QACjC,MAAM,CAAA,KAAK,aAAL,KAAK,uBAAL,KAAK,CAAE,KAAK,EAAE,CAAA,CAAC;QACrB,MAAA,IAAI,CAAC,OAAO,oDAAI,CAAC;IACnB,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,OAAuB;QAChC,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,eAAe,CAAC,CAAC;QACnC,CAAC;QAED,IAAI,IAAI,CAAC,eAAe,CAAC,SAAS,EAAE,CAAC;YACnC,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;QAC1C,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACnD,CAAC;IACH,CAAC;CACF;AAhDD,8CAgDC"}

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/server/auth/clients.d.ts

@@ -0,0 +1,19 @@
+import { OAuthClientInformationFull } from "../../shared/auth.js";
+/**
+ * Stores information about registered OAuth clients for this server.
+ */
+export interface OAuthRegisteredClientsStore {
+    /**
+     * Returns information about a registered client, based on its ID.
+     */
+    getClient(clientId: string): OAuthClientInformationFull | undefined | Promise<OAuthClientInformationFull | undefined>;
+    /**
+     * Registers a new client with the server. The client ID and secret will be automatically generated by the library. A modified version of the client information can be returned to reflect specific values enforced by the server.
+     *
+     * NOTE: Implementations should NOT delete expired client secrets in-place. Auth middleware provided by this library will automatically check the `client_secret_expires_at` field and reject requests with expired secrets. Any custom logic for authenticating clients should check the `client_secret_expires_at` field as well.
+     *
+     * If unimplemented, dynamic client registration is unsupported.
+     */
+    registerClient?(client: OAuthClientInformationFull): OAuthClientInformationFull | Promise<OAuthClientInformationFull>;
+}
+//# sourceMappingURL=clients.d.ts.map

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/server/auth/clients.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clients.d.ts","sourceRoot":"","sources":["../../../../src/server/auth/clients.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,0BAA0B,EAAE,MAAM,sBAAsB,CAAC;AAElE;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,0BAA0B,GAAG,SAAS,GAAG,OAAO,CAAC,0BAA0B,GAAG,SAAS,CAAC,CAAC;IAEtH;;;;;;OAMG;IACH,cAAc,CAAC,CAAC,MAAM,EAAE,0BAA0B,GAAG,0BAA0B,GAAG,OAAO,CAAC,0BAA0B,CAAC,CAAC;CACvH"}

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/server/auth/clients.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=clients.js.map

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/server/auth/clients.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clients.js","sourceRoot":"","sources":["../../../../src/server/auth/clients.ts"],"names":[],"mappings":""}

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/server/auth/errors.d.ts

@@ -0,0 +1,126 @@
+import { OAuthErrorResponse } from "../../shared/auth.js";
+/**
+ * Base class for all OAuth errors
+ */
+export declare class OAuthError extends Error {
+    readonly errorCode: string;
+    readonly errorUri?: string | undefined;
+    constructor(errorCode: string, message: string, errorUri?: string | undefined);
+    /**
+     * Converts the error to a standard OAuth error response object
+     */
+    toResponseObject(): OAuthErrorResponse;
+}
+/**
+ * Invalid request error - The request is missing a required parameter,
+ * includes an invalid parameter value, includes a parameter more than once,
+ * or is otherwise malformed.
+ */
+export declare class InvalidRequestError extends OAuthError {
+    constructor(message: string, errorUri?: string);
+}
+/**
+ * Invalid client error - Client authentication failed (e.g., unknown client, no client
+ * authentication included, or unsupported authentication method).
+ */
+export declare class InvalidClientError extends OAuthError {
+    constructor(message: string, errorUri?: string);
+}
+/**
+ * Invalid grant error - The provided authorization grant or refresh token is
+ * invalid, expired, revoked, does not match the redirection URI used in the
+ * authorization request, or was issued to another client.
+ */
+export declare class InvalidGrantError extends OAuthError {
+    constructor(message: string, errorUri?: string);
+}
+/**
+ * Unauthorized client error - The authenticated client is not authorized to use
+ * this authorization grant type.
+ */
+export declare class UnauthorizedClientError extends OAuthError {
+    constructor(message: string, errorUri?: string);
+}
+/**
+ * Unsupported grant type error - The authorization grant type is not supported
+ * by the authorization server.
+ */
+export declare class UnsupportedGrantTypeError extends OAuthError {
+    constructor(message: string, errorUri?: string);
+}
+/**
+ * Invalid scope error - The requested scope is invalid, unknown, malformed, or
+ * exceeds the scope granted by the resource owner.
+ */
+export declare class InvalidScopeError extends OAuthError {
+    constructor(message: string, errorUri?: string);
+}
+/**
+ * Access denied error - The resource owner or authorization server denied the request.
+ */
+export declare class AccessDeniedError extends OAuthError {
+    constructor(message: string, errorUri?: string);
+}
+/**
+ * Server error - The authorization server encountered an unexpected condition
+ * that prevented it from fulfilling the request.
+ */
+export declare class ServerError extends OAuthError {
+    constructor(message: string, errorUri?: string);
+}
+/**
+ * Temporarily unavailable error - The authorization server is currently unable to
+ * handle the request due to a temporary overloading or maintenance of the server.
+ */
+export declare class TemporarilyUnavailableError extends OAuthError {
+    constructor(message: string, errorUri?: string);
+}
+/**
+ * Unsupported response type error - The authorization server does not support
+ * obtaining an authorization code using this method.
+ */
+export declare class UnsupportedResponseTypeError extends OAuthError {
+    constructor(message: string, errorUri?: string);
+}
+/**
+ * Unsupported token type error - The authorization server does not support
+ * the requested token type.
+ */
+export declare class UnsupportedTokenTypeError extends OAuthError {
+    constructor(message: string, errorUri?: string);
+}
+/**
+ * Invalid token error - The access token provided is expired, revoked, malformed,
+ * or invalid for other reasons.
+ */
+export declare class InvalidTokenError extends OAuthError {
+    constructor(message: string, errorUri?: string);
+}
+/**
+ * Method not allowed error - The HTTP method used is not allowed for this endpoint.
+ * (Custom, non-standard error)
+ */
+export declare class MethodNotAllowedError extends OAuthError {
+    constructor(message: string, errorUri?: string);
+}
+/**
+ * Too many requests error - Rate limit exceeded.
+ * (Custom, non-standard error based on RFC 6585)
+ */
+export declare class TooManyRequestsError extends OAuthError {
+    constructor(message: string, errorUri?: string);
+}
+/**
+ * Invalid client metadata error - The client metadata is invalid.
+ * (Custom error for dynamic client registration - RFC 7591)
+ */
+export declare class InvalidClientMetadataError extends OAuthError {
+    constructor(message: string, errorUri?: string);
+}
+/**
+ * Insufficient scope error - The request requires higher privileges than provided by the access token.
+ */
+export declare class InsufficientScopeError extends OAuthError {
+    constructor(message: string, errorUri?: string);
+}
+//# sourceMappingURL=errors.d.ts.map

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/server/auth/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../src/server/auth/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAE1D;;GAEG;AACH,qBAAa,UAAW,SAAQ,KAAK;aAEjB,SAAS,EAAE,MAAM;aAEjB,QAAQ,CAAC,EAAE,MAAM;gBAFjB,SAAS,EAAE,MAAM,EACjC,OAAO,EAAE,MAAM,EACC,QAAQ,CAAC,EAAE,MAAM,YAAA;IAMnC;;OAEG;IACH,gBAAgB,IAAI,kBAAkB;CAYvC;AAED;;;;GAIG;AACH,qBAAa,mBAAoB,SAAQ,UAAU;gBACrC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAG/C;AAED;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,UAAU;gBACpC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAG/C;AAED;;;;GAIG;AACH,qBAAa,iBAAkB,SAAQ,UAAU;gBACnC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAG/C;AAED;;;GAGG;AACH,qBAAa,uBAAwB,SAAQ,UAAU;gBACzC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAG/C;AAED;;;GAGG;AACH,qBAAa,yBAA0B,SAAQ,UAAU;gBAC3C,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAG/C;AAED;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,UAAU;gBACnC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAG/C;AAED;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,UAAU;gBACnC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAG/C;AAED;;;GAGG;AACH,qBAAa,WAAY,SAAQ,UAAU;gBAC7B,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAG/C;AAED;;;GAGG;AACH,qBAAa,2BAA4B,SAAQ,UAAU;gBAC7C,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAG/C;AAED;;;GAGG;AACH,qBAAa,4BAA6B,SAAQ,UAAU;gBAC9C,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAG/C;AAED;;;GAGG;AACH,qBAAa,yBAA0B,SAAQ,UAAU;gBAC3C,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAG/C;AAED;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,UAAU;gBACnC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAG/C;AAED;;;GAGG;AACH,qBAAa,qBAAsB,SAAQ,UAAU;gBACvC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAG/C;AAED;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,UAAU;gBACtC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAG/C;AAED;;;GAGG;AACH,qBAAa,0BAA2B,SAAQ,UAAU;gBAC5C,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAG/C;AAED;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,UAAU;gBACxC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;CAG/C"}

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/server/auth/errors.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsufficientScopeError = exports.InvalidClientMetadataError = exports.TooManyRequestsError = exports.MethodNotAllowedError = exports.InvalidTokenError = exports.UnsupportedTokenTypeError = exports.UnsupportedResponseTypeError = exports.TemporarilyUnavailableError = exports.ServerError = exports.AccessDeniedError = exports.InvalidScopeError = exports.UnsupportedGrantTypeError = exports.UnauthorizedClientError = exports.InvalidGrantError = exports.InvalidClientError = exports.InvalidRequestError = exports.OAuthError = void 0;
+/**
+ * Base class for all OAuth errors
+ */
+class OAuthError extends Error {
+    constructor(errorCode, message, errorUri) {
+        super(message);
+        this.errorCode = errorCode;
+        this.errorUri = errorUri;
+        this.name = this.constructor.name;
+    }
+    /**
+     * Converts the error to a standard OAuth error response object
+     */
+    toResponseObject() {
+        const response = {
+            error: this.errorCode,
+            error_description: this.message
+        };
+        if (this.errorUri) {
+            response.error_uri = this.errorUri;
+        }
+        return response;
+    }
+}
+exports.OAuthError = OAuthError;
+/**
+ * Invalid request error - The request is missing a required parameter,
+ * includes an invalid parameter value, includes a parameter more than once,
+ * or is otherwise malformed.
+ */
+class InvalidRequestError extends OAuthError {
+    constructor(message, errorUri) {
+        super("invalid_request", message, errorUri);
+    }
+}
+exports.InvalidRequestError = InvalidRequestError;
+/**
+ * Invalid client error - Client authentication failed (e.g., unknown client, no client
+ * authentication included, or unsupported authentication method).
+ */
+class InvalidClientError extends OAuthError {
+    constructor(message, errorUri) {
+        super("invalid_client", message, errorUri);
+    }
+}
+exports.InvalidClientError = InvalidClientError;
+/**
+ * Invalid grant error - The provided authorization grant or refresh token is
+ * invalid, expired, revoked, does not match the redirection URI used in the
+ * authorization request, or was issued to another client.
+ */
+class InvalidGrantError extends OAuthError {
+    constructor(message, errorUri) {
+        super("invalid_grant", message, errorUri);
+    }
+}
+exports.InvalidGrantError = InvalidGrantError;
+/**
+ * Unauthorized client error - The authenticated client is not authorized to use
+ * this authorization grant type.
+ */
+class UnauthorizedClientError extends OAuthError {
+    constructor(message, errorUri) {
+        super("unauthorized_client", message, errorUri);
+    }
+}
+exports.UnauthorizedClientError = UnauthorizedClientError;
+/**
+ * Unsupported grant type error - The authorization grant type is not supported
+ * by the authorization server.
+ */
+class UnsupportedGrantTypeError extends OAuthError {
+    constructor(message, errorUri) {
+        super("unsupported_grant_type", message, errorUri);
+    }
+}
+exports.UnsupportedGrantTypeError = UnsupportedGrantTypeError;
+/**
+ * Invalid scope error - The requested scope is invalid, unknown, malformed, or
+ * exceeds the scope granted by the resource owner.
+ */
+class InvalidScopeError extends OAuthError {
+    constructor(message, errorUri) {
+        super("invalid_scope", message, errorUri);
+    }
+}
+exports.InvalidScopeError = InvalidScopeError;
+/**
+ * Access denied error - The resource owner or authorization server denied the request.
+ */
+class AccessDeniedError extends OAuthError {
+    constructor(message, errorUri) {
+        super("access_denied", message, errorUri);
+    }
+}
+exports.AccessDeniedError = AccessDeniedError;
+/**
+ * Server error - The authorization server encountered an unexpected condition
+ * that prevented it from fulfilling the request.
+ */
+class ServerError extends OAuthError {
+    constructor(message, errorUri) {
+        super("server_error", message, errorUri);
+    }
+}
+exports.ServerError = ServerError;
+/**
+ * Temporarily unavailable error - The authorization server is currently unable to
+ * handle the request due to a temporary overloading or maintenance of the server.
+ */
+class TemporarilyUnavailableError extends OAuthError {
+    constructor(message, errorUri) {
+        super("temporarily_unavailable", message, errorUri);
+    }
+}
+exports.TemporarilyUnavailableError = TemporarilyUnavailableError;
+/**
+ * Unsupported response type error - The authorization server does not support
+ * obtaining an authorization code using this method.
+ */
+class UnsupportedResponseTypeError extends OAuthError {
+    constructor(message, errorUri) {
+        super("unsupported_response_type", message, errorUri);
+    }
+}
+exports.UnsupportedResponseTypeError = UnsupportedResponseTypeError;
+/**
+ * Unsupported token type error - The authorization server does not support
+ * the requested token type.
+ */
+class UnsupportedTokenTypeError extends OAuthError {
+    constructor(message, errorUri) {
+        super("unsupported_token_type", message, errorUri);
+    }
+}
+exports.UnsupportedTokenTypeError = UnsupportedTokenTypeError;
+/**
+ * Invalid token error - The access token provided is expired, revoked, malformed,
+ * or invalid for other reasons.
+ */
+class InvalidTokenError extends OAuthError {
+    constructor(message, errorUri) {
+        super("invalid_token", message, errorUri);
+    }
+}
+exports.InvalidTokenError = InvalidTokenError;
+/**
+ * Method not allowed error - The HTTP method used is not allowed for this endpoint.
+ * (Custom, non-standard error)
+ */
+class MethodNotAllowedError extends OAuthError {
+    constructor(message, errorUri) {
+        super("method_not_allowed", message, errorUri);
+    }
+}
+exports.MethodNotAllowedError = MethodNotAllowedError;
+/**
+ * Too many requests error - Rate limit exceeded.
+ * (Custom, non-standard error based on RFC 6585)
+ */
+class TooManyRequestsError extends OAuthError {
+    constructor(message, errorUri) {
+        super("too_many_requests", message, errorUri);
+    }
+}
+exports.TooManyRequestsError = TooManyRequestsError;
+/**
+ * Invalid client metadata error - The client metadata is invalid.
+ * (Custom error for dynamic client registration - RFC 7591)
+ */
+class InvalidClientMetadataError extends OAuthError {
+    constructor(message, errorUri) {
+        super("invalid_client_metadata", message, errorUri);
+    }
+}
+exports.InvalidClientMetadataError = InvalidClientMetadataError;
+/**
+ * Insufficient scope error - The request requires higher privileges than provided by the access token.
+ */
+class InsufficientScopeError extends OAuthError {
+    constructor(message, errorUri) {
+        super("insufficient_scope", message, errorUri);
+    }
+}
+exports.InsufficientScopeError = InsufficientScopeError;
+//# sourceMappingURL=errors.js.map

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/server/auth/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../../src/server/auth/errors.ts"],"names":[],"mappings":";;;AAEA;;GAEG;AACH,MAAa,UAAW,SAAQ,KAAK;IACnC,YACkB,SAAiB,EACjC,OAAe,EACC,QAAiB;QAEjC,KAAK,CAAC,OAAO,CAAC,CAAC;QAJC,cAAS,GAAT,SAAS,CAAQ;QAEjB,aAAQ,GAAR,QAAQ,CAAS;QAGjC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;IACpC,CAAC;IAED;;OAEG;IACH,gBAAgB;QACd,MAAM,QAAQ,GAAuB;YACnC,KAAK,EAAE,IAAI,CAAC,SAAS;YACrB,iBAAiB,EAAE,IAAI,CAAC,OAAO;SAChC,CAAC;QAEF,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClB,QAAQ,CAAC,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC;QACrC,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;CACF;AAzBD,gCAyBC;AAED;;;;GAIG;AACH,MAAa,mBAAoB,SAAQ,UAAU;IACjD,YAAY,OAAe,EAAE,QAAiB;QAC5C,KAAK,CAAC,iBAAiB,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC9C,CAAC;CACF;AAJD,kDAIC;AAED;;;GAGG;AACH,MAAa,kBAAmB,SAAQ,UAAU;IAChD,YAAY,OAAe,EAAE,QAAiB;QAC5C,KAAK,CAAC,gBAAgB,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC7C,CAAC;CACF;AAJD,gDAIC;AAED;;;;GAIG;AACH,MAAa,iBAAkB,SAAQ,UAAU;IAC/C,YAAY,OAAe,EAAE,QAAiB;QAC5C,KAAK,CAAC,eAAe,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC5C,CAAC;CACF;AAJD,8CAIC;AAED;;;GAGG;AACH,MAAa,uBAAwB,SAAQ,UAAU;IACrD,YAAY,OAAe,EAAE,QAAiB;QAC5C,KAAK,CAAC,qBAAqB,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IAClD,CAAC;CACF;AAJD,0DAIC;AAED;;;GAGG;AACH,MAAa,yBAA0B,SAAQ,UAAU;IACvD,YAAY,OAAe,EAAE,QAAiB;QAC5C,KAAK,CAAC,wBAAwB,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IACrD,CAAC;CACF;AAJD,8DAIC;AAED;;;GAGG;AACH,MAAa,iBAAkB,SAAQ,UAAU;IAC/C,YAAY,OAAe,EAAE,QAAiB;QAC5C,KAAK,CAAC,eAAe,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC5C,CAAC;CACF;AAJD,8CAIC;AAED;;GAEG;AACH,MAAa,iBAAkB,SAAQ,UAAU;IAC/C,YAAY,OAAe,EAAE,QAAiB;QAC5C,KAAK,CAAC,eAAe,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC5C,CAAC;CACF;AAJD,8CAIC;AAED;;;GAGG;AACH,MAAa,WAAY,SAAQ,UAAU;IACzC,YAAY,OAAe,EAAE,QAAiB;QAC5C,KAAK,CAAC,cAAc,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC3C,CAAC;CACF;AAJD,kCAIC;AAED;;;GAGG;AACH,MAAa,2BAA4B,SAAQ,UAAU;IACzD,YAAY,OAAe,EAAE,QAAiB;QAC5C,KAAK,CAAC,yBAAyB,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IACtD,CAAC;CACF;AAJD,kEAIC;AAED;;;GAGG;AACH,MAAa,4BAA6B,SAAQ,UAAU;IAC1D,YAAY,OAAe,EAAE,QAAiB;QAC5C,KAAK,CAAC,2BAA2B,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IACxD,CAAC;CACF;AAJD,oEAIC;AAED;;;GAGG;AACH,MAAa,yBAA0B,SAAQ,UAAU;IACvD,YAAY,OAAe,EAAE,QAAiB;QAC5C,KAAK,CAAC,wBAAwB,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IACrD,CAAC;CACF;AAJD,8DAIC;AAED;;;GAGG;AACH,MAAa,iBAAkB,SAAQ,UAAU;IAC/C,YAAY,OAAe,EAAE,QAAiB;QAC5C,KAAK,CAAC,eAAe,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IAC5C,CAAC;CACF;AAJD,8CAIC;AAED;;;GAGG;AACH,MAAa,qBAAsB,SAAQ,UAAU;IACnD,YAAY,OAAe,EAAE,QAAiB;QAC5C,KAAK,CAAC,oBAAoB,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IACjD,CAAC;CACF;AAJD,sDAIC;AAED;;;GAGG;AACH,MAAa,oBAAqB,SAAQ,UAAU;IAClD,YAAY,OAAe,EAAE,QAAiB;QAC5C,KAAK,CAAC,mBAAmB,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IAChD,CAAC;CACF;AAJD,oDAIC;AAED;;;GAGG;AACH,MAAa,0BAA2B,SAAQ,UAAU;IACxD,YAAY,OAAe,EAAE,QAAiB;QAC5C,KAAK,CAAC,yBAAyB,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IACtD,CAAC;CACF;AAJD,gEAIC;AAED;;GAEG;AACH,MAAa,sBAAuB,SAAQ,UAAU;IACpD,YAAY,OAAe,EAAE,QAAiB;QAC5C,KAAK,CAAC,oBAAoB,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;IACjD,CAAC;CACF;AAJD,wDAIC"}

crypto-indicators-mcp/node_modules/@modelcontextprotocol/sdk/dist/cjs/server/auth/handlers/authorize.d.ts

@@ -0,0 +1,13 @@
+import { RequestHandler } from "express";
+import { OAuthServerProvider } from "../provider.js";
+import { Options as RateLimitOptions } from "express-rate-limit";
+export type AuthorizationHandlerOptions = {
+    provider: OAuthServerProvider;
+    /**
+     * Rate limiting configuration for the authorization endpoint.
+     * Set to false to disable rate limiting for this endpoint.
+     */
+    rateLimit?: Partial<RateLimitOptions> | false;
+};
+export declare function authorizationHandler({ provider, rateLimit: rateLimitConfig }: AuthorizationHandlerOptions): RequestHandler;
+//# sourceMappingURL=authorize.d.ts.map