fixparser-plugin-mcp 9.1.7-bfcb9d6f → 9.1.7-c415bb75

package/build/cjs/MCPLocal.js

@@ -1,7 +1,9 @@
 "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)
@@ -15,6 +17,14 @@ 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
@@ -25,897 +35,643 @@ __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");
-var fixStringSchema = import_zod.z.object({
-  fixString: import_zod.z.string()
-});
-var orderSchema = import_zod.z.object({
-  clOrdID: import_zod.z.string(),
-  handlInst: import_zod.z.enum(["1", "2", "3"]),
-  quantity: import_zod.z.string(),
-  price: import_zod.z.string(),
-  ordType: import_zod.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"
-  ]),
-  side: import_zod.z.enum(["1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H"]),
-  symbol: import_zod.z.string(),
-  timeInForce: import_zod.z.enum(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C"])
-});
-var marketDataRequestSchema = import_zod.z.object({
-  mdUpdateType: import_zod.z.enum(["0", "1"]),
-  symbols: import_zod.z.array(import_zod.z.string()),
-  mdReqID: import_zod.z.string(),
-  subscriptionRequestType: import_zod.z.enum(["0", "1", "2"]),
-  mdEntryTypes: import_zod.z.array(
-    import_zod.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",
-      "R",
-      "S",
-      "T",
-      "U",
-      "V",
-      "W",
-      "X",
-      "Y",
-      "Z",
-      "a",
-      "b",
-      "c",
-      "d",
-      "e",
-      "g",
-      "h",
-      "i",
-      "t"
-    ])
-  )
-});
-var MCPLocal = class {
+
+// src/MCPBase.ts
+var MCPBase = class {
+  /**
+   * Optional logger instance for diagnostics and output.
+   * @protected
+   */
+  logger;
+  /**
+   * FIXParser instance, set during plugin register().
+   * @protected
+   */
   parser;
-  server = new import_server.Server(
-    {
-      name: "fixparser",
-      version: "1.0.0"
-    },
-    {
-      capabilities: {
-        tools: {
-          parse: {
-            description: "Parses a FIX message and describes it in plain language",
-            parameters: {
-              type: "object",
-              properties: {
-                fixString: { type: "string" }
-              },
-              required: ["fixString"]
-            }
-          },
-          parseToJSON: {
-            description: "Parses a FIX message into JSON",
-            parameters: {
-              type: "object",
-              properties: {
-                fixString: { type: "string" }
-              },
-              required: ["fixString"]
-            }
-          },
-          verifyOrder: {
-            description: "Verifies order parameters before execution",
-            parameters: {
-              type: "object",
-              properties: {
-                clOrdID: { type: "string" },
-                handlInst: { type: "string", enum: ["1", "2", "3"] },
-                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"
-                  ]
-                },
-                side: {
-                  type: "string",
-                  enum: [
-                    "1",
-                    "2",
-                    "3",
-                    "4",
-                    "5",
-                    "6",
-                    "7",
-                    "8",
-                    "9",
-                    "A",
-                    "B",
-                    "C",
-                    "D",
-                    "E",
-                    "F",
-                    "G",
-                    "H"
-                  ]
-                },
-                symbol: { type: "string" },
-                timeInForce: {
-                  type: "string",
-                  enum: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C"]
-                }
-              },
-              required: [
-                "clOrdID",
-                "handlInst",
-                "quantity",
-                "price",
-                "ordType",
-                "side",
-                "symbol",
-                "timeInForce"
-              ]
-            }
-          },
-          executeOrder: {
-            description: "Executes a verified order",
-            parameters: {
-              type: "object",
-              properties: {
-                clOrdID: { type: "string" },
-                handlInst: { type: "string", enum: ["1", "2", "3"] },
-                quantity: { type: "string" },
-                price: { type: "string" },
-                ordType: { type: "string" },
-                side: { type: "string" },
-                symbol: { type: "string" },
-                timeInForce: { type: "string" }
-              },
-              required: [
-                "clOrdID",
-                "handlInst",
-                "quantity",
-                "price",
-                "ordType",
-                "side",
-                "symbol",
-                "timeInForce"
-              ]
-            }
-          },
-          marketDataRequest: {
-            description: "Requests market data for specified symbols",
-            parameters: {
-              type: "object",
-              properties: {
-                mdUpdateType: { type: "string", enum: ["0", "1"] },
-                symbols: { type: "array", items: { type: "string" } },
-                mdReqID: { type: "string" },
-                subscriptionRequestType: { type: "string", enum: ["0", "1", "2"] },
-                mdEntryTypes: { type: "array", items: { type: "string" } }
-              },
-              required: ["mdUpdateType", "symbols", "mdReqID", "subscriptionRequestType", "mdEntryTypes"]
-            }
-          }
-        },
-        resources: {
-          greeting: {
-            description: "A simple greeting resource",
-            uri: "greeting-resource"
-          },
-          stockGraph: {
-            description: "Generates a price chart for a given symbol",
-            uri: "stockGraph/{symbol}"
-          },
-          stockPriceHistory: {
-            description: "Returns price history for a given symbol",
-            uri: "stockPriceHistory/{symbol}"
-          }
-        }
-      }
-    }
-  );
-  transport = new import_stdio.StdioServerTransport();
+  /**
+   * Called when server is setup and listening.
+   * @protected
+   */
   onReady = void 0;
-  pendingRequests = /* @__PURE__ */ new Map();
+  /**
+   * Map to store verified orders before execution
+   * @protected
+   */
   verifiedOrders = /* @__PURE__ */ new Map();
-  // Store market data prices with timestamps
+  /**
+   * 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;
-  // Maximum number of price points to store per symbol
   constructor({ logger, onReady }) {
-    if (onReady) this.onReady = onReady;
+    this.logger = logger;
+    this.onReady = onReady;
   }
-  async register(parser) {
-    this.parser = parser;
-    this.parser.addOnMessageCallback((message) => {
-      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)
-              }
-            });
-          }
+};
+
+// 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"
         }
-        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);
+      },
+      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"
         }
-        if (id) {
-          const callback = this.pendingRequests.get(id);
-          if (callback) {
-            callback(message);
-            this.pendingRequests.delete(id);
-          }
+      },
+      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"
         }
-      }
-    });
-    this.addWorkflows();
-    await this.server.connect(this.transport);
-    if (this.onReady) {
-      this.onReady();
+      },
+      required: ["mdUpdateType", "symbols", "mdReqID", "subscriptionRequestType"]
     }
-  }
-  addWorkflows() {
-    if (!this.parser) {
-      return;
+  },
+  getStockGraph: {
+    description: "Generates a price chart for a given symbol",
+    schema: {
+      type: "object",
+      properties: {
+        symbol: { type: "string" }
+      },
+      required: ["symbol"]
     }
-    if (!this.server) {
-      return;
+  },
+  getStockPriceHistory: {
+    description: "Returns price history for a given symbol",
+    schema: {
+      type: "object",
+      properties: {
+        symbol: { type: "string" }
+      },
+      required: ["symbol"]
     }
-    this.server.setRequestHandler(
-      import_zod.z.object({ method: import_zod.z.literal("resources/list") }),
-      async (request, extra) => {
+  }
+};
+
+// 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 {
-          resources: [
+          content: [
             {
-              name: "greeting",
-              description: "A simple greeting resource",
-              uri: "greeting-resource"
+              type: "text",
+              text: "Error: Not connected. Ignoring message.",
+              uri: "marketDataRequest"
             }
-          ]
+          ],
+          isError: true
         };
       }
-    );
-    this.server.setRequestHandler(
-      import_zod.z.object({ method: import_zod.z.literal("resources/templates/list") }),
-      async (request, extra) => {
+      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 {
-          resourceTemplates: [
-            {
-              name: "stockGraph",
-              description: "Generates a price chart for a given symbol",
-              uriTemplate: "stockGraph/{symbol}",
-              parameters: {
-                type: "object",
-                properties: {
-                  symbol: { type: "string" }
-                },
-                required: ["symbol"]
-              }
-            },
+          content: [
             {
-              name: "stockPriceHistory",
-              description: "Returns price history for a given symbol",
-              uriTemplate: "stockPriceHistory/{symbol}",
-              parameters: {
-                type: "object",
-                properties: {
-                  symbol: { type: "string" }
-                },
-                required: ["symbol"]
-              }
+              type: "text",
+              text: `No price data available for ${symbol}`,
+              uri: "getStockGraph"
             }
           ]
         };
       }
-    );
-    this.server.setRequestHandler(
-      import_zod.z.object({ method: import_zod.z.literal("tools/list") }),
-      async (request, extra) => {
-        return {
-          tools: [
-            {
-              name: "parse",
-              description: "Parses a FIX message and describes it in plain language",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  fixString: { type: "string" }
-                },
-                required: ["fixString"]
-              }
-            },
+      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 config = {
+        type: "line",
+        data: {
+          labels,
+          datasets: [
             {
-              name: "parseToJSON",
-              description: "Parses a FIX message into JSON",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  fixString: { type: "string" }
-                },
-                required: ["fixString"]
-              }
+              label: "Bid",
+              data: bidData,
+              borderColor: "#28a745",
+              backgroundColor: "rgba(40, 167, 69, 0.1)",
+              fill: false,
+              tension: 0.4
             },
             {
-              name: "verifyOrder",
-              description: "Verifies order parameters before execution",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  clOrdID: { type: "string" },
-                  handlInst: { type: "string", enum: ["1", "2", "3"] },
-                  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"
-                    ]
-                  },
-                  side: {
-                    type: "string",
-                    enum: [
-                      "1",
-                      "2",
-                      "3",
-                      "4",
-                      "5",
-                      "6",
-                      "7",
-                      "8",
-                      "9",
-                      "A",
-                      "B",
-                      "C",
-                      "D",
-                      "E",
-                      "F",
-                      "G",
-                      "H"
-                    ]
-                  },
-                  symbol: { type: "string" },
-                  timeInForce: {
-                    type: "string",
-                    enum: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C"]
-                  }
-                },
-                required: [
-                  "clOrdID",
-                  "handlInst",
-                  "quantity",
-                  "price",
-                  "ordType",
-                  "side",
-                  "symbol",
-                  "timeInForce"
-                ]
-              }
+              label: "Offer",
+              data: offerData,
+              borderColor: "#dc3545",
+              backgroundColor: "rgba(220, 53, 69, 0.1)",
+              fill: false,
+              tension: 0.4
             },
             {
-              name: "executeOrder",
-              description: "Executes a verified order",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  clOrdID: { type: "string" },
-                  handlInst: { type: "string", enum: ["1", "2", "3"] },
-                  quantity: { type: "string" },
-                  price: { type: "string" },
-                  ordType: { type: "string" },
-                  side: { type: "string" },
-                  symbol: { type: "string" },
-                  timeInForce: { type: "string" }
-                },
-                required: [
-                  "clOrdID",
-                  "handlInst",
-                  "quantity",
-                  "price",
-                  "ordType",
-                  "side",
-                  "symbol",
-                  "timeInForce"
-                ]
-              }
+              label: "Spread",
+              data: spreadData,
+              borderColor: "#6c757d",
+              backgroundColor: "rgba(108, 117, 125, 0.1)",
+              fill: false,
+              tension: 0.4
             },
             {
-              name: "marketDataRequest",
-              description: "Requests market data for specified symbols",
-              inputSchema: {
-                type: "object",
-                properties: {
-                  mdUpdateType: { type: "string", enum: ["0", "1"] },
-                  symbols: { type: "array", items: { type: "string" } },
-                  mdReqID: { type: "string" },
-                  subscriptionRequestType: { type: "string", enum: ["0", "1", "2"] },
-                  mdEntryTypes: { type: "array", items: { type: "string" } }
-                },
-                required: [
-                  "mdUpdateType",
-                  "symbols",
-                  "mdReqID",
-                  "subscriptionRequestType",
-                  "mdEntryTypes"
-                ]
-              }
+              label: "Volume",
+              data: volumeData,
+              borderColor: "#007bff",
+              backgroundColor: "rgba(0, 123, 255, 0.1)",
+              fill: true,
+              tension: 0.4
             }
           ]
-        };
-      }
-    );
-    this.server.setRequestHandler(
-      import_zod.z.object({
-        method: import_zod.z.literal("resources/read"),
-        params: import_zod.z.object({
-          uri: import_zod.z.string()
-        })
-      }),
-      async (request, extra) => {
-        const { uri } = request.params;
-        switch (uri) {
-          case "greeting-resource":
-            return {
-              contents: [
-                {
-                  type: "text",
-                  text: "Hello, world!",
-                  uri: "greeting-resource"
-                }
-              ]
-            };
-          case "stockGraph":
-            return {
-              contents: [
-                {
-                  type: "text",
-                  text: "This resource requires a symbol parameter. Please use the stockGraph/{symbol} resource.",
-                  uri: "stockGraph"
-                }
-              ]
-            };
-          case "stockPriceHistory":
-            return {
-              contents: [
-                {
-                  type: "text",
-                  text: "This resource requires a symbol parameter. Please use the stockPriceHistory/{symbol} resource.",
-                  uri: "stockPriceHistory"
-                }
-              ]
-            };
-          default:
-            if (uri.startsWith("stockGraph/")) {
-              const symbol = uri.split("/")[1];
-              const priceHistory = this.marketDataPrices.get(symbol) || [];
-              if (priceHistory.length === 0) {
-                return {
-                  contents: [
-                    {
-                      type: "text",
-                      text: `No price data available for ${symbol}`
-                    }
-                  ]
-                };
-              }
-              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>`;
-              return {
-                contents: [
-                  {
-                    type: "text",
-                    text: svg
-                  }
-                ]
-              };
+        },
+        options: {
+          responsive: true,
+          plugins: {
+            title: {
+              display: true,
+              text: `${symbol} Market Data`
             }
-            if (uri.startsWith("stockPriceHistory/")) {
-              const symbol = uri.split("/")[1];
-              const priceHistory = this.marketDataPrices.get(symbol) || [];
-              if (priceHistory.length === 0) {
-                return {
-                  contents: [
-                    {
-                      type: "text",
-                      text: `No price data available for ${symbol}`
-                    }
-                  ]
-                };
-              }
-              return {
-                contents: [
-                  {
-                    type: "text",
-                    text: JSON.stringify(
-                      {
-                        symbol,
-                        count: priceHistory.length,
-                        prices: priceHistory.map((point) => ({
-                          timestamp: new Date(point.timestamp).toISOString(),
-                          price: point.price
-                        }))
-                      },
-                      null,
-                      2
-                    )
-                  }
-                ]
-              };
+          },
+          scales: {
+            y: {
+              beginAtZero: false
             }
-            return {
-              contents: [
-                {
-                  type: "text",
-                  text: `Resource not found: ${uri}`,
-                  uri
-                }
-              ],
-              isError: true
-            };
-        }
-      }
-    );
-    this.server.setRequestHandler(
-      import_zod.z.object({
-        method: import_zod.z.literal("parse"),
-        params: fixStringSchema
-      }),
-      async (request, extra) => {
-        try {
-          const args = request.params;
-          const parsedMessage = this.parser?.parse(args.fixString);
-          if (!parsedMessage || parsedMessage.length === 0) {
-            return {
-              contents: [{ type: "text", text: "Error: Failed to parse FIX string" }],
-              isError: true
-            };
           }
-          return {
-            contents: [
-              {
-                type: "text",
-                text: `${parsedMessage[0].description}
-${parsedMessage[0].messageTypeDescription}`
-              }
-            ]
-          };
-        } catch (error) {
-          return {
-            contents: [
-              {
-                type: "text",
-                text: `Error: ${error instanceof Error ? error.message : "Failed to parse FIX string"}`
-              }
-            ],
-            isError: true
-          };
         }
-      }
-    );
-    this.server.setRequestHandler(
-      import_zod.z.object({
-        method: import_zod.z.literal("parseToJSON"),
-        params: fixStringSchema
-      }),
-      async (request, extra) => {
-        try {
-          const args = request.params;
-          const parsedMessage = this.parser?.parse(args.fixString);
-          if (!parsedMessage || parsedMessage.length === 0) {
-            return {
-              contents: [{ type: "text", text: "Error: Failed to parse FIX string" }],
-              isError: true
-            };
+      };
+      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
+            }
           }
-          return {
-            contents: [
-              {
-                type: "text",
-                text: `${parsedMessage[0].toFIXJSON()}`
-              }
-            ]
-          };
-        } catch (error) {
-          return {
-            contents: [
-              {
-                type: "text",
-                text: `Error: ${error instanceof Error ? error.message : "Failed to parse FIX string"}`
-              }
-            ],
-            isError: true
-          };
-        }
+        ]
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error instanceof Error ? error.message : "Failed to generate chart"}`,
+            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"
+            }
+          ]
+        };
       }
-    );
-    this.server.setRequestHandler(
-      import_zod.z.object({
-        method: import_zod.z.literal("verifyOrder"),
-        params: orderSchema
-      }),
-      async (request, extra) => {
-        try {
-          const args = request.params;
-          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 {
-            contents: [
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
               {
-                type: "text",
-                text: `VERIFICATION: All parameters valid. Ready to proceed with order execution.
-                                    
+                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
+                }))
+              },
+              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
+      };
+    }
+  };
+};
+
+// 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]})
@@ -926,171 +682,542 @@ Parameters verified:
 - Symbol: ${args.symbol}
 - TimeInForce: ${args.timeInForce} (${timeInForceNames[args.timeInForce]})
 
-To execute this order, call the executeOrder tool with these exact same parameters.`
-              }
-            ]
-          };
-        } catch (error) {
-          return {
-            contents: [
-              {
-                type: "text",
-                text: `Error: ${error instanceof Error ? error.message : "Failed to verify order parameters"}`
-              }
-            ],
-            isError: true
-          };
-        }
+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
+        };
       }
-    );
-    this.server.setRequestHandler(
-      import_zod.z.object({
-        method: import_zod.z.literal("executeOrder"),
-        params: orderSchema
-      }),
-      async (request, extra) => {
-        try {
-          const args = request.params;
-          const verifiedOrder = this.verifiedOrders.get(args.clOrdID);
-          if (!verifiedOrder) {
-            return {
-              contents: [
-                {
-                  type: "text",
-                  text: `Error: Order ${args.clOrdID} has not been verified. Please call verifyOrder first.`
-                }
-              ],
-              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"
           }
-          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 {
-              contents: [
-                {
-                  type: "text",
-                  text: "Error: Order parameters do not match the verified order. Please use the exact same parameters that were verified."
-                }
-              ],
-              isError: true
-            };
+        ]
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error instanceof Error ? error.message : "Failed to execute order"}`,
+            uri: "executeOrder"
           }
-          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 {
-              contents: [
-                {
-                  type: "text",
-                  text: "Error: Not connected. Ignoring message."
-                }
-              ],
-              isError: true
-            };
+        ],
+        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"
           }
-          this.parser?.send(order);
-          const fixData = await response;
-          this.verifiedOrders.delete(args.clOrdID);
-          return {
-            contents: [
-              {
-                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())}`
-              }
-            ]
-          };
-        } catch (error) {
-          return {
-            contents: [
-              {
-                type: "text",
-                text: `Error: ${error instanceof Error ? error.message : "Failed to execute order"}`
-              }
-            ],
-            isError: true
-          };
-        }
+        ]
+      };
+    } 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;
+  server = new import_server.Server(
+    {
+      name: "fixparser",
+      version: "1.0.0"
+    },
+    {
+      capabilities: {
+        tools: Object.entries(toolSchemas).reduce(
+          (acc, [name, { description, schema }]) => {
+            acc[name] = {
+              description,
+              parameters: schema
+            };
+            return acc;
+          },
+          {}
+        )
+      }
+    }
+  );
+  transport = new import_stdio.StdioServerTransport();
+  constructor({ logger, onReady }) {
+    super({ logger, onReady });
+  }
+  async register(parser) {
+    this.parser = parser;
+    this.parser.addOnMessageCallback((message) => {
+      handleMessage(message, this.parser, this.pendingRequests, this.marketDataPrices, this.MAX_PRICE_HISTORY);
+    });
+    this.addWorkflows();
+    await this.server.connect(this.transport);
+    if (this.onReady) {
+      this.onReady();
+    }
+  }
+  addWorkflows() {
+    if (!this.parser) {
+      return;
+    }
+    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("marketDataRequest"),
-        params: marketDataRequestSchema
+        method: import_zod.z.literal("tools/call"),
+        params: import_zod.z.object({
+          name: import_zod.z.string(),
+          arguments: import_zod.z.any(),
+          _meta: import_zod.z.object({
+            progressToken: import_zod.z.number()
+          }).optional()
+        })
       }),
-      async (request, extra) => {
-        try {
-          const args = request.params;
-          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 {
-              contents: [
-                {
-                  type: "text",
-                  text: "Error: Not connected. Ignoring message."
-                }
-              ],
-              isError: true
-            };
-          }
-          this.parser?.send(mdr);
-          const fixData = await response;
-          return {
-            contents: [
-              {
-                type: "text",
-                text: `Market data for ${args.symbols.join(", ")}: ${JSON.stringify(fixData.toFIXJSON())}`
-              }
-            ]
-          };
-        } catch (error) {
+      async (request) => {
+        const { name, arguments: args } = request.params;
+        const toolHandlers = createToolHandlers(
+          this.parser,
+          this.verifiedOrders,
+          this.pendingRequests,
+          this.marketDataPrices
+        );
+        const handler = toolHandlers[name];
+        if (!handler) {
           return {
-            contents: [
+            content: [
               {
                 type: "text",
-                text: `Error: ${error instanceof Error ? error.message : "Failed to request market data"}`
+                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 () => {