fixparser-plugin-mcp 9.1.7-2924f547 → 9.1.7-2cd4ac1b

package/build/esm/MCPRemote.mjs

@@ -5,2212 +5,38 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
-
-// src/MCPBase.ts
-var MCPBase = class {
+import {
+  Field,
+  Fields,
+  HandlInst,
+  MDEntryType,
+  Messages,
+  OrdType,
+  SubscriptionRequestType,
+  TimeInForce
+} from "fixparser";
+var transports = {};
+var MCPRemote = class {
+  /**
+   * Port number the server will listen on.
+   * @private
+   */
+  port;
   /**
    * Optional logger instance for diagnostics and output.
-   * @protected
+   * @private
    */
   logger;
   /**
    * FIXParser instance, set during plugin register().
-   * @protected
-   */
-  parser;
-  /**
-   * Called when server is setup and listening.
-   * @protected
-   */
-  onReady = void 0;
-  /**
-   * Map to store verified orders before execution
-   * @protected
-   */
-  verifiedOrders = /* @__PURE__ */ new Map();
-  /**
-   * Map to store pending market data requests
-   * @protected
-   */
-  pendingRequests = /* @__PURE__ */ new Map();
-  /**
-   * Map to store market data prices
-   * @protected
-   */
-  marketDataPrices = /* @__PURE__ */ new Map();
-  /**
-   * Maximum number of price history entries to keep per symbol
-   * @protected
-   */
-  MAX_PRICE_HISTORY = 1e5;
-  constructor({ logger, onReady }) {
-    this.logger = logger;
-    this.onReady = onReady;
-  }
-};
-
-// src/schemas/schemas.ts
-var toolSchemas = {
-  parse: {
-    description: "Parses a FIX message and describes it in plain language",
-    schema: {
-      type: "object",
-      properties: {
-        fixString: { type: "string" }
-      },
-      required: ["fixString"]
-    }
-  },
-  parseToJSON: {
-    description: "Parses a FIX message into JSON",
-    schema: {
-      type: "object",
-      properties: {
-        fixString: { type: "string" }
-      },
-      required: ["fixString"]
-    }
-  },
-  verifyOrder: {
-    description: "Verifies order parameters before execution. verifyOrder must be called before executeOrder.",
-    schema: {
-      type: "object",
-      properties: {
-        clOrdID: { type: "string" },
-        handlInst: {
-          type: "string",
-          enum: ["1", "2", "3"],
-          description: "Handling Instructions: 1=Automated Execution No Intervention, 2=Automated Execution Intervention OK, 3=Manual Order"
-        },
-        quantity: { type: "string" },
-        price: { type: "string" },
-        ordType: {
-          type: "string",
-          enum: [
-            "1",
-            "2",
-            "3",
-            "4",
-            "5",
-            "6",
-            "7",
-            "8",
-            "9",
-            "A",
-            "B",
-            "C",
-            "D",
-            "E",
-            "F",
-            "G",
-            "H",
-            "I",
-            "J",
-            "K",
-            "L",
-            "M",
-            "P",
-            "Q",
-            "R",
-            "S"
-          ],
-          description: "Order Type: 1=Market, 2=Limit, 3=Stop, 4=StopLimit, 5=MarketOnClose, 6=WithOrWithout, 7=LimitOrBetter, 8=LimitWithOrWithout, 9=OnBasis, A=OnClose, B=LimitOnClose, C=ForexMarket, D=PreviouslyQuoted, E=PreviouslyIndicated, F=ForexLimit, G=ForexSwap, H=ForexPreviouslyQuoted, I=Funari, J=MarketIfTouched, K=MarketWithLeftOverAsLimit, L=PreviousFundValuationPoint, M=NextFundValuationPoint, P=Pegged, Q=CounterOrderSelection, R=StopOnBidOrOffer, S=StopLimitOnBidOrOffer"
-        },
-        side: {
-          type: "string",
-          enum: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H"],
-          description: "Side: 1=Buy, 2=Sell, 3=BuyMinus, 4=SellPlus, 5=SellShort, 6=SellShortExempt, 7=Undisclosed, 8=Cross, 9=CrossShort, A=CrossShortExempt, B=AsDefined, C=Opposite, D=Subscribe, E=Redeem, F=Lend, G=Borrow, H=SellUndisclosed"
-        },
-        symbol: { type: "string" },
-        timeInForce: {
-          type: "string",
-          enum: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C"],
-          description: "Time In Force: 0=Day, 1=GoodTillCancel, 2=AtTheOpening, 3=ImmediateOrCancel, 4=FillOrKill, 5=GoodTillCrossing, 6=GoodTillDate, 7=AtTheClose, 8=GoodThroughCrossing, 9=AtCrossing, A=GoodForTime, B=GoodForAuction, C=GoodForMonth"
-        }
-      },
-      required: ["clOrdID", "handlInst", "quantity", "price", "ordType", "side", "symbol", "timeInForce"]
-    }
-  },
-  executeOrder: {
-    description: "Executes a verified order. verifyOrder must be called before executeOrder.",
-    schema: {
-      type: "object",
-      properties: {
-        clOrdID: { type: "string" },
-        handlInst: {
-          type: "string",
-          enum: ["1", "2", "3"],
-          description: "Handling Instructions: 1=Automated Execution No Intervention, 2=Automated Execution Intervention OK, 3=Manual Order"
-        },
-        quantity: { type: "string" },
-        price: { type: "string" },
-        ordType: {
-          type: "string",
-          enum: [
-            "1",
-            "2",
-            "3",
-            "4",
-            "5",
-            "6",
-            "7",
-            "8",
-            "9",
-            "A",
-            "B",
-            "C",
-            "D",
-            "E",
-            "F",
-            "G",
-            "H",
-            "I",
-            "J",
-            "K",
-            "L",
-            "M",
-            "P",
-            "Q",
-            "R",
-            "S"
-          ],
-          description: "Order Type: 1=Market, 2=Limit, 3=Stop, 4=StopLimit, 5=MarketOnClose, 6=WithOrWithout, 7=LimitOrBetter, 8=LimitWithOrWithout, 9=OnBasis, A=OnClose, B=LimitOnClose, C=ForexMarket, D=PreviouslyQuoted, E=PreviouslyIndicated, F=ForexLimit, G=ForexSwap, H=ForexPreviouslyQuoted, I=Funari, J=MarketIfTouched, K=MarketWithLeftOverAsLimit, L=PreviousFundValuationPoint, M=NextFundValuationPoint, P=Pegged, Q=CounterOrderSelection, R=StopOnBidOrOffer, S=StopLimitOnBidOrOffer"
-        },
-        side: {
-          type: "string",
-          enum: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H"],
-          description: "Side: 1=Buy, 2=Sell, 3=BuyMinus, 4=SellPlus, 5=SellShort, 6=SellShortExempt, 7=Undisclosed, 8=Cross, 9=CrossShort, A=CrossShortExempt, B=AsDefined, C=Opposite, D=Subscribe, E=Redeem, F=Lend, G=Borrow, H=SellUndisclosed"
-        },
-        symbol: { type: "string" },
-        timeInForce: {
-          type: "string",
-          enum: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C"],
-          description: "Time In Force: 0=Day, 1=GoodTillCancel, 2=AtTheOpening, 3=ImmediateOrCancel, 4=FillOrKill, 5=GoodTillCrossing, 6=GoodTillDate, 7=AtTheClose, 8=GoodThroughCrossing, 9=AtCrossing, A=GoodForTime, B=GoodForAuction, C=GoodForMonth"
-        }
-      },
-      required: ["clOrdID", "handlInst", "quantity", "price", "ordType", "side", "symbol", "timeInForce"]
-    }
-  },
-  marketDataRequest: {
-    description: "Requests market data for specified symbols",
-    schema: {
-      type: "object",
-      properties: {
-        mdUpdateType: {
-          type: "string",
-          enum: ["0", "1"],
-          description: "Market Data Update Type: 0=Full Refresh, 1=Incremental Refresh"
-        },
-        symbols: { type: "array", items: { type: "string" } },
-        mdReqID: { type: "string" },
-        subscriptionRequestType: {
-          type: "string",
-          enum: ["0", "1", "2"],
-          description: "Subscription Request Type: 0=Snapshot, 1=Snapshot + Updates, 2=Disable Previous Snapshot + Update Request"
-        },
-        mdEntryTypes: {
-          type: "array",
-          items: {
-            type: "string",
-            enum: [
-              "0",
-              "1",
-              "2",
-              "3",
-              "4",
-              "5",
-              "6",
-              "7",
-              "8",
-              "9",
-              "A",
-              "B",
-              "C",
-              "D",
-              "E",
-              "F",
-              "G",
-              "H",
-              "I",
-              "J",
-              "K",
-              "L",
-              "M",
-              "N",
-              "O",
-              "P",
-              "Q",
-              "R",
-              "S",
-              "T",
-              "U",
-              "V",
-              "W",
-              "X",
-              "Y",
-              "Z"
-            ]
-          },
-          description: "Market Data Entry Types: 0=Bid, 1=Offer, 2=Trade, 3=Index Value, 4=Opening Price, 5=Closing Price, 6=Settlement Price, 7=High Price, 8=Low Price, 9=Trade Volume, A=Open Interest, B=Simulated Sell Price, C=Simulated Buy Price, D=Empty Book, E=Session High Bid, F=Session Low Offer, G=Fixing Price, H=Electronic Volume, I=Threshold Limits and Price Band Variation, J=Clearing Price, K=Open Interest Change, L=Last Trade Price, M=Last Trade Volume, N=Last Trade Time, O=Last Trade Tick, P=Last Trade Exchange, Q=Last Trade ID, R=Last Trade Side, S=Last Trade Price Change, T=Last Trade Price Change Percent, U=Last Trade Price Change Basis Points, V=Last Trade Price Change Points, W=Last Trade Price Change Ticks, X=Last Trade Price Change Ticks Percent, Y=Last Trade Price Change Ticks Basis Points, Z=Last Trade Price Change Ticks Points"
-        }
-      },
-      required: ["mdUpdateType", "symbols", "mdReqID", "subscriptionRequestType"]
-    }
-  },
-  getStockGraph: {
-    description: "Generates a price chart for a given symbol",
-    schema: {
-      type: "object",
-      properties: {
-        symbol: { type: "string" }
-      },
-      required: ["symbol"]
-    }
-  },
-  getStockPriceHistory: {
-    description: "Returns price history for a given symbol",
-    schema: {
-      type: "object",
-      properties: {
-        symbol: { type: "string" }
-      },
-      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, volumes) {
-    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 = [];
-    for (let i = 0; i < Math.min(ema12.length, ema26.length); i++) {
-      const macdLine = ema12[i] - ema26[i];
-      macd.push({
-        macd: macdLine,
-        signal: 0,
-        // Would need to calculate signal line
-        histogram: 0
-        // Would need to calculate histogram
-      });
-    }
-    return macd;
-  }
-  // Calculate ADX
-  calculateAdx(prices, highs, lows) {
-    const adx = [];
-    for (let i = 14; i < prices.length; i++) {
-      adx.push(Math.random() * 50 + 25);
-    }
-    return adx;
-  }
-  // Calculate DMI
-  calculateDmi(prices, highs, lows) {
-    const dmi = [];
-    for (let i = 14; i < prices.length; i++) {
-      dmi.push({
-        plusDI: Math.random() * 50 + 25,
-        minusDI: Math.random() * 50 + 25,
-        adx: Math.random() * 50 + 25
-      });
-    }
-    return dmi;
-  }
-  // Calculate Ichimoku Cloud
-  calculateIchimoku(prices, highs, lows) {
-    const ichimoku = [];
-    for (let i = 26; i < prices.length; i++) {
-      ichimoku.push({
-        tenkan: prices[i],
-        kijun: prices[i],
-        senkouA: prices[i],
-        senkouB: prices[i],
-        chikou: prices[i]
-      });
-    }
-    return ichimoku;
-  }
-  // Calculate Parabolic SAR
-  calculateParabolicSAR(prices, highs, lows) {
-    const sar = [];
-    for (let i = 0; i < prices.length; i++) {
-      sar.push(prices[i] * 0.98);
-    }
-    return sar;
-  }
-  // Calculate Stochastic
-  calculateStochastic(prices, highs, lows) {
-    const stochastic = [];
-    for (let i = 14; i < prices.length; i++) {
-      stochastic.push({
-        k: Math.random() * 100,
-        d: Math.random() * 100
-      });
-    }
-    return stochastic;
-  }
-  // Calculate CCI
-  calculateCci(prices, highs, lows) {
-    const cci = [];
-    for (let i = 20; i < prices.length; i++) {
-      cci.push(Math.random() * 200 - 100);
-    }
-    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 = [];
-    for (let i = 14; i < prices.length; i++) {
-      williamsR.push(Math.random() * 100 - 100);
-    }
-    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 = [];
-    for (let i = 20; i < prices.length; i++) {
-      keltner.push({
-        upper: prices[i] * 1.02,
-        middle: prices[i],
-        lower: prices[i] * 0.98
-      });
-    }
-    return keltner;
-  }
-  // Calculate Donchian Channels
-  calculateDonchianChannels(prices, highs, lows) {
-    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 = [];
-    for (let i = 10; i < prices.length; i++) {
-      volatility.push(Math.random() * 10);
-    }
-    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 = [];
-    for (let i = 20; i < prices.length; i++) {
-      cmf.push(Math.random() * 2 - 1);
-    }
-    return cmf;
-  }
-  // Calculate Accumulation/Distribution Line
-  calculateAdl(prices) {
-    const adl = [0];
-    for (let i = 1; i < prices.length; i++) {
-      adl.push(adl[i - 1] + (prices[i] - prices[i - 1]));
-    }
-    return adl;
-  }
-  // Calculate Volume Rate of Change
-  calculateVolumeROC(prices) {
-    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 = [];
-    for (let i = 14; i < prices.length; i++) {
-      mfi.push(Math.random() * 100);
-    }
-    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 pp = prices[i];
-      pivotPoints.push({
-        pp,
-        r1: pp * 1.01,
-        r2: pp * 1.02,
-        r3: pp * 1.03,
-        s1: pp * 0.99,
-        s2: pp * 0.98,
-        s3: pp * 0.97
-      });
-    }
-    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 = [];
-    for (let i = 0; i < prices.length; i++) {
-      elliottWave.push({
-        waves: [prices[i]],
-        currentWave: 1,
-        wavePosition: 0.5
-      });
-    }
-    return elliottWave;
-  }
-  // Calculate Harmonic Patterns
-  calculateHarmonicPatterns(prices) {
-    const harmonicPatterns = [];
-    for (let i = 0; i < prices.length; i++) {
-      harmonicPatterns.push({
-        type: "Gartley",
-        completion: 0.618,
-        target: prices[i] * 1.1,
-        stopLoss: prices[i] * 0.9
-      });
-    }
-    return harmonicPatterns;
-  }
-  // Calculate Position Size
-  calculatePositionSize(currentPrice, targetEntry, stopLoss) {
-    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, avgVolume) {
-    return (currentPrice - startPrice) / (startPrice * 0.1);
-  }
-  // Calculate Ornstein-Uhlenbeck
-  calculateOrnsteinUhlenbeck(currentPrice, startPrice, avgVolume) {
-    return {
-      mean: startPrice,
-      speed: 0.1,
-      volatility: avgVolume * 0.01,
-      currentValue: currentPrice
-    };
-  }
-  // Calculate Kalman Filter
-  calculateKalmanFilter(currentPrice, startPrice, avgVolume) {
-    return {
-      state: currentPrice,
-      covariance: avgVolume * 1e-3,
-      gain: 0.5
-    };
-  }
-  // Calculate ARIMA
-  calculateArima(currentPrice, startPrice, avgVolume) {
-    return {
-      forecast: [currentPrice * 1.01, currentPrice * 1.02],
-      residuals: [0, 0],
-      aic: 100
-    };
-  }
-  // Calculate GARCH
-  calculateGarch(currentPrice, startPrice, avgVolume) {
-    return {
-      volatility: avgVolume * 0.01,
-      persistence: 0.9,
-      meanReversion: 0.1
-    };
-  }
-  // Calculate Hilbert Transform
-  calculateHilbertTransform(currentPrice, startPrice, avgVolume) {
-    return {
-      analytic: [currentPrice],
-      phase: [0],
-      amplitude: [currentPrice]
-    };
-  }
-  // Calculate Wavelet Transform
-  calculateWaveletTransform(currentPrice, startPrice, avgVolume) {
-    return {
-      coefficients: [currentPrice],
-      scales: [1]
-    };
-  }
-  // 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, this.volumes);
-    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, this.volumes),
-      keltner: this.calculateKeltnerChannels(this.prices, this.highs, this.lows),
-      donchian: this.calculateDonchianChannels(this.prices, this.highs, this.lows),
-      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(this.prices),
-      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, analysis.avgVolume),
-        ornsteinUhlenbeck: this.calculateOrnsteinUhlenbeck(
-          analysis.currentPrice,
-          analysis.startPrice,
-          analysis.avgVolume
-        ),
-        kalmanFilter: this.calculateKalmanFilter(
-          analysis.currentPrice,
-          analysis.startPrice,
-          analysis.avgVolume
-        ),
-        arima: this.calculateArima(analysis.currentPrice, analysis.startPrice, analysis.avgVolume),
-        garch: this.calculateGarch(analysis.currentPrice, analysis.startPrice, analysis.avgVolume),
-        hilbertTransform: this.calculateHilbertTransform(
-          analysis.currentPrice,
-          analysis.startPrice,
-          analysis.avgVolume
-        ),
-        waveletTransform: this.calculateWaveletTransform(
-          analysis.currentPrice,
-          analysis.startPrice,
-          analysis.avgVolume
-        )
-      },
-      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
-import { Field, Fields, MDEntryType, Messages } from "fixparser";
-import QuickChart from "quickchart-js";
-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 || [
-        MDEntryType.Bid,
-        MDEntryType.Offer,
-        MDEntryType.Trade,
-        MDEntryType.IndexValue,
-        MDEntryType.OpeningPrice,
-        MDEntryType.ClosingPrice,
-        MDEntryType.SettlementPrice,
-        MDEntryType.TradingSessionHighPrice,
-        MDEntryType.TradingSessionLowPrice,
-        MDEntryType.VWAP,
-        MDEntryType.Imbalance,
-        MDEntryType.TradeVolume,
-        MDEntryType.OpenInterest,
-        MDEntryType.CompositeUnderlyingPrice,
-        MDEntryType.SimulatedSellPrice,
-        MDEntryType.SimulatedBuyPrice,
-        MDEntryType.MarginRate,
-        MDEntryType.MidPrice,
-        MDEntryType.EmptyBook,
-        MDEntryType.SettleHighPrice,
-        MDEntryType.SettleLowPrice,
-        MDEntryType.PriorSettlePrice,
-        MDEntryType.SessionHighBid,
-        MDEntryType.SessionLowOffer,
-        MDEntryType.EarlyPrices,
-        MDEntryType.AuctionClearingPrice,
-        MDEntryType.SwapValueFactor,
-        MDEntryType.DailyValueAdjustmentForLongPositions,
-        MDEntryType.CumulativeValueAdjustmentForLongPositions,
-        MDEntryType.DailyValueAdjustmentForShortPositions,
-        MDEntryType.CumulativeValueAdjustmentForShortPositions,
-        MDEntryType.FixingPrice,
-        MDEntryType.CashRate,
-        MDEntryType.RecoveryRate,
-        MDEntryType.RecoveryRateForLong,
-        MDEntryType.RecoveryRateForShort,
-        MDEntryType.MarketBid,
-        MDEntryType.MarketOffer,
-        MDEntryType.ShortSaleMinPrice,
-        MDEntryType.PreviousClosingPrice,
-        MDEntryType.ThresholdLimitPriceBanding,
-        MDEntryType.DailyFinancingValue,
-        MDEntryType.AccruedFinancingValue,
-        MDEntryType.TWAP
-      ];
-      const messageFields = [
-        new Field(Fields.MsgType, Messages.MarketDataRequest),
-        new Field(Fields.SenderCompID, parser.sender),
-        new Field(Fields.MsgSeqNum, parser.getNextTargetMsgSeqNum()),
-        new Field(Fields.TargetCompID, parser.target),
-        new Field(Fields.SendingTime, parser.getTimestamp()),
-        new Field(Fields.MDReqID, args.mdReqID),
-        new Field(Fields.SubscriptionRequestType, args.subscriptionRequestType),
-        new Field(Fields.MarketDepth, 0),
-        new Field(Fields.MDUpdateType, args.mdUpdateType)
-      ];
-      messageFields.push(new Field(Fields.NoRelatedSym, args.symbols.length));
-      args.symbols.forEach((symbol) => {
-        messageFields.push(new Field(Fields.Symbol, symbol));
-      });
-      messageFields.push(new Field(Fields.NoMDEntryTypes, entryTypes.length));
-      entryTypes.forEach((entryType) => {
-        messageFields.push(new Field(Fields.MDEntryType, entryType));
-      });
-      const mdr = parser.createMessage(...messageFields);
-      if (!parser.connected) {
-        parser.logger.log({
-          level: "error",
-          message: "Not connected. Cannot send market data request."
-        });
-        return {
-          content: [
-            {
-              type: "text",
-              text: "Error: Not connected. Ignoring message.",
-              uri: "marketDataRequest"
-            }
-          ],
-          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: [
-          {
-            type: "text",
-            text: `Market data for ${args.symbols.join(", ")}: ${JSON.stringify(fixData.toFIXJSON())}`,
-            uri: "marketDataRequest"
-          }
-        ]
-      };
-    } catch (error) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error: ${error instanceof Error ? error.message : "Failed to request market data"}`,
-            uri: "marketDataRequest"
-          }
-        ],
-        isError: true
-      };
-    }
-  };
-};
-var createGetStockGraphHandler = (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}`,
-              uri: "getStockGraph"
-            }
-          ]
-        };
-      }
-      const chart = new QuickChart();
-      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 tradeData = priceHistory.map((point) => point.trade);
-      const vwapData = priceHistory.map((point) => point.vwap);
-      const twapData = priceHistory.map((point) => point.twap);
-      const config = {
-        type: "line",
-        data: {
-          labels,
-          datasets: [
-            {
-              label: "Bid",
-              data: bidData,
-              borderColor: "#28a745",
-              backgroundColor: "rgba(40, 167, 69, 0.1)",
-              fill: false,
-              tension: 0.4
-            },
-            {
-              label: "Offer",
-              data: offerData,
-              borderColor: "#dc3545",
-              backgroundColor: "rgba(220, 53, 69, 0.1)",
-              fill: false,
-              tension: 0.4
-            },
-            {
-              label: "Spread",
-              data: spreadData,
-              borderColor: "#6c757d",
-              backgroundColor: "rgba(108, 117, 125, 0.1)",
-              fill: false,
-              tension: 0.4
-            },
-            {
-              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",
-              data: volumeData,
-              borderColor: "#007bff",
-              backgroundColor: "rgba(0, 123, 255, 0.1)",
-              fill: true,
-              tension: 0.4
-            }
-          ]
-        },
-        options: {
-          responsive: true,
-          plugins: {
-            title: {
-              display: true,
-              text: `${symbol} Market Data`
-            }
-          },
-          scales: {
-            y: {
-              beginAtZero: false
-            }
-          }
-        }
-      };
-      chart.setConfig(config);
-      const imageBuffer = await chart.toBinary();
-      const base64 = imageBuffer.toString("base64");
-      return {
-        content: [
-          {
-            type: "resource",
-            resource: {
-              uri: "resource://graph",
-              mimeType: "image/png",
-              blob: base64
-            }
-          }
-        ]
-      };
-    } catch (error) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error: ${error instanceof Error ? error.message : "Failed to generate graph"}`,
-            uri: "getStockGraph"
-          }
-        ],
-        isError: true
-      };
-    }
-  };
-};
-var createGetStockPriceHistoryHandler = (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}`,
-              uri: "getStockPriceHistory"
-            }
-          ]
-        };
-      }
-      return {
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify(
-              {
-                symbol,
-                count: priceHistory.length,
-                data: priceHistory.map((point) => ({
-                  timestamp: new Date(point.timestamp).toISOString(),
-                  bid: point.bid,
-                  offer: point.offer,
-                  spread: point.spread,
-                  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,
-              2
-            ),
-            uri: "getStockPriceHistory"
-          }
-        ]
-      };
-    } catch (error) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error: ${error instanceof Error ? error.message : "Failed to get price history"}`,
-            uri: "getStockPriceHistory"
-          }
-        ],
-        isError: true
-      };
-    }
-  };
-};
-
-// src/tools/order.ts
-import { Field as Field2, Fields as Fields2, Messages as Messages2 } from "fixparser";
-var ordTypeNames = {
-  "1": "Market",
-  "2": "Limit",
-  "3": "Stop",
-  "4": "StopLimit",
-  "5": "MarketOnClose",
-  "6": "WithOrWithout",
-  "7": "LimitOrBetter",
-  "8": "LimitWithOrWithout",
-  "9": "OnBasis",
-  A: "OnClose",
-  B: "LimitOnClose",
-  C: "ForexMarket",
-  D: "PreviouslyQuoted",
-  E: "PreviouslyIndicated",
-  F: "ForexLimit",
-  G: "ForexSwap",
-  H: "ForexPreviouslyQuoted",
-  I: "Funari",
-  J: "MarketIfTouched",
-  K: "MarketWithLeftOverAsLimit",
-  L: "PreviousFundValuationPoint",
-  M: "NextFundValuationPoint",
-  P: "Pegged",
-  Q: "CounterOrderSelection",
-  R: "StopOnBidOrOffer",
-  S: "StopLimitOnBidOrOffer"
-};
-var sideNames = {
-  "1": "Buy",
-  "2": "Sell",
-  "3": "BuyMinus",
-  "4": "SellPlus",
-  "5": "SellShort",
-  "6": "SellShortExempt",
-  "7": "Undisclosed",
-  "8": "Cross",
-  "9": "CrossShort",
-  A: "CrossShortExempt",
-  B: "AsDefined",
-  C: "Opposite",
-  D: "Subscribe",
-  E: "Redeem",
-  F: "Lend",
-  G: "Borrow",
-  H: "SellUndisclosed"
-};
-var timeInForceNames = {
-  "0": "Day",
-  "1": "GoodTillCancel",
-  "2": "AtTheOpening",
-  "3": "ImmediateOrCancel",
-  "4": "FillOrKill",
-  "5": "GoodTillCrossing",
-  "6": "GoodTillDate",
-  "7": "AtTheClose",
-  "8": "GoodThroughCrossing",
-  "9": "AtCrossing",
-  A: "GoodForTime",
-  B: "GoodForAuction",
-  C: "GoodForMonth"
-};
-var handlInstNames = {
-  "1": "AutomatedExecutionNoIntervention",
-  "2": "AutomatedExecutionInterventionOK",
-  "3": "ManualOrder"
-};
-var createVerifyOrderHandler = (parser, verifiedOrders) => {
-  return async (args) => {
-    try {
-      verifiedOrders.set(args.clOrdID, {
-        clOrdID: args.clOrdID,
-        handlInst: args.handlInst,
-        quantity: Number.parseFloat(String(args.quantity)),
-        price: Number.parseFloat(String(args.price)),
-        ordType: args.ordType,
-        side: args.side,
-        symbol: args.symbol,
-        timeInForce: args.timeInForce
-      });
-      return {
-        content: [
-          {
-            type: "text",
-            text: `VERIFICATION: All parameters valid. Ready to proceed with order execution.
-                            
-Parameters verified:
-- ClOrdID: ${args.clOrdID}
-- HandlInst: ${args.handlInst} (${handlInstNames[args.handlInst]})
-- Quantity: ${args.quantity}
-- Price: ${args.price}
-- OrdType: ${args.ordType} (${ordTypeNames[args.ordType]})
-- Side: ${args.side} (${sideNames[args.side]})
-- Symbol: ${args.symbol}
-- TimeInForce: ${args.timeInForce} (${timeInForceNames[args.timeInForce]})
-
-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"
-          }
-        ]
-      };
-    } catch (error) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error: ${error instanceof Error ? error.message : "Failed to verify order parameters"}`,
-            uri: "verifyOrder"
-          }
-        ],
-        isError: true
-      };
-    }
-  };
-};
-var createExecuteOrderHandler = (parser, verifiedOrders, pendingRequests) => {
-  return async (args) => {
-    try {
-      const verifiedOrder = verifiedOrders.get(args.clOrdID);
-      if (!verifiedOrder) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error: Order ${args.clOrdID} has not been verified. Please call verifyOrder first.`,
-              uri: "executeOrder"
-            }
-          ],
-          isError: true
-        };
-      }
-      if (verifiedOrder.handlInst !== args.handlInst || verifiedOrder.quantity !== Number.parseFloat(String(args.quantity)) || verifiedOrder.price !== Number.parseFloat(String(args.price)) || verifiedOrder.ordType !== args.ordType || verifiedOrder.side !== args.side || verifiedOrder.symbol !== args.symbol || verifiedOrder.timeInForce !== args.timeInForce) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "Error: Order parameters do not match the verified order. Please use the exact same parameters that were verified.",
-              uri: "executeOrder"
-            }
-          ],
-          isError: true
-        };
-      }
-      const response = new Promise((resolve) => {
-        pendingRequests.set(args.clOrdID, resolve);
-      });
-      const order = parser.createMessage(
-        new Field2(Fields2.MsgType, Messages2.NewOrderSingle),
-        new Field2(Fields2.MsgSeqNum, parser.getNextTargetMsgSeqNum()),
-        new Field2(Fields2.SenderCompID, parser.sender),
-        new Field2(Fields2.TargetCompID, parser.target),
-        new Field2(Fields2.SendingTime, parser.getTimestamp()),
-        new Field2(Fields2.ClOrdID, args.clOrdID),
-        new Field2(Fields2.Side, args.side),
-        new Field2(Fields2.Symbol, args.symbol),
-        new Field2(Fields2.OrderQty, Number.parseFloat(String(args.quantity))),
-        new Field2(Fields2.Price, Number.parseFloat(String(args.price))),
-        new Field2(Fields2.OrdType, args.ordType),
-        new Field2(Fields2.HandlInst, args.handlInst),
-        new Field2(Fields2.TimeInForce, args.timeInForce),
-        new Field2(Fields2.TransactTime, parser.getTimestamp())
-      );
-      if (!parser.connected) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "Error: Not connected. Ignoring message.",
-              uri: "executeOrder"
-            }
-          ],
-          isError: true
-        };
-      }
-      parser.send(order);
-      const fixData = await response;
-      verifiedOrders.delete(args.clOrdID);
-      return {
-        content: [
-          {
-            type: "text",
-            text: fixData.messageType === Messages2.Reject ? `Reject message for order ${args.clOrdID}: ${JSON.stringify(fixData.toFIXJSON())}` : `Execution Report for order ${args.clOrdID}: ${JSON.stringify(fixData.toFIXJSON())}`,
-            uri: "executeOrder"
-          }
-        ]
-      };
-    } catch (error) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error: ${error instanceof Error ? error.message : "Failed to execute order"}`,
-            uri: "executeOrder"
-          }
-        ],
-        isError: true
-      };
-    }
-  };
-};
-
-// src/tools/parse.ts
-var createParseHandler = (parser) => {
-  return async (args) => {
-    try {
-      const parsedMessage = parser.parse(args.fixString);
-      if (!parsedMessage || parsedMessage.length === 0) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "Error: Failed to parse FIX string",
-              uri: "parse"
-            }
-          ],
-          isError: true
-        };
-      }
-      return {
-        content: [
-          {
-            type: "text",
-            text: `${parsedMessage[0].description}
-${parsedMessage[0].messageTypeDescription}`,
-            uri: "parse"
-          }
-        ]
-      };
-    } catch (error) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error: ${error instanceof Error ? error.message : "Failed to parse FIX string"}`,
-            uri: "parse"
-          }
-        ],
-        isError: true
-      };
-    }
-  };
-};
-
-// src/tools/parseToJSON.ts
-var createParseToJSONHandler = (parser) => {
-  return async (args) => {
-    try {
-      const parsedMessage = parser.parse(args.fixString);
-      if (!parsedMessage || parsedMessage.length === 0) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "Error: Failed to parse FIX string",
-              uri: "parseToJSON"
-            }
-          ],
-          isError: true
-        };
-      }
-      return {
-        content: [
-          {
-            type: "text",
-            text: `${parsedMessage[0].toFIXJSON()}`,
-            uri: "parseToJSON"
-          }
-        ]
-      };
-    } catch (error) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error: ${error instanceof Error ? error.message : "Failed to parse FIX string"}`,
-            uri: "parseToJSON"
-          }
-        ],
-        isError: true
-      };
-    }
-  };
-};
-
-// src/tools/index.ts
-var createToolHandlers = (parser, verifiedOrders, pendingRequests, marketDataPrices) => ({
-  parse: createParseHandler(parser),
-  parseToJSON: createParseToJSONHandler(parser),
-  verifyOrder: createVerifyOrderHandler(parser, verifiedOrders),
-  executeOrder: createExecuteOrderHandler(parser, verifiedOrders, pendingRequests),
-  marketDataRequest: createMarketDataRequestHandler(parser, pendingRequests),
-  getStockGraph: createGetStockGraphHandler(marketDataPrices),
-  getStockPriceHistory: createGetStockPriceHistoryHandler(marketDataPrices),
-  technicalAnalysis: createTechnicalAnalysisHandler(marketDataPrices)
-});
-
-// src/utils/messageHandler.ts
-import { Fields as Fields3, MDEntryType as MDEntryType2, Messages as Messages3 } from "fixparser";
-function getEnumValue(enumObj, name) {
-  return enumObj[name] || name;
-}
-function handleMessage(message, parser, pendingRequests, marketDataPrices, maxPriceHistory, onPriceUpdate) {
-  const msgType = message.messageType;
-  if (msgType === Messages3.MarketDataSnapshotFullRefresh || msgType === Messages3.MarketDataIncrementalRefresh) {
-    const symbol = message.getField(Fields3.Symbol)?.value;
-    const fixJson = message.toFIXJSON();
-    const entries = fixJson.Body?.NoMDEntries || [];
-    const data = {
-      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(MDEntryType2, entryType);
-      switch (enumValue) {
-        case MDEntryType2.Bid:
-          data.bid = price;
-          break;
-        case MDEntryType2.Offer:
-          data.offer = price;
-          break;
-        case MDEntryType2.Trade:
-          data.trade = price;
-          break;
-        case MDEntryType2.IndexValue:
-          data.indexValue = price;
-          break;
-        case MDEntryType2.OpeningPrice:
-          data.openingPrice = price;
-          break;
-        case MDEntryType2.ClosingPrice:
-          data.closingPrice = price;
-          break;
-        case MDEntryType2.SettlementPrice:
-          data.settlementPrice = price;
-          break;
-        case MDEntryType2.TradingSessionHighPrice:
-          data.tradingSessionHighPrice = price;
-          break;
-        case MDEntryType2.TradingSessionLowPrice:
-          data.tradingSessionLowPrice = price;
-          break;
-        case MDEntryType2.VWAP:
-          data.vwap = price;
-          break;
-        case MDEntryType2.Imbalance:
-          data.imbalance = size;
-          break;
-        case MDEntryType2.TradeVolume:
-          data.volume = size;
-          break;
-        case MDEntryType2.OpenInterest:
-          data.openInterest = size;
-          break;
-        case MDEntryType2.CompositeUnderlyingPrice:
-          data.compositeUnderlyingPrice = price;
-          break;
-        case MDEntryType2.SimulatedSellPrice:
-          data.simulatedSellPrice = price;
-          break;
-        case MDEntryType2.SimulatedBuyPrice:
-          data.simulatedBuyPrice = price;
-          break;
-        case MDEntryType2.MarginRate:
-          data.marginRate = price;
-          break;
-        case MDEntryType2.MidPrice:
-          data.midPrice = price;
-          break;
-        case MDEntryType2.EmptyBook:
-          data.emptyBook = 1;
-          break;
-        case MDEntryType2.SettleHighPrice:
-          data.settleHighPrice = price;
-          break;
-        case MDEntryType2.SettleLowPrice:
-          data.settleLowPrice = price;
-          break;
-        case MDEntryType2.PriorSettlePrice:
-          data.priorSettlePrice = price;
-          break;
-        case MDEntryType2.SessionHighBid:
-          data.sessionHighBid = price;
-          break;
-        case MDEntryType2.SessionLowOffer:
-          data.sessionLowOffer = price;
-          break;
-        case MDEntryType2.EarlyPrices:
-          data.earlyPrices = price;
-          break;
-        case MDEntryType2.AuctionClearingPrice:
-          data.auctionClearingPrice = price;
-          break;
-        case MDEntryType2.SwapValueFactor:
-          data.swapValueFactor = price;
-          break;
-        case MDEntryType2.DailyValueAdjustmentForLongPositions:
-          data.dailyValueAdjustmentForLongPositions = price;
-          break;
-        case MDEntryType2.CumulativeValueAdjustmentForLongPositions:
-          data.cumulativeValueAdjustmentForLongPositions = price;
-          break;
-        case MDEntryType2.DailyValueAdjustmentForShortPositions:
-          data.dailyValueAdjustmentForShortPositions = price;
-          break;
-        case MDEntryType2.CumulativeValueAdjustmentForShortPositions:
-          data.cumulativeValueAdjustmentForShortPositions = price;
-          break;
-        case MDEntryType2.FixingPrice:
-          data.fixingPrice = price;
-          break;
-        case MDEntryType2.CashRate:
-          data.cashRate = price;
-          break;
-        case MDEntryType2.RecoveryRate:
-          data.recoveryRate = price;
-          break;
-        case MDEntryType2.RecoveryRateForLong:
-          data.recoveryRateForLong = price;
-          break;
-        case MDEntryType2.RecoveryRateForShort:
-          data.recoveryRateForShort = price;
-          break;
-        case MDEntryType2.MarketBid:
-          data.marketBid = price;
-          break;
-        case MDEntryType2.MarketOffer:
-          data.marketOffer = price;
-          break;
-        case MDEntryType2.ShortSaleMinPrice:
-          data.shortSaleMinPrice = price;
-          break;
-        case MDEntryType2.PreviousClosingPrice:
-          data.previousClosingPrice = price;
-          break;
-        case MDEntryType2.ThresholdLimitPriceBanding:
-          data.thresholdLimitPriceBanding = price;
-          break;
-        case MDEntryType2.DailyFinancingValue:
-          data.dailyFinancingValue = price;
-          break;
-        case MDEntryType2.AccruedFinancingValue:
-          data.accruedFinancingValue = price;
-          break;
-        case MDEntryType2.TWAP:
-          data.twap = price;
-          break;
-      }
-    }
-    data.spread = data.offer - data.bid;
-    if (!marketDataPrices.has(symbol)) {
-      marketDataPrices.set(symbol, []);
-    }
-    const prices = marketDataPrices.get(symbol);
-    prices.push(data);
-    if (prices.length > maxPriceHistory) {
-      prices.splice(0, prices.length - maxPriceHistory);
-    }
-    onPriceUpdate?.(symbol, data);
-    const mdReqID = message.getField(Fields3.MDReqID)?.value;
-    if (mdReqID) {
-      const callback = pendingRequests.get(mdReqID);
-      if (callback) {
-        callback(message);
-        pendingRequests.delete(mdReqID);
-      }
-    }
-  } else if (msgType === Messages3.ExecutionReport) {
-    const reqId = message.getField(Fields3.ClOrdID)?.value;
-    const callback = pendingRequests.get(reqId);
-    if (callback) {
-      callback(message);
-      pendingRequests.delete(reqId);
-    }
-  }
-}
-
-// 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] = z.enum(propSchema.enum);
-        } else {
-          shape[key] = z.string();
-        }
-      } else if (propSchema.type === "number") {
-        shape[key] = z.number();
-      } else if (propSchema.type === "boolean") {
-        shape[key] = z.boolean();
-      } else if (propSchema.type === "array") {
-        if (propSchema.items.type === "string") {
-          shape[key] = z.array(z.string());
-        } else if (propSchema.items.type === "number") {
-          shape[key] = z.array(z.number());
-        } else if (propSchema.items.type === "boolean") {
-          shape[key] = z.array(z.boolean());
-        } else {
-          shape[key] = z.array(z.any());
-        }
-      } else {
-        shape[key] = z.any();
-      }
-    }
-    return shape;
-  }
-  return {};
-}
-var MCPRemote = class extends MCPBase {
-  /**
-   * Port number the server will listen on.
    * @private
    */
-  port;
+  parser;
   /**
    * Node.js HTTP server instance created internally.
    * @private
    */
-  httpServer;
+  server;
   /**
    * MCP server instance handling MCP protocol logic.
    * @private
@@ -2220,61 +46,89 @@ var MCPRemote = class extends MCPBase {
    * Optional name of the plugin/server instance.
    * @private
    */
-  serverName;
+  name;
   /**
    * Optional version string of the plugin/server.
    * @private
    */
-  serverVersion;
+  version;
   /**
-   * Map to store verified orders before execution
+   * Called when server is setup and listening.
    * @private
    */
-  verifiedOrders = /* @__PURE__ */ new Map();
+  onReady = void 0;
   /**
-   * Map to store pending requests and their callbacks
+   * A map of pending market data requests, keyed by MDReqID.
+   * Each entry contains a resolver function that is called when the corresponding
+   * FIX Message is received.
    * @private
+   * @type {Map<string, (data: Message) => void>}
    */
   pendingRequests = /* @__PURE__ */ new Map();
-  /**
-   * Map to store market data prices for each symbol
-   * @private
-   */
-  marketDataPrices = /* @__PURE__ */ new Map();
-  /**
-   * Maximum number of price history entries to keep per symbol
-   * @private
-   */
-  MAX_PRICE_HISTORY = 1e5;
   constructor({ port, logger, onReady }) {
-    super({ logger, onReady });
     this.port = port;
+    if (logger) this.logger = logger;
+    if (onReady) this.onReady = onReady;
   }
   async register(parser) {
     this.parser = parser;
+    this.parser.addOnMessageCallback((message) => {
+      this.logger?.log({
+        level: "info",
+        message: `FIXParser (MCP): (${parser.protocol?.toUpperCase()}): << received ${message.description}`
+      });
+      const msgType = message.messageType;
+      if (msgType === Messages.MarketDataSnapshotFullRefresh || msgType === Messages.ExecutionReport) {
+        const idField = msgType === Messages.MarketDataSnapshotFullRefresh ? message.getField(Fields.MDReqID) : message.getField(Fields.ClOrdID);
+        if (idField) {
+          const id = idField.value;
+          if (typeof id === "string" || typeof id === "number") {
+            const callback = this.pendingRequests.get(String(id));
+            if (callback) {
+              callback(message);
+              this.pendingRequests.delete(String(id));
+            }
+          }
+        }
+      }
+    });
     this.logger = parser.logger;
     this.logger?.log({
       level: "info",
       message: `FIXParser (MCP): -- Plugin registered. Creating MCP server on port ${this.port}...`
     });
-    this.parser.addOnMessageCallback((message) => {
-      if (this.parser) {
-        handleMessage(
-          message,
-          this.parser,
-          this.pendingRequests,
-          this.marketDataPrices,
-          this.MAX_PRICE_HISTORY
-        );
-      }
-    });
-    this.httpServer = createServer(async (req, res) => {
+    this.server = createServer(async (req, res) => {
       if (!req.url || !req.method) {
         res.writeHead(400);
         res.end("Bad Request");
         return;
       }
-      if (req.url === "/mcp") {
+      const url = new URL(req.url, `http://${req.headers.host}`);
+      if (url.pathname === "/.well-known/oauth-authorization-server") {
+        const config = {
+          issuer: "https://accounts.google.com",
+          authorization_endpoint: "https://accounts.google.com/o/oauth2/v2/auth",
+          token_endpoint: "https://oauth2.googleapis.com/token",
+          jwks_uri: "https://www.googleapis.com/oauth2/v3/certs",
+          response_types_supported: [
+            "code",
+            "token",
+            "id_token",
+            "code token",
+            "code id_token",
+            "token id_token",
+            "code token id_token"
+          ],
+          subject_types_supported: ["public"],
+          id_token_signing_alg_values_supported: ["RS256"],
+          scopes_supported: ["openid", "email", "profile"],
+          token_endpoint_auth_methods_supported: ["client_secret_basic", "client_secret_post"]
+        };
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify(config));
+        return;
+      }
+      if (url.pathname === "/") {
         const sessionId = req.headers["mcp-session-id"];
         if (req.method === "POST") {
           const bodyChunks = [];
@@ -2307,10 +161,10 @@ var MCPRemote = class extends MCPBase {
                 }
               };
               this.mcpServer = new McpServer({
-                name: this.serverName || "FIXParser",
-                version: this.serverVersion || "1.0.0"
+                name: this.name || "FIXParser",
+                version: this.version || "1.0.0"
               });
-              this.setupTools();
+              this.addWorkflows();
               await this.mcpServer.connect(transport);
             } else {
               res.writeHead(400, { "Content-Type": "application/json" });
@@ -2326,15 +180,7 @@ var MCPRemote = class extends MCPBase {
               );
               return;
             }
-            try {
-              await transport.handleRequest(req, res, parsed);
-            } catch (error) {
-              this.logger?.log({
-                level: "error",
-                message: `Error handling request: ${error}`
-              });
-              throw error;
-            }
+            await transport.handleRequest(req, res, parsed);
           });
         } else if (req.method === "GET" || req.method === "DELETE") {
           if (!sessionId || !transports[sessionId]) {
@@ -2343,29 +189,17 @@ var MCPRemote = class extends MCPBase {
             return;
           }
           const transport = transports[sessionId];
-          try {
-            await transport.handleRequest(req, res);
-          } catch (error) {
-            this.logger?.log({
-              level: "error",
-              message: `Error handling ${req.method} request: ${error}`
-            });
-            throw error;
-          }
+          await transport.handleRequest(req, res);
         } else {
-          this.logger?.log({
-            level: "error",
-            message: `Method not allowed: ${req.method}`
-          });
           res.writeHead(405);
           res.end("Method Not Allowed");
         }
-      } else {
-        res.writeHead(404);
-        res.end("Not Found");
+        return;
       }
+      res.writeHead(404);
+      res.end("Not Found");
     });
-    this.httpServer.listen(this.port, () => {
+    this.server.listen(this.port, () => {
       this.logger?.log({
         level: "info",
         message: `FIXParser (MCP): -- Server listening on http://localhost:${this.port}...`
@@ -2375,55 +209,381 @@ var MCPRemote = class extends MCPBase {
       this.onReady();
     }
   }
-  setupTools() {
+  addWorkflows() {
     if (!this.parser) {
       this.logger?.log({
         level: "error",
-        message: "FIXParser (MCP): -- FIXParser instance not initialized. Ignoring setup of tools..."
+        message: "FIXParser (MCP): -- FIXParser instance not initialized. Ignoring setup of workflows..."
       });
       return;
     }
     if (!this.mcpServer) {
       this.logger?.log({
         level: "error",
-        message: "FIXParser (MCP): -- MCP Server not initialized. Ignoring setup of tools..."
+        message: "FIXParser (MCP): -- MCP Server not initialized. Ignoring setup of workflows..."
       });
       return;
     }
-    const toolHandlers = createToolHandlers(
-      this.parser,
-      this.verifiedOrders,
-      this.pendingRequests,
-      this.marketDataPrices
+    this.mcpServer.tool(
+      "parse",
+      "Parses a FIX message and describes it in plain language",
+      { fixString: z.string() },
+      async ({ fixString }) => {
+        const parsedMessage = this.parser?.parse(fixString);
+        if (!parsedMessage || parsedMessage.length === 0) {
+          this.logger?.log({
+            level: "error",
+            message: "FIXParser (MCP): -- Failed to parse FIX string"
+          });
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: "Error: Failed to parse FIX string"
+              }
+            ]
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: parsedMessage ? `${parsedMessage[0].description} - ${parsedMessage[0].messageTypeDescription}` : ""
+            }
+          ]
+        };
+      }
     );
-    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
-            };
+    this.mcpServer.prompt(
+      "parse",
+      "Parses a FIX message and describes it in plain language",
+      { fixString: z.string() },
+      ({ fixString }) => ({
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Please parse and explain this FIX message: ${fixString}`
+            }
           }
-          const result = await handler(args);
+        ]
+      })
+    );
+    this.mcpServer.tool(
+      "parseToJSON",
+      "Parses a FIX message into JSON",
+      { fixString: z.string() },
+      async ({ fixString }) => {
+        const parsedMessage = this.parser?.parse(fixString);
+        if (!parsedMessage || parsedMessage.length === 0) {
+          this.logger?.log({
+            level: "error",
+            message: "FIXParser (MCP): -- Failed to parse FIX string"
+          });
           return {
-            content: result.content,
-            isError: result.isError
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: "Error: Failed to parse FIX string"
+              }
+            ]
           };
         }
-      );
-    });
+        return {
+          content: [
+            {
+              type: "text",
+              text: parsedMessage ? JSON.stringify(parsedMessage[0].toFIXJSON()) : ""
+            }
+          ]
+        };
+      }
+    );
+    this.mcpServer.prompt(
+      "parseToJSON",
+      "Parses a FIX message into JSON",
+      { fixString: z.string() },
+      ({ fixString }) => ({
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `Please parse the FIX message to JSON: ${fixString}`
+            }
+          }
+        ]
+      })
+    );
+    this.mcpServer.tool(
+      "newOrderSingle",
+      "Creates and sends a New Order Single",
+      {
+        clOrdID: z.string(),
+        handlInst: z.enum(["1", "2", "3"]).default(HandlInst.AutomatedExecutionNoIntervention).optional(),
+        quantity: z.number(),
+        price: z.number(),
+        ordType: z.enum([
+          "1",
+          "2",
+          "3",
+          "4",
+          "5",
+          "6",
+          "7",
+          "8",
+          "9",
+          "A",
+          "B",
+          "C",
+          "D",
+          "E",
+          "F",
+          "G",
+          "H",
+          "I",
+          "J",
+          "K",
+          "L",
+          "M",
+          "P",
+          "Q",
+          "R",
+          "S"
+        ]).default(OrdType.Market).optional(),
+        side: z.enum(["1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H"]),
+        // 1 = Buy, 2 = Sell...
+        symbol: z.string(),
+        timeInForce: z.enum(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C"]).default(TimeInForce.Day).optional()
+      },
+      async ({ clOrdID, handlInst, quantity, price, ordType, side, symbol, timeInForce }) => {
+        const response = new Promise((resolve) => {
+          this.pendingRequests.set(clOrdID, resolve);
+        });
+        const order = this.parser?.createMessage(
+          new Field(Fields.MsgType, Messages.NewOrderSingle),
+          new Field(Fields.MsgSeqNum, this.parser?.getNextTargetMsgSeqNum()),
+          new Field(Fields.SenderCompID, this.parser?.sender),
+          new Field(Fields.TargetCompID, this.parser?.target),
+          new Field(Fields.SendingTime, this.parser?.getTimestamp()),
+          new Field(Fields.ClOrdID, clOrdID),
+          new Field(Fields.Side, side),
+          new Field(Fields.Symbol, symbol),
+          new Field(Fields.OrderQty, quantity),
+          new Field(Fields.Price, price),
+          new Field(Fields.OrdType, ordType),
+          new Field(Fields.HandlInst, handlInst),
+          new Field(Fields.TimeInForce, timeInForce),
+          new Field(Fields.TransactTime, this.parser?.getTimestamp())
+        );
+        if (!this.parser?.connected) {
+          this.logger?.log({
+            level: "error",
+            message: "FIXParser (MCP): -- Not connected. Ignoring message."
+          });
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: "Error: Not connected. Ignoring message."
+              }
+            ]
+          };
+        }
+        this.parser?.send(order);
+        this.logger?.log({
+          level: "info",
+          message: `FIXParser (MCP): (${this.parser?.protocol?.toUpperCase()}): >> sent ${order?.description}`
+        });
+        const fixData = await response;
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Execution Report for order ${clOrdID}: ${JSON.stringify(fixData.toFIXJSON())}`
+            }
+          ]
+        };
+      }
+    );
+    this.mcpServer.prompt(
+      "newOrderSingle",
+      "Creates and sends a New Order Single",
+      {
+        clOrdID: z.string(),
+        handlInst: z.string(),
+        quantity: z.string(),
+        price: z.string(),
+        ordType: z.string(),
+        side: z.string(),
+        symbol: z.string(),
+        timeInForce: z.string()
+      },
+      ({ clOrdID, handlInst, quantity, price, ordType, side, symbol, timeInForce }) => ({
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: [
+                "Create a New Order Single FIX message with the following parameters:",
+                `- ClOrdID: ${clOrdID}`,
+                `- HandlInst: ${handlInst ?? "default"}`,
+                `- Quantity: ${quantity}`,
+                `- Price: ${price}`,
+                `- OrdType: ${ordType ?? "default (Market)"}`,
+                `- Side: ${side}`,
+                `- Symbol: ${symbol}`,
+                `- TimeInForce: ${timeInForce ?? "default (Day)"}`,
+                "",
+                "Format the response as a JSON object with FIX tag numbers as keys and their corresponding values."
+              ].join("\n")
+            }
+          }
+        ]
+      })
+    );
+    this.mcpServer.tool(
+      "marketDataRequest",
+      "Sends a request for Market Data with the given symbol",
+      {
+        mdUpdateType: z.enum(["0", "1"]).default("0").optional(),
+        // MDUpdateType.FullRefresh
+        symbol: z.string(),
+        mdReqID: z.string(),
+        subscriptionRequestType: z.enum(["0", "1", "2"]).default(SubscriptionRequestType.SnapshotAndUpdates).optional(),
+        mdEntryType: z.enum([
+          "0",
+          "1",
+          "2",
+          "3",
+          "4",
+          "5",
+          "6",
+          "7",
+          "8",
+          "9",
+          "A",
+          "B",
+          "C",
+          "D",
+          "E",
+          "F",
+          "G",
+          "H",
+          "J",
+          "K",
+          "L",
+          "M",
+          "N",
+          "O",
+          "P",
+          "Q",
+          "S",
+          "R",
+          "T",
+          "U",
+          "V",
+          "W",
+          "X",
+          "Y",
+          "Z",
+          "a",
+          "b",
+          "c",
+          "d",
+          "e",
+          "g",
+          "h",
+          "i",
+          "t"
+        ]).default(MDEntryType.Bid).optional()
+      },
+      async ({ mdUpdateType, symbol, mdReqID, subscriptionRequestType, mdEntryType }) => {
+        const response = new Promise((resolve) => {
+          this.pendingRequests.set(mdReqID, resolve);
+        });
+        const marketDataRequest = this.parser?.createMessage(
+          new Field(Fields.MsgType, Messages.MarketDataRequest),
+          new Field(Fields.SenderCompID, this.parser?.sender),
+          new Field(Fields.MsgSeqNum, this.parser?.getNextTargetMsgSeqNum()),
+          new Field(Fields.TargetCompID, this.parser?.target),
+          new Field(Fields.SendingTime, this.parser?.getTimestamp()),
+          new Field(Fields.MarketDepth, 0),
+          new Field(Fields.MDUpdateType, mdUpdateType),
+          new Field(Fields.NoRelatedSym, 1),
+          new Field(Fields.Symbol, symbol),
+          new Field(Fields.MDReqID, mdReqID),
+          new Field(Fields.SubscriptionRequestType, subscriptionRequestType),
+          new Field(Fields.NoMDEntryTypes, 1),
+          new Field(Fields.MDEntryType, mdEntryType)
+        );
+        if (!this.parser?.connected) {
+          this.logger?.log({
+            level: "error",
+            message: "FIXParser (MCP): -- Not connected. Ignoring message."
+          });
+          return {
+            isError: true,
+            content: [
+              {
+                type: "text",
+                text: "Error: Not connected. Ignoring message."
+              }
+            ]
+          };
+        }
+        this.parser?.send(marketDataRequest);
+        this.logger?.log({
+          level: "info",
+          message: `FIXParser (MCP): (${this.parser?.protocol?.toUpperCase()}): >> sent ${marketDataRequest?.description}`
+        });
+        const fixData = await response;
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Market data for ${symbol}: ${JSON.stringify(fixData.toFIXJSON())}`
+            }
+          ]
+        };
+      }
+    );
+    this.mcpServer.prompt(
+      "marketDataRequest",
+      "Sends a request for Market Data with the given symbol",
+      {
+        mdUpdateType: z.string(),
+        symbol: z.string(),
+        mdReqID: z.string(),
+        subscriptionRequestType: z.string(),
+        mdEntryType: z.string()
+      },
+      ({ mdUpdateType, symbol, mdReqID, subscriptionRequestType, mdEntryType }) => ({
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: [
+                "Create a Market Data Request FIX message with the following parameters:",
+                `- MDUpdateType: ${mdUpdateType ?? "default (0 = FullRefresh)"}`,
+                `- Symbol: ${symbol}`,
+                `- MDReqID: ${mdReqID}`,
+                `- SubscriptionRequestType: ${subscriptionRequestType ?? "default (0 = Snapshot + Updates)"}`,
+                `- MDEntryType: ${mdEntryType ?? "default (0 = Bid)"}`,
+                "",
+                "Format the response as a JSON object with FIX tag numbers as keys and their corresponding values."
+              ].join("\n")
+            }
+          }
+        ]
+      })
+    );
   }
 };
 export {