fixparser-plugin-mcp 9.1.7-b2f9f891 → 9.1.7-b6430f19

package/build/esm/MCPLocal.mjs

@@ -1,935 +0,0 @@
-// src/MCPLocal.ts
-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 Server(
-    {
-      name: "fixparser",
-      version: "1.0.0"
-    },
-    {
-      capabilities: {
-        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",
-            parameters: {
-              type: "object",
-              properties: {
-                symbol: { type: "string" }
-              },
-              required: ["symbol"]
-            }
-          },
-          stockPriceHistory: {
-            description: "Returns price history for a given symbol",
-            uri: "stockPriceHistory",
-            parameters: {
-              type: "object",
-              properties: {
-                symbol: { type: "string" }
-              },
-              required: ["symbol"]
-            }
-          }
-        }
-      }
-    }
-  );
-  transport = new StdioServerTransport();
-  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 || 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}`
-            });
-          }
-        }
-        if (msgType === Messages.MarketDataSnapshotFullRefresh) {
-          const mdReqID = message.getField(Fields.MDReqID);
-          if (mdReqID) id = String(mdReqID.value);
-        } else if (msgType === Messages.ExecutionReport) {
-          const clOrdID = message.getField(Fields.ClOrdID);
-          if (clOrdID) id = String(clOrdID.value);
-        } else if (msgType === Messages.Reject) {
-          const refSeqNum = message.getField(Fields.RefSeqNum);
-          if (refSeqNum) id = String(refSeqNum.value);
-        }
-        if (id) {
-          const callback = this.pendingRequests.get(id);
-          if (callback) {
-            callback(message);
-            this.pendingRequests.delete(id);
-          }
-        }
-      }
-    });
-    this.addWorkflows();
-    await this.server.connect(this.transport);
-    if (this.onReady) {
-      this.onReady();
-    }
-  }
-  addWorkflows() {
-    if (!this.parser) {
-      return;
-    }
-    if (!this.server) {
-      return;
-    }
-    this.server.setRequestHandler(
-      z.object({ method: z.literal("resources/list") }),
-      async (request, extra) => {
-        return {
-          resources: [
-            {
-              name: "greeting",
-              description: "A simple greeting resource",
-              uri: "greeting-resource"
-            },
-            {
-              name: "stockGraph",
-              description: "Generates a price chart for a given symbol",
-              uri: "stockGraph",
-              parameters: {
-                type: "object",
-                properties: {
-                  symbol: { type: "string" }
-                },
-                required: ["symbol"]
-              }
-            },
-            {
-              name: "stockPriceHistory",
-              description: "Returns price history for a given symbol",
-              uri: "stockPriceHistory",
-              parameters: {
-                type: "object",
-                properties: {
-                  symbol: { type: "string" }
-                },
-                required: ["symbol"]
-              }
-            }
-          ]
-        };
-      }
-    );
-    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",
-              parameters: {
-                type: "object",
-                properties: {
-                  fixString: { type: "string" }
-                },
-                required: ["fixString"]
-              }
-            },
-            {
-              name: "parseToJSON",
-              description: "Parses a FIX message into JSON",
-              parameters: {
-                type: "object",
-                properties: {
-                  fixString: { type: "string" }
-                },
-                required: ["fixString"]
-              }
-            },
-            {
-              name: "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"
-                ]
-              }
-            },
-            {
-              name: "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"
-                ]
-              }
-            },
-            {
-              name: "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"
-                ]
-              }
-            }
-          ]
-        };
-      }
-    );
-    this.server.setRequestHandler(z.object({ method: z.literal("parse") }), async (request, extra) => {
-      try {
-        const args = request.params;
-        const parsedMessage = this.parser?.parse(args.fixString);
-        if (!parsedMessage || parsedMessage.length === 0) {
-          return {
-            content: [{ type: "text", text: "Error: Failed to parse FIX string" }],
-            isError: true
-          };
-        }
-        return {
-          content: [
-            {
-              type: "text",
-              text: `${parsedMessage[0].description}
-${parsedMessage[0].messageTypeDescription}`
-            }
-          ]
-        };
-      } catch (error) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error: ${error instanceof Error ? error.message : "Failed to parse FIX string"}`
-            }
-          ],
-          isError: true
-        };
-      }
-    });
-    this.server.setRequestHandler(
-      z.object({ method: z.literal("parseToJSON") }),
-      async (request, extra) => {
-        try {
-          const args = request.params;
-          const parsedMessage = this.parser?.parse(args.fixString);
-          if (!parsedMessage || parsedMessage.length === 0) {
-            return {
-              content: [{ type: "text", text: "Error: Failed to parse FIX string" }],
-              isError: true
-            };
-          }
-          return {
-            content: [
-              {
-                type: "text",
-                text: `${parsedMessage[0].toFIXJSON()}`
-              }
-            ]
-          };
-        } catch (error) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: ${error instanceof Error ? error.message : "Failed to parse FIX string"}`
-              }
-            ],
-            isError: true
-          };
-        }
-      }
-    );
-    this.server.setRequestHandler(
-      z.object({ method: z.literal("verifyOrder") }),
-      async (request, extra) => {
-        try {
-          const args = request.params;
-          this.verifiedOrders.set(args.clOrdID, {
-            clOrdID: args.clOrdID,
-            handlInst: args.handlInst,
-            quantity: Number.parseFloat(args.quantity),
-            price: Number.parseFloat(args.price),
-            ordType: args.ordType,
-            side: args.side,
-            symbol: args.symbol,
-            timeInForce: args.timeInForce
-          });
-          const ordTypeNames = {
-            "1": "Market",
-            "2": "Limit",
-            "3": "Stop",
-            "4": "StopLimit",
-            "5": "MarketOnClose",
-            "6": "WithOrWithout",
-            "7": "LimitOrBetter",
-            "8": "LimitWithOrWithout",
-            "9": "OnBasis",
-            A: "OnClose",
-            B: "LimitOnClose",
-            C: "ForexMarket",
-            D: "PreviouslyQuoted",
-            E: "PreviouslyIndicated",
-            F: "ForexLimit",
-            G: "ForexSwap",
-            H: "ForexPreviouslyQuoted",
-            I: "Funari",
-            J: "MarketIfTouched",
-            K: "MarketWithLeftOverAsLimit",
-            L: "PreviousFundValuationPoint",
-            M: "NextFundValuationPoint",
-            P: "Pegged",
-            Q: "CounterOrderSelection",
-            R: "StopOnBidOrOffer",
-            S: "StopLimitOnBidOrOffer"
-          };
-          const sideNames = {
-            "1": "Buy",
-            "2": "Sell",
-            "3": "BuyMinus",
-            "4": "SellPlus",
-            "5": "SellShort",
-            "6": "SellShortExempt",
-            "7": "Undisclosed",
-            "8": "Cross",
-            "9": "CrossShort",
-            A: "CrossShortExempt",
-            B: "AsDefined",
-            C: "Opposite",
-            D: "Subscribe",
-            E: "Redeem",
-            F: "Lend",
-            G: "Borrow",
-            H: "SellUndisclosed"
-          };
-          const timeInForceNames = {
-            "0": "Day",
-            "1": "GoodTillCancel",
-            "2": "AtTheOpening",
-            "3": "ImmediateOrCancel",
-            "4": "FillOrKill",
-            "5": "GoodTillCrossing",
-            "6": "GoodTillDate",
-            "7": "AtTheClose",
-            "8": "GoodThroughCrossing",
-            "9": "AtCrossing",
-            A: "GoodForTime",
-            B: "GoodForAuction",
-            C: "GoodForMonth"
-          };
-          const handlInstNames = {
-            "1": "AutomatedExecutionNoIntervention",
-            "2": "AutomatedExecutionInterventionOK",
-            "3": "ManualOrder"
-          };
-          return {
-            content: [
-              {
-                type: "text",
-                text: `VERIFICATION: All parameters valid. Ready to proceed with order execution.
-                                    
-Parameters verified:
-- ClOrdID: ${args.clOrdID}
-- HandlInst: ${args.handlInst} (${handlInstNames[args.handlInst]})
-- Quantity: ${args.quantity}
-- Price: ${args.price}
-- OrdType: ${args.ordType} (${ordTypeNames[args.ordType]})
-- Side: ${args.side} (${sideNames[args.side]})
-- Symbol: ${args.symbol}
-- TimeInForce: ${args.timeInForce} (${timeInForceNames[args.timeInForce]})
-
-To execute this order, call the executeOrder tool with these exact same parameters.`
-              }
-            ]
-          };
-        } catch (error) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: ${error instanceof Error ? error.message : "Failed to verify order parameters"}`
-              }
-            ],
-            isError: true
-          };
-        }
-      }
-    );
-    this.server.setRequestHandler(
-      z.object({ method: z.literal("executeOrder") }),
-      async (request, extra) => {
-        try {
-          const args = request.params;
-          const verifiedOrder = this.verifiedOrders.get(args.clOrdID);
-          if (!verifiedOrder) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: `Error: Order ${args.clOrdID} has not been verified. Please call verifyOrder first.`
-                }
-              ],
-              isError: true
-            };
-          }
-          if (verifiedOrder.handlInst !== args.handlInst || verifiedOrder.quantity !== Number.parseFloat(args.quantity) || verifiedOrder.price !== Number.parseFloat(args.price) || verifiedOrder.ordType !== args.ordType || verifiedOrder.side !== args.side || verifiedOrder.symbol !== args.symbol || verifiedOrder.timeInForce !== args.timeInForce) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: "Error: Order parameters do not match the verified order. Please use the exact same parameters that were verified."
-                }
-              ],
-              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) {
-            return {
-              content: [
-                {
-                  type: "text",
-                  text: "Error: Not connected. Ignoring message."
-                }
-              ],
-              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.setRequestHandler(
-      z.object({ method: z.literal("marketDataRequest") }),
-      async (request, extra) => {
-        try {
-          const args = request.params;
-          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 {
-              content: [
-                {
-                  type: "text",
-                  text: "Error: Not connected. Ignoring message."
-                }
-              ],
-              isError: true
-            };
-          }
-          this.parser?.send(mdr);
-          const fixData = await response;
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Market data for ${args.symbols.join(", ")}: ${JSON.stringify(fixData.toFIXJSON())}`
-              }
-            ]
-          };
-        } catch (error) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Error: ${error instanceof Error ? error.message : "Failed to request market data"}`
-              }
-            ],
-            isError: true
-          };
-        }
-      }
-    );
-    this.server.setRequestHandler(
-      z.object({ method: z.literal("greeting-resource") }),
-      async (request, extra) => {
-        this.parser?.logger.log({
-          level: "info",
-          message: "MCP Server Resource called: greeting-resource"
-        });
-        return {
-          content: [
-            {
-              type: "text",
-              text: "Hello, world!"
-            }
-          ]
-        };
-      }
-    );
-    this.server.setRequestHandler(
-      z.object({ method: z.literal("stockGraph") }),
-      async (request, extra) => {
-        this.parser?.logger.log({
-          level: "info",
-          message: "MCP Server Resource called: stockGraph"
-        });
-        const args = request.params;
-        const symbol = args.symbol;
-        const priceHistory = this.marketDataPrices.get(symbol) || [];
-        if (priceHistory.length === 0) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `No price data available for ${symbol}`
-              }
-            ]
-          };
-        }
-        const width = 600;
-        const height = 300;
-        const padding = 40;
-        const xScale = (width - 2 * padding) / (priceHistory.length - 1);
-        const yMin = Math.min(...priceHistory.map((d) => d.price));
-        const yMax = Math.max(...priceHistory.map((d) => d.price));
-        const yScale = (height - 2 * padding) / (yMax - yMin);
-        const points = priceHistory.map((d, i) => {
-          const x = padding + i * xScale;
-          const y = height - padding - (d.price - yMin) * yScale;
-          return `${x},${y}`;
-        }).join(" L ");
-        const svg = `<?xml version="1.0" encoding="UTF-8"?>
-<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg">
-    <!-- Background -->
-    <rect width="100%" height="100%" fill="#f8f9fa"/>
-    
-    <!-- Grid lines -->
-    <g stroke="#e9ecef" stroke-width="1">
-        ${Array.from({ length: 5 }, (_, i) => {
-          const y = padding + (height - 2 * padding) * i / 4;
-          return `<line x1="${padding}" y1="${y}" x2="${width - padding}" y2="${y}"/>`;
-        }).join("\n")}
-    </g>
-    
-    <!-- Price line -->
-    <path d="M ${points}" 
-          fill="none" 
-          stroke="#007bff" 
-          stroke-width="2"/>
-    
-    <!-- Data points -->
-    ${priceHistory.map((d, i) => {
-          const x = padding + i * xScale;
-          const y = height - padding - (d.price - yMin) * yScale;
-          return `<circle cx="${x}" cy="${y}" r="3" fill="#007bff"/>`;
-        }).join("\n")}
-    
-    <!-- Labels -->
-    <g font-family="Arial" font-size="12" fill="#495057">
-        ${Array.from({ length: 5 }, (_, i) => {
-          const x = padding + (width - 2 * padding) * i / 4;
-          const index = Math.floor((priceHistory.length - 1) * i / 4);
-          const timestamp = new Date(priceHistory[index].timestamp).toLocaleTimeString();
-          return `<text x="${x + padding}" y="${height - padding + 20}" text-anchor="middle">${timestamp}</text>`;
-        }).join("\n")}
-        ${Array.from({ length: 5 }, (_, i) => {
-          const y = padding + (height - 2 * padding) * i / 4;
-          const price = yMax - (yMax - yMin) * i / 4;
-          return `<text x="${padding - 5}" y="${y + 4}" text-anchor="end">$${price.toFixed(2)}</text>`;
-        }).join("\n")}
-    </g>
-    
-    <!-- Title -->
-    <text x="${width / 2}" y="${padding / 2}" 
-          font-family="Arial" font-size="16" font-weight="bold" 
-          text-anchor="middle" fill="#212529">
-        ${symbol} - Price Chart (${priceHistory.length} points)
-    </text>
-</svg>`;
-        return {
-          content: [
-            {
-              type: "text",
-              text: svg
-            }
-          ]
-        };
-      }
-    );
-    this.server.setRequestHandler(
-      z.object({ method: z.literal("stockPriceHistory") }),
-      async (request, extra) => {
-        this.parser?.logger.log({
-          level: "info",
-          message: "MCP Server Resource called: stockPriceHistory"
-        });
-        const args = request.params;
-        const symbol = args.symbol;
-        const priceHistory = this.marketDataPrices.get(symbol) || [];
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(
-                {
-                  symbol,
-                  count: priceHistory.length,
-                  prices: priceHistory.map((point) => ({
-                    timestamp: new Date(point.timestamp).toISOString(),
-                    price: point.price
-                  }))
-                },
-                null,
-                2
-              )
-            }
-          ]
-        };
-      }
-    );
-    process.on("SIGINT", async () => {
-      await this.server.close();
-      process.exit(0);
-    });
-  }
-};
-export {
-  MCPLocal
-};
-//# sourceMappingURL=MCPLocal.mjs.map