fixparser-plugin-mcp 9.1.7-8fdb1e41 → 9.1.7-9a071f36

package/build/esm/MCPLocal.mjs

@@ -1,181 +1,11 @@
 // src/MCPLocal.ts
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  GetPromptRequestSchema,
-  ListPromptsRequestSchema,
-  ListResourcesRequestSchema,
-  ListToolsRequestSchema
-} from "@modelcontextprotocol/sdk/types.js";
 import { Field, Fields, Messages } from "fixparser";
-var parseInputSchema = {
-  type: "object",
-  properties: {
-    fixString: {
-      type: "string",
-      description: "FIX message string to parse"
-    }
-  },
-  required: ["fixString"]
-};
-var parseToJSONInputSchema = {
-  type: "object",
-  properties: {
-    fixString: {
-      type: "string",
-      description: "FIX message string to parse"
-    }
-  },
-  required: ["fixString"]
-};
-var orderSchema = {
-  type: "object",
-  properties: {
-    clOrdID: {
-      type: "string",
-      description: "Client Order ID"
-    },
-    handlInst: {
-      type: "string",
-      enum: ["1", "2", "3"],
-      description: "Handling instruction (1=Manual, 2=Automated, 3=AutomatedNoIntervention)"
-    },
-    quantity: {
-      type: "number",
-      description: "Order quantity"
-    },
-    price: {
-      type: "number",
-      description: "Order price"
-    },
-    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)"
-    },
-    side: {
-      type: "string",
-      enum: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H"],
-      description: "Order 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",
-      description: "Trading symbol"
-    },
-    timeInForce: {
-      type: "string",
-      enum: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C"],
-      description: "Time in force (0=Day, 1=Good Till Cancel, 2=At Opening, 3=Immediate or Cancel, 4=Fill or Kill, 5=Good Till Crossing, 6=Good Till Date)"
-    }
-  },
-  required: ["clOrdID", "handlInst", "quantity", "price", "ordType", "side", "symbol", "timeInForce"]
-};
-var marketDataRequestInputSchema = {
-  type: "object",
-  properties: {
-    mdUpdateType: {
-      type: "string",
-      enum: ["0", "1"],
-      description: 'Market data update type (IMPORTANT: Use the numeric/alphabetic value, not the descriptive name. For example, use "0" for FullRefresh, "1" for IncrementalRefresh)'
-    },
-    symbol: {
-      type: "string",
-      description: "Trading symbol"
-    },
-    mdReqID: {
-      type: "string",
-      description: "Market data request ID"
-    },
-    subscriptionRequestType: {
-      type: "string",
-      enum: ["0", "1", "2"],
-      description: 'Subscription request type (IMPORTANT: Use the numeric/alphabetic value, not the descriptive name. For example, use "0" for Snapshot + Updates, "1" for Snapshot, "2" for Unsubscribe)'
-    },
-    mdEntryType: {
-      type: "string",
-      enum: [
-        "0",
-        "1",
-        "2",
-        "3",
-        "4",
-        "5",
-        "6",
-        "7",
-        "8",
-        "9",
-        "A",
-        "B",
-        "C",
-        "D",
-        "E",
-        "F",
-        "G",
-        "H",
-        "J",
-        "K",
-        "L",
-        "M",
-        "N",
-        "O",
-        "P",
-        "Q",
-        "S",
-        "R",
-        "T",
-        "U",
-        "V",
-        "W",
-        "X",
-        "Y",
-        "Z",
-        "a",
-        "b",
-        "c",
-        "d",
-        "e",
-        "g",
-        "h",
-        "i",
-        "t"
-      ],
-      description: 'Market data entry type (IMPORTANT: Use the numeric/alphabetic value, not the descriptive name. For example, use "0" for Bid, "1" for Offer, "2" for Trade, "3" for Index Value, "4" for Opening Price)'
-    }
-  },
-  required: ["symbol", "mdReqID"]
-};
+import { z } from "zod";
 var MCPLocal = class {
-  // private logger: Logger | undefined;
   parser;
-  server = new Server(
+  server = new McpServer(
     {
       name: "fixparser",
       version: "1.0.0"
@@ -233,606 +63,565 @@ var MCPLocal = class {
     if (!this.server) {
       return;
     }
-    const validateArgs = (args, schema) => {
-      const result = {};
-      for (const [key, propSchema] of Object.entries(schema.properties || {})) {
-        const prop = propSchema;
-        const value = args?.[key];
-        if (prop.required && (value === void 0 || value === null)) {
-          throw new Error(`Required property '${key}' is missing`);
-        }
-        if (value !== void 0) {
-          result[key] = value;
-        } else if (prop.default !== void 0) {
-          result[key] = prop.default;
-        }
-      }
-      return result;
-    };
-    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
-      return {
-        resources: []
-      };
-    });
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
-      return {
-        tools: [
-          {
-            name: "parse",
-            description: "Parses a FIX message and describes it in plain language",
-            inputSchema: parseInputSchema
-          },
-          {
-            name: "parseToJSON",
-            description: "Parses a FIX message into JSON",
-            inputSchema: parseToJSONInputSchema
-          },
-          {
-            name: "verifyOrder",
-            description: "Verifies all parameters for a New Order Single. This is the first step - verification only, no order is sent.",
-            inputSchema: orderSchema
-          },
-          {
-            name: "executeOrder",
-            description: "Executes a New Order Single after verification. This is the second step - only call after successful verification.",
-            inputSchema: orderSchema
-          },
-          {
-            name: "marketDataRequest",
-            description: "Sends a request for Market Data with the given symbol. IMPORTANT: All parameters must be explicitly provided by the user - no assumptions will be made.",
-            inputSchema: marketDataRequestInputSchema
-          }
-        ]
-      };
-    });
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-      switch (name) {
-        case "parse": {
-          try {
-            const { fixString } = validateArgs(args, parseInputSchema);
-            const parsedMessage = this.parser?.parse(fixString);
-            if (!parsedMessage || parsedMessage.length === 0) {
-              return {
-                isError: true,
-                content: [{ type: "text", text: "Error: Failed to parse FIX string" }]
-              };
-            }
+    this.server.tool(
+      "parse",
+      "Parses a FIX message and describes it in plain language",
+      {
+        fixString: z.string().describe("FIX message string to parse")
+      },
+      async (args) => {
+        try {
+          const parsedMessage = this.parser?.parse(args.fixString);
+          if (!parsedMessage || parsedMessage.length === 0) {
             return {
-              content: [
-                {
-                  type: "text",
-                  text: `${parsedMessage[0].description}
-${parsedMessage[0].messageTypeDescription}`
-                }
-              ]
-            };
-          } catch (error) {
-            return {
-              isError: true,
-              content: [
-                {
-                  type: "text",
-                  text: `Error: ${error instanceof Error ? error.message : "Failed to parse FIX string"}`
-                }
-              ]
+              content: [{ type: "text", text: "Error: Failed to parse FIX string" }],
+              isError: true
             };
           }
+          return {
+            content: [
+              {
+                type: "text",
+                text: `${parsedMessage[0].description}
+${parsedMessage[0].messageTypeDescription}`
+              }
+            ]
+          };
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: ${error instanceof Error ? error.message : "Failed to parse FIX string"}`
+              }
+            ],
+            isError: true
+          };
         }
-        case "parseToJSON": {
-          try {
-            const { fixString } = validateArgs(args, parseToJSONInputSchema);
-            const parsedMessage = this.parser?.parse(fixString);
-            if (!parsedMessage || parsedMessage.length === 0) {
-              return {
-                isError: true,
-                content: [{ type: "text", text: "Error: Failed to parse FIX string" }]
-              };
-            }
+      }
+    );
+    this.server.tool(
+      "parseToJSON",
+      "Parses a FIX message into JSON",
+      {
+        fixString: z.string().describe("FIX message string to parse")
+      },
+      async (args) => {
+        try {
+          const parsedMessage = this.parser?.parse(args.fixString);
+          if (!parsedMessage || parsedMessage.length === 0) {
             return {
-              content: [
-                {
-                  type: "text",
-                  text: `${parsedMessage[0].toFIXJSON()}`
-                }
-              ]
-            };
-          } catch (error) {
-            return {
-              isError: true,
-              content: [
-                {
-                  type: "text",
-                  text: `Error: ${error instanceof Error ? error.message : "Failed to parse FIX string"}`
-                }
-              ]
+              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
+          };
         }
-        case "verifyOrder": {
-          try {
-            const { clOrdID, handlInst, quantity, price, ordType, side, symbol, timeInForce } = validateArgs(args, orderSchema);
-            this.verifiedOrders.set(clOrdID, {
-              clOrdID,
-              handlInst,
-              quantity,
-              price,
-              ordType,
-              side,
-              symbol,
-              timeInForce
-            });
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `VERIFICATION: All parameters valid. Ready to proceed with order execution.
+      }
+    );
+    this.server.tool(
+      "verifyOrder",
+      "Verifies all parameters for a New Order Single. This is the first step - verification only, no order is sent.",
+      {
+        clOrdID: z.string().describe("Client Order ID"),
+        handlInst: z.enum(["1", "2", "3"]).describe("Handling instruction (1=Manual, 2=Automated, 3=AutomatedNoIntervention)"),
+        quantity: z.string().describe("Order quantity"),
+        price: z.string().describe("Order price"),
+        ordType: z.string().describe("Order type (1=Market, 2=Limit, 3=Stop)"),
+        side: z.string().describe("Order side (1=Buy, 2=Sell, etc.)"),
+        symbol: z.string().describe("Trading symbol"),
+        timeInForce: z.string().describe("Time in force (0=Day, 1=Good Till Cancel, etc.)")
+      },
+      async (args) => {
+        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
+          });
+          return {
+            content: [
+              {
+                type: "text",
+                text: `VERIFICATION: All parameters valid. Ready to proceed with order execution.
                                     
 Parameters verified:
-- ClOrdID: ${clOrdID}
-- HandlInst: ${handlInst}
-- Quantity: ${quantity}
-- Price: ${price}
-- OrdType: ${ordType}
-- Side: ${side}
-- Symbol: ${symbol}
-- TimeInForce: ${timeInForce}
+- ClOrdID: ${args.clOrdID}
+- HandlInst: ${args.handlInst}
+- Quantity: ${args.quantity}
+- Price: ${args.price}
+- OrdType: ${args.ordType}
+- Side: ${args.side}
+- Symbol: ${args.symbol}
+- TimeInForce: ${args.timeInForce}
 
 To execute this order, call the executeOrder tool with these exact same parameters.`
-                }
-              ]
-            };
-          } catch (error) {
-            return {
-              isError: true,
-              content: [
-                {
-                  type: "text",
-                  text: `Error: ${error instanceof Error ? error.message : "Failed to verify order parameters"}`
-                }
-              ]
-            };
-          }
+              }
+            ]
+          };
+        } catch (error) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Error: ${error instanceof Error ? error.message : "Failed to verify order parameters"}`
+              }
+            ],
+            isError: true
+          };
         }
-        case "executeOrder": {
-          try {
-            const { clOrdID, handlInst, quantity, price, ordType, side, symbol, timeInForce } = validateArgs(args, orderSchema);
-            const verifiedOrder = this.verifiedOrders.get(clOrdID);
-            if (!verifiedOrder) {
-              return {
-                isError: true,
-                content: [
-                  {
-                    type: "text",
-                    text: `Error: Order ${clOrdID} has not been verified. Please call verifyOrder first.`
-                  }
-                ]
-              };
-            }
-            if (verifiedOrder.handlInst !== handlInst || verifiedOrder.quantity !== quantity || verifiedOrder.price !== price || verifiedOrder.ordType !== ordType || verifiedOrder.side !== side || verifiedOrder.symbol !== symbol || verifiedOrder.timeInForce !== timeInForce) {
-              return {
-                isError: true,
-                content: [
-                  {
-                    type: "text",
-                    text: "Error: Order parameters do not match the verified order. Please use the exact same parameters that were verified."
-                  }
-                ]
-              };
-            }
-            const response = new Promise((resolve) => {
-              this.pendingRequests.set(clOrdID, resolve);
-            });
-            const order = this.parser?.createMessage(
-              new Field(Fields.MsgType, Messages.NewOrderSingle),
-              new Field(Fields.MsgSeqNum, this.parser?.getNextTargetMsgSeqNum()),
-              new Field(Fields.SenderCompID, this.parser?.sender),
-              new Field(Fields.TargetCompID, this.parser?.target),
-              new Field(Fields.SendingTime, this.parser?.getTimestamp()),
-              new Field(Fields.ClOrdID, clOrdID),
-              new Field(Fields.Side, side),
-              new Field(Fields.Symbol, symbol),
-              new Field(Fields.OrderQty, quantity),
-              new Field(Fields.Price, price),
-              new Field(Fields.OrdType, ordType),
-              new Field(Fields.HandlInst, handlInst),
-              new Field(Fields.TimeInForce, timeInForce),
-              new Field(Fields.TransactTime, this.parser?.getTimestamp())
-            );
-            if (!this.parser?.connected) {
-              return {
-                isError: true,
-                content: [
-                  {
-                    type: "text",
-                    text: "Error: Not connected. Ignoring message."
-                  }
-                ]
-              };
-            }
-            this.parser?.send(order);
-            const fixData = await response;
-            this.verifiedOrders.delete(clOrdID);
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: fixData.messageType === Messages.Reject ? `Reject message for order ${clOrdID}: ${JSON.stringify(fixData.toFIXJSON())}` : `Execution Report for order ${clOrdID}: ${JSON.stringify(fixData.toFIXJSON())}`
-                }
-              ]
-            };
-          } catch (error) {
+      }
+    );
+    this.server.tool(
+      "executeOrder",
+      "Executes a New Order Single after verification. This is the second step - only call after successful verification.",
+      {
+        clOrdID: z.string().describe("Client Order ID"),
+        handlInst: z.enum(["1", "2", "3"]).describe("Handling instruction (1=Manual, 2=Automated, 3=AutomatedNoIntervention)"),
+        quantity: z.string().describe("Order quantity"),
+        price: z.string().describe("Order price"),
+        ordType: z.string().describe("Order type (1=Market, 2=Limit, 3=Stop)"),
+        side: z.string().describe("Order side (1=Buy, 2=Sell, etc.)"),
+        symbol: z.string().describe("Trading symbol"),
+        timeInForce: z.string().describe("Time in force (0=Day, 1=Good Till Cancel, etc.)")
+      },
+      async (args) => {
+        try {
+          const verifiedOrder = this.verifiedOrders.get(args.clOrdID);
+          if (!verifiedOrder) {
             return {
-              isError: true,
               content: [
                 {
                   type: "text",
-                  text: `Error: ${error instanceof Error ? error.message : "Failed to execute order"}`
+                  text: `Error: Order ${args.clOrdID} has not been verified. Please call verifyOrder first.`
                 }
-              ]
+              ],
+              isError: true
             };
           }
-        }
-        case "marketDataRequest": {
-          try {
-            const { mdUpdateType, symbol, mdReqID, subscriptionRequestType, mdEntryType } = validateArgs(
-              args,
-              marketDataRequestInputSchema
-            );
-            const response = new Promise((resolve) => {
-              this.pendingRequests.set(mdReqID, resolve);
-            });
-            const marketDataRequest = this.parser?.createMessage(
-              new Field(Fields.MsgType, Messages.MarketDataRequest),
-              new Field(Fields.SenderCompID, this.parser?.sender),
-              new Field(Fields.MsgSeqNum, this.parser?.getNextTargetMsgSeqNum()),
-              new Field(Fields.TargetCompID, this.parser?.target),
-              new Field(Fields.SendingTime, this.parser?.getTimestamp()),
-              new Field(Fields.MarketDepth, 0),
-              new Field(Fields.MDUpdateType, mdUpdateType),
-              new Field(Fields.NoRelatedSym, 1),
-              new Field(Fields.Symbol, symbol),
-              new Field(Fields.MDReqID, mdReqID),
-              new Field(Fields.SubscriptionRequestType, subscriptionRequestType),
-              new Field(Fields.NoMDEntryTypes, 1),
-              new Field(Fields.MDEntryType, mdEntryType)
-            );
-            if (!this.parser?.connected) {
-              return {
-                isError: true,
-                content: [
-                  {
-                    type: "text",
-                    text: "Error: Not connected. Ignoring message."
-                  }
-                ]
-              };
-            }
-            this.parser?.send(marketDataRequest);
-            const fixData = await response;
+          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: `Market data for ${symbol}: ${JSON.stringify(fixData.toFIXJSON())}`
+                  text: "Error: Order parameters do not match the verified order. Please use the exact same parameters that were verified."
                 }
-              ]
+              ],
+              isError: true
             };
-          } catch (error) {
+          }
+          const response = new Promise((resolve) => {
+            this.pendingRequests.set(args.clOrdID, resolve);
+          });
+          const order = this.parser?.createMessage(
+            new Field(Fields.MsgType, Messages.NewOrderSingle),
+            new Field(Fields.MsgSeqNum, this.parser?.getNextTargetMsgSeqNum()),
+            new Field(Fields.SenderCompID, this.parser?.sender),
+            new Field(Fields.TargetCompID, this.parser?.target),
+            new Field(Fields.SendingTime, this.parser?.getTimestamp()),
+            new Field(Fields.ClOrdID, args.clOrdID),
+            new Field(Fields.Side, args.side),
+            new Field(Fields.Symbol, args.symbol),
+            new Field(Fields.OrderQty, Number.parseFloat(args.quantity)),
+            new Field(Fields.Price, Number.parseFloat(args.price)),
+            new Field(Fields.OrdType, args.ordType),
+            new Field(Fields.HandlInst, args.handlInst),
+            new Field(Fields.TimeInForce, args.timeInForce),
+            new Field(Fields.TransactTime, this.parser?.getTimestamp())
+          );
+          if (!this.parser?.connected) {
             return {
-              isError: true,
               content: [
                 {
                   type: "text",
-                  text: `Error: ${error instanceof Error ? error.message : "Failed to request market data"}`
+                  text: "Error: Not connected. Ignoring message."
                 }
-              ]
+              ],
+              isError: true
             };
           }
-        }
-        default:
-          throw new Error(`Unknown tool: ${name}`);
-      }
-    });
-    this.server.setRequestHandler(ListPromptsRequestSchema, async () => {
-      return {
-        prompts: [
-          {
-            name: "parse",
-            description: "Parses a FIX message and describes it in plain language",
-            arguments: [
-              {
-                name: "fixString",
-                description: "FIX message string to parse",
-                required: true
-              }
-            ]
-          },
-          {
-            name: "parseToJSON",
-            description: "Parses a FIX message into JSON",
-            arguments: [
-              {
-                name: "fixString",
-                description: "FIX message string to parse",
-                required: true
-              }
-            ]
-          },
-          {
-            name: "verifyOrder",
-            description: "Verifies all parameters for a New Order Single. This is the first step - verification only, no order is sent.",
-            arguments: [
-              {
-                name: "clOrdID",
-                description: "Client Order ID",
-                required: true
-              },
-              {
-                name: "handlInst",
-                description: "Handling instruction (1=Manual, 2=Automated, 3=AutomatedNoIntervention)",
-                required: true
-              },
-              {
-                name: "quantity",
-                description: "Order quantity",
-                required: true
-              },
-              {
-                name: "price",
-                description: "Order price",
-                required: true
-              },
-              {
-                name: "ordType",
-                description: "Order type (1=Market, 2=Limit, 3=Stop)",
-                required: true
-              },
-              {
-                name: "side",
-                description: "Order 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)",
-                required: true
-              },
-              {
-                name: "symbol",
-                description: "Trading symbol",
-                required: true
-              },
-              {
-                name: "timeInForce",
-                description: "Time in force (0=Day, 1=Good Till Cancel, 2=At Opening, 3=Immediate or Cancel, 4=Fill or Kill, 5=Good Till Crossing, 6=Good Till Date)",
-                required: true
-              }
-            ]
-          },
-          {
-            name: "executeOrder",
-            description: "Executes a New Order Single after verification. This is the second step - only call after successful verification.",
-            arguments: [
-              {
-                name: "clOrdID",
-                description: "Client Order ID",
-                required: true
-              },
-              {
-                name: "handlInst",
-                description: "Handling instruction (1=Manual, 2=Automated, 3=AutomatedNoIntervention)",
-                required: true
-              },
-              {
-                name: "quantity",
-                description: "Order quantity",
-                required: true
-              },
-              {
-                name: "price",
-                description: "Order price",
-                required: true
-              },
-              {
-                name: "ordType",
-                description: "Order type (1=Market, 2=Limit, 3=Stop)",
-                required: true
-              },
-              {
-                name: "side",
-                description: "Order 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)",
-                required: true
-              },
-              {
-                name: "symbol",
-                description: "Trading symbol",
-                required: true
-              },
-              {
-                name: "timeInForce",
-                description: "Time in force (0=Day, 1=Good Till Cancel, 2=At Opening, 3=Immediate or Cancel, 4=Fill or Kill, 5=Good Till Crossing, 6=Good Till Date)",
-                required: true
-              }
-            ]
-          },
-          {
-            name: "marketDataRequest",
-            description: "Sends a request for Market Data with the given symbol. IMPORTANT: All parameters must be explicitly provided by the user - no assumptions will be made.",
-            arguments: [
-              {
-                name: "mdUpdateType",
-                description: "Market data update type (0=FullRefresh, 1=IncrementalRefresh)",
-                required: true
-              },
-              {
-                name: "symbol",
-                description: "Trading symbol",
-                required: true
-              },
-              {
-                name: "mdReqID",
-                description: "Market data request ID",
-                required: true
-              },
-              {
-                name: "subscriptionRequestType",
-                description: "Subscription request type (0=Snapshot + Updates, 1=Snapshot, 2=Unsubscribe)",
-                required: true
-              },
-              {
-                name: "mdEntryType",
-                description: "Market data entry type (0=Bid, 1=Offer, 2=Trade, 3=Index Value, 4=Opening Price)",
-                required: true
-              }
-            ]
-          }
-        ]
-      };
-    });
-    this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-      switch (name) {
-        case "parse": {
-          const fixString = args?.fixString || "";
+          this.parser?.send(order);
+          const fixData = await response;
+          this.verifiedOrders.delete(args.clOrdID);
           return {
-            messages: [
+            content: [
               {
-                role: "user",
-                content: {
-                  type: "text",
-                  text: `Please parse and explain this FIX message: ${fixString}`
-                }
+                type: "text",
+                text: fixData.messageType === Messages.Reject ? `Reject message for order ${args.clOrdID}: ${JSON.stringify(fixData.toFIXJSON())}` : `Execution Report for order ${args.clOrdID}: ${JSON.stringify(fixData.toFIXJSON())}`
               }
             ]
           };
-        }
-        case "parseToJSON": {
-          const fixString = args?.fixString || "";
+        } catch (error) {
           return {
-            messages: [
+            content: [
               {
-                role: "user",
-                content: {
-                  type: "text",
-                  text: `Please parse the FIX message to JSON: ${fixString}`
-                }
+                type: "text",
+                text: `Error: ${error instanceof Error ? error.message : "Failed to execute order"}`
               }
-            ]
+            ],
+            isError: true
           };
         }
-        case "verifyOrder": {
-          const { clOrdID, handlInst, quantity, price, ordType, side, symbol, timeInForce } = args || {};
-          return {
-            messages: [
-              {
-                role: "user",
-                content: {
+      }
+    );
+    this.server.tool(
+      "marketDataRequest",
+      "Sends a request for Market Data with the given symbol. IMPORTANT: All parameters must be explicitly provided by the user - no assumptions will be made.",
+      {
+        mdUpdateType: z.enum(["0", "1"]).describe("Market data update type (0=FullRefresh, 1=IncrementalRefresh)"),
+        symbol: z.string().describe("Trading symbol"),
+        mdReqID: z.string().describe("Market data request ID"),
+        subscriptionRequestType: z.enum(["0", "1", "2"]).describe("Subscription request type (0=Snapshot + Updates, 1=Snapshot, 2=Unsubscribe)"),
+        mdEntryType: z.string().describe("Market data entry type (0=Bid, 1=Offer, 2=Trade, etc.)")
+      },
+      async (args) => {
+        try {
+          const response = new Promise((resolve) => {
+            this.pendingRequests.set(args.mdReqID, resolve);
+          });
+          const marketDataRequest = this.parser?.createMessage(
+            new Field(Fields.MsgType, Messages.MarketDataRequest),
+            new Field(Fields.SenderCompID, this.parser?.sender),
+            new Field(Fields.MsgSeqNum, this.parser?.getNextTargetMsgSeqNum()),
+            new Field(Fields.TargetCompID, this.parser?.target),
+            new Field(Fields.SendingTime, this.parser?.getTimestamp()),
+            new Field(Fields.MarketDepth, 0),
+            new Field(Fields.MDUpdateType, args.mdUpdateType),
+            new Field(Fields.NoRelatedSym, 1),
+            new Field(Fields.Symbol, args.symbol),
+            new Field(Fields.MDReqID, args.mdReqID),
+            new Field(Fields.SubscriptionRequestType, args.subscriptionRequestType),
+            new Field(Fields.NoMDEntryTypes, 1),
+            new Field(Fields.MDEntryType, args.mdEntryType)
+          );
+          if (!this.parser?.connected) {
+            return {
+              content: [
+                {
                   type: "text",
-                  text: [
-                    "You are an AI assistant that helps users verify FIX New Order Single parameters.",
-                    "This is STEP 1 of 2 - VERIFICATION ONLY. No order will be sent at this stage.",
-                    "",
-                    "You must verify that all required fields are provided and valid:",
-                    "- ClOrdID (Client Order ID)",
-                    "- HandlInst (1=Manual, 2=Automated, 3=AutomatedNoIntervention)",
-                    "- Quantity (Order quantity)",
-                    "- Price (Order price)",
-                    "- OrdType (1=Market, 2=Limit, 3=Stop)",
-                    "- 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 (Trading symbol)",
-                    "- TimeInForce (0=Day, 1=Good Till Cancel, 2=At Opening, 3=Immediate or Cancel, 4=Fill or Kill, 5=Good Till Crossing, 6=Good Till Date)",
-                    "",
-                    "Current parameters to verify:",
-                    `- ClOrdID: ${clOrdID}`,
-                    `- HandlInst: ${handlInst}`,
-                    `- Quantity: ${quantity}`,
-                    `- Price: ${price}`,
-                    `- OrdType: ${ordType}`,
-                    `- Side: ${side}`,
-                    `- Symbol: ${symbol}`,
-                    `- TimeInForce: ${timeInForce}`,
-                    "",
-                    "If all parameters are valid, respond with:",
-                    "`VERIFICATION: All parameters valid. Ready to proceed.`",
-                    "",
-                    "Otherwise, list the missing or invalid ones.",
-                    "",
-                    "IMPORTANT: This is only verification. To actually send the order, the user must call the executeOrder tool with the same parameters."
-                  ].join("\n")
+                  text: "Error: Not connected. Ignoring message."
                 }
-              }
-            ]
-          };
-        }
-        case "executeOrder": {
-          const { clOrdID, handlInst, quantity, price, ordType, side, symbol, timeInForce } = args || {};
+              ],
+              isError: true
+            };
+          }
+          this.parser?.send(marketDataRequest);
+          const fixData = await response;
           return {
-            messages: [
+            content: [
               {
-                role: "user",
-                content: {
-                  type: "text",
-                  text: [
-                    "You are an AI assistant that helps users execute FIX New Order Single messages.",
-                    "This is STEP 2 of 2 - EXECUTION. This will send the order to the market.",
-                    "",
-                    "IMPORTANT: This tool should only be called after successful verification of all parameters.",
-                    "",
-                    "Parameters to execute:",
-                    `- ClOrdID: ${clOrdID}`,
-                    `- HandlInst: ${handlInst}`,
-                    `- Quantity: ${quantity}`,
-                    `- Price: ${price}`,
-                    `- OrdType: ${ordType}`,
-                    `- Side: ${side}`,
-                    `- Symbol: ${symbol}`,
-                    `- TimeInForce: ${timeInForce}`,
-                    "",
-                    "IMPORTANT: The response will be either:",
-                    "1. An Execution Report (MsgType=8) if the order was successfully placed",
-                    "2. A Reject message (MsgType=3) if the order failed to execute (e.g., due to missing or invalid parameters)"
-                  ].join("\n")
-                }
+                type: "text",
+                text: `Market data for ${args.symbol}: ${JSON.stringify(fixData.toFIXJSON())}`
               }
             ]
           };
-        }
-        case "marketDataRequest": {
-          const { mdUpdateType, symbol, mdReqID, subscriptionRequestType, mdEntryType } = args || {};
+        } catch (error) {
           return {
-            messages: [
+            content: [
               {
-                role: "user",
-                content: {
-                  type: "text",
-                  text: [
-                    "You are an AI assistant that helps users create FIX Market Data Request messages.",
-                    "You must **first verify** that all required fields are provided:",
-                    "- MDUpdateType (0=FullRefresh, 1=IncrementalRefresh)",
-                    "- Symbol (Trading symbol)",
-                    "- MDReqID (Market data request ID)",
-                    "- SubscriptionRequestType (0=Snapshot + Updates, 1=Snapshot, 2=Unsubscribe)",
-                    "- MDEntryType (0=Bid, 1=Offer, 2=Trade, 3=Index Value, 4=Opening Price)",
-                    "",
-                    "Only when all fields are present and valid, respond with:",
-                    "`VERIFICATION: All parameters valid. Ready to proceed.`",
-                    "",
-                    "Otherwise, list the missing or invalid ones.",
-                    "",
-                    "Do not create the FIX message until verification is complete.",
-                    "",
-                    "Current parameters:",
-                    `- MDUpdateType: ${mdUpdateType}`,
-                    `- Symbol: ${symbol}`,
-                    `- MDReqID: ${mdReqID}`,
-                    `- SubscriptionRequestType: ${subscriptionRequestType}`,
-                    `- MDEntryType: ${mdEntryType}`
-                  ].join("\n")
-                }
+                type: "text",
+                text: `Error: ${error instanceof Error ? error.message : "Failed to request market data"}`
               }
-            ]
+            ],
+            isError: true
           };
         }
-        default:
-          throw new Error(`Unknown prompt: ${name}`);
       }
-    });
+    );
+    this.server.prompt(
+      "parse",
+      "Parses a FIX message and describes it in plain language",
+      {
+        fixString: z.string().describe("FIX message string to parse")
+      },
+      async (args) => {
+        return {
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text: `Please parse and explain this FIX message: ${args.fixString}`
+              }
+            }
+          ]
+        };
+      }
+    );
+    this.server.prompt(
+      "parseToJSON",
+      "Parses a FIX message into JSON",
+      {
+        fixString: z.string().describe("FIX message string to parse")
+      },
+      async (args) => {
+        return {
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text: `Please parse the FIX message to JSON: ${args.fixString}`
+              }
+            }
+          ]
+        };
+      }
+    );
+    this.server.prompt(
+      "verifyOrder",
+      "Verifies all parameters for a New Order Single. This is the first step - verification only, no order is sent.",
+      {
+        clOrdID: z.string().describe("Client Order ID"),
+        handlInst: z.enum(["1", "2", "3"]).describe("Handling instruction (1=Manual, 2=Automated, 3=AutomatedNoIntervention)"),
+        quantity: z.string().describe("Order quantity"),
+        price: z.string().describe("Order price"),
+        ordType: z.string().describe("Order type (1=Market, 2=Limit, 3=Stop)"),
+        side: z.string().describe("Order side (1=Buy, 2=Sell, etc.)"),
+        symbol: z.string().describe("Trading symbol"),
+        timeInForce: z.string().describe("Time in force (0=Day, 1=Good Till Cancel, etc.)")
+      },
+      async (args) => {
+        return {
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text: [
+                  "You are an AI assistant that helps users verify FIX New Order Single parameters.",
+                  "This is STEP 1 of 2 - VERIFICATION ONLY. No order will be sent at this stage.",
+                  "",
+                  "You must verify that all required fields are provided and valid:",
+                  "- ClOrdID (Client Order ID)",
+                  "- HandlInst (1=Manual, 2=Automated, 3=AutomatedNoIntervention)",
+                  "- Quantity (Order quantity)",
+                  "- Price (Order price)",
+                  "- OrdType (1=Market, 2=Limit, 3=Stop)",
+                  "- 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 (Trading symbol)",
+                  "- TimeInForce (0=Day, 1=Good Till Cancel, 2=At Opening, 3=Immediate or Cancel, 4=Fill or Kill, 5=Good Till Crossing, 6=Good Till Date)",
+                  "",
+                  "Current parameters to verify:",
+                  `- ClOrdID: ${args.clOrdID}`,
+                  `- HandlInst: ${args.handlInst}`,
+                  `- Quantity: ${args.quantity}`,
+                  `- Price: ${args.price}`,
+                  `- OrdType: ${args.ordType}`,
+                  `- Side: ${args.side}`,
+                  `- Symbol: ${args.symbol}`,
+                  `- TimeInForce: ${args.timeInForce}`,
+                  "",
+                  "If all parameters are valid, respond with:",
+                  "`VERIFICATION: All parameters valid. Ready to proceed.`",
+                  "",
+                  "Otherwise, list the missing or invalid ones.",
+                  "",
+                  "IMPORTANT: This is only verification. To actually send the order, the user must call the executeOrder tool with the same parameters."
+                ].join("\n")
+              }
+            }
+          ]
+        };
+      }
+    );
+    this.server.prompt(
+      "executeOrder",
+      "Executes a New Order Single after verification. This is the second step - only call after successful verification.",
+      {
+        clOrdID: z.string().describe("Client Order ID"),
+        handlInst: z.enum(["1", "2", "3"]).describe("Handling instruction (1=Manual, 2=Automated, 3=AutomatedNoIntervention)"),
+        quantity: z.string().describe("Order quantity"),
+        price: z.string().describe("Order price"),
+        ordType: z.string().describe("Order type (1=Market, 2=Limit, 3=Stop)"),
+        side: z.string().describe("Order side (1=Buy, 2=Sell, etc.)"),
+        symbol: z.string().describe("Trading symbol"),
+        timeInForce: z.string().describe("Time in force (0=Day, 1=Good Till Cancel, etc.)")
+      },
+      async (args) => {
+        return {
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text: [
+                  "You are an AI assistant that helps users execute FIX New Order Single messages.",
+                  "This is STEP 2 of 2 - EXECUTION. This will send the order to the market.",
+                  "",
+                  "IMPORTANT: This tool should only be called after successful verification of all parameters.",
+                  "",
+                  "Parameters to execute:",
+                  `- ClOrdID: ${args.clOrdID}`,
+                  `- HandlInst: ${args.handlInst}`,
+                  `- Quantity: ${args.quantity}`,
+                  `- Price: ${args.price}`,
+                  `- OrdType: ${args.ordType}`,
+                  `- Side: ${args.side}`,
+                  `- Symbol: ${args.symbol}`,
+                  `- TimeInForce: ${args.timeInForce}`,
+                  "",
+                  "IMPORTANT: The response will be either:",
+                  "1. An Execution Report (MsgType=8) if the order was successfully placed",
+                  "2. A Reject message (MsgType=3) if the order failed to execute (e.g., due to missing or invalid parameters)"
+                ].join("\n")
+              }
+            }
+          ]
+        };
+      }
+    );
+    this.server.prompt(
+      "marketDataRequest",
+      "Sends a request for Market Data with the given symbol. IMPORTANT: All parameters must be explicitly provided by the user - no assumptions will be made.",
+      {
+        mdUpdateType: z.enum(["0", "1"]).describe("Market data update type (0=FullRefresh, 1=IncrementalRefresh)"),
+        symbol: z.string().describe("Trading symbol"),
+        mdReqID: z.string().describe("Market data request ID"),
+        subscriptionRequestType: z.enum(["0", "1", "2"]).describe("Subscription request type (0=Snapshot + Updates, 1=Snapshot, 2=Unsubscribe)"),
+        mdEntryType: z.string().describe("Market data entry type (0=Bid, 1=Offer, 2=Trade, etc.)")
+      },
+      async (args) => {
+        return {
+          messages: [
+            {
+              role: "user",
+              content: {
+                type: "text",
+                text: [
+                  "You are an AI assistant that helps users create FIX Market Data Request messages.",
+                  "You must **first verify** that all required fields are provided:",
+                  "- MDUpdateType (0=FullRefresh, 1=IncrementalRefresh)",
+                  "- Symbol (Trading symbol)",
+                  "- MDReqID (Market data request ID)",
+                  "- SubscriptionRequestType (0=Snapshot + Updates, 1=Snapshot, 2=Unsubscribe)",
+                  "- MDEntryType (0=Bid, 1=Offer, 2=Trade, 3=Index Value, 4=Opening Price)",
+                  "",
+                  "Only when all fields are present and valid, respond with:",
+                  "`VERIFICATION: All parameters valid. Ready to proceed.`",
+                  "",
+                  "Otherwise, list the missing or invalid ones.",
+                  "",
+                  "Do not create the FIX message until verification is complete.",
+                  "",
+                  "Current parameters:",
+                  `- MDUpdateType: ${args.mdUpdateType}`,
+                  `- Symbol: ${args.symbol}`,
+                  `- MDReqID: ${args.mdReqID}`,
+                  `- SubscriptionRequestType: ${args.subscriptionRequestType}`,
+                  `- MDEntryType: ${args.mdEntryType}`
+                ].join("\n")
+              }
+            }
+          ]
+        };
+      }
+    );
+    this.server.resource(
+      "stockGraph",
+      new ResourceTemplate("stock://{symbol}", { list: void 0 }),
+      async (uri, variables) => {
+        const symbol = variables.symbol;
+        const data = [
+          { time: "09:30", price: 150 },
+          { time: "10:30", price: 152.5 },
+          { time: "11:30", price: 151.75 },
+          { time: "12:30", price: 153.25 },
+          { time: "13:30", price: 154 },
+          { time: "14:30", price: 153.5 },
+          { time: "15:30", price: 155 },
+          { time: "16:00", price: 154.75 }
+        ];
+        const width = 600;
+        const height = 300;
+        const padding = 40;
+        const xScale = (width - 2 * padding) / (data.length - 1);
+        const yMin = Math.min(...data.map((d) => d.price));
+        const yMax = Math.max(...data.map((d) => d.price));
+        const yScale = (height - 2 * padding) / (yMax - yMin);
+        const points = data.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 -->
+    ${data.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">
+        ${data.map((d, i) => {
+          const x = padding + i * xScale;
+          return `<text x="${x}" y="${height - padding + 20}" text-anchor="middle">${d.time}</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} - 1 Day Price Chart
+    </text>
+</svg>`;
+        return {
+          contents: [
+            {
+              uri: uri.href,
+              text: svg
+            }
+          ]
+        };
+      }
+    );
     process.on("SIGINT", async () => {
       await this.server.close();
       process.exit(0);