fixparser-plugin-mcp 9.1.7-57d70bb1 → 9.1.7-5d282a9e

package/build/cjs/MCPRemote.js

@@ -166,7 +166,7 @@ var toolSchemas = {
     }
   },
   executeOrder: {
-    description: "Executes a verified order. verifyOrder must be called before executeOrder. user has to explicitly allow executeOrder.",
+    description: "Executes a verified order. verifyOrder must be called before executeOrder.",
     schema: {
       type: "object",
       properties: {
@@ -310,8 +310,1567 @@ var toolSchemas = {
       },
       required: ["symbol"]
     }
+  },
+  technicalAnalysis: {
+    description: "Performs comprehensive technical analysis on market data for a given symbol, including indicators like SMA, EMA, RSI, Bollinger Bands, and trading signals",
+    schema: {
+      type: "object",
+      properties: {
+        symbol: {
+          type: "string",
+          description: "The trading symbol to analyze (e.g., AAPL, MSFT, EURUSD)"
+        }
+      },
+      required: ["symbol"]
+    }
+  }
+};
+
+// src/tools/analytics.ts
+function sum(numbers) {
+  return numbers.reduce((acc, val) => acc + val, 0);
+}
+var TechnicalAnalyzer = class {
+  prices;
+  volumes;
+  highs;
+  lows;
+  constructor(data) {
+    this.prices = data.map((d) => d.trade > 0 ? d.trade : d.midPrice);
+    this.volumes = data.map((d) => d.volume);
+    this.highs = data.map((d) => d.tradingSessionHighPrice > 0 ? d.tradingSessionHighPrice : d.trade);
+    this.lows = data.map((d) => d.tradingSessionLowPrice > 0 ? d.tradingSessionLowPrice : d.trade);
+  }
+  // Calculate Simple Moving Average
+  calculateSMA(data, period) {
+    const sma = [];
+    for (let i = period - 1; i < data.length; i++) {
+      const sum2 = data.slice(i - period + 1, i + 1).reduce((a, b) => a + b, 0);
+      sma.push(sum2 / period);
+    }
+    return sma;
+  }
+  // Calculate Exponential Moving Average
+  calculateEMA(data, period) {
+    const multiplier = 2 / (period + 1);
+    const ema = [data[0]];
+    for (let i = 1; i < data.length; i++) {
+      ema.push(data[i] * multiplier + ema[i - 1] * (1 - multiplier));
+    }
+    return ema;
+  }
+  // Calculate RSI
+  calculateRSI(data, period = 14) {
+    if (data.length < period + 1) return [];
+    const changes = [];
+    for (let i = 1; i < data.length; i++) {
+      changes.push(data[i] - data[i - 1]);
+    }
+    const gains = changes.map((change) => change > 0 ? change : 0);
+    const losses = changes.map((change) => change < 0 ? Math.abs(change) : 0);
+    let avgGain = gains.slice(0, period).reduce((a, b) => a + b, 0) / period;
+    let avgLoss = losses.slice(0, period).reduce((a, b) => a + b, 0) / period;
+    const rsi = [];
+    for (let i = period; i < changes.length; i++) {
+      const rs = avgGain / avgLoss;
+      rsi.push(100 - 100 / (1 + rs));
+      avgGain = (avgGain * (period - 1) + gains[i]) / period;
+      avgLoss = (avgLoss * (period - 1) + losses[i]) / period;
+    }
+    return rsi;
+  }
+  // Calculate Bollinger Bands
+  calculateBollingerBands(data, period = 20, stdDev = 2) {
+    if (data.length < period) return [];
+    const sma = this.calculateSMA(data, period);
+    const bands = [];
+    for (let i = 0; i < sma.length; i++) {
+      const dataSlice = data.slice(i, i + period);
+      const mean = sma[i];
+      const variance = dataSlice.reduce((sum2, price) => sum2 + (price - mean) ** 2, 0) / period;
+      const standardDeviation = Math.sqrt(variance);
+      const upper = mean + standardDeviation * stdDev;
+      const lower = mean - standardDeviation * stdDev;
+      bands.push({
+        upper,
+        middle: mean,
+        lower,
+        bandwidth: (upper - lower) / mean * 100,
+        percentB: (data[i] - lower) / (upper - lower) * 100
+      });
+    }
+    return bands;
+  }
+  // Calculate maximum drawdown
+  calculateMaxDrawdown(prices) {
+    let maxPrice = prices[0];
+    let maxDrawdown = 0;
+    for (let i = 1; i < prices.length; i++) {
+      if (prices[i] > maxPrice) {
+        maxPrice = prices[i];
+      }
+      const drawdown = (maxPrice - prices[i]) / maxPrice;
+      if (drawdown > maxDrawdown) {
+        maxDrawdown = drawdown;
+      }
+    }
+    return maxDrawdown;
+  }
+  // Calculate Average True Range (ATR)
+  calculateAtr(prices, highs, lows) {
+    if (prices.length < 2) return [];
+    const trueRanges = [];
+    for (let i = 1; i < prices.length; i++) {
+      const high = highs[i] || prices[i];
+      const low = lows[i] || prices[i];
+      const prevClose = prices[i - 1];
+      const tr1 = high - low;
+      const tr2 = Math.abs(high - prevClose);
+      const tr3 = Math.abs(low - prevClose);
+      trueRanges.push(Math.max(tr1, tr2, tr3));
+    }
+    const atr = [];
+    if (trueRanges.length >= 14) {
+      let sum2 = trueRanges.slice(0, 14).reduce((a, b) => a + b, 0);
+      atr.push(sum2 / 14);
+      for (let i = 14; i < trueRanges.length; i++) {
+        sum2 = sum2 - trueRanges[i - 14] + trueRanges[i];
+        atr.push(sum2 / 14);
+      }
+    }
+    return atr;
+  }
+  // Calculate maximum consecutive losses
+  calculateMaxConsecutiveLosses(prices) {
+    let maxConsecutive = 0;
+    let currentConsecutive = 0;
+    for (let i = 1; i < prices.length; i++) {
+      if (prices[i] < prices[i - 1]) {
+        currentConsecutive++;
+        maxConsecutive = Math.max(maxConsecutive, currentConsecutive);
+      } else {
+        currentConsecutive = 0;
+      }
+    }
+    return maxConsecutive;
+  }
+  // Calculate win rate
+  calculateWinRate(prices) {
+    let wins = 0;
+    let total = 0;
+    for (let i = 1; i < prices.length; i++) {
+      if (prices[i] !== prices[i - 1]) {
+        total++;
+        if (prices[i] > prices[i - 1]) {
+          wins++;
+        }
+      }
+    }
+    return total > 0 ? wins / total : 0;
+  }
+  // Calculate profit factor
+  calculateProfitFactor(prices) {
+    let grossProfit = 0;
+    let grossLoss = 0;
+    for (let i = 1; i < prices.length; i++) {
+      const change = prices[i] - prices[i - 1];
+      if (change > 0) {
+        grossProfit += change;
+      } else {
+        grossLoss += Math.abs(change);
+      }
+    }
+    return grossLoss > 0 ? grossProfit / grossLoss : 0;
+  }
+  // Calculate Weighted Moving Average
+  calculateWma(data, period) {
+    const wma = [];
+    const weights = Array.from({ length: period }, (_, i) => i + 1);
+    const weightSum = weights.reduce((a, b) => a + b, 0);
+    for (let i = period - 1; i < data.length; i++) {
+      let weightedSum = 0;
+      for (let j = 0; j < period; j++) {
+        weightedSum += data[i - j] * weights[j];
+      }
+      wma.push(weightedSum / weightSum);
+    }
+    return wma;
+  }
+  // Calculate Volume Weighted Moving Average
+  calculateVwma(prices, period) {
+    const vwma = [];
+    for (let i = period - 1; i < prices.length; i++) {
+      let volumeSum = 0;
+      let priceVolumeSum = 0;
+      for (let j = 0; j < period; j++) {
+        const volume = this.volumes[i - j] || 1;
+        volumeSum += volume;
+        priceVolumeSum += prices[i - j] * volume;
+      }
+      vwma.push(priceVolumeSum / volumeSum);
+    }
+    return vwma;
+  }
+  // Calculate MACD
+  calculateMacd(prices) {
+    const ema12 = this.calculateEMA(prices, 12);
+    const ema26 = this.calculateEMA(prices, 26);
+    const macd = [];
+    const macdLine = [];
+    for (let i = 0; i < Math.min(ema12.length, ema26.length); i++) {
+      macdLine.push(ema12[i] - ema26[i]);
+    }
+    const signalLine = this.calculateEMA(macdLine, 9);
+    for (let i = 0; i < Math.min(macdLine.length, signalLine.length); i++) {
+      macd.push({
+        macd: macdLine[i],
+        signal: signalLine[i],
+        histogram: macdLine[i] - signalLine[i]
+      });
+    }
+    return macd;
+  }
+  // Calculate ADX (Average Directional Index)
+  calculateAdx(prices, highs, lows) {
+    if (prices.length < 14) return [];
+    const period = 14;
+    const adx = [];
+    const trueRanges = [];
+    const plusDM = [];
+    const minusDM = [];
+    trueRanges.push(highs[0] - lows[0]);
+    plusDM.push(0);
+    minusDM.push(0);
+    for (let i = 1; i < prices.length; i++) {
+      const high = highs[i] || prices[i];
+      const low = lows[i] || prices[i];
+      const prevHigh = highs[i - 1] || prices[i - 1];
+      const prevLow = lows[i - 1] || prices[i - 1];
+      const prevClose = prices[i - 1];
+      const tr1 = high - low;
+      const tr2 = Math.abs(high - prevClose);
+      const tr3 = Math.abs(low - prevClose);
+      trueRanges.push(Math.max(tr1, tr2, tr3));
+      const upMove = high - prevHigh;
+      const downMove = prevLow - low;
+      if (upMove > downMove && upMove > 0) {
+        plusDM.push(upMove);
+        minusDM.push(0);
+      } else if (downMove > upMove && downMove > 0) {
+        plusDM.push(0);
+        minusDM.push(downMove);
+      } else {
+        plusDM.push(0);
+        minusDM.push(0);
+      }
+    }
+    const smoothedTR = [];
+    const smoothedPlusDM = [];
+    const smoothedMinusDM = [];
+    let sumTR = 0;
+    let sumPlusDM = 0;
+    let sumMinusDM = 0;
+    for (let i = 0; i < period; i++) {
+      sumTR += trueRanges[i];
+      sumPlusDM += plusDM[i];
+      sumMinusDM += minusDM[i];
+    }
+    smoothedTR.push(sumTR);
+    smoothedPlusDM.push(sumPlusDM);
+    smoothedMinusDM.push(sumMinusDM);
+    for (let i = period; i < trueRanges.length; i++) {
+      const newTR = smoothedTR[smoothedTR.length - 1] - smoothedTR[smoothedTR.length - 1] / period + trueRanges[i];
+      const newPlusDM = smoothedPlusDM[smoothedPlusDM.length - 1] - smoothedPlusDM[smoothedPlusDM.length - 1] / period + plusDM[i];
+      const newMinusDM = smoothedMinusDM[smoothedMinusDM.length - 1] - smoothedMinusDM[smoothedMinusDM.length - 1] / period + minusDM[i];
+      smoothedTR.push(newTR);
+      smoothedPlusDM.push(newPlusDM);
+      smoothedMinusDM.push(newMinusDM);
+    }
+    const plusDI = [];
+    const minusDI = [];
+    for (let i = 0; i < smoothedTR.length; i++) {
+      plusDI.push(smoothedPlusDM[i] / smoothedTR[i] * 100);
+      minusDI.push(smoothedMinusDM[i] / smoothedTR[i] * 100);
+    }
+    const dx = [];
+    for (let i = 0; i < plusDI.length; i++) {
+      const diSum = plusDI[i] + minusDI[i];
+      const diDiff = Math.abs(plusDI[i] - minusDI[i]);
+      dx.push(diSum > 0 ? diDiff / diSum * 100 : 0);
+    }
+    if (dx.length < period) return [];
+    let sumDX = 0;
+    for (let i = 0; i < period; i++) {
+      sumDX += dx[i];
+    }
+    adx.push(sumDX / period);
+    for (let i = period; i < dx.length; i++) {
+      const newADX = adx[adx.length - 1] - adx[adx.length - 1] / period + dx[i];
+      adx.push(newADX);
+    }
+    return adx;
+  }
+  // Calculate DMI (Directional Movement Index)
+  calculateDmi(prices, highs, lows) {
+    if (prices.length < 14) return [];
+    const period = 14;
+    const dmi = [];
+    const trueRanges = [];
+    const plusDM = [];
+    const minusDM = [];
+    trueRanges.push(highs[0] - lows[0]);
+    plusDM.push(0);
+    minusDM.push(0);
+    for (let i = 1; i < prices.length; i++) {
+      const high = highs[i] || prices[i];
+      const low = lows[i] || prices[i];
+      const prevHigh = highs[i - 1] || prices[i - 1];
+      const prevLow = lows[i - 1] || prices[i - 1];
+      const prevClose = prices[i - 1];
+      const tr1 = high - low;
+      const tr2 = Math.abs(high - prevClose);
+      const tr3 = Math.abs(low - prevClose);
+      trueRanges.push(Math.max(tr1, tr2, tr3));
+      const upMove = high - prevHigh;
+      const downMove = prevLow - low;
+      if (upMove > downMove && upMove > 0) {
+        plusDM.push(upMove);
+        minusDM.push(0);
+      } else if (downMove > upMove && downMove > 0) {
+        plusDM.push(0);
+        minusDM.push(downMove);
+      } else {
+        plusDM.push(0);
+        minusDM.push(0);
+      }
+    }
+    const smoothedTR = [];
+    const smoothedPlusDM = [];
+    const smoothedMinusDM = [];
+    let sumTR = 0;
+    let sumPlusDM = 0;
+    let sumMinusDM = 0;
+    for (let i = 0; i < period; i++) {
+      sumTR += trueRanges[i];
+      sumPlusDM += plusDM[i];
+      sumMinusDM += minusDM[i];
+    }
+    smoothedTR.push(sumTR);
+    smoothedPlusDM.push(sumPlusDM);
+    smoothedMinusDM.push(sumMinusDM);
+    for (let i = period; i < trueRanges.length; i++) {
+      const newTR = smoothedTR[smoothedTR.length - 1] - smoothedTR[smoothedTR.length - 1] / period + trueRanges[i];
+      const newPlusDM = smoothedPlusDM[smoothedPlusDM.length - 1] - smoothedPlusDM[smoothedPlusDM.length - 1] / period + plusDM[i];
+      const newMinusDM = smoothedMinusDM[smoothedMinusDM.length - 1] - smoothedMinusDM[smoothedMinusDM.length - 1] / period + minusDM[i];
+      smoothedTR.push(newTR);
+      smoothedPlusDM.push(newPlusDM);
+      smoothedMinusDM.push(newMinusDM);
+    }
+    const plusDI = [];
+    const minusDI = [];
+    for (let i = 0; i < smoothedTR.length; i++) {
+      plusDI.push(smoothedPlusDM[i] / smoothedTR[i] * 100);
+      minusDI.push(smoothedMinusDM[i] / smoothedTR[i] * 100);
+    }
+    const dx = [];
+    for (let i = 0; i < plusDI.length; i++) {
+      const diSum = plusDI[i] + minusDI[i];
+      const diDiff = Math.abs(plusDI[i] - minusDI[i]);
+      dx.push(diSum > 0 ? diDiff / diSum * 100 : 0);
+    }
+    if (dx.length < period) return [];
+    const adx = [];
+    let sumDX = 0;
+    for (let i = 0; i < period; i++) {
+      sumDX += dx[i];
+    }
+    adx.push(sumDX / period);
+    for (let i = period; i < dx.length; i++) {
+      const newADX = adx[adx.length - 1] - adx[adx.length - 1] / period + dx[i];
+      adx.push(newADX);
+    }
+    for (let i = 0; i < adx.length; i++) {
+      dmi.push({
+        plusDI: plusDI[i + period - 1] || 0,
+        minusDI: minusDI[i + period - 1] || 0,
+        adx: adx[i]
+      });
+    }
+    return dmi;
+  }
+  // Calculate Ichimoku Cloud
+  calculateIchimoku(prices, highs, lows) {
+    if (prices.length < 52) return [];
+    const ichimoku = [];
+    const tenkanSen = [];
+    for (let i = 8; i < prices.length; i++) {
+      const periodHigh = Math.max(...highs.slice(i - 8, i + 1));
+      const periodLow = Math.min(...lows.slice(i - 8, i + 1));
+      tenkanSen.push((periodHigh + periodLow) / 2);
+    }
+    const kijunSen = [];
+    for (let i = 25; i < prices.length; i++) {
+      const periodHigh = Math.max(...highs.slice(i - 25, i + 1));
+      const periodLow = Math.min(...lows.slice(i - 25, i + 1));
+      kijunSen.push((periodHigh + periodLow) / 2);
+    }
+    const senkouSpanA = [];
+    for (let i = 0; i < Math.min(tenkanSen.length, kijunSen.length); i++) {
+      senkouSpanA.push((tenkanSen[i] + kijunSen[i]) / 2);
+    }
+    const senkouSpanB = [];
+    for (let i = 51; i < prices.length; i++) {
+      const periodHigh = Math.max(...highs.slice(i - 51, i + 1));
+      const periodLow = Math.min(...lows.slice(i - 51, i + 1));
+      senkouSpanB.push((periodHigh + periodLow) / 2);
+    }
+    const chikouSpan = [];
+    for (let i = 26; i < prices.length; i++) {
+      chikouSpan.push(prices[i - 26]);
+    }
+    const minLength = Math.min(
+      tenkanSen.length,
+      kijunSen.length,
+      senkouSpanA.length,
+      senkouSpanB.length,
+      chikouSpan.length
+    );
+    for (let i = 0; i < minLength; i++) {
+      ichimoku.push({
+        tenkan: tenkanSen[i],
+        kijun: kijunSen[i],
+        senkouA: senkouSpanA[i],
+        senkouB: senkouSpanB[i],
+        chikou: chikouSpan[i]
+      });
+    }
+    return ichimoku;
+  }
+  // Calculate Parabolic SAR
+  calculateParabolicSAR(prices, highs, lows) {
+    if (prices.length < 2) return [];
+    const sar = [];
+    const accelerationFactor = 0.02;
+    const maximumAcceleration = 0.2;
+    let currentSAR = lows[0];
+    let isLong = true;
+    let af = accelerationFactor;
+    let ep = highs[0];
+    sar.push(currentSAR);
+    for (let i = 1; i < prices.length; i++) {
+      const high = highs[i] || prices[i];
+      const low = lows[i] || prices[i];
+      if (isLong) {
+        if (low < currentSAR) {
+          isLong = false;
+          currentSAR = ep;
+          ep = low;
+          af = accelerationFactor;
+        } else {
+          if (high > ep) {
+            ep = high;
+            af = Math.min(af + accelerationFactor, maximumAcceleration);
+          }
+          currentSAR = currentSAR + af * (ep - currentSAR);
+          if (i > 0) {
+            const prevLow = lows[i - 1] || prices[i - 1];
+            currentSAR = Math.min(currentSAR, prevLow);
+          }
+        }
+      } else {
+        if (high > currentSAR) {
+          isLong = true;
+          currentSAR = ep;
+          ep = high;
+          af = accelerationFactor;
+        } else {
+          if (low < ep) {
+            ep = low;
+            af = Math.min(af + accelerationFactor, maximumAcceleration);
+          }
+          currentSAR = currentSAR + af * (ep - currentSAR);
+          if (i > 0) {
+            const prevHigh = highs[i - 1] || prices[i - 1];
+            currentSAR = Math.max(currentSAR, prevHigh);
+          }
+        }
+      }
+      sar.push(currentSAR);
+    }
+    return sar;
+  }
+  // Calculate Stochastic
+  calculateStochastic(prices, highs, lows) {
+    const stochastic = [];
+    const period = 14;
+    const smoothK = 3;
+    const smoothD = 3;
+    if (prices.length < period) return [];
+    const percentK = [];
+    for (let i = period - 1; i < prices.length; i++) {
+      const high = Math.max(...highs.slice(i - period + 1, i + 1));
+      const low = Math.min(...lows.slice(i - period + 1, i + 1));
+      const close = prices[i];
+      const k = (close - low) / (high - low) * 100;
+      percentK.push(k);
+    }
+    const smoothedK = [];
+    for (let i = smoothK - 1; i < percentK.length; i++) {
+      const sum2 = percentK.slice(i - smoothK + 1, i + 1).reduce((a, b) => a + b, 0);
+      smoothedK.push(sum2 / smoothK);
+    }
+    for (let i = smoothD - 1; i < smoothedK.length; i++) {
+      const sum2 = smoothedK.slice(i - smoothD + 1, i + 1).reduce((a, b) => a + b, 0);
+      const d = sum2 / smoothD;
+      stochastic.push({
+        k: smoothedK[i],
+        d
+      });
+    }
+    return stochastic;
+  }
+  // Calculate CCI
+  calculateCci(prices, highs, lows) {
+    const cci = [];
+    const period = 20;
+    if (prices.length < period) return [];
+    for (let i = period - 1; i < prices.length; i++) {
+      const slice = prices.slice(i - period + 1, i + 1);
+      const typicalPrices = slice.map((price, idx) => {
+        const high = highs[i - period + 1 + idx] || price;
+        const low = lows[i - period + 1 + idx] || price;
+        return (high + low + price) / 3;
+      });
+      const sma = typicalPrices.reduce((a, b) => a + b, 0) / period;
+      const meanDeviation = typicalPrices.reduce((sum2, tp) => sum2 + Math.abs(tp - sma), 0) / period;
+      const currentTP = (highs[i] + lows[i] + prices[i]) / 3;
+      const cciValue = meanDeviation !== 0 ? (currentTP - sma) / (0.015 * meanDeviation) : 0;
+      cci.push(cciValue);
+    }
+    return cci;
+  }
+  // Calculate Rate of Change
+  calculateRoc(prices) {
+    const roc = [];
+    for (let i = 10; i < prices.length; i++) {
+      roc.push((prices[i] - prices[i - 10]) / prices[i - 10] * 100);
+    }
+    return roc;
+  }
+  // Calculate Williams %R
+  calculateWilliamsR(prices) {
+    const williamsR = [];
+    const period = 14;
+    if (prices.length < period) return [];
+    for (let i = period - 1; i < prices.length; i++) {
+      const slice = prices.slice(i - period + 1, i + 1);
+      const high = Math.max(...slice);
+      const low = Math.min(...slice);
+      const close = prices[i];
+      const wr = (high - close) / (high - low) * -100;
+      williamsR.push(wr);
+    }
+    return williamsR;
+  }
+  // Calculate Momentum
+  calculateMomentum(prices) {
+    const momentum = [];
+    for (let i = 10; i < prices.length; i++) {
+      momentum.push(prices[i] - prices[i - 10]);
+    }
+    return momentum;
+  }
+  // Calculate Keltner Channels
+  calculateKeltnerChannels(prices, highs, lows) {
+    const keltner = [];
+    const period = 20;
+    const multiplier = 2;
+    if (prices.length < period) return [];
+    const ema = this.calculateEMA(prices, period);
+    const atr = this.calculateAtr(prices, highs, lows);
+    for (let i = 0; i < Math.min(ema.length, atr.length); i++) {
+      const middle = ema[i];
+      const atrValue = atr[i];
+      keltner.push({
+        upper: middle + multiplier * atrValue,
+        middle,
+        lower: middle - multiplier * atrValue
+      });
+    }
+    return keltner;
+  }
+  // Calculate Donchian Channels
+  calculateDonchianChannels(prices) {
+    const donchian = [];
+    for (let i = 20; i < prices.length; i++) {
+      const slice = prices.slice(i - 20, i);
+      donchian.push({
+        upper: Math.max(...slice),
+        middle: (Math.max(...slice) + Math.min(...slice)) / 2,
+        lower: Math.min(...slice)
+      });
+    }
+    return donchian;
+  }
+  // Calculate Chaikin Volatility
+  calculateChaikinVolatility(prices, highs, lows) {
+    const volatility = [];
+    const period = 10;
+    if (prices.length < period * 2) return [];
+    const highLowRange = [];
+    for (let i = 0; i < prices.length; i++) {
+      const high = highs[i] || prices[i];
+      const low = lows[i] || prices[i];
+      highLowRange.push(high - low);
+    }
+    const emaRange = this.calculateEMA(highLowRange, period);
+    for (let i = period; i < emaRange.length; i++) {
+      const currentEMA = emaRange[i];
+      const pastEMA = emaRange[i - period];
+      const volatilityValue = pastEMA !== 0 ? (currentEMA - pastEMA) / pastEMA * 100 : 0;
+      volatility.push(volatilityValue);
+    }
+    return volatility;
+  }
+  // Calculate On Balance Volume
+  calculateObv(volumes) {
+    const obv = [volumes[0]];
+    for (let i = 1; i < volumes.length; i++) {
+      obv.push(obv[i - 1] + volumes[i]);
+    }
+    return obv;
+  }
+  // Calculate Chaikin Money Flow
+  calculateCmf(prices, highs, lows, volumes) {
+    const cmf = [];
+    const period = 20;
+    if (prices.length < period) return [];
+    for (let i = period - 1; i < prices.length; i++) {
+      let totalMoneyFlowVolume = 0;
+      let totalVolume = 0;
+      for (let j = i - period + 1; j <= i; j++) {
+        const high = highs[j] || prices[j];
+        const low = lows[j] || prices[j];
+        const close = prices[j];
+        const volume = volumes[j] || 1;
+        const moneyFlowMultiplier = (close - low - (high - close)) / (high - low);
+        const moneyFlowVolume = moneyFlowMultiplier * volume;
+        totalMoneyFlowVolume += moneyFlowVolume;
+        totalVolume += volume;
+      }
+      const cmfValue = totalVolume !== 0 ? totalMoneyFlowVolume / totalVolume : 0;
+      cmf.push(cmfValue);
+    }
+    return cmf;
+  }
+  // Calculate Accumulation/Distribution Line
+  calculateAdl(prices) {
+    const adl = [0];
+    for (let i = 1; i < prices.length; i++) {
+      const high = this.highs[i] || prices[i];
+      const low = this.lows[i] || prices[i];
+      const close = prices[i];
+      const volume = this.volumes[i] || 1;
+      const moneyFlowMultiplier = (close - low - (high - close)) / (high - low);
+      const moneyFlowVolume = moneyFlowMultiplier * volume;
+      adl.push(adl[i - 1] + moneyFlowVolume);
+    }
+    return adl;
+  }
+  // Calculate Volume Rate of Change
+  calculateVolumeROC() {
+    const volumeROC = [];
+    for (let i = 10; i < this.volumes.length; i++) {
+      volumeROC.push((this.volumes[i] - this.volumes[i - 10]) / this.volumes[i - 10] * 100);
+    }
+    return volumeROC;
+  }
+  // Calculate Money Flow Index
+  calculateMfi(prices, highs, lows, volumes) {
+    const mfi = [];
+    const period = 14;
+    if (prices.length < period + 1) return [];
+    for (let i = period; i < prices.length; i++) {
+      let positiveMoneyFlow = 0;
+      let negativeMoneyFlow = 0;
+      for (let j = i - period + 1; j <= i; j++) {
+        const high = highs[j] || prices[j];
+        const low = lows[j] || prices[j];
+        const close = prices[j];
+        const volume = volumes[j] || 1;
+        const typicalPrice = (high + low + close) / 3;
+        const moneyFlow = typicalPrice * volume;
+        if (j > i - period + 1) {
+          const prevHigh = highs[j - 1] || prices[j - 1];
+          const prevLow = lows[j - 1] || prices[j - 1];
+          const prevClose = prices[j - 1];
+          const prevTypicalPrice = (prevHigh + prevLow + prevClose) / 3;
+          if (typicalPrice > prevTypicalPrice) {
+            positiveMoneyFlow += moneyFlow;
+          } else if (typicalPrice < prevTypicalPrice) {
+            negativeMoneyFlow += moneyFlow;
+          }
+        }
+      }
+      const moneyRatio = negativeMoneyFlow !== 0 ? positiveMoneyFlow / negativeMoneyFlow : 0;
+      const mfiValue = 100 - 100 / (1 + moneyRatio);
+      mfi.push(mfiValue);
+    }
+    return mfi;
+  }
+  // Calculate VWAP
+  calculateVwap(prices, volumes) {
+    const vwap = [];
+    let cumulativePV = 0;
+    let cumulativeVolume = 0;
+    for (let i = 0; i < prices.length; i++) {
+      cumulativePV += prices[i] * (volumes[i] || 1);
+      cumulativeVolume += volumes[i] || 1;
+      vwap.push(cumulativePV / cumulativeVolume);
+    }
+    return vwap;
+  }
+  // Calculate Pivot Points
+  calculatePivotPoints(prices) {
+    const pivotPoints = [];
+    for (let i = 0; i < prices.length; i++) {
+      const high = this.highs[i] || prices[i];
+      const low = this.lows[i] || prices[i];
+      const close = prices[i];
+      const pp = (high + low + close) / 3;
+      const r1 = 2 * pp - low;
+      const s1 = 2 * pp - high;
+      const r2 = pp + (high - low);
+      const s2 = pp - (high - low);
+      const r3 = high + 2 * (pp - low);
+      const s3 = low - 2 * (high - pp);
+      pivotPoints.push({
+        pp,
+        r1,
+        r2,
+        r3,
+        s1,
+        s2,
+        s3
+      });
+    }
+    return pivotPoints;
+  }
+  // Calculate Fibonacci Levels
+  calculateFibonacciLevels(prices) {
+    const fibonacci = [];
+    for (let i = 0; i < prices.length; i++) {
+      const price = prices[i];
+      fibonacci.push({
+        retracement: {
+          level0: price,
+          level236: price * 0.764,
+          level382: price * 0.618,
+          level500: price * 0.5,
+          level618: price * 0.382,
+          level786: price * 0.214,
+          level100: price * 0
+        },
+        extension: {
+          level1272: price * 1.272,
+          level1618: price * 1.618,
+          level2618: price * 2.618,
+          level4236: price * 4.236
+        }
+      });
+    }
+    return fibonacci;
+  }
+  // Calculate Gann Levels
+  calculateGannLevels(prices) {
+    const gannLevels = [];
+    for (let i = 0; i < prices.length; i++) {
+      gannLevels.push(prices[i] * (1 + i * 0.01));
+    }
+    return gannLevels;
+  }
+  // Calculate Elliott Wave
+  calculateElliottWave(prices) {
+    const elliottWave = [];
+    if (prices.length < 10) return [];
+    for (let i = 0; i < prices.length; i++) {
+      const waves = [];
+      let currentWave = 1;
+      let wavePosition = 0.5;
+      if (i >= 4) {
+        const recentPrices = prices.slice(i - 4, i + 1);
+        const swings = this.detectPriceSwings(recentPrices);
+        if (swings.length >= 3) {
+          waves.push(...swings.slice(0, 3));
+          currentWave = Math.min(swings.length, 5);
+          wavePosition = this.calculateWavePosition(recentPrices);
+        }
+      }
+      elliottWave.push({
+        waves: waves.length > 0 ? waves : [prices[i]],
+        currentWave,
+        wavePosition
+      });
+    }
+    return elliottWave;
+  }
+  // Helper method to detect price swings
+  detectPriceSwings(prices) {
+    const swings = [];
+    for (let i = 1; i < prices.length - 1; i++) {
+      const prev = prices[i - 1];
+      const curr = prices[i];
+      const next = prices[i + 1];
+      if (curr > prev && curr > next) {
+        swings.push(curr);
+      } else if (curr < prev && curr < next) {
+        swings.push(curr);
+      }
+    }
+    return swings;
+  }
+  // Helper method to calculate wave position
+  calculateWavePosition(prices) {
+    if (prices.length < 2) return 0.5;
+    const current = prices[prices.length - 1];
+    const min = Math.min(...prices);
+    const max = Math.max(...prices);
+    return max !== min ? (current - min) / (max - min) : 0.5;
+  }
+  // Calculate Harmonic Patterns
+  calculateHarmonicPatterns(prices) {
+    const harmonicPatterns = [];
+    if (prices.length < 5) return [];
+    for (let i = 4; i < prices.length; i++) {
+      const recentPrices = prices.slice(i - 4, i + 1);
+      const pattern = this.detectHarmonicPattern(recentPrices);
+      harmonicPatterns.push(pattern);
+    }
+    return harmonicPatterns;
+  }
+  // Helper method to detect harmonic patterns
+  detectHarmonicPattern(prices) {
+    if (prices.length < 5) {
+      return {
+        type: "Unknown",
+        completion: 0,
+        target: prices[prices.length - 1] * 1.1,
+        stopLoss: prices[prices.length - 1] * 0.9
+      };
+    }
+    const swings = this.detectPriceSwings(prices);
+    if (swings.length < 4) {
+      return {
+        type: "Unknown",
+        completion: 0,
+        target: prices[prices.length - 1] * 1.1,
+        stopLoss: prices[prices.length - 1] * 0.9
+      };
+    }
+    const [A, B, C, D] = swings.slice(-4);
+    const X = prices[0];
+    const abRatio = Math.abs((B - A) / (X - A));
+    const bcRatio = Math.abs((C - B) / (A - B));
+    const cdRatio = Math.abs((D - C) / (B - C));
+    const adRatio = Math.abs((D - A) / (X - A));
+    const isGartley = Math.abs(abRatio - 0.618) < 0.1 && bcRatio >= 0.382 && bcRatio <= 0.886 && cdRatio >= 1.13 && cdRatio <= 1.618 && Math.abs(adRatio - 0.786) < 0.1;
+    if (isGartley) {
+      const completion = this.calculatePatternCompletion(prices);
+      const target = D + (D - C) * 0.618;
+      const stopLoss = D - (D - C) * 0.382;
+      return {
+        type: "Gartley",
+        completion,
+        target,
+        stopLoss
+      };
+    }
+    const isButterfly = Math.abs(abRatio - 0.786) < 0.1 && bcRatio >= 0.382 && bcRatio <= 0.886 && cdRatio >= 1.618 && cdRatio <= 2.618 && Math.abs(adRatio - 1.27) < 0.1;
+    if (isButterfly) {
+      const completion = this.calculatePatternCompletion(prices);
+      const target = D + (D - C) * 1.27;
+      const stopLoss = D - (D - C) * 0.5;
+      return {
+        type: "Butterfly",
+        completion,
+        target,
+        stopLoss
+      };
+    }
+    return {
+      type: "Unknown",
+      completion: 0,
+      target: prices[prices.length - 1] * 1.1,
+      stopLoss: prices[prices.length - 1] * 0.9
+    };
+  }
+  // Helper method to calculate pattern completion
+  calculatePatternCompletion(prices) {
+    if (prices.length < 2) return 0;
+    const current = prices[prices.length - 1];
+    const min = Math.min(...prices);
+    const max = Math.max(...prices);
+    return max !== min ? (current - min) / (max - min) : 0;
+  }
+  // Calculate Position Size
+  calculatePositionSize(currentPrice, targetEntry, stopLoss) {
+    void currentPrice;
+    const riskPerShare = Math.abs(targetEntry - stopLoss);
+    return riskPerShare > 0 ? 100 / riskPerShare : 1;
+  }
+  // Calculate Confidence
+  calculateConfidence(signals) {
+    return Math.min(signals.length * 10, 100);
+  }
+  // Calculate Risk Level
+  calculateRiskLevel(volatility) {
+    if (volatility < 20) return "LOW";
+    if (volatility < 40) return "MEDIUM";
+    return "HIGH";
+  }
+  // Calculate Z-Score
+  calculateZScore(currentPrice, startPrice) {
+    return (currentPrice - startPrice) / (startPrice * 0.1);
+  }
+  // Calculate Ornstein-Uhlenbeck
+  calculateOrnsteinUhlenbeck(currentPrice, startPrice, avgVolume) {
+    const priceChanges = this.calculatePriceChanges();
+    const mean = startPrice;
+    let speed = 0.1;
+    if (priceChanges.length > 1) {
+      const variance = priceChanges.reduce((sum2, change) => sum2 + change * change, 0) / priceChanges.length;
+      speed = Math.max(0.01, Math.min(1, variance * 10));
+    }
+    const volatility = avgVolume * 0.01;
+    return {
+      mean,
+      speed,
+      volatility,
+      currentValue: currentPrice
+    };
+  }
+  // Calculate Kalman Filter
+  calculateKalmanFilter(currentPrice, startPrice, avgVolume) {
+    const measurementNoise = avgVolume * 1e-3;
+    const processNoise = avgVolume * 1e-4;
+    let state = startPrice;
+    let covariance = measurementNoise;
+    const priceChanges = this.calculatePriceChanges();
+    if (priceChanges.length > 0) {
+      const predictedState = state;
+      const predictedCovariance = covariance + processNoise;
+      const kalmanGain = predictedCovariance / (predictedCovariance + measurementNoise);
+      state = predictedState + kalmanGain * (currentPrice - predictedState);
+      covariance = (1 - kalmanGain) * predictedCovariance;
+      return {
+        state,
+        covariance,
+        gain: kalmanGain
+      };
+    }
+    return {
+      state: currentPrice,
+      covariance,
+      gain: 0.5
+    };
+  }
+  // Calculate ARIMA
+  calculateArima(currentPrice) {
+    const priceChanges = this.calculatePriceChanges();
+    if (priceChanges.length < 3) {
+      return {
+        forecast: [currentPrice * 1.01, currentPrice * 1.02],
+        residuals: [0, 0],
+        aic: 100
+      };
+    }
+    const n = priceChanges.length;
+    let sumY = 0;
+    let sumY1 = 0;
+    let sumYY1 = 0;
+    let sumY1Sq = 0;
+    for (let i = 1; i < n; i++) {
+      const y = priceChanges[i];
+      const y1 = priceChanges[i - 1];
+      sumY += y;
+      sumY1 += y1;
+      sumYY1 += y * y1;
+      sumY1Sq += y1 * y1;
+    }
+    const phi = (n * sumYY1 - sumY * sumY1) / (n * sumY1Sq - sumY1 * sumY1);
+    const c = (sumY - phi * sumY1) / n;
+    const residuals = [];
+    for (let i = 1; i < n; i++) {
+      const predicted = c + phi * priceChanges[i - 1];
+      residuals.push(priceChanges[i] - predicted);
+    }
+    const rss = residuals.reduce((sum2, r) => sum2 + r * r, 0);
+    const aic = n * Math.log(rss / n) + 2 * 2;
+    const lastChange = priceChanges[priceChanges.length - 1];
+    const forecast1 = currentPrice + (c + phi * lastChange);
+    const forecast2 = forecast1 + (c + phi * (c + phi * lastChange));
+    return {
+      forecast: [forecast1, forecast2],
+      residuals,
+      aic
+    };
+  }
+  // Calculate GARCH
+  calculateGarch(avgVolume) {
+    const priceChanges = this.calculatePriceChanges();
+    if (priceChanges.length < 5) {
+      return {
+        volatility: avgVolume * 0.01,
+        persistence: 0.9,
+        meanReversion: 0.1
+      };
+    }
+    const squaredReturns = priceChanges.map((change) => change * change);
+    const meanSquaredReturn = squaredReturns.reduce((sum2, sq) => sum2 + sq, 0) / squaredReturns.length;
+    let persistence = 0.9;
+    if (squaredReturns.length > 1) {
+      const variance = squaredReturns.reduce((sum2, sq) => sum2 + sq, 0) / squaredReturns.length;
+      persistence = Math.min(0.99, Math.max(0.5, variance / meanSquaredReturn));
+    }
+    const meanReversion = meanSquaredReturn * (1 - persistence);
+    const volatility = Math.sqrt(meanSquaredReturn);
+    return {
+      volatility,
+      persistence,
+      meanReversion
+    };
+  }
+  // Calculate Hilbert Transform
+  calculateHilbertTransform(currentPrice) {
+    const priceChanges = this.calculatePriceChanges();
+    if (priceChanges.length < 3) {
+      return {
+        analytic: [currentPrice],
+        phase: [0],
+        amplitude: [currentPrice]
+      };
+    }
+    const n = priceChanges.length;
+    const analytic = [];
+    const phase = [];
+    const amplitude = [];
+    for (let i = 0; i < n; i++) {
+      let hilbertValue = 0;
+      for (let j = 0; j < n; j++) {
+        if (i !== j) {
+          hilbertValue += priceChanges[j] / (Math.PI * (i - j));
+        }
+      }
+      const realPart = priceChanges[i];
+      const imagPart = hilbertValue;
+      const analyticValue = Math.sqrt(realPart * realPart + imagPart * imagPart);
+      analytic.push(analyticValue);
+      const phaseValue = Math.atan2(imagPart, realPart);
+      phase.push(phaseValue);
+      amplitude.push(analyticValue);
+    }
+    return {
+      analytic,
+      phase,
+      amplitude
+    };
+  }
+  // Calculate Wavelet Transform
+  calculateWaveletTransform(currentPrice) {
+    const priceChanges = this.calculatePriceChanges();
+    if (priceChanges.length < 4) {
+      return {
+        coefficients: [currentPrice],
+        scales: [1]
+      };
+    }
+    const coefficients = [];
+    const scales = [];
+    const n = priceChanges.length;
+    const maxLevel = Math.floor(Math.log2(n));
+    for (let level = 1; level <= maxLevel; level++) {
+      const step = 2 ** (level - 1);
+      const scale = step;
+      for (let i = 0; i < n - step; i += step * 2) {
+        if (i + step < n) {
+          const coefficient = (priceChanges[i] - priceChanges[i + step]) / Math.sqrt(2);
+          coefficients.push(coefficient);
+          scales.push(scale);
+        }
+      }
+    }
+    if (coefficients.length === 0) {
+      coefficients.push(currentPrice);
+      scales.push(1);
+    }
+    return {
+      coefficients,
+      scales
+    };
+  }
+  // Calculate Black-Scholes
+  calculateBlackScholes(currentPrice, startPrice, avgVolume) {
+    const S = currentPrice;
+    const K = startPrice;
+    const T = 1;
+    const r = 0.05;
+    const sigma = avgVolume * 0.01;
+    const d1 = (Math.log(S / K) + (r + sigma * sigma / 2) * T) / (sigma * Math.sqrt(T));
+    const d2 = d1 - sigma * Math.sqrt(T);
+    const callPrice = S * this.normalCDF(d1) - K * Math.exp(-r * T) * this.normalCDF(d2);
+    const putPrice = K * Math.exp(-r * T) * this.normalCDF(-d2) - S * this.normalCDF(-d1);
+    return {
+      callPrice,
+      putPrice,
+      delta: this.normalCDF(d1),
+      gamma: this.normalPDF(d1) / (S * sigma * Math.sqrt(T)),
+      theta: -S * this.normalPDF(d1) * sigma / (2 * Math.sqrt(T)) - r * K * Math.exp(-r * T) * this.normalCDF(d2),
+      vega: S * Math.sqrt(T) * this.normalPDF(d1),
+      rho: K * T * Math.exp(-r * T) * this.normalCDF(d2)
+    };
+  }
+  // Normal CDF approximation
+  normalCDF(x) {
+    return 0.5 * (1 + this.erf(x / Math.sqrt(2)));
+  }
+  // Normal PDF
+  normalPDF(x) {
+    return Math.exp(-x * x / 2) / Math.sqrt(2 * Math.PI);
+  }
+  // Error function approximation
+  erf(x) {
+    const a1 = 0.254829592;
+    const a2 = -0.284496736;
+    const a3 = 1.421413741;
+    const a4 = -1.453152027;
+    const a5 = 1.061405429;
+    const p = 0.3275911;
+    const sign = x >= 0 ? 1 : -1;
+    const absX = Math.abs(x);
+    const t = 1 / (1 + p * absX);
+    const y = 1 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-absX * absX);
+    return sign * y;
+  }
+  // Calculate price changes for volatility
+  calculatePriceChanges() {
+    const changes = [];
+    for (let i = 1; i < this.prices.length; i++) {
+      changes.push((this.prices[i] - this.prices[i - 1]) / this.prices[i - 1]);
+    }
+    return changes;
+  }
+  // Generate comprehensive market analysis
+  analyze() {
+    const currentPrice = this.prices[this.prices.length - 1];
+    const startPrice = this.prices[0];
+    const sessionHigh = Math.max(...this.highs);
+    const sessionLow = Math.min(...this.lows);
+    const totalVolume = sum(this.volumes);
+    const avgVolume = totalVolume / this.volumes.length;
+    const priceChanges = this.calculatePriceChanges();
+    const volatility = priceChanges.length > 0 ? Math.sqrt(
+      priceChanges.reduce((sum2, change) => sum2 + change ** 2, 0) / priceChanges.length
+    ) * Math.sqrt(252) * 100 : 0;
+    const sessionReturn = (currentPrice - startPrice) / startPrice * 100;
+    const pricePosition = (currentPrice - sessionLow) / (sessionHigh - sessionLow) * 100;
+    const trueVWAP = this.prices.reduce((sum2, price, i) => sum2 + price * this.volumes[i], 0) / totalVolume;
+    const momentum5 = this.prices.length > 5 ? (currentPrice - this.prices[Math.max(0, this.prices.length - 6)]) / this.prices[Math.max(0, this.prices.length - 6)] * 100 : 0;
+    const momentum10 = this.prices.length > 10 ? (currentPrice - this.prices[Math.max(0, this.prices.length - 11)]) / this.prices[Math.max(0, this.prices.length - 11)] * 100 : 0;
+    const maxDrawdown = this.calculateMaxDrawdown(this.prices);
+    const atrValues = this.calculateAtr(this.prices, this.highs, this.lows);
+    const atr = atrValues.length > 0 ? atrValues[atrValues.length - 1] : 0;
+    const impliedVolatility = volatility;
+    const realizedVolatility = volatility;
+    const sharpeRatio = sessionReturn / volatility;
+    const sortinoRatio = sessionReturn / realizedVolatility;
+    const calmarRatio = sessionReturn / maxDrawdown;
+    const maxConsecutiveLosses = this.calculateMaxConsecutiveLosses(this.prices);
+    const winRate = this.calculateWinRate(this.prices);
+    const profitFactor = this.calculateProfitFactor(this.prices);
+    return {
+      currentPrice,
+      startPrice,
+      sessionHigh,
+      sessionLow,
+      totalVolume,
+      avgVolume,
+      volatility,
+      sessionReturn,
+      pricePosition,
+      trueVWAP,
+      momentum5,
+      momentum10,
+      maxDrawdown,
+      atr,
+      impliedVolatility,
+      realizedVolatility,
+      sharpeRatio,
+      sortinoRatio,
+      calmarRatio,
+      maxConsecutiveLosses,
+      winRate,
+      profitFactor
+    };
+  }
+  // Generate technical indicators
+  getTechnicalIndicators() {
+    return {
+      sma5: this.calculateSMA(this.prices, 5),
+      sma10: this.calculateSMA(this.prices, 10),
+      sma20: this.calculateSMA(this.prices, 20),
+      sma50: this.calculateSMA(this.prices, 50),
+      sma200: this.calculateSMA(this.prices, 200),
+      ema8: this.calculateEMA(this.prices, 8),
+      ema12: this.calculateEMA(this.prices, 12),
+      ema21: this.calculateEMA(this.prices, 21),
+      ema26: this.calculateEMA(this.prices, 26),
+      wma20: this.calculateWma(this.prices, 20),
+      vwma20: this.calculateVwma(this.prices, 20),
+      macd: this.calculateMacd(this.prices),
+      adx: this.calculateAdx(this.prices, this.highs, this.lows),
+      dmi: this.calculateDmi(this.prices, this.highs, this.lows),
+      ichimoku: this.calculateIchimoku(this.prices, this.highs, this.lows),
+      parabolicSAR: this.calculateParabolicSAR(this.prices, this.highs, this.lows),
+      rsi: this.calculateRSI(this.prices, 14),
+      stochastic: this.calculateStochastic(this.prices, this.highs, this.lows),
+      cci: this.calculateCci(this.prices, this.highs, this.lows),
+      roc: this.calculateRoc(this.prices),
+      williamsR: this.calculateWilliamsR(this.prices),
+      momentum: this.calculateMomentum(this.prices),
+      bollinger: this.calculateBollingerBands(this.prices, 20, 2),
+      atr: this.calculateAtr(this.prices, this.highs, this.lows),
+      keltner: this.calculateKeltnerChannels(this.prices, this.highs, this.lows),
+      donchian: this.calculateDonchianChannels(this.prices),
+      chaikinVolatility: this.calculateChaikinVolatility(this.prices, this.highs, this.lows),
+      obv: this.calculateObv(this.volumes),
+      cmf: this.calculateCmf(this.prices, this.highs, this.lows, this.volumes),
+      adl: this.calculateAdl(this.prices),
+      volumeROC: this.calculateVolumeROC(),
+      mfi: this.calculateMfi(this.prices, this.highs, this.lows, this.volumes),
+      vwap: this.calculateVwap(this.prices, this.volumes),
+      pivotPoints: this.calculatePivotPoints(this.prices),
+      fibonacci: this.calculateFibonacciLevels(this.prices),
+      gannLevels: this.calculateGannLevels(this.prices),
+      elliottWave: this.calculateElliottWave(this.prices),
+      harmonicPatterns: this.calculateHarmonicPatterns(this.prices)
+    };
+  }
+  // Generate trading signals
+  generateSignals() {
+    const analysis = this.analyze();
+    let bullishSignals = 0;
+    let bearishSignals = 0;
+    const signals = [];
+    if (analysis.currentPrice > analysis.trueVWAP) {
+      signals.push(
+        `\u2713 BULLISH: Price above VWAP (+${((analysis.currentPrice - analysis.trueVWAP) / analysis.trueVWAP * 100).toFixed(2)}%)`
+      );
+      bullishSignals++;
+    } else {
+      signals.push(
+        `\u2717 BEARISH: Price below VWAP (${((analysis.currentPrice - analysis.trueVWAP) / analysis.trueVWAP * 100).toFixed(2)}%)`
+      );
+      bearishSignals++;
+    }
+    if (analysis.momentum5 > 0 && analysis.momentum10 > 0) {
+      signals.push("\u2713 BULLISH: Positive momentum on both timeframes");
+      bullishSignals++;
+    } else if (analysis.momentum5 < 0 && analysis.momentum10 < 0) {
+      signals.push("\u2717 BEARISH: Negative momentum on both timeframes");
+      bearishSignals++;
+    } else {
+      signals.push("\u25D0 MIXED: Conflicting momentum signals");
+    }
+    const currentVolume = this.volumes[this.volumes.length - 1];
+    const volumeRatio = currentVolume / analysis.avgVolume;
+    if (volumeRatio > 1.2 && analysis.sessionReturn > 0) {
+      signals.push("\u2713 BULLISH: Above-average volume supporting upward move");
+      bullishSignals++;
+    } else if (volumeRatio > 1.2 && analysis.sessionReturn < 0) {
+      signals.push("\u2717 BEARISH: Above-average volume supporting downward move");
+      bearishSignals++;
+    } else {
+      signals.push("\u25D0 NEUTRAL: Volume not providing clear direction");
+    }
+    if (analysis.pricePosition > 65 && analysis.volatility > 30) {
+      signals.push("\u2717 BEARISH: High in range with elevated volatility - reversal risk");
+      bearishSignals++;
+    } else if (analysis.pricePosition < 35 && analysis.volatility > 30) {
+      signals.push("\u2713 BULLISH: Low in range with volatility - potential bounce");
+      bullishSignals++;
+    } else {
+      signals.push("\u25D0 NEUTRAL: Price position and volatility not extreme");
+    }
+    return { bullishSignals, bearishSignals, signals };
+  }
+  // Generate comprehensive JSON analysis
+  generateJSONAnalysis(symbol) {
+    const analysis = this.analyze();
+    const indicators = this.getTechnicalIndicators();
+    const signals = this.generateSignals();
+    const currentSMA5 = indicators.sma5.length > 0 ? indicators.sma5[indicators.sma5.length - 1] : null;
+    const currentSMA10 = indicators.sma10.length > 0 ? indicators.sma10[indicators.sma10.length - 1] : null;
+    const currentSMA20 = indicators.sma20.length > 0 ? indicators.sma20[indicators.sma20.length - 1] : null;
+    const currentSMA50 = indicators.sma50.length > 0 ? indicators.sma50[indicators.sma50.length - 1] : null;
+    const currentSMA200 = indicators.sma200.length > 0 ? indicators.sma200[indicators.sma200.length - 1] : null;
+    const currentEMA8 = indicators.ema8[indicators.ema8.length - 1];
+    const currentEMA12 = indicators.ema12[indicators.ema12.length - 1];
+    const currentEMA21 = indicators.ema21[indicators.ema21.length - 1];
+    const currentEMA26 = indicators.ema26[indicators.ema26.length - 1];
+    const currentWMA20 = indicators.wma20.length > 0 ? indicators.wma20[indicators.wma20.length - 1] : null;
+    const currentVWMA20 = indicators.vwma20.length > 0 ? indicators.vwma20[indicators.vwma20.length - 1] : null;
+    const currentMACD = indicators.macd.length > 0 ? indicators.macd[indicators.macd.length - 1] : null;
+    const currentADX = indicators.adx.length > 0 ? indicators.adx[indicators.adx.length - 1] : null;
+    const currentDMI = indicators.dmi.length > 0 ? indicators.dmi[indicators.dmi.length - 1] : null;
+    const currentIchimoku = indicators.ichimoku.length > 0 ? indicators.ichimoku[indicators.ichimoku.length - 1] : null;
+    const currentParabolicSAR = indicators.parabolicSAR.length > 0 ? indicators.parabolicSAR[indicators.parabolicSAR.length - 1] : null;
+    const currentRSI = indicators.rsi.length > 0 ? indicators.rsi[indicators.rsi.length - 1] : null;
+    const currentStochastic = indicators.stochastic.length > 0 ? indicators.stochastic[indicators.stochastic.length - 1] : null;
+    const currentCCI = indicators.cci.length > 0 ? indicators.cci[indicators.cci.length - 1] : null;
+    const currentROC = indicators.roc.length > 0 ? indicators.roc[indicators.roc.length - 1] : null;
+    const currentWilliamsR = indicators.williamsR.length > 0 ? indicators.williamsR[indicators.williamsR.length - 1] : null;
+    const currentMomentum = indicators.momentum.length > 0 ? indicators.momentum[indicators.momentum.length - 1] : null;
+    const currentBB = indicators.bollinger.length > 0 ? indicators.bollinger[indicators.bollinger.length - 1] : null;
+    const currentAtr = indicators.atr.length > 0 ? indicators.atr[indicators.atr.length - 1] : null;
+    const currentKeltner = indicators.keltner.length > 0 ? indicators.keltner[indicators.keltner.length - 1] : null;
+    const currentDonchian = indicators.donchian.length > 0 ? indicators.donchian[indicators.donchian.length - 1] : null;
+    const currentChaikinVolatility = indicators.chaikinVolatility.length > 0 ? indicators.chaikinVolatility[indicators.chaikinVolatility.length - 1] : null;
+    const currentObv = indicators.obv.length > 0 ? indicators.obv[indicators.obv.length - 1] : null;
+    const currentCmf = indicators.cmf.length > 0 ? indicators.cmf[indicators.cmf.length - 1] : null;
+    const currentAdl = indicators.adl.length > 0 ? indicators.adl[indicators.adl.length - 1] : null;
+    const currentVolumeROC = indicators.volumeROC.length > 0 ? indicators.volumeROC[indicators.volumeROC.length - 1] : null;
+    const currentMfi = indicators.mfi.length > 0 ? indicators.mfi[indicators.mfi.length - 1] : null;
+    const currentVwap = indicators.vwap.length > 0 ? indicators.vwap[indicators.vwap.length - 1] : null;
+    const currentPivotPoints = indicators.pivotPoints.length > 0 ? indicators.pivotPoints[indicators.pivotPoints.length - 1] : null;
+    const currentFibonacci = indicators.fibonacci.length > 0 ? indicators.fibonacci[indicators.fibonacci.length - 1] : null;
+    const currentGannLevels = indicators.gannLevels.length > 0 ? indicators.gannLevels : [];
+    const currentElliottWave = indicators.elliottWave.length > 0 ? indicators.elliottWave[indicators.elliottWave.length - 1] : null;
+    const currentHarmonicPatterns = indicators.harmonicPatterns.length > 0 ? indicators.harmonicPatterns : [];
+    const currentVolume = this.volumes[this.volumes.length - 1];
+    const volumeRatio = currentVolume / analysis.avgVolume;
+    const currentDrawdown = (analysis.sessionHigh - analysis.currentPrice) / analysis.sessionHigh * 100;
+    const rangeWidth = (analysis.sessionHigh - analysis.sessionLow) / analysis.sessionLow * 100;
+    const priceVsVWAP = (analysis.currentPrice - analysis.trueVWAP) / analysis.trueVWAP * 100;
+    const totalScore = signals.bullishSignals - signals.bearishSignals;
+    const overallSignal = totalScore > 0 ? "BULLISH_BIAS" : totalScore < 0 ? "BEARISH_BIAS" : "NEUTRAL";
+    const targetEntry = Math.max(analysis.sessionLow * 1.005, analysis.trueVWAP * 0.998);
+    const stopLoss = analysis.sessionLow * 0.995;
+    const profitTarget = analysis.sessionHigh * 0.995;
+    const riskRewardRatio = (profitTarget - analysis.currentPrice) / (analysis.currentPrice - stopLoss);
+    const positionSize = this.calculatePositionSize(analysis.currentPrice, targetEntry, stopLoss);
+    const maxRisk = positionSize * (targetEntry - stopLoss);
+    return {
+      symbol,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      marketStructure: {
+        currentPrice: analysis.currentPrice,
+        startPrice: analysis.startPrice,
+        sessionHigh: analysis.sessionHigh,
+        sessionLow: analysis.sessionLow,
+        rangeWidth,
+        totalVolume: analysis.totalVolume,
+        sessionPerformance: analysis.sessionReturn,
+        positionInRange: analysis.pricePosition
+      },
+      volatility: {
+        impliedVolatility: analysis.impliedVolatility,
+        realizedVolatility: analysis.realizedVolatility,
+        atr: analysis.atr,
+        maxDrawdown: analysis.maxDrawdown * 100,
+        currentDrawdown
+      },
+      technicalIndicators: {
+        sma5: currentSMA5,
+        sma10: currentSMA10,
+        sma20: currentSMA20,
+        sma50: currentSMA50,
+        sma200: currentSMA200,
+        ema8: currentEMA8,
+        ema12: currentEMA12,
+        ema21: currentEMA21,
+        ema26: currentEMA26,
+        wma20: currentWMA20,
+        vwma20: currentVWMA20,
+        macd: currentMACD,
+        adx: currentADX,
+        dmi: currentDMI,
+        ichimoku: currentIchimoku,
+        parabolicSAR: currentParabolicSAR,
+        rsi: currentRSI,
+        stochastic: currentStochastic,
+        cci: currentCCI,
+        roc: currentROC,
+        williamsR: currentWilliamsR,
+        momentum: currentMomentum,
+        bollingerBands: currentBB ? {
+          upper: currentBB.upper,
+          middle: currentBB.middle,
+          lower: currentBB.lower,
+          bandwidth: currentBB.bandwidth,
+          percentB: currentBB.percentB
+        } : null,
+        atr: currentAtr,
+        keltnerChannels: currentKeltner ? {
+          upper: currentKeltner.upper,
+          middle: currentKeltner.middle,
+          lower: currentKeltner.lower
+        } : null,
+        donchianChannels: currentDonchian ? {
+          upper: currentDonchian.upper,
+          middle: currentDonchian.middle,
+          lower: currentDonchian.lower
+        } : null,
+        chaikinVolatility: currentChaikinVolatility,
+        obv: currentObv,
+        cmf: currentCmf,
+        adl: currentAdl,
+        volumeROC: currentVolumeROC,
+        mfi: currentMfi,
+        vwap: currentVwap
+      },
+      volumeAnalysis: {
+        currentVolume,
+        averageVolume: Math.round(analysis.avgVolume),
+        volumeRatio,
+        trueVWAP: analysis.trueVWAP,
+        priceVsVWAP,
+        obv: currentObv,
+        cmf: currentCmf,
+        mfi: currentMfi
+      },
+      momentum: {
+        momentum5: analysis.momentum5,
+        momentum10: analysis.momentum10,
+        sessionROC: analysis.sessionReturn,
+        rsi: currentRSI,
+        stochastic: currentStochastic,
+        cci: currentCCI
+      },
+      supportResistance: {
+        pivotPoints: currentPivotPoints,
+        fibonacci: currentFibonacci,
+        gannLevels: currentGannLevels,
+        elliottWave: currentElliottWave,
+        harmonicPatterns: currentHarmonicPatterns
+      },
+      tradingSignals: {
+        ...signals,
+        overallSignal,
+        signalScore: totalScore,
+        confidence: this.calculateConfidence(signals.signals),
+        riskLevel: this.calculateRiskLevel(analysis.volatility)
+      },
+      statisticalModels: {
+        zScore: this.calculateZScore(analysis.currentPrice, analysis.startPrice),
+        ornsteinUhlenbeck: this.calculateOrnsteinUhlenbeck(
+          analysis.currentPrice,
+          analysis.startPrice,
+          analysis.avgVolume
+        ),
+        kalmanFilter: this.calculateKalmanFilter(
+          analysis.currentPrice,
+          analysis.startPrice,
+          analysis.avgVolume
+        ),
+        arima: this.calculateArima(analysis.currentPrice),
+        garch: this.calculateGarch(analysis.avgVolume),
+        hilbertTransform: this.calculateHilbertTransform(analysis.currentPrice),
+        waveletTransform: this.calculateWaveletTransform(analysis.currentPrice)
+      },
+      optionsAnalysis: (() => {
+        const blackScholes = this.calculateBlackScholes(
+          analysis.currentPrice,
+          analysis.startPrice,
+          analysis.avgVolume
+        );
+        if (!blackScholes) return null;
+        return {
+          blackScholes,
+          impliedVolatility: analysis.impliedVolatility,
+          delta: blackScholes.delta,
+          gamma: blackScholes.gamma,
+          theta: blackScholes.theta,
+          vega: blackScholes.vega,
+          rho: blackScholes.rho,
+          greeks: {
+            delta: blackScholes.delta,
+            gamma: blackScholes.gamma,
+            theta: blackScholes.theta,
+            vega: blackScholes.vega,
+            rho: blackScholes.rho
+          }
+        };
+      })(),
+      riskManagement: {
+        targetEntry,
+        stopLoss,
+        profitTarget,
+        riskRewardRatio,
+        positionSize,
+        maxRisk
+      },
+      performance: {
+        sharpeRatio: analysis.sharpeRatio,
+        sortinoRatio: analysis.sortinoRatio,
+        calmarRatio: analysis.calmarRatio,
+        maxDrawdown: analysis.maxDrawdown * 100,
+        winRate: analysis.winRate,
+        profitFactor: analysis.profitFactor,
+        totalReturn: analysis.sessionReturn,
+        volatility: analysis.volatility
+      }
+    };
   }
 };
+var createTechnicalAnalysisHandler = (marketDataPrices) => {
+  return async (args) => {
+    try {
+      const symbol = args.symbol;
+      const priceHistory = marketDataPrices.get(symbol) || [];
+      if (priceHistory.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No price data available for ${symbol}. Please request market data first.`,
+              uri: "technicalAnalysis"
+            }
+          ]
+        };
+      }
+      const hasValidData = priceHistory.every(
+        (entry) => typeof entry.trade === "number" && !Number.isNaN(entry.trade) && typeof entry.midPrice === "number" && !Number.isNaN(entry.midPrice)
+      );
+      if (!hasValidData) {
+        throw new Error("Invalid market data");
+      }
+      const analyzer = new TechnicalAnalyzer(priceHistory);
+      const analysis = analyzer.generateJSONAnalysis(symbol);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Technical Analysis for ${symbol}:
+
+${JSON.stringify(analysis, null, 2)}`,
+            uri: "technicalAnalysis"
+          }
+        ]
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error performing technical analysis: ${error instanceof Error ? error.message : "Unknown error"}`,
+            uri: "technicalAnalysis"
+          }
+        ],
+        isError: true
+      };
+    }
+  };
+};
 
 // src/tools/marketData.ts
 var import_fixparser = require("fixparser");
@@ -319,10 +1878,63 @@ var import_quickchart_js = __toESM(require("quickchart-js"), 1);
 var createMarketDataRequestHandler = (parser, pendingRequests) => {
   return async (args) => {
     try {
+      parser.logger.log({
+        level: "info",
+        message: `Sending market data request for symbols: ${args.symbols.join(", ")}`
+      });
       const response = new Promise((resolve) => {
         pendingRequests.set(args.mdReqID, resolve);
+        parser.logger.log({
+          level: "info",
+          message: `Registered callback for market data request ID: ${args.mdReqID}`
+        });
       });
-      const entryTypes = args.mdEntryTypes || [import_fixparser.MDEntryType.Bid, import_fixparser.MDEntryType.Offer, import_fixparser.MDEntryType.TradeVolume];
+      const entryTypes = args.mdEntryTypes || [
+        import_fixparser.MDEntryType.Bid,
+        import_fixparser.MDEntryType.Offer,
+        import_fixparser.MDEntryType.Trade,
+        import_fixparser.MDEntryType.IndexValue,
+        import_fixparser.MDEntryType.OpeningPrice,
+        import_fixparser.MDEntryType.ClosingPrice,
+        import_fixparser.MDEntryType.SettlementPrice,
+        import_fixparser.MDEntryType.TradingSessionHighPrice,
+        import_fixparser.MDEntryType.TradingSessionLowPrice,
+        import_fixparser.MDEntryType.VWAP,
+        import_fixparser.MDEntryType.Imbalance,
+        import_fixparser.MDEntryType.TradeVolume,
+        import_fixparser.MDEntryType.OpenInterest,
+        import_fixparser.MDEntryType.CompositeUnderlyingPrice,
+        import_fixparser.MDEntryType.SimulatedSellPrice,
+        import_fixparser.MDEntryType.SimulatedBuyPrice,
+        import_fixparser.MDEntryType.MarginRate,
+        import_fixparser.MDEntryType.MidPrice,
+        import_fixparser.MDEntryType.EmptyBook,
+        import_fixparser.MDEntryType.SettleHighPrice,
+        import_fixparser.MDEntryType.SettleLowPrice,
+        import_fixparser.MDEntryType.PriorSettlePrice,
+        import_fixparser.MDEntryType.SessionHighBid,
+        import_fixparser.MDEntryType.SessionLowOffer,
+        import_fixparser.MDEntryType.EarlyPrices,
+        import_fixparser.MDEntryType.AuctionClearingPrice,
+        import_fixparser.MDEntryType.SwapValueFactor,
+        import_fixparser.MDEntryType.DailyValueAdjustmentForLongPositions,
+        import_fixparser.MDEntryType.CumulativeValueAdjustmentForLongPositions,
+        import_fixparser.MDEntryType.DailyValueAdjustmentForShortPositions,
+        import_fixparser.MDEntryType.CumulativeValueAdjustmentForShortPositions,
+        import_fixparser.MDEntryType.FixingPrice,
+        import_fixparser.MDEntryType.CashRate,
+        import_fixparser.MDEntryType.RecoveryRate,
+        import_fixparser.MDEntryType.RecoveryRateForLong,
+        import_fixparser.MDEntryType.RecoveryRateForShort,
+        import_fixparser.MDEntryType.MarketBid,
+        import_fixparser.MDEntryType.MarketOffer,
+        import_fixparser.MDEntryType.ShortSaleMinPrice,
+        import_fixparser.MDEntryType.PreviousClosingPrice,
+        import_fixparser.MDEntryType.ThresholdLimitPriceBanding,
+        import_fixparser.MDEntryType.DailyFinancingValue,
+        import_fixparser.MDEntryType.AccruedFinancingValue,
+        import_fixparser.MDEntryType.TWAP
+      ];
       const messageFields = [
         new import_fixparser.Field(import_fixparser.Fields.MsgType, import_fixparser.Messages.MarketDataRequest),
         new import_fixparser.Field(import_fixparser.Fields.SenderCompID, parser.sender),
@@ -344,6 +1956,10 @@ var createMarketDataRequestHandler = (parser, pendingRequests) => {
       });
       const mdr = parser.createMessage(...messageFields);
       if (!parser.connected) {
+        parser.logger.log({
+          level: "error",
+          message: "Not connected. Cannot send market data request."
+        });
         return {
           content: [
             {
@@ -355,8 +1971,16 @@ var createMarketDataRequestHandler = (parser, pendingRequests) => {
           isError: true
         };
       }
+      parser.logger.log({
+        level: "info",
+        message: `Sending market data request message: ${JSON.stringify(mdr?.toFIXJSON())}`
+      });
       parser.send(mdr);
       const fixData = await response;
+      parser.logger.log({
+        level: "info",
+        message: `Received market data response for request ID: ${args.mdReqID}`
+      });
       return {
         content: [
           {
@@ -380,6 +2004,72 @@ var createMarketDataRequestHandler = (parser, pendingRequests) => {
     }
   };
 };
+var aggregateMarketData = (priceHistory, maxPoints = 490) => {
+  if (priceHistory.length <= maxPoints) {
+    return priceHistory;
+  }
+  const result = [];
+  const step = priceHistory.length / maxPoints;
+  result.push(priceHistory[0]);
+  for (let i = 1; i < maxPoints - 1; i++) {
+    const startIndex = Math.floor(i * step);
+    const endIndex = Math.floor((i + 1) * step);
+    const segment = priceHistory.slice(startIndex, endIndex);
+    if (segment.length === 0) continue;
+    const aggregatedPoint = {
+      timestamp: segment[0].timestamp,
+      // Use timestamp of first point in segment
+      bid: segment.reduce((sum2, p) => sum2 + p.bid, 0) / segment.length,
+      offer: segment.reduce((sum2, p) => sum2 + p.offer, 0) / segment.length,
+      spread: segment.reduce((sum2, p) => sum2 + p.spread, 0) / segment.length,
+      volume: segment.reduce((sum2, p) => sum2 + p.volume, 0) / segment.length,
+      trade: segment.reduce((sum2, p) => sum2 + p.trade, 0) / segment.length,
+      indexValue: segment.reduce((sum2, p) => sum2 + p.indexValue, 0) / segment.length,
+      openingPrice: segment.reduce((sum2, p) => sum2 + p.openingPrice, 0) / segment.length,
+      closingPrice: segment.reduce((sum2, p) => sum2 + p.closingPrice, 0) / segment.length,
+      settlementPrice: segment.reduce((sum2, p) => sum2 + p.settlementPrice, 0) / segment.length,
+      tradingSessionHighPrice: segment.reduce((sum2, p) => sum2 + p.tradingSessionHighPrice, 0) / segment.length,
+      tradingSessionLowPrice: segment.reduce((sum2, p) => sum2 + p.tradingSessionLowPrice, 0) / segment.length,
+      vwap: segment.reduce((sum2, p) => sum2 + p.vwap, 0) / segment.length,
+      imbalance: segment.reduce((sum2, p) => sum2 + p.imbalance, 0) / segment.length,
+      openInterest: segment.reduce((sum2, p) => sum2 + p.openInterest, 0) / segment.length,
+      compositeUnderlyingPrice: segment.reduce((sum2, p) => sum2 + p.compositeUnderlyingPrice, 0) / segment.length,
+      simulatedSellPrice: segment.reduce((sum2, p) => sum2 + p.simulatedSellPrice, 0) / segment.length,
+      simulatedBuyPrice: segment.reduce((sum2, p) => sum2 + p.simulatedBuyPrice, 0) / segment.length,
+      marginRate: segment.reduce((sum2, p) => sum2 + p.marginRate, 0) / segment.length,
+      midPrice: segment.reduce((sum2, p) => sum2 + p.midPrice, 0) / segment.length,
+      emptyBook: segment.reduce((sum2, p) => sum2 + p.emptyBook, 0) / segment.length,
+      settleHighPrice: segment.reduce((sum2, p) => sum2 + p.settleHighPrice, 0) / segment.length,
+      settleLowPrice: segment.reduce((sum2, p) => sum2 + p.settleLowPrice, 0) / segment.length,
+      priorSettlePrice: segment.reduce((sum2, p) => sum2 + p.priorSettlePrice, 0) / segment.length,
+      sessionHighBid: segment.reduce((sum2, p) => sum2 + p.sessionHighBid, 0) / segment.length,
+      sessionLowOffer: segment.reduce((sum2, p) => sum2 + p.sessionLowOffer, 0) / segment.length,
+      earlyPrices: segment.reduce((sum2, p) => sum2 + p.earlyPrices, 0) / segment.length,
+      auctionClearingPrice: segment.reduce((sum2, p) => sum2 + p.auctionClearingPrice, 0) / segment.length,
+      swapValueFactor: segment.reduce((sum2, p) => sum2 + p.swapValueFactor, 0) / segment.length,
+      dailyValueAdjustmentForLongPositions: segment.reduce((sum2, p) => sum2 + p.dailyValueAdjustmentForLongPositions, 0) / segment.length,
+      cumulativeValueAdjustmentForLongPositions: segment.reduce((sum2, p) => sum2 + p.cumulativeValueAdjustmentForLongPositions, 0) / segment.length,
+      dailyValueAdjustmentForShortPositions: segment.reduce((sum2, p) => sum2 + p.dailyValueAdjustmentForShortPositions, 0) / segment.length,
+      cumulativeValueAdjustmentForShortPositions: segment.reduce((sum2, p) => sum2 + p.cumulativeValueAdjustmentForShortPositions, 0) / segment.length,
+      fixingPrice: segment.reduce((sum2, p) => sum2 + p.fixingPrice, 0) / segment.length,
+      cashRate: segment.reduce((sum2, p) => sum2 + p.cashRate, 0) / segment.length,
+      recoveryRate: segment.reduce((sum2, p) => sum2 + p.recoveryRate, 0) / segment.length,
+      recoveryRateForLong: segment.reduce((sum2, p) => sum2 + p.recoveryRateForLong, 0) / segment.length,
+      recoveryRateForShort: segment.reduce((sum2, p) => sum2 + p.recoveryRateForShort, 0) / segment.length,
+      marketBid: segment.reduce((sum2, p) => sum2 + p.marketBid, 0) / segment.length,
+      marketOffer: segment.reduce((sum2, p) => sum2 + p.marketOffer, 0) / segment.length,
+      shortSaleMinPrice: segment.reduce((sum2, p) => sum2 + p.shortSaleMinPrice, 0) / segment.length,
+      previousClosingPrice: segment.reduce((sum2, p) => sum2 + p.previousClosingPrice, 0) / segment.length,
+      thresholdLimitPriceBanding: segment.reduce((sum2, p) => sum2 + p.thresholdLimitPriceBanding, 0) / segment.length,
+      dailyFinancingValue: segment.reduce((sum2, p) => sum2 + p.dailyFinancingValue, 0) / segment.length,
+      accruedFinancingValue: segment.reduce((sum2, p) => sum2 + p.accruedFinancingValue, 0) / segment.length,
+      twap: segment.reduce((sum2, p) => sum2 + p.twap, 0) / segment.length
+    };
+    result.push(aggregatedPoint);
+  }
+  result.push(priceHistory[priceHistory.length - 1]);
+  return result;
+};
 var createGetStockGraphHandler = (marketDataPrices) => {
   return async (args) => {
     try {
@@ -396,15 +2086,22 @@ var createGetStockGraphHandler = (marketDataPrices) => {
           ]
         };
       }
+      const aggregatedData = aggregateMarketData(priceHistory, 500);
       const chart = new import_quickchart_js.default();
       chart.setWidth(1200);
       chart.setHeight(600);
       chart.setBackgroundColor("transparent");
-      const labels = priceHistory.map((point) => new Date(point.timestamp).toLocaleTimeString());
-      const bidData = priceHistory.map((point) => point.bid);
-      const offerData = priceHistory.map((point) => point.offer);
-      const spreadData = priceHistory.map((point) => point.spread);
-      const volumeData = priceHistory.map((point) => point.volume);
+      const labels = aggregatedData.map((point) => new Date(point.timestamp).toLocaleTimeString());
+      const bidData = aggregatedData.map((point) => point.bid);
+      const offerData = aggregatedData.map((point) => point.offer);
+      const spreadData = aggregatedData.map((point) => point.spread);
+      const volumeData = aggregatedData.map((point) => point.volume);
+      const tradeData = aggregatedData.map((point) => point.trade);
+      const vwapData = aggregatedData.map((point) => point.vwap);
+      const twapData = aggregatedData.map((point) => point.twap);
+      const maxVolume = Math.max(...volumeData.filter((v) => v > 0));
+      const maxPrice = Math.max(...bidData, ...offerData, ...tradeData, ...vwapData, ...twapData);
+      const normalizedVolumeData = volumeData.map((v) => v / maxVolume * maxPrice * 0.3);
       const config = {
         type: "line",
         data: {
@@ -435,8 +2132,32 @@ var createGetStockGraphHandler = (marketDataPrices) => {
               tension: 0.4
             },
             {
-              label: "Volume",
-              data: volumeData,
+              label: "Trade",
+              data: tradeData,
+              borderColor: "#ffc107",
+              backgroundColor: "rgba(255, 193, 7, 0.1)",
+              fill: false,
+              tension: 0.4
+            },
+            {
+              label: "VWAP",
+              data: vwapData,
+              borderColor: "#17a2b8",
+              backgroundColor: "rgba(23, 162, 184, 0.1)",
+              fill: false,
+              tension: 0.4
+            },
+            {
+              label: "TWAP",
+              data: twapData,
+              borderColor: "#6610f2",
+              backgroundColor: "rgba(102, 16, 242, 0.1)",
+              fill: false,
+              tension: 0.4
+            },
+            {
+              label: "Volume (Normalized)",
+              data: normalizedVolumeData,
               borderColor: "#007bff",
               backgroundColor: "rgba(0, 123, 255, 0.1)",
               fill: true,
@@ -449,12 +2170,16 @@ var createGetStockGraphHandler = (marketDataPrices) => {
           plugins: {
             title: {
               display: true,
-              text: `${symbol} Market Data`
+              text: `${symbol} Market Data (Volume normalized to 30% of max price)`
             }
           },
           scales: {
             y: {
-              beginAtZero: false
+              beginAtZero: false,
+              title: {
+                display: true,
+                text: "Price / Normalized Volume"
+              }
             }
           }
         }
@@ -479,7 +2204,7 @@ var createGetStockGraphHandler = (marketDataPrices) => {
         content: [
           {
             type: "text",
-            text: `Error: ${error instanceof Error ? error.message : "Failed to generate chart"}`,
+            text: `Error: ${error instanceof Error ? error.message : "Failed to generate graph"}`,
             uri: "getStockGraph"
           }
         ],
@@ -504,6 +2229,7 @@ var createGetStockPriceHistoryHandler = (marketDataPrices) => {
           ]
         };
       }
+      const aggregatedData = aggregateMarketData(priceHistory, 500);
       return {
         content: [
           {
@@ -511,13 +2237,55 @@ var createGetStockPriceHistoryHandler = (marketDataPrices) => {
             text: JSON.stringify(
               {
                 symbol,
-                count: priceHistory.length,
-                data: priceHistory.map((point) => ({
+                count: aggregatedData.length,
+                originalCount: priceHistory.length,
+                data: aggregatedData.map((point) => ({
                   timestamp: new Date(point.timestamp).toISOString(),
                   bid: point.bid,
                   offer: point.offer,
                   spread: point.spread,
-                  volume: point.volume
+                  volume: point.volume,
+                  trade: point.trade,
+                  indexValue: point.indexValue,
+                  openingPrice: point.openingPrice,
+                  closingPrice: point.closingPrice,
+                  settlementPrice: point.settlementPrice,
+                  tradingSessionHighPrice: point.tradingSessionHighPrice,
+                  tradingSessionLowPrice: point.tradingSessionLowPrice,
+                  vwap: point.vwap,
+                  imbalance: point.imbalance,
+                  openInterest: point.openInterest,
+                  compositeUnderlyingPrice: point.compositeUnderlyingPrice,
+                  simulatedSellPrice: point.simulatedSellPrice,
+                  simulatedBuyPrice: point.simulatedBuyPrice,
+                  marginRate: point.marginRate,
+                  midPrice: point.midPrice,
+                  emptyBook: point.emptyBook,
+                  settleHighPrice: point.settleHighPrice,
+                  settleLowPrice: point.settleLowPrice,
+                  priorSettlePrice: point.priorSettlePrice,
+                  sessionHighBid: point.sessionHighBid,
+                  sessionLowOffer: point.sessionLowOffer,
+                  earlyPrices: point.earlyPrices,
+                  auctionClearingPrice: point.auctionClearingPrice,
+                  swapValueFactor: point.swapValueFactor,
+                  dailyValueAdjustmentForLongPositions: point.dailyValueAdjustmentForLongPositions,
+                  cumulativeValueAdjustmentForLongPositions: point.cumulativeValueAdjustmentForLongPositions,
+                  dailyValueAdjustmentForShortPositions: point.dailyValueAdjustmentForShortPositions,
+                  cumulativeValueAdjustmentForShortPositions: point.cumulativeValueAdjustmentForShortPositions,
+                  fixingPrice: point.fixingPrice,
+                  cashRate: point.cashRate,
+                  recoveryRate: point.recoveryRate,
+                  recoveryRateForLong: point.recoveryRateForLong,
+                  recoveryRateForShort: point.recoveryRateForShort,
+                  marketBid: point.marketBid,
+                  marketOffer: point.marketOffer,
+                  shortSaleMinPrice: point.shortSaleMinPrice,
+                  previousClosingPrice: point.previousClosingPrice,
+                  thresholdLimitPriceBanding: point.thresholdLimitPriceBanding,
+                  dailyFinancingValue: point.dailyFinancingValue,
+                  accruedFinancingValue: point.accruedFinancingValue,
+                  twap: point.twap
                 }))
               },
               null,
@@ -532,7 +2300,7 @@ var createGetStockPriceHistoryHandler = (marketDataPrices) => {
         content: [
           {
             type: "text",
-            text: `Error: ${error instanceof Error ? error.message : "Failed to get stock price history"}`,
+            text: `Error: ${error instanceof Error ? error.message : "Failed to get price history"}`,
             uri: "getStockPriceHistory"
           }
         ],
@@ -613,6 +2381,7 @@ var handlInstNames = {
 };
 var createVerifyOrderHandler = (parser, verifiedOrders) => {
   return async (args) => {
+    void parser;
     try {
       verifiedOrders.set(args.clOrdID, {
         clOrdID: args.clOrdID,
@@ -640,7 +2409,7 @@ Parameters verified:
 - Symbol: ${args.symbol}
 - TimeInForce: ${args.timeInForce} (${timeInForceNames[args.timeInForce]})
 
-To execute this order, call the executeOrder tool with these exact same parameters.`,
+To execute this order, call the executeOrder tool with these exact same parameters. Important: The user has to explicitly confirm before executeOrder is called!`,
             uri: "verifyOrder"
           }
         ]
@@ -836,48 +2605,211 @@ var createToolHandlers = (parser, verifiedOrders, pendingRequests, marketDataPri
   executeOrder: createExecuteOrderHandler(parser, verifiedOrders, pendingRequests),
   marketDataRequest: createMarketDataRequestHandler(parser, pendingRequests),
   getStockGraph: createGetStockGraphHandler(marketDataPrices),
-  getStockPriceHistory: createGetStockPriceHistoryHandler(marketDataPrices)
+  getStockPriceHistory: createGetStockPriceHistoryHandler(marketDataPrices),
+  technicalAnalysis: createTechnicalAnalysisHandler(marketDataPrices)
 });
 
 // src/utils/messageHandler.ts
 var import_fixparser3 = require("fixparser");
+function getEnumValue(enumObj, name) {
+  return enumObj[name] || name;
+}
 function handleMessage(message, parser, pendingRequests, marketDataPrices, maxPriceHistory, onPriceUpdate) {
-  parser.logger.log({
-    level: "info",
-    message: `MCP Server received message: ${message.messageType}: ${message.description}`
-  });
+  void parser;
   const msgType = message.messageType;
-  if (msgType === import_fixparser3.Messages.MarketDataSnapshotFullRefresh) {
+  if (msgType === import_fixparser3.Messages.MarketDataSnapshotFullRefresh || msgType === import_fixparser3.Messages.MarketDataIncrementalRefresh) {
     const symbol = message.getField(import_fixparser3.Fields.Symbol)?.value;
-    const entries = message.getField(import_fixparser3.Fields.NoMDEntries)?.value;
-    let bid = 0;
-    let offer = 0;
-    let volume = 0;
-    const entryTypes = message.getFields(import_fixparser3.Fields.MDEntryType);
-    const entryPrices = message.getFields(import_fixparser3.Fields.MDEntryPx);
-    const entrySizes = message.getFields(import_fixparser3.Fields.MDEntrySize);
-    if (entryTypes && entryPrices && entrySizes) {
-      for (let i = 0; i < entries; i++) {
-        const entryType = entryTypes[i]?.value;
-        const entryPrice = Number.parseFloat(entryPrices[i]?.value);
-        const entrySize = Number.parseFloat(entrySizes[i]?.value);
-        if (entryType === import_fixparser3.MDEntryType.Bid) {
-          bid = entryPrice;
-        } else if (entryType === import_fixparser3.MDEntryType.Offer) {
-          offer = entryPrice;
-        }
-        volume += entrySize;
-      }
-    }
-    const spread = offer - bid;
-    const timestamp = Date.now();
+    const fixJson = message.toFIXJSON();
+    const entries = fixJson.Body?.NoMDEntries || [];
     const data = {
-      timestamp,
-      bid,
-      offer,
-      spread,
-      volume
+      timestamp: Date.now(),
+      bid: 0,
+      offer: 0,
+      spread: 0,
+      volume: 0,
+      trade: 0,
+      indexValue: 0,
+      openingPrice: 0,
+      closingPrice: 0,
+      settlementPrice: 0,
+      tradingSessionHighPrice: 0,
+      tradingSessionLowPrice: 0,
+      vwap: 0,
+      imbalance: 0,
+      openInterest: 0,
+      compositeUnderlyingPrice: 0,
+      simulatedSellPrice: 0,
+      simulatedBuyPrice: 0,
+      marginRate: 0,
+      midPrice: 0,
+      emptyBook: 0,
+      settleHighPrice: 0,
+      settleLowPrice: 0,
+      priorSettlePrice: 0,
+      sessionHighBid: 0,
+      sessionLowOffer: 0,
+      earlyPrices: 0,
+      auctionClearingPrice: 0,
+      swapValueFactor: 0,
+      dailyValueAdjustmentForLongPositions: 0,
+      cumulativeValueAdjustmentForLongPositions: 0,
+      dailyValueAdjustmentForShortPositions: 0,
+      cumulativeValueAdjustmentForShortPositions: 0,
+      fixingPrice: 0,
+      cashRate: 0,
+      recoveryRate: 0,
+      recoveryRateForLong: 0,
+      recoveryRateForShort: 0,
+      marketBid: 0,
+      marketOffer: 0,
+      shortSaleMinPrice: 0,
+      previousClosingPrice: 0,
+      thresholdLimitPriceBanding: 0,
+      dailyFinancingValue: 0,
+      accruedFinancingValue: 0,
+      twap: 0
     };
+    for (const entry of entries) {
+      const entryType = entry.MDEntryType;
+      const price = entry.MDEntryPx ? Number.parseFloat(entry.MDEntryPx) : 0;
+      const size = entry.MDEntrySize ? Number.parseFloat(entry.MDEntrySize) : 0;
+      const enumValue = getEnumValue(import_fixparser3.MDEntryType, entryType);
+      switch (enumValue) {
+        case import_fixparser3.MDEntryType.Bid:
+          data.bid = price;
+          break;
+        case import_fixparser3.MDEntryType.Offer:
+          data.offer = price;
+          break;
+        case import_fixparser3.MDEntryType.Trade:
+          data.trade = price;
+          break;
+        case import_fixparser3.MDEntryType.IndexValue:
+          data.indexValue = price;
+          break;
+        case import_fixparser3.MDEntryType.OpeningPrice:
+          data.openingPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.ClosingPrice:
+          data.closingPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.SettlementPrice:
+          data.settlementPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.TradingSessionHighPrice:
+          data.tradingSessionHighPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.TradingSessionLowPrice:
+          data.tradingSessionLowPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.VWAP:
+          data.vwap = price;
+          break;
+        case import_fixparser3.MDEntryType.Imbalance:
+          data.imbalance = size;
+          break;
+        case import_fixparser3.MDEntryType.TradeVolume:
+          data.volume = size;
+          break;
+        case import_fixparser3.MDEntryType.OpenInterest:
+          data.openInterest = size;
+          break;
+        case import_fixparser3.MDEntryType.CompositeUnderlyingPrice:
+          data.compositeUnderlyingPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.SimulatedSellPrice:
+          data.simulatedSellPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.SimulatedBuyPrice:
+          data.simulatedBuyPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.MarginRate:
+          data.marginRate = price;
+          break;
+        case import_fixparser3.MDEntryType.MidPrice:
+          data.midPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.EmptyBook:
+          data.emptyBook = 1;
+          break;
+        case import_fixparser3.MDEntryType.SettleHighPrice:
+          data.settleHighPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.SettleLowPrice:
+          data.settleLowPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.PriorSettlePrice:
+          data.priorSettlePrice = price;
+          break;
+        case import_fixparser3.MDEntryType.SessionHighBid:
+          data.sessionHighBid = price;
+          break;
+        case import_fixparser3.MDEntryType.SessionLowOffer:
+          data.sessionLowOffer = price;
+          break;
+        case import_fixparser3.MDEntryType.EarlyPrices:
+          data.earlyPrices = price;
+          break;
+        case import_fixparser3.MDEntryType.AuctionClearingPrice:
+          data.auctionClearingPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.SwapValueFactor:
+          data.swapValueFactor = price;
+          break;
+        case import_fixparser3.MDEntryType.DailyValueAdjustmentForLongPositions:
+          data.dailyValueAdjustmentForLongPositions = price;
+          break;
+        case import_fixparser3.MDEntryType.CumulativeValueAdjustmentForLongPositions:
+          data.cumulativeValueAdjustmentForLongPositions = price;
+          break;
+        case import_fixparser3.MDEntryType.DailyValueAdjustmentForShortPositions:
+          data.dailyValueAdjustmentForShortPositions = price;
+          break;
+        case import_fixparser3.MDEntryType.CumulativeValueAdjustmentForShortPositions:
+          data.cumulativeValueAdjustmentForShortPositions = price;
+          break;
+        case import_fixparser3.MDEntryType.FixingPrice:
+          data.fixingPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.CashRate:
+          data.cashRate = price;
+          break;
+        case import_fixparser3.MDEntryType.RecoveryRate:
+          data.recoveryRate = price;
+          break;
+        case import_fixparser3.MDEntryType.RecoveryRateForLong:
+          data.recoveryRateForLong = price;
+          break;
+        case import_fixparser3.MDEntryType.RecoveryRateForShort:
+          data.recoveryRateForShort = price;
+          break;
+        case import_fixparser3.MDEntryType.MarketBid:
+          data.marketBid = price;
+          break;
+        case import_fixparser3.MDEntryType.MarketOffer:
+          data.marketOffer = price;
+          break;
+        case import_fixparser3.MDEntryType.ShortSaleMinPrice:
+          data.shortSaleMinPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.PreviousClosingPrice:
+          data.previousClosingPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.ThresholdLimitPriceBanding:
+          data.thresholdLimitPriceBanding = price;
+          break;
+        case import_fixparser3.MDEntryType.DailyFinancingValue:
+          data.dailyFinancingValue = price;
+          break;
+        case import_fixparser3.MDEntryType.AccruedFinancingValue:
+          data.accruedFinancingValue = price;
+          break;
+        case import_fixparser3.MDEntryType.TWAP:
+          data.twap = price;
+          break;
+      }
+    }
+    data.spread = data.offer - data.bid;
     if (!marketDataPrices.has(symbol)) {
       marketDataPrices.set(symbol, []);
     }
@@ -887,6 +2819,14 @@ function handleMessage(message, parser, pendingRequests, marketDataPrices, maxPr
       prices.splice(0, prices.length - maxPriceHistory);
     }
     onPriceUpdate?.(symbol, data);
+    const mdReqID = message.getField(import_fixparser3.Fields.MDReqID)?.value;
+    if (mdReqID) {
+      const callback = pendingRequests.get(mdReqID);
+      if (callback) {
+        callback(message);
+        pendingRequests.delete(mdReqID);
+      }
+    }
   } else if (msgType === import_fixparser3.Messages.ExecutionReport) {
     const reqId = message.getField(import_fixparser3.Fields.ClOrdID)?.value;
     const callback = pendingRequests.get(reqId);
@@ -899,6 +2839,39 @@ function handleMessage(message, parser, pendingRequests, marketDataPrices, maxPr
 
 // src/MCPRemote.ts
 var transports = {};
+function jsonSchemaToZod(schema) {
+  if (schema.type === "object") {
+    const shape = {};
+    for (const [key, prop] of Object.entries(schema.properties || {})) {
+      const propSchema = prop;
+      if (propSchema.type === "string") {
+        if (propSchema.enum) {
+          shape[key] = import_zod.z.enum(propSchema.enum);
+        } else {
+          shape[key] = import_zod.z.string();
+        }
+      } else if (propSchema.type === "number") {
+        shape[key] = import_zod.z.number();
+      } else if (propSchema.type === "boolean") {
+        shape[key] = import_zod.z.boolean();
+      } else if (propSchema.type === "array") {
+        if (propSchema.items.type === "string") {
+          shape[key] = import_zod.z.array(import_zod.z.string());
+        } else if (propSchema.items.type === "number") {
+          shape[key] = import_zod.z.array(import_zod.z.number());
+        } else if (propSchema.items.type === "boolean") {
+          shape[key] = import_zod.z.array(import_zod.z.boolean());
+        } else {
+          shape[key] = import_zod.z.array(import_zod.z.any());
+        }
+      } else {
+        shape[key] = import_zod.z.any();
+      }
+    }
+    return shape;
+  }
+  return {};
+}
 var MCPRemote = class extends MCPBase {
   /**
    * Port number the server will listen on.
@@ -941,7 +2914,7 @@ var MCPRemote = class extends MCPBase {
    */
   marketDataPrices = /* @__PURE__ */ new Map();
   /**
-   * Maximum number of price points to store per symbol
+   * Maximum number of price history entries to keep per symbol
    * @private
    */
   MAX_PRICE_HISTORY = 1e5;
@@ -963,31 +2936,7 @@ var MCPRemote = class extends MCPBase {
           this.parser,
           this.pendingRequests,
           this.marketDataPrices,
-          this.MAX_PRICE_HISTORY,
-          (symbol, data) => {
-            this.mcpServer?.tool(
-              "priceUpdate",
-              {
-                description: "Price update notification",
-                schema: import_zod.z.object({
-                  symbol: import_zod.z.string(),
-                  timestamp: import_zod.z.number(),
-                  bid: import_zod.z.number(),
-                  offer: import_zod.z.number(),
-                  spread: import_zod.z.number(),
-                  volume: import_zod.z.number()
-                })
-              },
-              () => ({
-                content: [
-                  {
-                    type: "text",
-                    text: JSON.stringify({ symbol, ...data })
-                  }
-                ]
-              })
-            );
-          }
+          this.MAX_PRICE_HISTORY
         );
       }
     });
@@ -1009,7 +2958,8 @@ var MCPRemote = class extends MCPBase {
             const body = Buffer.concat(bodyChunks).toString();
             try {
               parsed = JSON.parse(body);
-            } catch (err) {
+            } catch (error) {
+              void error;
               res.writeHead(400);
               res.end(JSON.stringify({ error: "Invalid JSON" }));
               return;
@@ -1049,7 +2999,15 @@ var MCPRemote = class extends MCPBase {
               );
               return;
             }
-            await transport.handleRequest(req, res, parsed);
+            try {
+              await transport.handleRequest(req, res, parsed);
+            } catch (error) {
+              this.logger?.log({
+                level: "error",
+                message: `Error handling request: ${error}`
+              });
+              throw error;
+            }
           });
         } else if (req.method === "GET" || req.method === "DELETE") {
           if (!sessionId || !transports[sessionId]) {
@@ -1058,8 +3016,20 @@ var MCPRemote = class extends MCPBase {
             return;
           }
           const transport = transports[sessionId];
-          await transport.handleRequest(req, res);
+          try {
+            await transport.handleRequest(req, res);
+          } catch (error) {
+            this.logger?.log({
+              level: "error",
+              message: `Error handling ${req.method} request: ${error}`
+            });
+            throw error;
+          }
         } else {
+          this.logger?.log({
+            level: "error",
+            message: `Method not allowed: ${req.method}`
+          });
           res.writeHead(405);
           res.end("Method Not Allowed");
         }
@@ -1093,69 +3063,40 @@ var MCPRemote = class extends MCPBase {
       });
       return;
     }
-    this.mcpServer.tool(
-      "tools/list",
-      {
-        description: "List available tools",
-        schema: import_zod.z.object({})
-      },
-      async () => {
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(
-                Object.entries(toolSchemas).map(([name, { description, schema }]) => ({
-                  name,
-                  description,
-                  inputSchema: schema
-                }))
-              )
-            }
-          ]
-        };
-      }
+    const toolHandlers = createToolHandlers(
+      this.parser,
+      this.verifiedOrders,
+      this.pendingRequests,
+      this.marketDataPrices
     );
-    this.mcpServer.tool(
-      "tools/call",
-      {
-        description: "Call a tool",
-        schema: import_zod.z.object({
-          name: import_zod.z.string(),
-          arguments: import_zod.z.any(),
-          _meta: import_zod.z.object({
-            progressToken: import_zod.z.number()
-          }).optional()
-        })
-      },
-      async (request) => {
-        const { name, arguments: args } = request;
-        const toolHandlers = createToolHandlers(
-          this.parser,
-          this.verifiedOrders,
-          this.pendingRequests,
-          this.marketDataPrices
-        );
-        const handler = toolHandlers[name];
-        if (!handler) {
+    Object.entries(toolSchemas).forEach(([name, { description, schema }]) => {
+      this.mcpServer?.registerTool(
+        name,
+        {
+          description,
+          inputSchema: jsonSchemaToZod(schema)
+        },
+        async (args) => {
+          const handler = toolHandlers[name];
+          if (!handler) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Tool not found: ${name}`
+                }
+              ],
+              isError: true
+            };
+          }
+          const result = await handler(args);
           return {
-            content: [
-              {
-                type: "text",
-                text: `Tool not found: ${name}`,
-                uri: name
-              }
-            ],
-            isError: true
+            content: result.content,
+            isError: result.isError
           };
         }
-        const result = await handler(args);
-        return {
-          content: result.content,
-          isError: result.isError
-        };
-      }
-    );
+      );
+    });
   }
 };
 // Annotate the CommonJS export names for ESM import in node: