fixparser-plugin-mcp 9.1.7-d4e49d72 → 9.1.7-d7ecb477

package/build/cjs/index.js

@@ -1,1368 +0,0 @@
-"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)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  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/index.ts
-var index_exports = {};
-__export(index_exports, {
-  MCPLocal: () => MCPLocal,
-  MCPRemote: () => MCPRemote
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/MCPLocal.ts
-var import_server = require("@modelcontextprotocol/sdk/server/index.js");
-var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
-var import_zod = require("zod");
-
-// src/MCPBase.ts
-var MCPBase = class {
-  /**
-   * Optional logger instance for diagnostics and output.
-   * @protected
-   */
-  logger;
-  /**
-   * FIXParser instance, set during plugin register().
-   * @protected
-   */
-  parser;
-  /**
-   * Called when server is setup and listening.
-   * @protected
-   */
-  onReady = void 0;
-  /**
-   * Map to store verified orders before execution
-   * @protected
-   */
-  verifiedOrders = /* @__PURE__ */ new Map();
-  /**
-   * Map to store pending market data requests
-   * @protected
-   */
-  pendingRequests = /* @__PURE__ */ new Map();
-  /**
-   * Map to store market data prices
-   * @protected
-   */
-  marketDataPrices = /* @__PURE__ */ new Map();
-  /**
-   * Maximum number of price history entries to keep per symbol
-   * @protected
-   */
-  MAX_PRICE_HISTORY = 1e5;
-  constructor({ logger, onReady }) {
-    this.logger = logger;
-    this.onReady = onReady;
-  }
-};
-
-// src/schemas/schemas.ts
-var toolSchemas = {
-  parse: {
-    description: "Parses a FIX message and describes it in plain language",
-    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
-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.TradeVolume];
-      const messageFields = [
-        new import_fixparser.Field(import_fixparser.Fields.MsgType, import_fixparser.Messages.MarketDataRequest),
-        new import_fixparser.Field(import_fixparser.Fields.SenderCompID, parser.sender),
-        new import_fixparser.Field(import_fixparser.Fields.MsgSeqNum, parser.getNextTargetMsgSeqNum()),
-        new import_fixparser.Field(import_fixparser.Fields.TargetCompID, parser.target),
-        new import_fixparser.Field(import_fixparser.Fields.SendingTime, parser.getTimestamp()),
-        new import_fixparser.Field(import_fixparser.Fields.MDReqID, args.mdReqID),
-        new import_fixparser.Field(import_fixparser.Fields.SubscriptionRequestType, args.subscriptionRequestType),
-        new import_fixparser.Field(import_fixparser.Fields.MarketDepth, 0),
-        new import_fixparser.Field(import_fixparser.Fields.MDUpdateType, args.mdUpdateType)
-      ];
-      messageFields.push(new import_fixparser.Field(import_fixparser.Fields.NoRelatedSym, args.symbols.length));
-      args.symbols.forEach((symbol) => {
-        messageFields.push(new import_fixparser.Field(import_fixparser.Fields.Symbol, symbol));
-      });
-      messageFields.push(new import_fixparser.Field(import_fixparser.Fields.NoMDEntryTypes, entryTypes.length));
-      entryTypes.forEach((entryType) => {
-        messageFields.push(new import_fixparser.Field(import_fixparser.Fields.MDEntryType, entryType));
-      });
-      const mdr = parser.createMessage(...messageFields);
-      if (!parser.connected) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "Error: Not connected. Ignoring message.",
-              uri: "marketDataRequest"
-            }
-          ],
-          isError: true
-        };
-      }
-      parser.send(mdr);
-      const fixData = await response;
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Market data for ${args.symbols.join(", ")}: ${JSON.stringify(fixData.toFIXJSON())}`,
-            uri: "marketDataRequest"
-          }
-        ]
-      };
-    } catch (error) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error: ${error instanceof Error ? error.message : "Failed to request market data"}`,
-            uri: "marketDataRequest"
-          }
-        ],
-        isError: true
-      };
-    }
-  };
-};
-var createGetStockGraphHandler = (marketDataPrices) => {
-  return async (args) => {
-    try {
-      const symbol = args.symbol;
-      const priceHistory = marketDataPrices.get(symbol) || [];
-      if (priceHistory.length === 0) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `No price data available for ${symbol}`,
-              uri: "getStockGraph"
-            }
-          ]
-        };
-      }
-      const chart = new import_quickchart_js.default();
-      chart.setWidth(1200);
-      chart.setHeight(600);
-      chart.setBackgroundColor("transparent");
-      const labels = priceHistory.map((point) => new Date(point.timestamp).toLocaleTimeString());
-      const bidData = priceHistory.map((point) => point.bid);
-      const offerData = priceHistory.map((point) => point.offer);
-      const spreadData = priceHistory.map((point) => point.spread);
-      const volumeData = priceHistory.map((point) => point.volume);
-      const 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: "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 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"
-            }
-          ]
-        };
-      }
-      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
-                }))
-              },
-              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]})
-- Quantity: ${args.quantity}
-- Price: ${args.price}
-- OrdType: ${args.ordType} (${ordTypeNames[args.ordType]})
-- Side: ${args.side} (${sideNames[args.side]})
-- Symbol: ${args.symbol}
-- TimeInForce: ${args.timeInForce} (${timeInForceNames[args.timeInForce]})
-
-To execute this order, call the executeOrder tool with these exact same parameters.`,
-            uri: "verifyOrder"
-          }
-        ]
-      };
-    } catch (error) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error: ${error instanceof Error ? error.message : "Failed to verify order parameters"}`,
-            uri: "verifyOrder"
-          }
-        ],
-        isError: true
-      };
-    }
-  };
-};
-var createExecuteOrderHandler = (parser, verifiedOrders, pendingRequests) => {
-  return async (args) => {
-    try {
-      const verifiedOrder = verifiedOrders.get(args.clOrdID);
-      if (!verifiedOrder) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error: Order ${args.clOrdID} has not been verified. Please call verifyOrder first.`,
-              uri: "executeOrder"
-            }
-          ],
-          isError: true
-        };
-      }
-      if (verifiedOrder.handlInst !== args.handlInst || verifiedOrder.quantity !== Number.parseFloat(String(args.quantity)) || verifiedOrder.price !== Number.parseFloat(String(args.price)) || verifiedOrder.ordType !== args.ordType || verifiedOrder.side !== args.side || verifiedOrder.symbol !== args.symbol || verifiedOrder.timeInForce !== args.timeInForce) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "Error: Order parameters do not match the verified order. Please use the exact same parameters that were verified.",
-              uri: "executeOrder"
-            }
-          ],
-          isError: true
-        };
-      }
-      const response = new Promise((resolve) => {
-        pendingRequests.set(args.clOrdID, resolve);
-      });
-      const order = parser.createMessage(
-        new import_fixparser2.Field(import_fixparser2.Fields.MsgType, import_fixparser2.Messages.NewOrderSingle),
-        new import_fixparser2.Field(import_fixparser2.Fields.MsgSeqNum, parser.getNextTargetMsgSeqNum()),
-        new import_fixparser2.Field(import_fixparser2.Fields.SenderCompID, parser.sender),
-        new import_fixparser2.Field(import_fixparser2.Fields.TargetCompID, parser.target),
-        new import_fixparser2.Field(import_fixparser2.Fields.SendingTime, parser.getTimestamp()),
-        new import_fixparser2.Field(import_fixparser2.Fields.ClOrdID, args.clOrdID),
-        new import_fixparser2.Field(import_fixparser2.Fields.Side, args.side),
-        new import_fixparser2.Field(import_fixparser2.Fields.Symbol, args.symbol),
-        new import_fixparser2.Field(import_fixparser2.Fields.OrderQty, Number.parseFloat(String(args.quantity))),
-        new import_fixparser2.Field(import_fixparser2.Fields.Price, Number.parseFloat(String(args.price))),
-        new import_fixparser2.Field(import_fixparser2.Fields.OrdType, args.ordType),
-        new import_fixparser2.Field(import_fixparser2.Fields.HandlInst, args.handlInst),
-        new import_fixparser2.Field(import_fixparser2.Fields.TimeInForce, args.timeInForce),
-        new import_fixparser2.Field(import_fixparser2.Fields.TransactTime, parser.getTimestamp())
-      );
-      if (!parser.connected) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "Error: Not connected. Ignoring message.",
-              uri: "executeOrder"
-            }
-          ],
-          isError: true
-        };
-      }
-      parser.send(order);
-      const fixData = await response;
-      verifiedOrders.delete(args.clOrdID);
-      return {
-        content: [
-          {
-            type: "text",
-            text: fixData.messageType === import_fixparser2.Messages.Reject ? `Reject message for order ${args.clOrdID}: ${JSON.stringify(fixData.toFIXJSON())}` : `Execution Report for order ${args.clOrdID}: ${JSON.stringify(fixData.toFIXJSON())}`,
-            uri: "executeOrder"
-          }
-        ]
-      };
-    } catch (error) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error: ${error instanceof Error ? error.message : "Failed to execute order"}`,
-            uri: "executeOrder"
-          }
-        ],
-        isError: true
-      };
-    }
-  };
-};
-
-// src/tools/parse.ts
-var createParseHandler = (parser) => {
-  return async (args) => {
-    try {
-      const parsedMessage = parser.parse(args.fixString);
-      if (!parsedMessage || parsedMessage.length === 0) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "Error: Failed to parse FIX string",
-              uri: "parse"
-            }
-          ],
-          isError: true
-        };
-      }
-      return {
-        content: [
-          {
-            type: "text",
-            text: `${parsedMessage[0].description}
-${parsedMessage[0].messageTypeDescription}`,
-            uri: "parse"
-          }
-        ]
-      };
-    } catch (error) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error: ${error instanceof Error ? error.message : "Failed to parse FIX string"}`,
-            uri: "parse"
-          }
-        ],
-        isError: true
-      };
-    }
-  };
-};
-
-// src/tools/parseToJSON.ts
-var createParseToJSONHandler = (parser) => {
-  return async (args) => {
-    try {
-      const parsedMessage = parser.parse(args.fixString);
-      if (!parsedMessage || parsedMessage.length === 0) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: "Error: Failed to parse FIX string",
-              uri: "parseToJSON"
-            }
-          ],
-          isError: true
-        };
-      }
-      return {
-        content: [
-          {
-            type: "text",
-            text: `${parsedMessage[0].toFIXJSON()}`,
-            uri: "parseToJSON"
-          }
-        ]
-      };
-    } catch (error) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Error: ${error instanceof Error ? error.message : "Failed to parse FIX string"}`,
-            uri: "parseToJSON"
-          }
-        ],
-        isError: true
-      };
-    }
-  };
-};
-
-// src/tools/index.ts
-var createToolHandlers = (parser, verifiedOrders, pendingRequests, marketDataPrices) => ({
-  parse: createParseHandler(parser),
-  parseToJSON: createParseToJSONHandler(parser),
-  verifyOrder: createVerifyOrderHandler(parser, verifiedOrders),
-  executeOrder: createExecuteOrderHandler(parser, verifiedOrders, pendingRequests),
-  marketDataRequest: createMarketDataRequestHandler(parser, pendingRequests),
-  getStockGraph: createGetStockGraphHandler(marketDataPrices),
-  getStockPriceHistory: createGetStockPriceHistoryHandler(marketDataPrices)
-});
-
-// src/utils/messageHandler.ts
-var import_fixparser3 = require("fixparser");
-function handleMessage(message, parser, pendingRequests, marketDataPrices, maxPriceHistory, onPriceUpdate) {
-  parser.logger.log({
-    level: "info",
-    message: `MCP Server received message: ${message.messageType}: ${message.description}`
-  });
-  const msgType = message.messageType;
-  if (msgType === import_fixparser3.Messages.MarketDataSnapshotFullRefresh) {
-    const symbol = message.getField(import_fixparser3.Fields.Symbol)?.value;
-    const entries = message.getField(import_fixparser3.Fields.NoMDEntries)?.value;
-    let bid = 0;
-    let offer = 0;
-    let volume = 0;
-    const entryTypes = message.getFields(import_fixparser3.Fields.MDEntryType);
-    const entryPrices = message.getFields(import_fixparser3.Fields.MDEntryPx);
-    const entrySizes = message.getFields(import_fixparser3.Fields.MDEntrySize);
-    if (entryTypes && entryPrices && entrySizes) {
-      for (let i = 0; i < entries; i++) {
-        const entryType = entryTypes[i]?.value;
-        const entryPrice = Number.parseFloat(entryPrices[i]?.value);
-        const entrySize = Number.parseFloat(entrySizes[i]?.value);
-        if (entryType === import_fixparser3.MDEntryType.Bid) {
-          bid = entryPrice;
-        } else if (entryType === import_fixparser3.MDEntryType.Offer) {
-          offer = entryPrice;
-        }
-        volume += entrySize;
-      }
-    }
-    const spread = offer - bid;
-    const timestamp = Date.now();
-    const data = {
-      timestamp,
-      bid,
-      offer,
-      spread,
-      volume
-    };
-    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);
-  } 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 points to store 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("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) => {
-        const { name, arguments: args } = request.params;
-        const toolHandlers = createToolHandlers(
-          this.parser,
-          this.verifiedOrders,
-          this.pendingRequests,
-          this.marketDataPrices
-        );
-        const handler = toolHandlers[name];
-        if (!handler) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Tool not found: ${name}`,
-                uri: name
-              }
-            ],
-            isError: true
-          };
-        }
-        const result = await handler(args);
-        return {
-          content: result.content,
-          isError: result.isError
-        };
-      }
-    );
-    process.on("SIGINT", async () => {
-      await this.server.close();
-      process.exit(0);
-    });
-  }
-};
-
-// src/MCPRemote.ts
-var import_node_crypto = require("node:crypto");
-var import_node_http = require("node:http");
-var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
-var import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
-var import_types = require("@modelcontextprotocol/sdk/types.js");
-var import_zod2 = require("zod");
-var transports = {};
-var MCPRemote = class extends MCPBase {
-  /**
-   * Port number the server will listen on.
-   * @private
-   */
-  port;
-  /**
-   * Node.js HTTP server instance created internally.
-   * @private
-   */
-  httpServer;
-  /**
-   * MCP server instance handling MCP protocol logic.
-   * @private
-   */
-  mcpServer;
-  /**
-   * Optional name of the plugin/server instance.
-   * @private
-   */
-  serverName;
-  /**
-   * Optional version string of the plugin/server.
-   * @private
-   */
-  serverVersion;
-  /**
-   * 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 points to store per symbol
-   * @private
-   */
-  MAX_PRICE_HISTORY = 1e5;
-  constructor({ port, logger, onReady }) {
-    super({ logger, onReady });
-    this.port = port;
-  }
-  async register(parser) {
-    this.parser = parser;
-    this.logger = parser.logger;
-    this.logger?.log({
-      level: "info",
-      message: `FIXParser (MCP): -- Plugin registered. Creating MCP server on port ${this.port}...`
-    });
-    this.parser.addOnMessageCallback((message) => {
-      if (this.parser) {
-        handleMessage(
-          message,
-          this.parser,
-          this.pendingRequests,
-          this.marketDataPrices,
-          this.MAX_PRICE_HISTORY,
-          (symbol, data) => {
-            this.mcpServer?.tool(
-              "priceUpdate",
-              {
-                description: "Price update notification",
-                schema: import_zod2.z.object({
-                  symbol: import_zod2.z.string(),
-                  timestamp: import_zod2.z.number(),
-                  bid: import_zod2.z.number(),
-                  offer: import_zod2.z.number(),
-                  spread: import_zod2.z.number(),
-                  volume: import_zod2.z.number()
-                })
-              },
-              () => ({
-                content: [
-                  {
-                    type: "text",
-                    text: JSON.stringify({ symbol, ...data })
-                  }
-                ]
-              })
-            );
-          }
-        );
-      }
-    });
-    this.httpServer = (0, import_node_http.createServer)(async (req, res) => {
-      console.log(req.headers);
-      this.logger?.log({
-        level: "info",
-        message: `Incoming request: ${req.method} ${req.url}`
-      });
-      if (!req.url || !req.method) {
-        this.logger?.log({
-          level: "error",
-          message: "Invalid request: missing URL or method"
-        });
-        res.writeHead(400);
-        res.end("Bad Request");
-        return;
-      }
-      if (req.url === "/mcp") {
-        const sessionId = req.headers["mcp-session-id"];
-        this.logger?.log({
-          level: "info",
-          message: `MCP request received. Session ID: ${sessionId || "none"}, headers: ${req.headers}`
-        });
-        if (req.method === "POST") {
-          const bodyChunks = [];
-          req.on("data", (chunk) => {
-            bodyChunks.push(chunk);
-          });
-          req.on("end", async () => {
-            let parsed;
-            const body = Buffer.concat(bodyChunks).toString();
-            try {
-              parsed = JSON.parse(body);
-              this.logger?.log({
-                level: "info",
-                message: `Parsed request body: ${JSON.stringify(parsed)}`
-              });
-            } catch (err) {
-              this.logger?.log({
-                level: "error",
-                message: `Failed to parse JSON body: ${err}`
-              });
-              res.writeHead(400);
-              res.end(JSON.stringify({ error: "Invalid JSON" }));
-              return;
-            }
-            let transport;
-            if (sessionId && transports[sessionId]) {
-              this.logger?.log({
-                level: "info",
-                message: `Using existing transport for session: ${sessionId}`
-              });
-              transport = transports[sessionId];
-            } else if (!sessionId && req.method === "POST" && (0, import_types.isInitializeRequest)(parsed)) {
-              this.logger?.log({
-                level: "info",
-                message: "Creating new transport for initialization request"
-              });
-              transport = new import_streamableHttp.StreamableHTTPServerTransport({
-                sessionIdGenerator: () => (0, import_node_crypto.randomUUID)(),
-                onsessioninitialized: (sessionId2) => {
-                  this.logger?.log({
-                    level: "info",
-                    message: `New session initialized: ${sessionId2}`
-                  });
-                  transports[sessionId2] = transport;
-                }
-              });
-              transport.onclose = () => {
-                if (transport.sessionId) {
-                  this.logger?.log({
-                    level: "info",
-                    message: `Session closed: ${transport.sessionId}`
-                  });
-                  delete transports[transport.sessionId];
-                }
-              };
-              this.mcpServer = new import_mcp.McpServer({
-                name: this.serverName || "FIXParser",
-                version: this.serverVersion || "1.0.0"
-              });
-              this.setupTools();
-              await this.mcpServer.connect(transport);
-            } else {
-              this.logger?.log({
-                level: "error",
-                message: "Invalid request: No valid session ID provided"
-              });
-              res.writeHead(400, { "Content-Type": "application/json" });
-              res.end(
-                JSON.stringify({
-                  jsonrpc: "2.0",
-                  error: {
-                    code: -32e3,
-                    message: "Bad Request: No valid session ID provided"
-                  },
-                  id: null
-                })
-              );
-              return;
-            }
-            try {
-              await transport.handleRequest(req, res, parsed);
-              this.logger?.log({
-                level: "info",
-                message: "Request handled successfully"
-              });
-            } 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]) {
-            this.logger?.log({
-              level: "error",
-              message: `Invalid session ID for ${req.method} request: ${sessionId}`
-            });
-            res.writeHead(400);
-            res.end("Invalid or missing session ID");
-            return;
-          }
-          const transport = transports[sessionId];
-          try {
-            await transport.handleRequest(req, res);
-            this.logger?.log({
-              level: "info",
-              message: `${req.method} request handled successfully for session: ${sessionId}`
-            });
-          } 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");
-        }
-      } else {
-        this.logger?.log({
-          level: "error",
-          message: `Not found: ${req.url}`
-        });
-        res.writeHead(404);
-        res.end("Not Found");
-      }
-    });
-    this.httpServer.listen(this.port, () => {
-      this.logger?.log({
-        level: "info",
-        message: `FIXParser (MCP): -- Server listening on http://localhost:${this.port}...`
-      });
-    });
-    if (this.onReady) {
-      this.onReady();
-    }
-  }
-  setupTools() {
-    if (!this.parser) {
-      this.logger?.log({
-        level: "error",
-        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 tools..."
-      });
-      return;
-    }
-    this.mcpServer.tool(
-      "tools/list",
-      {
-        description: "List available tools",
-        schema: import_zod2.z.object({})
-      },
-      async () => {
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(
-                Object.entries(toolSchemas).map(([name, { description, schema }]) => ({
-                  name,
-                  description,
-                  inputSchema: schema
-                }))
-              )
-            }
-          ]
-        };
-      }
-    );
-    this.mcpServer.tool(
-      "tools/call",
-      {
-        description: "Call a tool",
-        schema: import_zod2.z.object({
-          name: import_zod2.z.string(),
-          arguments: import_zod2.z.any(),
-          _meta: import_zod2.z.object({
-            progressToken: import_zod2.z.number()
-          }).optional()
-        })
-      },
-      async (request) => {
-        const { name, arguments: args } = request;
-        const toolHandlers = createToolHandlers(
-          this.parser,
-          this.verifiedOrders,
-          this.pendingRequests,
-          this.marketDataPrices
-        );
-        const handler = toolHandlers[name];
-        if (!handler) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Tool not found: ${name}`,
-                uri: name
-              }
-            ],
-            isError: true
-          };
-        }
-        const result = await handler(args);
-        return {
-          content: result.content,
-          isError: result.isError
-        };
-      }
-    );
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  MCPLocal,
-  MCPRemote
-});
-//# sourceMappingURL=index.js.map