fixparser-plugin-mcp 9.1.7-75ded9c1 → 9.1.7-89ae1451

package/build/cjs/MCPLocal.js

@@ -27,6 +27,103 @@ 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 symbolSchema = import_zod.z.object({
+  symbol: import_zod.z.string()
+});
+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 {
   parser;
   server = new import_server.Server(
@@ -185,11 +282,25 @@ var MCPLocal = class {
           },
           stockGraph: {
             description: "Generates a price chart for a given symbol",
-            uri: "stockGraph/{symbol}"
+            uri: "stockGraph",
+            parameters: {
+              type: "object",
+              properties: {
+                symbol: { type: "string" }
+              },
+              required: ["symbol"]
+            }
           },
           stockPriceHistory: {
             description: "Returns price history for a given symbol",
-            uri: "stockPriceHistory/{symbol}"
+            uri: "stockPriceHistory",
+            parameters: {
+              type: "object",
+              properties: {
+                symbol: { type: "string" }
+              },
+              required: ["symbol"]
+            }
           }
         }
       }
@@ -240,14 +351,6 @@ var MCPLocal = class {
               level: "info",
               message: `MCP Server added ${symbol}: ${priceNum}`
             });
-            this.server.notification({
-              method: "priceUpdate",
-              params: {
-                symbol: symbolStr,
-                price: priceNum,
-                timestamp: Number(timestamp)
-              }
-            });
           }
         }
         if (msgType === import_fixparser.Messages.MarketDataSnapshotFullRefresh) {
@@ -291,20 +394,11 @@ var MCPLocal = class {
               name: "greeting",
               description: "A simple greeting resource",
               uri: "greeting-resource"
-            }
-          ]
-        };
-      }
-    );
-    this.server.setRequestHandler(
-      import_zod.z.object({ method: import_zod.z.literal("resources/templates/list") }),
-      async (request, extra) => {
-        return {
-          resourceTemplates: [
+            },
             {
               name: "stockGraph",
               description: "Generates a price chart for a given symbol",
-              uriTemplate: "stockGraph/{symbol}",
+              uri: "stockGraph",
               parameters: {
                 type: "object",
                 properties: {
@@ -316,7 +410,7 @@ var MCPLocal = class {
             {
               name: "stockPriceHistory",
               description: "Returns price history for a given symbol",
-              uriTemplate: "stockPriceHistory/{symbol}",
+              uri: "stockPriceHistory",
               parameters: {
                 type: "object",
                 properties: {
@@ -491,176 +585,218 @@ var MCPLocal = class {
     );
     this.server.setRequestHandler(
       import_zod.z.object({
-        method: import_zod.z.literal("tools/call"),
+        method: import_zod.z.literal("resources/read"),
         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()
+          uri: import_zod.z.string()
         })
       }),
       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 {
-                  contents: [
-                    {
-                      type: "text",
-                      text: "Error: Failed to parse FIX string",
-                      uri: "parse"
-                    }
-                  ],
-                  isError: true
-                };
+        const { uri } = request.params;
+        switch (uri) {
+          case "greeting-resource":
+            return {
+              contents: [
+                {
+                  type: "text",
+                  text: "Hello, world!"
+                }
+              ]
+            };
+          case "stockGraph":
+            return {
+              contents: [
+                {
+                  type: "text",
+                  text: "This resource requires a symbol parameter. Please use the stockGraph resource with a symbol parameter."
+                }
+              ]
+            };
+          case "stockPriceHistory":
+            return {
+              contents: [
+                {
+                  type: "text",
+                  text: "This resource requires a symbol parameter. Please use the stockPriceHistory resource with a symbol parameter."
+                }
+              ]
+            };
+          default:
+            return {
+              contents: [
+                {
+                  type: "text",
+                  text: `Resource not found: ${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 {
+              content: [{ type: "text", text: "Error: Failed to parse FIX string" }],
+              isError: true
+            };
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: `${parsedMessage[0].description}
+${parsedMessage[0].messageTypeDescription}`
               }
-              return {
-                contents: [
-                  {
-                    type: "text",
-                    text: `${parsedMessage[0].description}
-${parsedMessage[0].messageTypeDescription}`,
-                    uri: "parse"
-                  }
-                ]
-              };
-            } catch (error) {
-              return {
-                contents: [
-                  {
-                    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 {
-                  contents: [
-                    {
-                      type: "text",
-                      text: "Error: Failed to parse FIX string",
-                      uri: "parseToJSON"
-                    }
-                  ],
-                  isError: true
-                };
+            ]
+          };
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: ${error instanceof Error ? error.message : "Failed to parse FIX string"}`
               }
-              return {
-                contents: [
-                  {
-                    type: "text",
-                    text: `${parsedMessage[0].toFIXJSON()}`,
-                    uri: "parseToJSON"
-                  }
-                ]
-              };
-            } catch (error) {
-              return {
-                contents: [
-                  {
-                    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 {
-                contents: [
-                  {
-                    type: "text",
-                    text: `VERIFICATION: All parameters valid. Ready to proceed with order execution.
-                                            
+            ],
+            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 {
+              content: [{ type: "text", text: "Error: Failed to parse FIX string" }],
+              isError: true
+            };
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: `${parsedMessage[0].toFIXJSON()}`
+              }
+            ]
+          };
+        } catch (error) {
+          return {
+            content: [
+              {
+                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("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 {
+            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]})
@@ -671,247 +807,209 @@ Parameters verified:
 - 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 {
-                contents: [
-                  {
-                    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 {
-                  contents: [
-                    {
-                      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 {
-                  contents: [
-                    {
-                      type: "text",
-                      text: "Error: Order parameters do not match the verified order. Please use the exact same parameters that were verified.",
-                      uri: "executeOrder"
-                    }
-                  ],
-                  isError: true
-                };
-              }
-              const response = new Promise((resolve) => {
-                this.pendingRequests.set(args.clOrdID, resolve);
-              });
-              const order = this.parser?.createMessage(
-                new import_fixparser.Field(import_fixparser.Fields.MsgType, import_fixparser.Messages.NewOrderSingle),
-                new import_fixparser.Field(import_fixparser.Fields.MsgSeqNum, this.parser?.getNextTargetMsgSeqNum()),
-                new import_fixparser.Field(import_fixparser.Fields.SenderCompID, this.parser?.sender),
-                new import_fixparser.Field(import_fixparser.Fields.TargetCompID, this.parser?.target),
-                new import_fixparser.Field(import_fixparser.Fields.SendingTime, this.parser?.getTimestamp()),
-                new import_fixparser.Field(import_fixparser.Fields.ClOrdID, args.clOrdID),
-                new import_fixparser.Field(import_fixparser.Fields.Side, args.side),
-                new import_fixparser.Field(import_fixparser.Fields.Symbol, args.symbol),
-                new import_fixparser.Field(import_fixparser.Fields.OrderQty, Number.parseFloat(args.quantity)),
-                new import_fixparser.Field(import_fixparser.Fields.Price, Number.parseFloat(args.price)),
-                new import_fixparser.Field(import_fixparser.Fields.OrdType, args.ordType),
-                new import_fixparser.Field(import_fixparser.Fields.HandlInst, args.handlInst),
-                new import_fixparser.Field(import_fixparser.Fields.TimeInForce, args.timeInForce),
-                new import_fixparser.Field(import_fixparser.Fields.TransactTime, this.parser?.getTimestamp())
-              );
-              if (!this.parser?.connected) {
-                return {
-                  contents: [
-                    {
-                      type: "text",
-                      text: "Error: Not connected. Ignoring message.",
-                      uri: "executeOrder"
-                    }
-                  ],
-                  isError: true
-                };
+To execute this order, call the executeOrder tool with these exact same parameters.`
               }
-              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())}`,
-                    uri: "executeOrder"
-                  }
-                ]
-              };
-            } catch (error) {
-              return {
-                contents: [
-                  {
-                    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 {
-                  contents: [
-                    {
-                      type: "text",
-                      text: "Error: Not connected. Ignoring message.",
-                      uri: "marketDataRequest"
-                    }
-                  ],
-                  isError: true
-                };
+            ]
+          };
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: ${error instanceof Error ? error.message : "Failed to verify order parameters"}`
               }
-              this.parser?.send(mdr);
-              const fixData = await response;
-              return {
-                contents: [
-                  {
-                    type: "text",
-                    text: `Market data for ${args.symbols.join(", ")}: ${JSON.stringify(fixData.toFIXJSON())}`,
-                    uri: "marketDataRequest"
-                  }
-                ]
-              };
-            } catch (error) {
-              return {
-                contents: [
-                  {
-                    type: "text",
-                    text: `Error: ${error instanceof Error ? error.message : "Failed to request market data"}`,
-                    uri: "marketDataRequest"
-                  }
-                ],
-                isError: true
-              };
-            }
-          default:
-            return {
-              contents: [
-                {
-                  type: "text",
-                  text: `Tool not found: ${name}`,
-                  uri: name
-                }
-              ],
-              isError: true
-            };
+            ],
+            isError: true
+          };
         }
       }
     );
     this.server.setRequestHandler(
       import_zod.z.object({
-        method: import_zod.z.literal("resources/read"),
-        params: import_zod.z.object({
-          uri: import_zod.z.string()
-        })
+        method: import_zod.z.literal("executeOrder"),
+        params: orderSchema
       }),
       async (request, extra) => {
-        const { uri } = request.params;
-        switch (uri) {
-          case "greeting-resource":
+        try {
+          const args = request.params;
+          const verifiedOrder = this.verifiedOrders.get(args.clOrdID);
+          if (!verifiedOrder) {
             return {
-              contents: [
+              content: [
                 {
                   type: "text",
-                  text: "Hello, world!",
-                  uri: "greeting-resource"
+                  text: `Error: Order ${args.clOrdID} has not been verified. Please call verifyOrder first.`
                 }
-              ]
+              ],
+              isError: true
             };
-          case "stockGraph":
+          }
+          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: [
+              content: [
                 {
                   type: "text",
-                  text: "This resource requires a symbol parameter. Please use the stockGraph/{symbol} resource.",
-                  uri: "stockGraph"
+                  text: "Error: Order parameters do not match the verified order. Please use the exact same parameters that were verified."
                 }
-              ]
+              ],
+              isError: true
             };
-          case "stockPriceHistory":
+          }
+          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: [
+              content: [
                 {
                   type: "text",
-                  text: "This resource requires a symbol parameter. Please use the stockPriceHistory/{symbol} resource.",
-                  uri: "stockPriceHistory"
+                  text: "Error: Not connected. Ignoring message."
                 }
-              ]
+              ],
+              isError: true
             };
-          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}`,
-                      uri
-                    }
-                  ]
-                };
+          }
+          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())}`
               }
-              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"?>
+            ]
+          };
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: ${error instanceof Error ? error.message : "Failed to execute order"}`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+    );
+    this.server.setRequestHandler(
+      import_zod.z.object({
+        method: import_zod.z.literal("marketDataRequest"),
+        params: marketDataRequestSchema
+      }),
+      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 {
+              content: [
+                {
+                  type: "text",
+                  text: "Error: Not connected. Ignoring message."
+                }
+              ],
+              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())}`
+              }
+            ]
+          };
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: ${error instanceof Error ? error.message : "Failed to request market data"}`
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+    );
+    this.server.setRequestHandler(
+      import_zod.z.object({
+        method: import_zod.z.literal("stockGraph"),
+        params: symbolSchema
+      }),
+      async (request, extra) => {
+        this.parser?.logger.log({
+          level: "info",
+          message: "MCP Server Resource called: stockGraph"
+        });
+        const args = request.params;
+        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}`
+              }
+            ]
+          };
+        }
+        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"/>
@@ -919,9 +1017,9 @@ To execute this order, call the executeOrder tool with these exact same paramete
     <!-- 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")}
+          const y = padding + (height - 2 * padding) * i / 4;
+          return `<line x1="${padding}" y1="${y}" x2="${width - padding}" y2="${y}"/>`;
+        }).join("\n")}
     </g>
     
     <!-- Price line -->
@@ -932,24 +1030,24 @@ To execute this order, call the executeOrder tool with these exact same paramete
     
     <!-- 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")}
+          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")}
+          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")}
+          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 -->
@@ -959,62 +1057,58 @@ To execute this order, call the executeOrder tool with these exact same paramete
         ${symbol} - Price Chart (${priceHistory.length} points)
     </text>
 </svg>`;
-              return {
-                contents: [
-                  {
-                    type: "text",
-                    text: svg,
-                    uri
-                  }
-                ]
-              };
+        return {
+          content: [
+            {
+              type: "text",
+              text: svg
             }
-            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}`,
-                      uri
-                    }
-                  ]
-                };
+          ]
+        };
+      }
+    );
+    this.server.setRequestHandler(
+      import_zod.z.object({
+        method: import_zod.z.literal("stockPriceHistory"),
+        params: symbolSchema
+      }),
+      async (request, extra) => {
+        this.parser?.logger.log({
+          level: "info",
+          message: "MCP Server Resource called: stockPriceHistory"
+        });
+        const args = request.params;
+        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}`
               }
-              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
-                    ),
-                    uri
-                  }
-                ]
-              };
-            }
-            return {
-              contents: [
-                {
-                  type: "text",
-                  text: `Resource not found: ${uri}`,
-                  uri
-                }
-              ],
-              isError: true
-            };
+            ]
+          };
         }
+        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
+              )
+            }
+          ]
+        };
       }
     );
     process.on("SIGINT", async () => {