fixparser-plugin-mcp 9.1.7-e80c38c2 → 9.1.7-eb1de32a

package/build/cjs/MCPLocal.js

@@ -35,9 +35,10 @@ __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_sharp = __toESM(require("sharp"), 1);
+var import_fixparser3 = require("fixparser");
 var import_zod = require("zod");
+
+// src/schemas/schemas.ts
 var toolSchemas = {
   parse: {
     description: "Parses a FIX message and describes it in plain language",
@@ -266,6 +267,516 @@ var toolSchemas = {
     }
   }
 };
+
+// src/tools/marketData.ts
+var import_fixparser = require("fixparser");
+var import_quickchart_js = __toESM(require("quickchart-js"), 1);
+var createMarketDataRequestHandler = (parser, pendingRequests) => {
+  return async (args) => {
+    try {
+      const response = new Promise((resolve) => {
+        pendingRequests.set(args.mdReqID, resolve);
+      });
+      const 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, args.mdEntryTypes.length));
+      args.mdEntryTypes.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(600);
+      chart.setHeight(300);
+      const labels = priceHistory.map((point) => new Date(point.timestamp).toLocaleTimeString());
+      const data = priceHistory.map((point) => point.price);
+      chart.setConfig({
+        type: "line",
+        data: {
+          labels,
+          datasets: [
+            {
+              label: symbol,
+              data,
+              borderColor: "#007bff",
+              backgroundColor: "rgba(0, 123, 255, 0.1)",
+              fill: true,
+              tension: 0.4
+            }
+          ]
+        },
+        options: {
+          plugins: {
+            title: {
+              display: true,
+              text: `${symbol} Price History`,
+              font: {
+                size: 16,
+                weight: "bold"
+              }
+            },
+            legend: {
+              display: true
+            }
+          },
+          scales: {
+            y: {
+              beginAtZero: false,
+              grid: {
+                color: "#e9ecef"
+              }
+            },
+            x: {
+              grid: {
+                display: false
+              }
+            }
+          }
+        }
+      });
+      const imageBuffer = await chart.toBinary();
+      const base64Image = imageBuffer.toString("base64");
+      return {
+        content: [
+          {
+            type: "image",
+            text: base64Image,
+            source: {
+              data: base64Image
+            },
+            uri: "getStockGraph",
+            mimeType: "image/png"
+          }
+        ]
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error instanceof Error ? error.message : "Failed to generate stock graph"}`,
+            uri: "getStockGraph"
+          }
+        ],
+        isError: true
+      };
+    }
+  };
+};
+var createGetStockPriceHistoryHandler = (marketDataPrices) => {
+  return async (args) => {
+    try {
+      const symbol = args.symbol;
+      const priceHistory = marketDataPrices.get(symbol) || [];
+      if (priceHistory.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No price data available for ${symbol}`,
+              uri: "getStockPriceHistory"
+            }
+          ]
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                symbol,
+                count: priceHistory.length,
+                prices: priceHistory.map((point) => ({
+                  timestamp: new Date(point.timestamp).toISOString(),
+                  price: point.price
+                }))
+              },
+              null,
+              2
+            ),
+            uri: "getStockPriceHistory"
+          }
+        ]
+      };
+    } catch (error) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: ${error instanceof Error ? error.message : "Failed to get stock price history"}`,
+            uri: "getStockPriceHistory"
+          }
+        ],
+        isError: true
+      };
+    }
+  };
+};
+
+// 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/MCPLocal.ts
 var MCPLocal = class {
   parser;
   server = new import_server.Server(
@@ -292,7 +803,6 @@ var MCPLocal = class {
   onReady = void 0;
   pendingRequests = /* @__PURE__ */ new Map();
   verifiedOrders = /* @__PURE__ */ new Map();
-  // Store market data prices with timestamps
   marketDataPrices = /* @__PURE__ */ new Map();
   MAX_PRICE_HISTORY = 1e5;
   // Maximum number of price points to store per symbol
@@ -307,16 +817,16 @@ var MCPLocal = class {
         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) {
+      if (msgType === import_fixparser3.Messages.MarketDataSnapshotFullRefresh || msgType === import_fixparser3.Messages.ExecutionReport || msgType === import_fixparser3.Messages.Reject || msgType === import_fixparser3.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 (msgType === import_fixparser3.Messages.MarketDataIncrementalRefresh || msgType === import_fixparser3.Messages.MarketDataSnapshotFullRefresh) {
+          const symbol = message.getField(import_fixparser3.Fields.Symbol);
+          const price = message.getField(import_fixparser3.Fields.MDEntryPx);
+          const timestamp = message.getField(import_fixparser3.Fields.MDEntryTime)?.value || Date.now();
           if (symbol?.value && price?.value) {
             const symbolStr = String(symbol.value);
             const priceNum = Number(price.value);
@@ -343,14 +853,14 @@ var MCPLocal = class {
             });
           }
         }
-        if (msgType === import_fixparser.Messages.MarketDataSnapshotFullRefresh) {
-          const mdReqID = message.getField(import_fixparser.Fields.MDReqID);
+        if (msgType === import_fixparser3.Messages.MarketDataSnapshotFullRefresh) {
+          const mdReqID = message.getField(import_fixparser3.Fields.MDReqID);
           if (mdReqID) id = String(mdReqID.value);
-        } else if (msgType === import_fixparser.Messages.ExecutionReport) {
-          const clOrdID = message.getField(import_fixparser.Fields.ClOrdID);
+        } else if (msgType === import_fixparser3.Messages.ExecutionReport) {
+          const clOrdID = message.getField(import_fixparser3.Fields.ClOrdID);
           if (clOrdID) id = String(clOrdID.value);
-        } else if (msgType === import_fixparser.Messages.Reject) {
-          const refSeqNum = message.getField(import_fixparser.Fields.RefSeqNum);
+        } else if (msgType === import_fixparser3.Messages.Reject) {
+          const refSeqNum = message.getField(import_fixparser3.Fields.RefSeqNum);
           if (refSeqNum) id = String(refSeqNum.value);
         }
         if (id) {
@@ -400,492 +910,30 @@ var MCPLocal = class {
       }),
       async (request, extra) => {
         const { name, arguments: args } = request.params;
-        switch (name) {
-          case "parse":
-            try {
-              const parsedMessage = this.parser?.parse(args.fixString);
-              if (!parsedMessage || parsedMessage.length === 0) {
-                return {
-                  content: [
-                    {
-                      type: "text",
-                      text: "Error: Failed to parse FIX string",
-                      uri: "parse"
-                    }
-                  ],
-                  isError: true
-                };
-              }
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: `${parsedMessage[0].description}
-${parsedMessage[0].messageTypeDescription}`,
-                    uri: "parse"
-                  }
-                ]
-              };
-            } catch (error) {
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: `Error: ${error instanceof Error ? error.message : "Failed to parse FIX string"}`,
-                    uri: "parse"
-                  }
-                ],
-                isError: true
-              };
-            }
-          case "parseToJSON":
-            try {
-              const parsedMessage = this.parser?.parse(args.fixString);
-              if (!parsedMessage || parsedMessage.length === 0) {
-                return {
-                  content: [
-                    {
-                      type: "text",
-                      text: "Error: Failed to parse FIX string",
-                      uri: "parseToJSON"
-                    }
-                  ],
-                  isError: true
-                };
-              }
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: `${parsedMessage[0].toFIXJSON()}`,
-                    uri: "parseToJSON"
-                  }
-                ]
-              };
-            } catch (error) {
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: `Error: ${error instanceof Error ? error.message : "Failed to parse FIX string"}`,
-                    uri: "parseToJSON"
-                  }
-                ],
-                isError: true
-              };
-            }
-          case "verifyOrder":
-            try {
-              this.verifiedOrders.set(args.clOrdID, {
-                clOrdID: args.clOrdID,
-                handlInst: args.handlInst,
-                quantity: Number.parseFloat(args.quantity),
-                price: Number.parseFloat(args.price),
-                ordType: args.ordType,
-                side: args.side,
-                symbol: args.symbol,
-                timeInForce: args.timeInForce
-              });
-              const ordTypeNames = {
-                "1": "Market",
-                "2": "Limit",
-                "3": "Stop",
-                "4": "StopLimit",
-                "5": "MarketOnClose",
-                "6": "WithOrWithout",
-                "7": "LimitOrBetter",
-                "8": "LimitWithOrWithout",
-                "9": "OnBasis",
-                A: "OnClose",
-                B: "LimitOnClose",
-                C: "ForexMarket",
-                D: "PreviouslyQuoted",
-                E: "PreviouslyIndicated",
-                F: "ForexLimit",
-                G: "ForexSwap",
-                H: "ForexPreviouslyQuoted",
-                I: "Funari",
-                J: "MarketIfTouched",
-                K: "MarketWithLeftOverAsLimit",
-                L: "PreviousFundValuationPoint",
-                M: "NextFundValuationPoint",
-                P: "Pegged",
-                Q: "CounterOrderSelection",
-                R: "StopOnBidOrOffer",
-                S: "StopLimitOnBidOrOffer"
-              };
-              const sideNames = {
-                "1": "Buy",
-                "2": "Sell",
-                "3": "BuyMinus",
-                "4": "SellPlus",
-                "5": "SellShort",
-                "6": "SellShortExempt",
-                "7": "Undisclosed",
-                "8": "Cross",
-                "9": "CrossShort",
-                A: "CrossShortExempt",
-                B: "AsDefined",
-                C: "Opposite",
-                D: "Subscribe",
-                E: "Redeem",
-                F: "Lend",
-                G: "Borrow",
-                H: "SellUndisclosed"
-              };
-              const timeInForceNames = {
-                "0": "Day",
-                "1": "GoodTillCancel",
-                "2": "AtTheOpening",
-                "3": "ImmediateOrCancel",
-                "4": "FillOrKill",
-                "5": "GoodTillCrossing",
-                "6": "GoodTillDate",
-                "7": "AtTheClose",
-                "8": "GoodThroughCrossing",
-                "9": "AtCrossing",
-                A: "GoodForTime",
-                B: "GoodForAuction",
-                C: "GoodForMonth"
-              };
-              const handlInstNames = {
-                "1": "AutomatedExecutionNoIntervention",
-                "2": "AutomatedExecutionInterventionOK",
-                "3": "ManualOrder"
-              };
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: `VERIFICATION: All parameters valid. Ready to proceed with order execution.
-                                            
-Parameters verified:
-- ClOrdID: ${args.clOrdID}
-- HandlInst: ${args.handlInst} (${handlInstNames[args.handlInst]})
-- Quantity: ${args.quantity}
-- Price: ${args.price}
-- OrdType: ${args.ordType} (${ordTypeNames[args.ordType]})
-- Side: ${args.side} (${sideNames[args.side]})
-- Symbol: ${args.symbol}
-- TimeInForce: ${args.timeInForce} (${timeInForceNames[args.timeInForce]})
-
-To execute this order, call the executeOrder tool with these exact same parameters.`,
-                    uri: "verifyOrder"
-                  }
-                ]
-              };
-            } catch (error) {
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: `Error: ${error instanceof Error ? error.message : "Failed to verify order parameters"}`,
-                    uri: "verifyOrder"
-                  }
-                ],
-                isError: true
-              };
-            }
-          case "executeOrder":
-            try {
-              const verifiedOrder = this.verifiedOrders.get(args.clOrdID);
-              if (!verifiedOrder) {
-                return {
-                  content: [
-                    {
-                      type: "text",
-                      text: `Error: Order ${args.clOrdID} has not been verified. Please call verifyOrder first.`,
-                      uri: "executeOrder"
-                    }
-                  ],
-                  isError: true
-                };
-              }
-              if (verifiedOrder.handlInst !== args.handlInst || verifiedOrder.quantity !== Number.parseFloat(args.quantity) || verifiedOrder.price !== Number.parseFloat(args.price) || verifiedOrder.ordType !== args.ordType || verifiedOrder.side !== args.side || verifiedOrder.symbol !== args.symbol || verifiedOrder.timeInForce !== args.timeInForce) {
-                return {
-                  content: [
-                    {
-                      type: "text",
-                      text: "Error: Order parameters do not match the verified order. Please use the exact same parameters that were verified.",
-                      uri: "executeOrder"
-                    }
-                  ],
-                  isError: true
-                };
+        const 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
               }
-              const response = new Promise((resolve) => {
-                this.pendingRequests.set(args.clOrdID, resolve);
-              });
-              const order = this.parser?.createMessage(
-                new import_fixparser.Field(import_fixparser.Fields.MsgType, import_fixparser.Messages.NewOrderSingle),
-                new import_fixparser.Field(import_fixparser.Fields.MsgSeqNum, this.parser?.getNextTargetMsgSeqNum()),
-                new import_fixparser.Field(import_fixparser.Fields.SenderCompID, this.parser?.sender),
-                new import_fixparser.Field(import_fixparser.Fields.TargetCompID, this.parser?.target),
-                new import_fixparser.Field(import_fixparser.Fields.SendingTime, this.parser?.getTimestamp()),
-                new import_fixparser.Field(import_fixparser.Fields.ClOrdID, args.clOrdID),
-                new import_fixparser.Field(import_fixparser.Fields.Side, args.side),
-                new import_fixparser.Field(import_fixparser.Fields.Symbol, args.symbol),
-                new import_fixparser.Field(import_fixparser.Fields.OrderQty, Number.parseFloat(args.quantity)),
-                new import_fixparser.Field(import_fixparser.Fields.Price, Number.parseFloat(args.price)),
-                new import_fixparser.Field(import_fixparser.Fields.OrdType, args.ordType),
-                new import_fixparser.Field(import_fixparser.Fields.HandlInst, args.handlInst),
-                new import_fixparser.Field(import_fixparser.Fields.TimeInForce, args.timeInForce),
-                new import_fixparser.Field(import_fixparser.Fields.TransactTime, this.parser?.getTimestamp())
-              );
-              if (!this.parser?.connected) {
-                return {
-                  content: [
-                    {
-                      type: "text",
-                      text: "Error: Not connected. Ignoring message.",
-                      uri: "executeOrder"
-                    }
-                  ],
-                  isError: true
-                };
-              }
-              this.parser?.send(order);
-              const fixData = await response;
-              this.verifiedOrders.delete(args.clOrdID);
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: fixData.messageType === import_fixparser.Messages.Reject ? `Reject message for order ${args.clOrdID}: ${JSON.stringify(fixData.toFIXJSON())}` : `Execution Report for order ${args.clOrdID}: ${JSON.stringify(fixData.toFIXJSON())}`,
-                    uri: "executeOrder"
-                  }
-                ]
-              };
-            } catch (error) {
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: `Error: ${error instanceof Error ? error.message : "Failed to execute order"}`,
-                    uri: "executeOrder"
-                  }
-                ],
-                isError: true
-              };
-            }
-          case "marketDataRequest":
-            try {
-              const response = new Promise((resolve) => {
-                this.pendingRequests.set(args.mdReqID, resolve);
-              });
-              const messageFields = [
-                new import_fixparser.Field(import_fixparser.Fields.MsgType, import_fixparser.Messages.MarketDataRequest),
-                new import_fixparser.Field(import_fixparser.Fields.SenderCompID, this.parser?.sender),
-                new import_fixparser.Field(import_fixparser.Fields.MsgSeqNum, this.parser?.getNextTargetMsgSeqNum()),
-                new import_fixparser.Field(import_fixparser.Fields.TargetCompID, this.parser?.target),
-                new import_fixparser.Field(import_fixparser.Fields.SendingTime, this.parser?.getTimestamp()),
-                new import_fixparser.Field(import_fixparser.Fields.MDReqID, args.mdReqID),
-                new import_fixparser.Field(import_fixparser.Fields.SubscriptionRequestType, args.subscriptionRequestType),
-                new import_fixparser.Field(import_fixparser.Fields.MarketDepth, 0),
-                new import_fixparser.Field(import_fixparser.Fields.MDUpdateType, args.mdUpdateType)
-              ];
-              messageFields.push(new import_fixparser.Field(import_fixparser.Fields.NoRelatedSym, args.symbols.length));
-              args.symbols.forEach((symbol) => {
-                messageFields.push(new import_fixparser.Field(import_fixparser.Fields.Symbol, symbol));
-              });
-              messageFields.push(new import_fixparser.Field(import_fixparser.Fields.NoMDEntryTypes, args.mdEntryTypes.length));
-              args.mdEntryTypes.forEach((entryType) => {
-                messageFields.push(new import_fixparser.Field(import_fixparser.Fields.MDEntryType, entryType));
-              });
-              const mdr = this.parser?.createMessage(...messageFields);
-              if (!this.parser?.connected) {
-                return {
-                  content: [
-                    {
-                      type: "text",
-                      text: "Error: Not connected. Ignoring message.",
-                      uri: "marketDataRequest"
-                    }
-                  ],
-                  isError: true
-                };
-              }
-              this.parser?.send(mdr);
-              const fixData = await response;
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: `Market data for ${args.symbols.join(", ")}: ${JSON.stringify(fixData.toFIXJSON())}`,
-                    uri: "marketDataRequest"
-                  }
-                ]
-              };
-            } catch (error) {
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: `Error: ${error instanceof Error ? error.message : "Failed to request market data"}`,
-                    uri: "marketDataRequest"
-                  }
-                ],
-                isError: true
-              };
-            }
-          case "getStockGraph":
-            try {
-              const symbol = args.symbol;
-              const priceHistory = this.marketDataPrices.get(symbol) || [];
-              if (priceHistory.length === 0) {
-                return {
-                  content: [
-                    {
-                      type: "text",
-                      text: `No price data available for ${symbol}`,
-                      uri: "getStockGraph"
-                    }
-                  ]
-                };
-              }
-              const width = 600;
-              const height = 300;
-              const padding = 40;
-              const xScale = (width - 2 * padding) / (priceHistory.length - 1);
-              const yMin = Math.min(...priceHistory.map((d) => d.price));
-              const yMax = Math.max(...priceHistory.map((d) => d.price));
-              const yScale = (height - 2 * padding) / (yMax - yMin);
-              const points = priceHistory.map((d, i) => {
-                const x = padding + i * xScale;
-                const y = height - padding - (d.price - yMin) * yScale;
-                return `${x},${y}`;
-              }).join(" L ");
-              const svg = `<?xml version="1.0" encoding="UTF-8"?>
-<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">
-    <!-- Background -->
-    <rect width="100%" height="100%" fill="#f8f9fa"/>
-    
-    <!-- Grid lines -->
-    <g stroke="#e9ecef" stroke-width="1">
-        ${Array.from({ length: 5 }, (_, i) => {
-                const y = padding + (height - 2 * padding) * i / 4;
-                return `<line x1="${padding}" y1="${y}" x2="${width - padding}" y2="${y}"/>`;
-              }).join("\n")}
-    </g>
-    
-    <!-- Price line -->
-    <path d="M ${points}" 
-          fill="none" 
-          stroke="#007bff" 
-          stroke-width="2"/>
-    
-    <!-- Data points -->
-    ${priceHistory.map((d, i) => {
-                const x = padding + i * xScale;
-                const y = height - padding - (d.price - yMin) * yScale;
-                return `<circle cx="${x}" cy="${y}" r="3" fill="#007bff"/>`;
-              }).join("\n")}
-    
-    <!-- Labels -->
-    <g font-family="Arial" font-size="12" fill="#495057">
-        ${Array.from({ length: 5 }, (_, i) => {
-                const x = padding + (width - 2 * padding) * i / 4;
-                const index = Math.floor((priceHistory.length - 1) * i / 4);
-                const timestamp = new Date(priceHistory[index].timestamp).toLocaleTimeString();
-                return `<text x="${x + padding}" y="${height - padding + 20}" text-anchor="middle">${timestamp}</text>`;
-              }).join("\n")}
-        ${Array.from({ length: 5 }, (_, i) => {
-                const y = padding + (height - 2 * padding) * i / 4;
-                const price = yMax - (yMax - yMin) * i / 4;
-                return `<text x="${padding - 5}" y="${y + 4}" text-anchor="end">$${price.toFixed(2)}</text>`;
-              }).join("\n")}
-    </g>
-    
-    <!-- Title -->
-    <text x="${width / 2}" y="${padding / 2}" 
-          font-family="Arial" font-size="16" font-weight="bold" 
-          text-anchor="middle" fill="#212529">
-        ${symbol} - Price Chart (${priceHistory.length} points)
-    </text>
-</svg>`;
-              const pngBuffer = await (0, import_sharp.default)(Buffer.from(svg)).png().toBuffer();
-              const base64Png = pngBuffer.toString("base64");
-              return {
-                content: [
-                  {
-                    type: "image",
-                    text: base64Png,
-                    uri: "getStockGraph",
-                    mimeType: "image/png"
-                  }
-                ]
-              };
-            } catch (error) {
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: `Error: ${error instanceof Error ? error.message : "Failed to generate stock graph"}`,
-                    uri: "getStockGraph"
-                  }
-                ],
-                isError: true
-              };
-            }
-          case "getStockPriceHistory":
-            try {
-              const symbol = args.symbol;
-              const priceHistory = this.marketDataPrices.get(symbol) || [];
-              if (priceHistory.length === 0) {
-                return {
-                  content: [
-                    {
-                      type: "text",
-                      text: `No price data available for ${symbol}`,
-                      uri: "getStockPriceHistory"
-                    }
-                  ]
-                };
-              }
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: JSON.stringify(
-                      {
-                        symbol,
-                        count: priceHistory.length,
-                        prices: priceHistory.map((point) => ({
-                          timestamp: new Date(point.timestamp).toISOString(),
-                          price: point.price
-                        }))
-                      },
-                      null,
-                      2
-                    ),
-                    uri: "getStockPriceHistory"
-                  }
-                ]
-              };
-            } catch (error) {
-              return {
-                content: [
-                  {
-                    type: "text",
-                    text: `Error: ${error instanceof Error ? error.message : "Failed to get stock price history"}`,
-                    uri: "getStockPriceHistory"
-                  }
-                ],
-                isError: true
-              };
-            }
-          default:
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Tool not found: ${name}`,
-                  uri: name
-                }
-              ],
-              isError: true
-            };
+            ],
+            isError: true
+          };
         }
+        const result = await handler(args);
+        return {
+          content: result.content,
+          isError: result.isError
+        };
       }
     );
     process.on("SIGINT", async () => {