fixparser-plugin-mcp 9.1.7-89ae1451 → 9.1.7-8efb79c3

package/build/esm/MCPRemote.mjs

@@ -5,38 +5,1243 @@ 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";
-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;
+
+// src/MCPBase.ts
+var MCPBase = class {
   /**
    * Optional logger instance for diagnostics and output.
-   * @private
+   * @protected
    */
   logger;
   /**
    * FIXParser instance, set during plugin register().
-   * @private
+   * @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"]
+    }
+  }
+};
+
+// 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)
+});
+
+// src/utils/messageHandler.ts
+import { Fields as Fields3, MDEntryType as MDEntryType2, Messages as Messages3 } from "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 === Messages3.MarketDataSnapshotFullRefresh || msgType === Messages3.MarketDataIncrementalRefresh) {
+    const symbol = message.getField(Fields3.Symbol)?.value;
+    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: 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) {
+      console.log(">>>>>>>>>>>>>>>>>>>>", entry);
+      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}`
+        });
+      }
+      switch (entryType) {
+        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)) {
+      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);
+    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;
   /**
    * Node.js HTTP server instance created internally.
    * @private
    */
-  server;
+  httpServer;
   /**
    * MCP server instance handling MCP protocol logic.
    * @private
@@ -46,89 +1251,65 @@ var MCPRemote = class {
    * Optional name of the plugin/server instance.
    * @private
    */
-  name;
+  serverName;
   /**
    * Optional version string of the plugin/server.
    * @private
    */
-  version;
+  serverVersion;
   /**
-   * Called when server is setup and listening.
+   * Map to store verified orders before execution
    * @private
    */
-  onReady = void 0;
+  verifiedOrders = /* @__PURE__ */ new Map();
   /**
-   * 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.
+   * Map to store pending requests and their callbacks
    * @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.server = createServer(async (req, res) => {
+    this.parser.addOnMessageCallback((message) => {
+      if (this.parser) {
+        handleMessage(
+          message,
+          this.parser,
+          this.pendingRequests,
+          this.marketDataPrices,
+          this.MAX_PRICE_HISTORY
+        );
+        this.logger?.log({
+          level: "info",
+          message: `Market Data Prices TEST: ${JSON.stringify(this.marketDataPrices)}`
+        });
+      }
+    });
+    this.httpServer = createServer(async (req, res) => {
       if (!req.url || !req.method) {
         res.writeHead(400);
         res.end("Bad Request");
         return;
       }
-      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 === "/") {
+      if (req.url === "/mcp") {
         const sessionId = req.headers["mcp-session-id"];
         if (req.method === "POST") {
           const bodyChunks = [];
@@ -161,10 +1342,10 @@ var MCPRemote = class {
                 }
               };
               this.mcpServer = new McpServer({
-                name: this.name || "FIXParser",
-                version: this.version || "1.0.0"
+                name: this.serverName || "FIXParser",
+                version: this.serverVersion || "1.0.0"
               });
-              this.addWorkflows();
+              this.setupTools();
               await this.mcpServer.connect(transport);
             } else {
               res.writeHead(400, { "Content-Type": "application/json" });
@@ -180,7 +1361,15 @@ var MCPRemote = class {
               );
               return;
             }
-            await transport.handleRequest(req, res, parsed);
+            try {
+              await transport.handleRequest(req, res, parsed);
+            } catch (error) {
+              this.logger?.log({
+                level: "error",
+                message: `Error handling request: ${error}`
+              });
+              throw error;
+            }
           });
         } else if (req.method === "GET" || req.method === "DELETE") {
           if (!sessionId || !transports[sessionId]) {
@@ -189,17 +1378,29 @@ var MCPRemote = class {
             return;
           }
           const transport = transports[sessionId];
-          await transport.handleRequest(req, res);
+          try {
+            await transport.handleRequest(req, res);
+          } catch (error) {
+            this.logger?.log({
+              level: "error",
+              message: `Error handling ${req.method} request: ${error}`
+            });
+            throw error;
+          }
         } else {
+          this.logger?.log({
+            level: "error",
+            message: `Method not allowed: ${req.method}`
+          });
           res.writeHead(405);
           res.end("Method Not Allowed");
         }
-        return;
+      } else {
+        res.writeHead(404);
+        res.end("Not Found");
       }
-      res.writeHead(404);
-      res.end("Not Found");
     });
-    this.server.listen(this.port, () => {
+    this.httpServer.listen(this.port, () => {
       this.logger?.log({
         level: "info",
         message: `FIXParser (MCP): -- Server listening on http://localhost:${this.port}...`
@@ -209,381 +1410,55 @@ var MCPRemote = class {
       this.onReady();
     }
   }
-  addWorkflows() {
+  setupTools() {
     if (!this.parser) {
       this.logger?.log({
         level: "error",
-        message: "FIXParser (MCP): -- FIXParser instance not initialized. Ignoring setup of workflows..."
+        message: "FIXParser (MCP): -- FIXParser instance not initialized. Ignoring setup of tools..."
       });
       return;
     }
     if (!this.mcpServer) {
       this.logger?.log({
         level: "error",
-        message: "FIXParser (MCP): -- MCP Server not initialized. Ignoring setup of workflows..."
+        message: "FIXParser (MCP): -- MCP Server not initialized. Ignoring setup of tools..."
       });
       return;
     }
-    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}` : ""
-            }
-          ]
-        };
-      }
-    );
-    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}`
-            }
-          }
-        ]
-      })
-    );
-    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 {
-            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}`
-            }
-          }
-        ]
-      })
+    const toolHandlers = createToolHandlers(
+      this.parser,
+      this.verifiedOrders,
+      this.pendingRequests,
+      this.marketDataPrices
     );
-    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")
-            }
+    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.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."
-          });
+          const result = await handler(args);
           return {
-            isError: true,
-            content: [
-              {
-                type: "text",
-                text: "Error: Not connected. Ignoring message."
-              }
-            ]
+            content: result.content,
+            isError: result.isError
           };
         }
-        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 {