fixparser-plugin-mcp 9.1.7-a0e655a2 → 9.1.7-a9d84740

package/build/esm/MCPLocal.mjs

@@ -1,20 +1,173 @@
 // src/MCPLocal.ts
-import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { Field, Fields, Messages } from "fixparser";
 import { z } from "zod";
 var MCPLocal = class {
   parser;
-  server = new McpServer(
+  server = new Server(
     {
       name: "fixparser",
       version: "1.0.0"
     },
     {
       capabilities: {
-        tools: {},
-        prompts: {},
-        resources: {}
+        tools: {
+          parse: {
+            description: "Parses a FIX message and describes it in plain language",
+            parameters: {
+              type: "object",
+              properties: {
+                fixString: { type: "string" }
+              },
+              required: ["fixString"]
+            }
+          },
+          parseToJSON: {
+            description: "Parses a FIX message into JSON",
+            parameters: {
+              type: "object",
+              properties: {
+                fixString: { type: "string" }
+              },
+              required: ["fixString"]
+            }
+          },
+          verifyOrder: {
+            description: "Verifies order parameters before execution",
+            parameters: {
+              type: "object",
+              properties: {
+                clOrdID: { type: "string" },
+                handlInst: { type: "string", enum: ["1", "2", "3"] },
+                quantity: { type: "string" },
+                price: { type: "string" },
+                ordType: {
+                  type: "string",
+                  enum: [
+                    "1",
+                    "2",
+                    "3",
+                    "4",
+                    "5",
+                    "6",
+                    "7",
+                    "8",
+                    "9",
+                    "A",
+                    "B",
+                    "C",
+                    "D",
+                    "E",
+                    "F",
+                    "G",
+                    "H",
+                    "I",
+                    "J",
+                    "K",
+                    "L",
+                    "M",
+                    "P",
+                    "Q",
+                    "R",
+                    "S"
+                  ]
+                },
+                side: {
+                  type: "string",
+                  enum: [
+                    "1",
+                    "2",
+                    "3",
+                    "4",
+                    "5",
+                    "6",
+                    "7",
+                    "8",
+                    "9",
+                    "A",
+                    "B",
+                    "C",
+                    "D",
+                    "E",
+                    "F",
+                    "G",
+                    "H"
+                  ]
+                },
+                symbol: { type: "string" },
+                timeInForce: {
+                  type: "string",
+                  enum: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C"]
+                }
+              },
+              required: [
+                "clOrdID",
+                "handlInst",
+                "quantity",
+                "price",
+                "ordType",
+                "side",
+                "symbol",
+                "timeInForce"
+              ]
+            }
+          },
+          executeOrder: {
+            description: "Executes a verified order",
+            parameters: {
+              type: "object",
+              properties: {
+                clOrdID: { type: "string" },
+                handlInst: { type: "string", enum: ["1", "2", "3"] },
+                quantity: { type: "string" },
+                price: { type: "string" },
+                ordType: { type: "string" },
+                side: { type: "string" },
+                symbol: { type: "string" },
+                timeInForce: { type: "string" }
+              },
+              required: [
+                "clOrdID",
+                "handlInst",
+                "quantity",
+                "price",
+                "ordType",
+                "side",
+                "symbol",
+                "timeInForce"
+              ]
+            }
+          },
+          marketDataRequest: {
+            description: "Requests market data for specified symbols",
+            parameters: {
+              type: "object",
+              properties: {
+                mdUpdateType: { type: "string", enum: ["0", "1"] },
+                symbols: { type: "array", items: { type: "string" } },
+                mdReqID: { type: "string" },
+                subscriptionRequestType: { type: "string", enum: ["0", "1", "2"] },
+                mdEntryTypes: { type: "array", items: { type: "string" } }
+              },
+              required: ["mdUpdateType", "symbols", "mdReqID", "subscriptionRequestType", "mdEntryTypes"]
+            }
+          }
+        },
+        resources: {
+          greeting: {
+            description: "A simple greeting resource",
+            uri: "greeting-resource"
+          },
+          stockGraph: {
+            description: "Generates a price chart for a given symbol",
+            uri: "stockGraph/{symbol}"
+          },
+          stockPriceHistory: {
+            description: "Returns price history for a given symbol",
+            uri: "stockPriceHistory/{symbol}"
+          }
+        }
       }
     }
   );
@@ -22,15 +175,57 @@ var MCPLocal = class {
   onReady = void 0;
   pendingRequests = /* @__PURE__ */ new Map();
   verifiedOrders = /* @__PURE__ */ new Map();
+  // Store market data prices with timestamps
+  marketDataPrices = /* @__PURE__ */ new Map();
+  MAX_PRICE_HISTORY = 1e5;
+  // Maximum number of price points to store per symbol
   constructor({ logger, onReady }) {
     if (onReady) this.onReady = onReady;
   }
   async register(parser) {
     this.parser = parser;
     this.parser.addOnMessageCallback((message) => {
+      this.parser?.logger.log({
+        level: "info",
+        message: `MCP Server received message: ${message.messageType}: ${message.description}`
+      });
       const msgType = message.messageType;
-      if (msgType === Messages.MarketDataSnapshotFullRefresh || msgType === Messages.ExecutionReport || msgType === Messages.Reject) {
+      if (msgType === Messages.MarketDataSnapshotFullRefresh || msgType === Messages.ExecutionReport || msgType === Messages.Reject || msgType === Messages.MarketDataIncrementalRefresh) {
+        this.parser?.logger.log({
+          level: "info",
+          message: `MCP Server handling message type: ${msgType}`
+        });
         let id;
+        if (msgType === Messages.MarketDataIncrementalRefresh || msgType === Messages.MarketDataSnapshotFullRefresh) {
+          const symbol = message.getField(Fields.Symbol);
+          const price = message.getField(Fields.MDEntryPx);
+          const timestamp = message.getField(Fields.MDEntryTime)?.value || Date.now();
+          if (symbol?.value && price?.value) {
+            const symbolStr = String(symbol.value);
+            const priceNum = Number(price.value);
+            const priceHistory = this.marketDataPrices.get(symbolStr) || [];
+            priceHistory.push({
+              timestamp: Number(timestamp),
+              price: priceNum
+            });
+            if (priceHistory.length > this.MAX_PRICE_HISTORY) {
+              priceHistory.shift();
+            }
+            this.marketDataPrices.set(symbolStr, priceHistory);
+            this.parser?.logger.log({
+              level: "info",
+              message: `MCP Server added ${symbol}: ${priceNum}`
+            });
+            this.server.notification({
+              method: "priceUpdate",
+              params: {
+                symbol: symbolStr,
+                price: priceNum,
+                timestamp: Number(timestamp)
+              }
+            });
+          }
+        }
         if (msgType === Messages.MarketDataSnapshotFullRefresh) {
           const mdReqID = message.getField(Fields.MDReqID);
           if (mdReqID) id = String(mdReqID.value);
@@ -63,549 +258,636 @@ var MCPLocal = class {
     if (!this.server) {
       return;
     }
-    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: "Error: Failed to parse FIX string" }],
-              isError: true
-            };
-          }
-          return {
-            content: [
-              {
-                type: "text",
-                text: `${parsedMessage[0].description}
-${parsedMessage[0].messageTypeDescription}`
+    this.server.setRequestHandler(
+      z.object({ method: z.literal("resources/list") }),
+      async (request, extra) => {
+        return {
+          resources: [
+            {
+              name: "greeting",
+              description: "A simple greeting resource",
+              uri: "greeting-resource"
+            }
+          ]
+        };
+      }
+    );
+    this.server.setRequestHandler(
+      z.object({ method: z.literal("resources/templates/list") }),
+      async (request, extra) => {
+        return {
+          resourceTemplates: [
+            {
+              name: "stockGraph",
+              description: "Generates a price chart for a given symbol",
+              uriTemplate: "stockGraph/{symbol}",
+              parameters: {
+                type: "object",
+                properties: {
+                  symbol: { type: "string" }
+                },
+                required: ["symbol"]
               }
-            ]
-          };
-        } catch (error) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: ${error instanceof Error ? error.message : "Failed to parse FIX string"}`
+            },
+            {
+              name: "stockPriceHistory",
+              description: "Returns price history for a given symbol",
+              uriTemplate: "stockPriceHistory/{symbol}",
+              parameters: {
+                type: "object",
+                properties: {
+                  symbol: { type: "string" }
+                },
+                required: ["symbol"]
               }
-            ],
-            isError: true
-          };
-        }
+            }
+          ]
+        };
       }
     );
-    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: "Error: Failed to parse FIX string" }],
-              isError: true
-            };
-          }
-          return {
-            content: [
-              {
-                type: "text",
-                text: `${parsedMessage[0].toFIXJSON()}`
+    this.server.setRequestHandler(
+      z.object({ method: z.literal("tools/list") }),
+      async (request, extra) => {
+        return {
+          tools: [
+            {
+              name: "parse",
+              description: "Parses a FIX message and describes it in plain language",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  fixString: { type: "string" }
+                },
+                required: ["fixString"]
               }
-            ]
-          };
-        } catch (error) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: ${error instanceof Error ? error.message : "Failed to parse FIX string"}`
+            },
+            {
+              name: "parseToJSON",
+              description: "Parses a FIX message into JSON",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  fixString: { type: "string" }
+                },
+                required: ["fixString"]
               }
-            ],
-            isError: true
-          };
-        }
+            },
+            {
+              name: "verifyOrder",
+              description: "Verifies order parameters before execution",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  clOrdID: { type: "string" },
+                  handlInst: { type: "string", enum: ["1", "2", "3"] },
+                  quantity: { type: "string" },
+                  price: { type: "string" },
+                  ordType: {
+                    type: "string",
+                    enum: [
+                      "1",
+                      "2",
+                      "3",
+                      "4",
+                      "5",
+                      "6",
+                      "7",
+                      "8",
+                      "9",
+                      "A",
+                      "B",
+                      "C",
+                      "D",
+                      "E",
+                      "F",
+                      "G",
+                      "H",
+                      "I",
+                      "J",
+                      "K",
+                      "L",
+                      "M",
+                      "P",
+                      "Q",
+                      "R",
+                      "S"
+                    ]
+                  },
+                  side: {
+                    type: "string",
+                    enum: [
+                      "1",
+                      "2",
+                      "3",
+                      "4",
+                      "5",
+                      "6",
+                      "7",
+                      "8",
+                      "9",
+                      "A",
+                      "B",
+                      "C",
+                      "D",
+                      "E",
+                      "F",
+                      "G",
+                      "H"
+                    ]
+                  },
+                  symbol: { type: "string" },
+                  timeInForce: {
+                    type: "string",
+                    enum: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C"]
+                  }
+                },
+                required: [
+                  "clOrdID",
+                  "handlInst",
+                  "quantity",
+                  "price",
+                  "ordType",
+                  "side",
+                  "symbol",
+                  "timeInForce"
+                ]
+              }
+            },
+            {
+              name: "executeOrder",
+              description: "Executes a verified order",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  clOrdID: { type: "string" },
+                  handlInst: { type: "string", enum: ["1", "2", "3"] },
+                  quantity: { type: "string" },
+                  price: { type: "string" },
+                  ordType: { type: "string" },
+                  side: { type: "string" },
+                  symbol: { type: "string" },
+                  timeInForce: { type: "string" }
+                },
+                required: [
+                  "clOrdID",
+                  "handlInst",
+                  "quantity",
+                  "price",
+                  "ordType",
+                  "side",
+                  "symbol",
+                  "timeInForce"
+                ]
+              }
+            },
+            {
+              name: "marketDataRequest",
+              description: "Requests market data for specified symbols",
+              inputSchema: {
+                type: "object",
+                properties: {
+                  mdUpdateType: { type: "string", enum: ["0", "1"] },
+                  symbols: { type: "array", items: { type: "string" } },
+                  mdReqID: { type: "string" },
+                  subscriptionRequestType: { type: "string", enum: ["0", "1", "2"] },
+                  mdEntryTypes: { type: "array", items: { type: "string" } }
+                },
+                required: [
+                  "mdUpdateType",
+                  "symbols",
+                  "mdReqID",
+                  "subscriptionRequestType",
+                  "mdEntryTypes"
+                ]
+              }
+            }
+          ]
+        };
       }
     );
-    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.
-                                    
+    this.server.setRequestHandler(
+      z.object({
+        method: z.literal("tools/call"),
+        params: z.object({
+          name: z.string(),
+          arguments: z.any(),
+          _meta: z.object({
+            progressToken: z.number()
+          })
+        })
+      }),
+      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
+                };
+              }
+              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
+                };
+              }
+              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.
+                                            
 Parameters verified:
 - ClOrdID: ${args.clOrdID}
-- HandlInst: ${args.handlInst}
+- HandlInst: ${args.handlInst} (${handlInstNames[args.handlInst]})
 - Quantity: ${args.quantity}
 - Price: ${args.price}
-- OrdType: ${args.ordType}
-- Side: ${args.side}
+- OrdType: ${args.ordType} (${ordTypeNames[args.ordType]})
+- Side: ${args.side} (${sideNames[args.side]})
 - Symbol: ${args.symbol}
-- TimeInForce: ${args.timeInForce}
+- TimeInForce: ${args.timeInForce} (${timeInForceNames[args.timeInForce]})
 
-To execute this order, call the executeOrder tool with these exact same parameters.`
+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
+                };
               }
-            ]
-          };
-        } catch (error) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: ${error instanceof Error ? error.message : "Failed to verify order parameters"}`
+              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
+                };
               }
-            ],
-            isError: true
-          };
-        }
-      }
-    );
-    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) {
+              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 {
+                  contents: [
+                    {
+                      type: "text",
+                      text: "Error: Not connected. Ignoring message.",
+                      uri: "executeOrder"
+                    }
+                  ],
+                  isError: true
+                };
+              }
+              this.parser?.send(order);
+              const fixData = await response;
+              this.verifiedOrders.delete(args.clOrdID);
+              return {
+                contents: [
+                  {
+                    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())}`,
+                    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 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.MDReqID, args.mdReqID),
+                new Field(Fields.SubscriptionRequestType, args.subscriptionRequestType),
+                new Field(Fields.MarketDepth, 0),
+                new Field(Fields.MDUpdateType, args.mdUpdateType)
+              ];
+              messageFields.push(new Field(Fields.NoRelatedSym, args.symbols.length));
+              args.symbols.forEach((symbol) => {
+                messageFields.push(new Field(Fields.Symbol, symbol));
+              });
+              messageFields.push(new Field(Fields.NoMDEntryTypes, args.mdEntryTypes.length));
+              args.mdEntryTypes.forEach((entryType) => {
+                messageFields.push(new Field(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
+                };
+              }
+              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 {
-              content: [
+              contents: [
                 {
                   type: "text",
-                  text: `Error: Order ${args.clOrdID} has not been verified. Please call verifyOrder first.`
+                  text: `Tool not found: ${name}`,
+                  uri: name
                 }
               ],
               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) {
+        }
+      }
+    );
+    this.server.setRequestHandler(
+      z.object({
+        method: z.literal("resources/read"),
+        params: z.object({
+          uri: z.string()
+        })
+      }),
+      async (request, extra) => {
+        const { uri } = request.params;
+        switch (uri) {
+          case "greeting-resource":
             return {
-              content: [
+              contents: [
                 {
                   type: "text",
-                  text: "Error: Order parameters do not match the verified order. Please use the exact same parameters that were verified."
+                  text: "Hello, world!",
+                  uri: "greeting-resource"
                 }
-              ],
-              isError: true
+              ]
             };
-          }
-          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) {
+          case "stockGraph":
             return {
-              content: [
+              contents: [
                 {
                   type: "text",
-                  text: "Error: Not connected. Ignoring message."
+                  text: "This resource requires a symbol parameter. Please use the stockGraph/{symbol} resource.",
+                  uri: "stockGraph"
                 }
-              ],
-              isError: true
+              ]
             };
-          }
-          this.parser?.send(order);
-          const fixData = await response;
-          this.verifiedOrders.delete(args.clOrdID);
-          return {
-            content: [
-              {
-                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())}`
-              }
-            ]
-          };
-        } catch (error) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: ${error instanceof Error ? error.message : "Failed to execute order"}`
-              }
-            ],
-            isError: true
-          };
-        }
-      }
-    );
-    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) {
+          case "stockPriceHistory":
             return {
-              content: [
+              contents: [
                 {
                   type: "text",
-                  text: "Error: Not connected. Ignoring message."
+                  text: "This resource requires a symbol parameter. Please use the stockPriceHistory/{symbol} resource.",
+                  uri: "stockPriceHistory"
                 }
-              ],
-              isError: true
+              ]
             };
-          }
-          this.parser?.send(marketDataRequest);
-          const fixData = await response;
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Market data for ${args.symbol}: ${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.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")
+          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.server.resource(
-      "greeting-resource",
-      "https://example.com/greetings/default",
-      { mimeType: "text/plain" },
-      async () => {
-        return {
-          contents: [
-            {
-              uri: "https://example.com/greetings/default",
-              text: "Hello, world!"
-            }
-          ]
-        };
-      }
-    );
-    this.server.resource(
-      "greeting",
-      new ResourceTemplate("greeting://{name}", { list: void 0 }),
-      async (uri, { name }) => ({
-        contents: [
-          {
-            uri: uri.href,
-            text: `Hello, ${name}!`
-          }
-        ]
-      })
-    );
-    this.server.resource(
-      "echo",
-      new ResourceTemplate("echo://{message}", { list: void 0 }),
-      async (uri, { message }) => ({
-        contents: [
-          {
-            uri: uri.href,
-            text: `Resource echo: ${message}`
-          }
-        ]
-      })
-    );
-    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"?>
+              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"/>
@@ -613,9 +895,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 -->
@@ -625,40 +907,90 @@ To execute this order, call the executeOrder tool with these exact same paramete
           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")}
+    ${priceHistory.map((d, i) => {
+                const x = padding + i * xScale;
+                const y = height - padding - (d.price - yMin) * yScale;
+                return `<circle cx="${x}" cy="${y}" r="3" fill="#007bff"/>`;
+              }).join("\n")}
     
     <!-- Labels -->
     <g font-family="Arial" font-size="12" fill="#495057">
-        ${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")}
+                const x = padding + (width - 2 * padding) * i / 4;
+                const index = Math.floor((priceHistory.length - 1) * i / 4);
+                const timestamp = new Date(priceHistory[index].timestamp).toLocaleTimeString();
+                return `<text x="${x + padding}" y="${height - padding + 20}" text-anchor="middle">${timestamp}</text>`;
+              }).join("\n")}
+        ${Array.from({ length: 5 }, (_, i) => {
+                const y = padding + (height - 2 * padding) * i / 4;
+                const price = yMax - (yMax - yMin) * i / 4;
+                return `<text x="${padding - 5}" y="${y + 4}" text-anchor="end">$${price.toFixed(2)}</text>`;
+              }).join("\n")}
     </g>
     
     <!-- Title -->
     <text x="${width / 2}" y="${padding / 2}" 
           font-family="Arial" font-size="16" font-weight="bold" 
           text-anchor="middle" fill="#212529">
-        ${symbol} - 1 Day Price Chart
+        ${symbol} - Price Chart (${priceHistory.length} points)
     </text>
 </svg>`;
-        return {
-          contents: [
-            {
-              uri: uri.href,
-              text: svg
+              return {
+                contents: [
+                  {
+                    type: "text",
+                    text: svg,
+                    uri
+                  }
+                ]
+              };
             }
-          ]
-        };
+            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
+                    }
+                  ]
+                };
+              }
+              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
+            };
+        }
       }
     );
     process.on("SIGINT", async () => {