fixparser-plugin-mcp 9.1.7-52ccb1d5 → 9.1.7-537ecaee

package/build/cjs/MCPLocal.js

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,14 +15,6 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/MCPLocal.ts
@@ -35,52 +25,8 @@ __export(MCPLocal_exports, {
 module.exports = __toCommonJS(MCPLocal_exports);
 var import_server = require("@modelcontextprotocol/sdk/server/index.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_fixparser = require("fixparser");
 var import_zod = require("zod");
-
-// src/MCPBase.ts
-var MCPBase = class {
-  /**
-   * Optional logger instance for diagnostics and output.
-   * @protected
-   */
-  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",
@@ -163,7 +109,7 @@ var toolSchemas = {
     }
   },
   executeOrder: {
-    description: "Executes a verified order. verifyOrder must be called before executeOrder.",
+    description: "Executes a verified order. verifyOrder must be called before executeOrder. user has to explicitly allow executeOrder.",
     schema: {
       type: "object",
       properties: {
@@ -280,12 +226,12 @@ var toolSchemas = {
               "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"
+            ],
+            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"]
+      required: ["mdUpdateType", "symbols", "mdReqID", "subscriptionRequestType", "mdEntryTypes"]
     }
   },
   getStockGraph: {
@@ -309,895 +255,8 @@ var toolSchemas = {
     }
   }
 };
-
-// src/tools/marketData.ts
-var import_fixparser = require("fixparser");
-var import_quickchart_js = __toESM(require("quickchart-js"), 1);
-var createMarketDataRequestHandler = (parser, pendingRequests) => {
-  return async (args) => {
-    try {
-      const response = new Promise((resolve) => {
-        pendingRequests.set(args.mdReqID, resolve);
-      });
-      const entryTypes = args.mdEntryTypes || [
-        import_fixparser.MDEntryType.Bid,
-        import_fixparser.MDEntryType.Offer,
-        import_fixparser.MDEntryType.Trade,
-        import_fixparser.MDEntryType.IndexValue,
-        import_fixparser.MDEntryType.OpeningPrice,
-        import_fixparser.MDEntryType.ClosingPrice,
-        import_fixparser.MDEntryType.SettlementPrice,
-        import_fixparser.MDEntryType.TradingSessionHighPrice,
-        import_fixparser.MDEntryType.TradingSessionLowPrice,
-        import_fixparser.MDEntryType.VWAP,
-        import_fixparser.MDEntryType.Imbalance,
-        import_fixparser.MDEntryType.TradeVolume,
-        import_fixparser.MDEntryType.OpenInterest,
-        import_fixparser.MDEntryType.CompositeUnderlyingPrice,
-        import_fixparser.MDEntryType.SimulatedSellPrice,
-        import_fixparser.MDEntryType.SimulatedBuyPrice,
-        import_fixparser.MDEntryType.MarginRate,
-        import_fixparser.MDEntryType.MidPrice,
-        import_fixparser.MDEntryType.EmptyBook,
-        import_fixparser.MDEntryType.SettleHighPrice,
-        import_fixparser.MDEntryType.SettleLowPrice,
-        import_fixparser.MDEntryType.PriorSettlePrice,
-        import_fixparser.MDEntryType.SessionHighBid,
-        import_fixparser.MDEntryType.SessionLowOffer,
-        import_fixparser.MDEntryType.EarlyPrices,
-        import_fixparser.MDEntryType.AuctionClearingPrice,
-        import_fixparser.MDEntryType.SwapValueFactor,
-        import_fixparser.MDEntryType.DailyValueAdjustmentForLongPositions,
-        import_fixparser.MDEntryType.CumulativeValueAdjustmentForLongPositions,
-        import_fixparser.MDEntryType.DailyValueAdjustmentForShortPositions,
-        import_fixparser.MDEntryType.CumulativeValueAdjustmentForShortPositions,
-        import_fixparser.MDEntryType.FixingPrice,
-        import_fixparser.MDEntryType.CashRate,
-        import_fixparser.MDEntryType.RecoveryRate,
-        import_fixparser.MDEntryType.RecoveryRateForLong,
-        import_fixparser.MDEntryType.RecoveryRateForShort,
-        import_fixparser.MDEntryType.MarketBid,
-        import_fixparser.MDEntryType.MarketOffer,
-        import_fixparser.MDEntryType.ShortSaleMinPrice,
-        import_fixparser.MDEntryType.PreviousClosingPrice,
-        import_fixparser.MDEntryType.ThresholdLimitPriceBanding,
-        import_fixparser.MDEntryType.DailyFinancingValue,
-        import_fixparser.MDEntryType.AccruedFinancingValue,
-        import_fixparser.MDEntryType.TWAP
-      ];
-      const messageFields = [
-        new import_fixparser.Field(import_fixparser.Fields.MsgType, import_fixparser.Messages.MarketDataRequest),
-        new import_fixparser.Field(import_fixparser.Fields.SenderCompID, parser.sender),
-        new import_fixparser.Field(import_fixparser.Fields.MsgSeqNum, parser.getNextTargetMsgSeqNum()),
-        new import_fixparser.Field(import_fixparser.Fields.TargetCompID, parser.target),
-        new import_fixparser.Field(import_fixparser.Fields.SendingTime, parser.getTimestamp()),
-        new import_fixparser.Field(import_fixparser.Fields.MDReqID, args.mdReqID),
-        new import_fixparser.Field(import_fixparser.Fields.SubscriptionRequestType, args.subscriptionRequestType),
-        new import_fixparser.Field(import_fixparser.Fields.MarketDepth, 0),
-        new import_fixparser.Field(import_fixparser.Fields.MDUpdateType, args.mdUpdateType)
-      ];
-      messageFields.push(new import_fixparser.Field(import_fixparser.Fields.NoRelatedSym, args.symbols.length));
-      args.symbols.forEach((symbol) => {
-        messageFields.push(new import_fixparser.Field(import_fixparser.Fields.Symbol, symbol));
-      });
-      messageFields.push(new import_fixparser.Field(import_fixparser.Fields.NoMDEntryTypes, entryTypes.length));
-      entryTypes.forEach((entryType) => {
-        messageFields.push(new import_fixparser.Field(import_fixparser.Fields.MDEntryType, entryType));
-      });
-      const mdr = parser.createMessage(...messageFields);
-      if (!parser.connected) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "Error: Not connected. Ignoring message.",
-              uri: "marketDataRequest"
-            }
-          ],
-          isError: true
-        };
-      }
-      parser.send(mdr);
-      const fixData = await response;
-      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 import_quickchart_js.default();
-      chart.setWidth(1200);
-      chart.setHeight(600);
-      chart.setBackgroundColor("transparent");
-      const labels = priceHistory.map((point) => new Date(point.timestamp).toLocaleTimeString());
-      const bidData = priceHistory.map((point) => point.bid);
-      const offerData = priceHistory.map((point) => point.offer);
-      const spreadData = priceHistory.map((point) => point.spread);
-      const volumeData = priceHistory.map((point) => point.volume);
-      const 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
-var import_fixparser2 = require("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.`,
-            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 import_fixparser2.Field(import_fixparser2.Fields.MsgType, import_fixparser2.Messages.NewOrderSingle),
-        new import_fixparser2.Field(import_fixparser2.Fields.MsgSeqNum, parser.getNextTargetMsgSeqNum()),
-        new import_fixparser2.Field(import_fixparser2.Fields.SenderCompID, parser.sender),
-        new import_fixparser2.Field(import_fixparser2.Fields.TargetCompID, parser.target),
-        new import_fixparser2.Field(import_fixparser2.Fields.SendingTime, parser.getTimestamp()),
-        new import_fixparser2.Field(import_fixparser2.Fields.ClOrdID, args.clOrdID),
-        new import_fixparser2.Field(import_fixparser2.Fields.Side, args.side),
-        new import_fixparser2.Field(import_fixparser2.Fields.Symbol, args.symbol),
-        new import_fixparser2.Field(import_fixparser2.Fields.OrderQty, Number.parseFloat(String(args.quantity))),
-        new import_fixparser2.Field(import_fixparser2.Fields.Price, Number.parseFloat(String(args.price))),
-        new import_fixparser2.Field(import_fixparser2.Fields.OrdType, args.ordType),
-        new import_fixparser2.Field(import_fixparser2.Fields.HandlInst, args.handlInst),
-        new import_fixparser2.Field(import_fixparser2.Fields.TimeInForce, args.timeInForce),
-        new import_fixparser2.Field(import_fixparser2.Fields.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 === import_fixparser2.Messages.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)
-});
-
-// src/utils/messageHandler.ts
-var import_fixparser3 = require("fixparser");
-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 === import_fixparser3.Messages.MarketDataSnapshotFullRefresh || msgType === import_fixparser3.Messages.MarketDataIncrementalRefresh) {
-    const symbol = message.getField(import_fixparser3.Fields.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;
-      switch (entryType) {
-        case import_fixparser3.MDEntryType.Bid:
-          data.bid = price;
-          break;
-        case import_fixparser3.MDEntryType.Offer:
-          data.offer = price;
-          break;
-        case import_fixparser3.MDEntryType.Trade:
-          data.trade = price;
-          break;
-        case import_fixparser3.MDEntryType.IndexValue:
-          data.indexValue = price;
-          break;
-        case import_fixparser3.MDEntryType.OpeningPrice:
-          data.openingPrice = price;
-          break;
-        case import_fixparser3.MDEntryType.ClosingPrice:
-          data.closingPrice = price;
-          break;
-        case import_fixparser3.MDEntryType.SettlementPrice:
-          data.settlementPrice = price;
-          break;
-        case import_fixparser3.MDEntryType.TradingSessionHighPrice:
-          data.tradingSessionHighPrice = price;
-          break;
-        case import_fixparser3.MDEntryType.TradingSessionLowPrice:
-          data.tradingSessionLowPrice = price;
-          break;
-        case import_fixparser3.MDEntryType.VWAP:
-          data.vwap = price;
-          break;
-        case import_fixparser3.MDEntryType.Imbalance:
-          data.imbalance = size;
-          break;
-        case import_fixparser3.MDEntryType.TradeVolume:
-          data.volume = size;
-          break;
-        case import_fixparser3.MDEntryType.OpenInterest:
-          data.openInterest = size;
-          break;
-        case import_fixparser3.MDEntryType.CompositeUnderlyingPrice:
-          data.compositeUnderlyingPrice = price;
-          break;
-        case import_fixparser3.MDEntryType.SimulatedSellPrice:
-          data.simulatedSellPrice = price;
-          break;
-        case import_fixparser3.MDEntryType.SimulatedBuyPrice:
-          data.simulatedBuyPrice = price;
-          break;
-        case import_fixparser3.MDEntryType.MarginRate:
-          data.marginRate = price;
-          break;
-        case import_fixparser3.MDEntryType.MidPrice:
-          data.midPrice = price;
-          break;
-        case import_fixparser3.MDEntryType.EmptyBook:
-          data.emptyBook = 1;
-          break;
-        case import_fixparser3.MDEntryType.SettleHighPrice:
-          data.settleHighPrice = price;
-          break;
-        case import_fixparser3.MDEntryType.SettleLowPrice:
-          data.settleLowPrice = price;
-          break;
-        case import_fixparser3.MDEntryType.PriorSettlePrice:
-          data.priorSettlePrice = price;
-          break;
-        case import_fixparser3.MDEntryType.SessionHighBid:
-          data.sessionHighBid = price;
-          break;
-        case import_fixparser3.MDEntryType.SessionLowOffer:
-          data.sessionLowOffer = price;
-          break;
-        case import_fixparser3.MDEntryType.EarlyPrices:
-          data.earlyPrices = price;
-          break;
-        case import_fixparser3.MDEntryType.AuctionClearingPrice:
-          data.auctionClearingPrice = price;
-          break;
-        case import_fixparser3.MDEntryType.SwapValueFactor:
-          data.swapValueFactor = price;
-          break;
-        case import_fixparser3.MDEntryType.DailyValueAdjustmentForLongPositions:
-          data.dailyValueAdjustmentForLongPositions = price;
-          break;
-        case import_fixparser3.MDEntryType.CumulativeValueAdjustmentForLongPositions:
-          data.cumulativeValueAdjustmentForLongPositions = price;
-          break;
-        case import_fixparser3.MDEntryType.DailyValueAdjustmentForShortPositions:
-          data.dailyValueAdjustmentForShortPositions = price;
-          break;
-        case import_fixparser3.MDEntryType.CumulativeValueAdjustmentForShortPositions:
-          data.cumulativeValueAdjustmentForShortPositions = price;
-          break;
-        case import_fixparser3.MDEntryType.FixingPrice:
-          data.fixingPrice = price;
-          break;
-        case import_fixparser3.MDEntryType.CashRate:
-          data.cashRate = price;
-          break;
-        case import_fixparser3.MDEntryType.RecoveryRate:
-          data.recoveryRate = price;
-          break;
-        case import_fixparser3.MDEntryType.RecoveryRateForLong:
-          data.recoveryRateForLong = price;
-          break;
-        case import_fixparser3.MDEntryType.RecoveryRateForShort:
-          data.recoveryRateForShort = price;
-          break;
-        case import_fixparser3.MDEntryType.MarketBid:
-          data.marketBid = price;
-          break;
-        case import_fixparser3.MDEntryType.MarketOffer:
-          data.marketOffer = price;
-          break;
-        case import_fixparser3.MDEntryType.ShortSaleMinPrice:
-          data.shortSaleMinPrice = price;
-          break;
-        case import_fixparser3.MDEntryType.PreviousClosingPrice:
-          data.previousClosingPrice = price;
-          break;
-        case import_fixparser3.MDEntryType.ThresholdLimitPriceBanding:
-          data.thresholdLimitPriceBanding = price;
-          break;
-        case import_fixparser3.MDEntryType.DailyFinancingValue:
-          data.dailyFinancingValue = price;
-          break;
-        case import_fixparser3.MDEntryType.AccruedFinancingValue:
-          data.accruedFinancingValue = price;
-          break;
-        case import_fixparser3.MDEntryType.TWAP:
-          data.twap = price;
-          break;
-      }
-    }
-    data.spread = data.offer - data.bid;
-    if (!marketDataPrices.has(symbol)) {
-      marketDataPrices.set(symbol, []);
-    }
-    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(import_fixparser3.Fields.MDReqID)?.value;
-    if (mdReqID) {
-      const callback = pendingRequests.get(mdReqID);
-      if (callback) {
-        callback(message);
-        pendingRequests.delete(mdReqID);
-      }
-    }
-  } else if (msgType === import_fixparser3.Messages.ExecutionReport) {
-    const reqId = message.getField(import_fixparser3.Fields.ClOrdID)?.value;
-    const callback = pendingRequests.get(reqId);
-    if (callback) {
-      callback(message);
-      pendingRequests.delete(reqId);
-    }
-  }
-}
-
-// src/MCPLocal.ts
-var MCPLocal = class extends MCPBase {
-  /**
-   * Map to store verified orders before execution
-   * @private
-   */
-  verifiedOrders = /* @__PURE__ */ new Map();
-  /**
-   * Map to store pending requests and their callbacks
-   * @private
-   */
-  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;
+var MCPLocal = class {
+  parser;
   server = new import_server.Server(
     {
       name: "fixparser",
@@ -1219,13 +278,78 @@ var MCPLocal = class extends MCPBase {
     }
   );
   transport = new import_stdio.StdioServerTransport();
+  onReady = void 0;
+  pendingRequests = /* @__PURE__ */ new Map();
+  verifiedOrders = /* @__PURE__ */ new Map();
+  // Store market data prices with timestamps
+  marketDataPrices = /* @__PURE__ */ new Map();
+  MAX_PRICE_HISTORY = 1e5;
+  // Maximum number of price points to store per symbol
   constructor({ logger, onReady }) {
-    super({ logger, onReady });
+    if (onReady) this.onReady = onReady;
   }
   async register(parser) {
     this.parser = parser;
     this.parser.addOnMessageCallback((message) => {
-      handleMessage(message, this.parser, this.pendingRequests, this.marketDataPrices, this.MAX_PRICE_HISTORY);
+      this.parser?.logger.log({
+        level: "info",
+        message: `MCP Server received message: ${message.messageType}: ${message.description}`
+      });
+      const msgType = message.messageType;
+      if (msgType === import_fixparser.Messages.MarketDataSnapshotFullRefresh || msgType === import_fixparser.Messages.ExecutionReport || msgType === import_fixparser.Messages.Reject || msgType === import_fixparser.Messages.MarketDataIncrementalRefresh) {
+        this.parser?.logger.log({
+          level: "info",
+          message: `MCP Server handling message type: ${msgType}`
+        });
+        let id;
+        if (msgType === import_fixparser.Messages.MarketDataIncrementalRefresh || msgType === import_fixparser.Messages.MarketDataSnapshotFullRefresh) {
+          const symbol = message.getField(import_fixparser.Fields.Symbol);
+          const price = message.getField(import_fixparser.Fields.MDEntryPx);
+          const timestamp = message.getField(import_fixparser.Fields.MDEntryTime)?.value || Date.now();
+          if (symbol?.value && price?.value) {
+            const symbolStr = String(symbol.value);
+            const priceNum = Number(price.value);
+            const priceHistory = this.marketDataPrices.get(symbolStr) || [];
+            priceHistory.push({
+              timestamp: Number(timestamp),
+              price: priceNum
+            });
+            if (priceHistory.length > this.MAX_PRICE_HISTORY) {
+              priceHistory.shift();
+            }
+            this.marketDataPrices.set(symbolStr, priceHistory);
+            this.parser?.logger.log({
+              level: "info",
+              message: `MCP Server added ${symbol}: ${priceNum}`
+            });
+            this.server.notification({
+              method: "priceUpdate",
+              params: {
+                symbol: symbolStr,
+                price: priceNum,
+                timestamp: Number(timestamp)
+              }
+            });
+          }
+        }
+        if (msgType === import_fixparser.Messages.MarketDataSnapshotFullRefresh) {
+          const mdReqID = message.getField(import_fixparser.Fields.MDReqID);
+          if (mdReqID) id = String(mdReqID.value);
+        } else if (msgType === import_fixparser.Messages.ExecutionReport) {
+          const clOrdID = message.getField(import_fixparser.Fields.ClOrdID);
+          if (clOrdID) id = String(clOrdID.value);
+        } else if (msgType === import_fixparser.Messages.Reject) {
+          const refSeqNum = message.getField(import_fixparser.Fields.RefSeqNum);
+          if (refSeqNum) id = String(refSeqNum.value);
+        }
+        if (id) {
+          const callback = this.pendingRequests.get(id);
+          if (callback) {
+            callback(message);
+            this.pendingRequests.delete(id);
+          }
+        }
+      }
     });
     this.addWorkflows();
     await this.server.connect(this.transport);
@@ -1240,15 +364,18 @@ var MCPLocal = class extends MCPBase {
     if (!this.server) {
       return;
     }
-    this.server.setRequestHandler(import_zod.z.object({ method: import_zod.z.literal("tools/list") }), async () => {
-      return {
-        tools: Object.entries(toolSchemas).map(([name, { description, schema }]) => ({
-          name,
-          description,
-          inputSchema: schema
-        }))
-      };
-    });
+    this.server.setRequestHandler(
+      import_zod.z.object({ method: import_zod.z.literal("tools/list") }),
+      async (request, extra) => {
+        return {
+          tools: Object.entries(toolSchemas).map(([name, { description, schema }]) => ({
+            name,
+            description,
+            inputSchema: schema
+          }))
+        };
+      }
+    );
     this.server.setRequestHandler(
       import_zod.z.object({
         method: import_zod.z.literal("tools/call"),
@@ -1260,32 +387,493 @@ var MCPLocal = class extends MCPBase {
           }).optional()
         })
       }),
-      async (request) => {
+      async (request, extra) => {
         const { name, arguments: args } = request.params;
-        const toolHandlers = createToolHandlers(
-          this.parser,
-          this.verifiedOrders,
-          this.pendingRequests,
-          this.marketDataPrices
-        );
-        const handler = toolHandlers[name];
-        if (!handler) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Tool not found: ${name}`,
-                uri: name
+        switch (name) {
+          case "parse":
+            try {
+              const parsedMessage = this.parser?.parse(args.fixString);
+              if (!parsedMessage || parsedMessage.length === 0) {
+                return {
+                  content: [
+                    {
+                      type: "text",
+                      text: "Error: Failed to parse FIX string",
+                      uri: "parse"
+                    }
+                  ],
+                  isError: true
+                };
               }
-            ],
-            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
+              };
+            }
+          case "parseToJSON":
+            try {
+              const parsedMessage = this.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
+              };
+            }
+          case "verifyOrder":
+            try {
+              this.verifiedOrders.set(args.clOrdID, {
+                clOrdID: args.clOrdID,
+                handlInst: args.handlInst,
+                quantity: Number.parseFloat(args.quantity),
+                price: Number.parseFloat(args.price),
+                ordType: args.ordType,
+                side: args.side,
+                symbol: args.symbol,
+                timeInForce: args.timeInForce
+              });
+              const 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"
+              };
+              const 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"
+              };
+              const 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"
+              };
+              const handlInstNames = {
+                "1": "AutomatedExecutionNoIntervention",
+                "2": "AutomatedExecutionInterventionOK",
+                "3": "ManualOrder"
+              };
+              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.`,
+                    uri: "verifyOrder"
+                  }
+                ]
+              };
+            } catch (error) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `Error: ${error instanceof Error ? error.message : "Failed to verify order parameters"}`,
+                    uri: "verifyOrder"
+                  }
+                ],
+                isError: true
+              };
+            }
+          case "executeOrder":
+            try {
+              const verifiedOrder = this.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(args.quantity) || verifiedOrder.price !== Number.parseFloat(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) => {
+                this.pendingRequests.set(args.clOrdID, resolve);
+              });
+              const order = this.parser?.createMessage(
+                new import_fixparser.Field(import_fixparser.Fields.MsgType, import_fixparser.Messages.NewOrderSingle),
+                new import_fixparser.Field(import_fixparser.Fields.MsgSeqNum, this.parser?.getNextTargetMsgSeqNum()),
+                new import_fixparser.Field(import_fixparser.Fields.SenderCompID, this.parser?.sender),
+                new import_fixparser.Field(import_fixparser.Fields.TargetCompID, this.parser?.target),
+                new import_fixparser.Field(import_fixparser.Fields.SendingTime, this.parser?.getTimestamp()),
+                new import_fixparser.Field(import_fixparser.Fields.ClOrdID, args.clOrdID),
+                new import_fixparser.Field(import_fixparser.Fields.Side, args.side),
+                new import_fixparser.Field(import_fixparser.Fields.Symbol, args.symbol),
+                new import_fixparser.Field(import_fixparser.Fields.OrderQty, Number.parseFloat(args.quantity)),
+                new import_fixparser.Field(import_fixparser.Fields.Price, Number.parseFloat(args.price)),
+                new import_fixparser.Field(import_fixparser.Fields.OrdType, args.ordType),
+                new import_fixparser.Field(import_fixparser.Fields.HandlInst, args.handlInst),
+                new import_fixparser.Field(import_fixparser.Fields.TimeInForce, args.timeInForce),
+                new import_fixparser.Field(import_fixparser.Fields.TransactTime, this.parser?.getTimestamp())
+              );
+              if (!this.parser?.connected) {
+                return {
+                  content: [
+                    {
+                      type: "text",
+                      text: "Error: Not connected. Ignoring message.",
+                      uri: "executeOrder"
+                    }
+                  ],
+                  isError: true
+                };
+              }
+              this.parser?.send(order);
+              const fixData = await response;
+              this.verifiedOrders.delete(args.clOrdID);
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: fixData.messageType === import_fixparser.Messages.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
+              };
+            }
+          case "marketDataRequest":
+            try {
+              const response = new Promise((resolve) => {
+                this.pendingRequests.set(args.mdReqID, resolve);
+              });
+              const messageFields = [
+                new import_fixparser.Field(import_fixparser.Fields.MsgType, import_fixparser.Messages.MarketDataRequest),
+                new import_fixparser.Field(import_fixparser.Fields.SenderCompID, this.parser?.sender),
+                new import_fixparser.Field(import_fixparser.Fields.MsgSeqNum, this.parser?.getNextTargetMsgSeqNum()),
+                new import_fixparser.Field(import_fixparser.Fields.TargetCompID, this.parser?.target),
+                new import_fixparser.Field(import_fixparser.Fields.SendingTime, this.parser?.getTimestamp()),
+                new import_fixparser.Field(import_fixparser.Fields.MDReqID, args.mdReqID),
+                new import_fixparser.Field(import_fixparser.Fields.SubscriptionRequestType, args.subscriptionRequestType),
+                new import_fixparser.Field(import_fixparser.Fields.MarketDepth, 0),
+                new import_fixparser.Field(import_fixparser.Fields.MDUpdateType, args.mdUpdateType)
+              ];
+              messageFields.push(new import_fixparser.Field(import_fixparser.Fields.NoRelatedSym, args.symbols.length));
+              args.symbols.forEach((symbol) => {
+                messageFields.push(new import_fixparser.Field(import_fixparser.Fields.Symbol, symbol));
+              });
+              messageFields.push(new import_fixparser.Field(import_fixparser.Fields.NoMDEntryTypes, args.mdEntryTypes.length));
+              args.mdEntryTypes.forEach((entryType) => {
+                messageFields.push(new import_fixparser.Field(import_fixparser.Fields.MDEntryType, entryType));
+              });
+              const mdr = this.parser?.createMessage(...messageFields);
+              if (!this.parser?.connected) {
+                return {
+                  content: [
+                    {
+                      type: "text",
+                      text: "Error: Not connected. Ignoring message.",
+                      uri: "marketDataRequest"
+                    }
+                  ],
+                  isError: true
+                };
+              }
+              this.parser?.send(mdr);
+              const fixData = await response;
+              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
+              };
+            }
+          case "getStockGraph":
+            try {
+              const symbol = args.symbol;
+              const priceHistory = this.marketDataPrices.get(symbol) || [];
+              if (priceHistory.length === 0) {
+                return {
+                  content: [
+                    {
+                      type: "text",
+                      text: `No price data available for ${symbol}`,
+                      uri: "getStockGraph"
+                    }
+                  ]
+                };
+              }
+              const width = 600;
+              const height = 300;
+              const padding = 40;
+              const xScale = (width - 2 * padding) / (priceHistory.length - 1);
+              const yMin = Math.min(...priceHistory.map((d) => d.price));
+              const yMax = Math.max(...priceHistory.map((d) => d.price));
+              const yScale = (height - 2 * padding) / (yMax - yMin);
+              const points = priceHistory.map((d, i) => {
+                const x = padding + i * xScale;
+                const y = height - padding - (d.price - yMin) * yScale;
+                return `${x},${y}`;
+              }).join(" L ");
+              const svg = `<?xml version="1.0" encoding="UTF-8"?>
+<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">
+    <!-- Background -->
+    <rect width="100%" height="100%" fill="#f8f9fa"/>
+    
+    <!-- Grid lines -->
+    <g stroke="#e9ecef" stroke-width="1">
+        ${Array.from({ length: 5 }, (_, i) => {
+                const y = padding + (height - 2 * padding) * i / 4;
+                return `<line x1="${padding}" y1="${y}" x2="${width - padding}" y2="${y}"/>`;
+              }).join("\n")}
+    </g>
+    
+    <!-- Price line -->
+    <path d="M ${points}" 
+          fill="none" 
+          stroke="#007bff" 
+          stroke-width="2"/>
+    
+    <!-- Data points -->
+    ${priceHistory.map((d, i) => {
+                const x = padding + i * xScale;
+                const y = height - padding - (d.price - yMin) * yScale;
+                return `<circle cx="${x}" cy="${y}" r="3" fill="#007bff"/>`;
+              }).join("\n")}
+    
+    <!-- Labels -->
+    <g font-family="Arial" font-size="12" fill="#495057">
+        ${Array.from({ length: 5 }, (_, i) => {
+                const x = padding + (width - 2 * padding) * i / 4;
+                const index = Math.floor((priceHistory.length - 1) * i / 4);
+                const timestamp = new Date(priceHistory[index].timestamp).toLocaleTimeString();
+                return `<text x="${x + padding}" y="${height - padding + 20}" text-anchor="middle">${timestamp}</text>`;
+              }).join("\n")}
+        ${Array.from({ length: 5 }, (_, i) => {
+                const y = padding + (height - 2 * padding) * i / 4;
+                const price = yMax - (yMax - yMin) * i / 4;
+                return `<text x="${padding - 5}" y="${y + 4}" text-anchor="end">$${price.toFixed(2)}</text>`;
+              }).join("\n")}
+    </g>
+    
+    <!-- Title -->
+    <text x="${width / 2}" y="${padding / 2}" 
+          font-family="Arial" font-size="16" font-weight="bold" 
+          text-anchor="middle" fill="#212529">
+        ${symbol} - Price Chart (${priceHistory.length} points)
+    </text>
+</svg>`;
+              const base64Svg = Buffer.from(svg).toString("base64");
+              return {
+                content: [
+                  {
+                    type: "image",
+                    text: base64Svg,
+                    uri: "getStockGraph",
+                    mimeType: "image/svg+xml"
+                  }
+                ]
+              };
+            } catch (error) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `Error: ${error instanceof Error ? error.message : "Failed to generate stock graph"}`,
+                    uri: "getStockGraph"
+                  }
+                ],
+                isError: true
+              };
+            }
+          case "getStockPriceHistory":
+            try {
+              const symbol = args.symbol;
+              const priceHistory = this.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,
+                        prices: priceHistory.map((point) => ({
+                          timestamp: new Date(point.timestamp).toISOString(),
+                          price: point.price
+                        }))
+                      },
+                      null,
+                      2
+                    ),
+                    uri: "getStockPriceHistory"
+                  }
+                ]
+              };
+            } catch (error) {
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `Error: ${error instanceof Error ? error.message : "Failed to get stock price history"}`,
+                    uri: "getStockPriceHistory"
+                  }
+                ],
+                isError: true
+              };
+            }
+          default:
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Tool not found: ${name}`,
+                  uri: name
+                }
+              ],
+              isError: true
+            };
         }
-        const result = await handler(args);
-        return {
-          content: result.content,
-          isError: result.isError
-        };
       }
     );
     process.on("SIGINT", async () => {