fixparser-plugin-mcp 9.1.7-63c797c5 → 9.1.7-67ba45e9

package/build/esm/MCPLocal.mjs

@@ -129,7 +129,7 @@ var toolSchemas = {
     }
   },
   executeOrder: {
-    description: "Executes a verified order. verifyOrder must be called before executeOrder. user has to explicitly allow executeOrder.",
+    description: "Executes a verified order. verifyOrder must be called before executeOrder.",
     schema: {
       type: "object",
       properties: {
@@ -282,10 +282,63 @@ 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.TradeVolume];
+      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),
@@ -307,6 +360,10 @@ var createMarketDataRequestHandler = (parser, pendingRequests) => {
       });
       const mdr = parser.createMessage(...messageFields);
       if (!parser.connected) {
+        parser.logger.log({
+          level: "error",
+          message: "Not connected. Cannot send market data request."
+        });
         return {
           content: [
             {
@@ -318,8 +375,16 @@ var createMarketDataRequestHandler = (parser, pendingRequests) => {
           isError: true
         };
       }
+      parser.logger.log({
+        level: "info",
+        message: `Sending market data request message: ${JSON.stringify(mdr?.toFIXJSON())}`
+      });
       parser.send(mdr);
       const fixData = await response;
+      parser.logger.log({
+        level: "info",
+        message: `Received market data response for request ID: ${args.mdReqID}`
+      });
       return {
         content: [
           {
@@ -368,6 +433,9 @@ var createGetStockGraphHandler = (marketDataPrices) => {
       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: {
@@ -397,6 +465,30 @@ var createGetStockGraphHandler = (marketDataPrices) => {
               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,
@@ -442,7 +534,7 @@ var createGetStockGraphHandler = (marketDataPrices) => {
         content: [
           {
             type: "text",
-            text: `Error: ${error instanceof Error ? error.message : "Failed to generate chart"}`,
+            text: `Error: ${error instanceof Error ? error.message : "Failed to generate graph"}`,
             uri: "getStockGraph"
           }
         ],
@@ -480,7 +572,48 @@ var createGetStockPriceHistoryHandler = (marketDataPrices) => {
                   bid: point.bid,
                   offer: point.offer,
                   spread: point.spread,
-                  volume: point.volume
+                  volume: point.volume,
+                  trade: point.trade,
+                  indexValue: point.indexValue,
+                  openingPrice: point.openingPrice,
+                  closingPrice: point.closingPrice,
+                  settlementPrice: point.settlementPrice,
+                  tradingSessionHighPrice: point.tradingSessionHighPrice,
+                  tradingSessionLowPrice: point.tradingSessionLowPrice,
+                  vwap: point.vwap,
+                  imbalance: point.imbalance,
+                  openInterest: point.openInterest,
+                  compositeUnderlyingPrice: point.compositeUnderlyingPrice,
+                  simulatedSellPrice: point.simulatedSellPrice,
+                  simulatedBuyPrice: point.simulatedBuyPrice,
+                  marginRate: point.marginRate,
+                  midPrice: point.midPrice,
+                  emptyBook: point.emptyBook,
+                  settleHighPrice: point.settleHighPrice,
+                  settleLowPrice: point.settleLowPrice,
+                  priorSettlePrice: point.priorSettlePrice,
+                  sessionHighBid: point.sessionHighBid,
+                  sessionLowOffer: point.sessionLowOffer,
+                  earlyPrices: point.earlyPrices,
+                  auctionClearingPrice: point.auctionClearingPrice,
+                  swapValueFactor: point.swapValueFactor,
+                  dailyValueAdjustmentForLongPositions: point.dailyValueAdjustmentForLongPositions,
+                  cumulativeValueAdjustmentForLongPositions: point.cumulativeValueAdjustmentForLongPositions,
+                  dailyValueAdjustmentForShortPositions: point.dailyValueAdjustmentForShortPositions,
+                  cumulativeValueAdjustmentForShortPositions: point.cumulativeValueAdjustmentForShortPositions,
+                  fixingPrice: point.fixingPrice,
+                  cashRate: point.cashRate,
+                  recoveryRate: point.recoveryRate,
+                  recoveryRateForLong: point.recoveryRateForLong,
+                  recoveryRateForShort: point.recoveryRateForShort,
+                  marketBid: point.marketBid,
+                  marketOffer: point.marketOffer,
+                  shortSaleMinPrice: point.shortSaleMinPrice,
+                  previousClosingPrice: point.previousClosingPrice,
+                  thresholdLimitPriceBanding: point.thresholdLimitPriceBanding,
+                  dailyFinancingValue: point.dailyFinancingValue,
+                  accruedFinancingValue: point.accruedFinancingValue,
+                  twap: point.twap
                 }))
               },
               null,
@@ -495,7 +628,7 @@ var createGetStockPriceHistoryHandler = (marketDataPrices) => {
         content: [
           {
             type: "text",
-            text: `Error: ${error instanceof Error ? error.message : "Failed to get stock price history"}`,
+            text: `Error: ${error instanceof Error ? error.message : "Failed to get price history"}`,
             uri: "getStockPriceHistory"
           }
         ],
@@ -603,7 +736,7 @@ Parameters verified:
 - Symbol: ${args.symbol}
 - TimeInForce: ${args.timeInForce} (${timeInForceNames[args.timeInForce]})
 
-To execute this order, call the executeOrder tool with these exact same parameters.`,
+To execute this order, call the executeOrder tool with these exact same parameters. Important: The user has to explicitly confirm before executeOrder is called!`,
             uri: "verifyOrder"
           }
         ]
@@ -804,52 +937,256 @@ var createToolHandlers = (parser, verifiedOrders, pendingRequests, marketDataPri
 
 // 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) {
   parser.logger.log({
     level: "info",
     message: `MCP Server received message: ${message.messageType}: ${message.description}`
   });
   const msgType = message.messageType;
-  if (msgType === Messages3.MarketDataSnapshotFullRefresh) {
+  if (msgType === Messages3.MarketDataSnapshotFullRefresh || msgType === Messages3.MarketDataIncrementalRefresh) {
     const symbol = message.getField(Fields3.Symbol)?.value;
-    const entries = message.getField(Fields3.NoMDEntries)?.value;
-    let bid = 0;
-    let offer = 0;
-    let volume = 0;
-    const entryTypes = message.getFields(Fields3.MDEntryType);
-    const entryPrices = message.getFields(Fields3.MDEntryPx);
-    const entrySizes = message.getFields(Fields3.MDEntrySize);
-    if (entryTypes && entryPrices && entrySizes) {
-      for (let i = 0; i < entries; i++) {
-        const entryType = entryTypes[i]?.value;
-        const entryPrice = Number.parseFloat(entryPrices[i]?.value);
-        const entrySize = Number.parseFloat(entrySizes[i]?.value);
-        if (entryType === MDEntryType2.Bid) {
-          bid = entryPrice;
-        } else if (entryType === MDEntryType2.Offer) {
-          offer = entryPrice;
-        }
-        volume += entrySize;
-      }
-    }
-    const spread = offer - bid;
-    const timestamp = Date.now();
+    parser.logger.log({
+      level: "info",
+      message: `Processing market data for symbol: ${symbol}`
+    });
+    const fixJson = message.toFIXJSON();
+    const entries = fixJson.Body?.NoMDEntries || [];
+    parser.logger.log({
+      level: "info",
+      message: `Found ${entries.length} market data entries`
+    });
     const data = {
-      timestamp,
-      bid,
-      offer,
-      spread,
-      volume
+      timestamp: Date.now(),
+      bid: 0,
+      offer: 0,
+      spread: 0,
+      volume: 0,
+      trade: 0,
+      indexValue: 0,
+      openingPrice: 0,
+      closingPrice: 0,
+      settlementPrice: 0,
+      tradingSessionHighPrice: 0,
+      tradingSessionLowPrice: 0,
+      vwap: 0,
+      imbalance: 0,
+      openInterest: 0,
+      compositeUnderlyingPrice: 0,
+      simulatedSellPrice: 0,
+      simulatedBuyPrice: 0,
+      marginRate: 0,
+      midPrice: 0,
+      emptyBook: 0,
+      settleHighPrice: 0,
+      settleLowPrice: 0,
+      priorSettlePrice: 0,
+      sessionHighBid: 0,
+      sessionLowOffer: 0,
+      earlyPrices: 0,
+      auctionClearingPrice: 0,
+      swapValueFactor: 0,
+      dailyValueAdjustmentForLongPositions: 0,
+      cumulativeValueAdjustmentForLongPositions: 0,
+      dailyValueAdjustmentForShortPositions: 0,
+      cumulativeValueAdjustmentForShortPositions: 0,
+      fixingPrice: 0,
+      cashRate: 0,
+      recoveryRate: 0,
+      recoveryRateForLong: 0,
+      recoveryRateForShort: 0,
+      marketBid: 0,
+      marketOffer: 0,
+      shortSaleMinPrice: 0,
+      previousClosingPrice: 0,
+      thresholdLimitPriceBanding: 0,
+      dailyFinancingValue: 0,
+      accruedFinancingValue: 0,
+      twap: 0
     };
+    for (const entry of entries) {
+      const entryType = entry.MDEntryType;
+      const price = entry.MDEntryPx ? Number.parseFloat(entry.MDEntryPx) : 0;
+      const size = entry.MDEntrySize ? Number.parseFloat(entry.MDEntrySize) : 0;
+      if (entryType === MDEntryType2.Bid || entryType === MDEntryType2.Offer || entryType === MDEntryType2.TradeVolume) {
+        parser.logger.log({
+          level: "info",
+          message: `Market Data Entry - Type: ${entryType}, Price: ${price}, Size: ${size}`
+        });
+      }
+      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;
+    console.log(">>>>>>>>>>>>>>>>>>>>", data);
     if (!marketDataPrices.has(symbol)) {
+      parser.logger.log({
+        level: "info",
+        message: `Creating new price history array for symbol: ${symbol}`
+      });
       marketDataPrices.set(symbol, []);
     }
     const prices = marketDataPrices.get(symbol);
     prices.push(data);
+    parser.logger.log({
+      level: "info",
+      message: `Updated price history for ${symbol}. Current size: ${prices.length}`
+    });
     if (prices.length > maxPriceHistory) {
       prices.splice(0, prices.length - maxPriceHistory);
+      parser.logger.log({
+        level: "info",
+        message: `Trimmed price history for ${symbol} to ${maxPriceHistory} entries`
+      });
     }
     onPriceUpdate?.(symbol, data);
+    const mdReqID = message.getField(Fields3.MDReqID)?.value;
+    if (mdReqID) {
+      const callback = pendingRequests.get(mdReqID);
+      if (callback) {
+        callback(message);
+        pendingRequests.delete(mdReqID);
+        parser.logger.log({
+          level: "info",
+          message: `Resolved market data request for ID: ${mdReqID}`
+        });
+      }
+    }
   } else if (msgType === Messages3.ExecutionReport) {
     const reqId = message.getField(Fields3.ClOrdID)?.value;
     const callback = pendingRequests.get(reqId);
@@ -878,7 +1215,7 @@ var MCPLocal = class extends MCPBase {
    */
   marketDataPrices = /* @__PURE__ */ new Map();
   /**
-   * Maximum number of price points to store per symbol
+   * Maximum number of price history entries to keep per symbol
    * @private
    */
   MAX_PRICE_HISTORY = 1e5;