fixparser-plugin-mcp 9.1.7-63c797c5 → 9.1.7-67ba45e9

package/build/cjs/index.js

@@ -166,7 +166,7 @@ var toolSchemas = {
     }
   },
   executeOrder: {
-    description: "Executes a verified order. verifyOrder must be called before executeOrder. user has to explicitly allow executeOrder.",
+    description: "Executes a verified order. verifyOrder must be called before executeOrder.",
     schema: {
       type: "object",
       properties: {
@@ -319,10 +319,63 @@ var import_quickchart_js = __toESM(require("quickchart-js"), 1);
 var createMarketDataRequestHandler = (parser, pendingRequests) => {
   return async (args) => {
     try {
+      parser.logger.log({
+        level: "info",
+        message: `Sending market data request for symbols: ${args.symbols.join(", ")}`
+      });
       const response = new Promise((resolve) => {
         pendingRequests.set(args.mdReqID, resolve);
+        parser.logger.log({
+          level: "info",
+          message: `Registered callback for market data request ID: ${args.mdReqID}`
+        });
       });
-      const entryTypes = args.mdEntryTypes || [import_fixparser.MDEntryType.Bid, import_fixparser.MDEntryType.Offer, import_fixparser.MDEntryType.TradeVolume];
+      const entryTypes = args.mdEntryTypes || [
+        import_fixparser.MDEntryType.Bid,
+        import_fixparser.MDEntryType.Offer,
+        import_fixparser.MDEntryType.Trade,
+        import_fixparser.MDEntryType.IndexValue,
+        import_fixparser.MDEntryType.OpeningPrice,
+        import_fixparser.MDEntryType.ClosingPrice,
+        import_fixparser.MDEntryType.SettlementPrice,
+        import_fixparser.MDEntryType.TradingSessionHighPrice,
+        import_fixparser.MDEntryType.TradingSessionLowPrice,
+        import_fixparser.MDEntryType.VWAP,
+        import_fixparser.MDEntryType.Imbalance,
+        import_fixparser.MDEntryType.TradeVolume,
+        import_fixparser.MDEntryType.OpenInterest,
+        import_fixparser.MDEntryType.CompositeUnderlyingPrice,
+        import_fixparser.MDEntryType.SimulatedSellPrice,
+        import_fixparser.MDEntryType.SimulatedBuyPrice,
+        import_fixparser.MDEntryType.MarginRate,
+        import_fixparser.MDEntryType.MidPrice,
+        import_fixparser.MDEntryType.EmptyBook,
+        import_fixparser.MDEntryType.SettleHighPrice,
+        import_fixparser.MDEntryType.SettleLowPrice,
+        import_fixparser.MDEntryType.PriorSettlePrice,
+        import_fixparser.MDEntryType.SessionHighBid,
+        import_fixparser.MDEntryType.SessionLowOffer,
+        import_fixparser.MDEntryType.EarlyPrices,
+        import_fixparser.MDEntryType.AuctionClearingPrice,
+        import_fixparser.MDEntryType.SwapValueFactor,
+        import_fixparser.MDEntryType.DailyValueAdjustmentForLongPositions,
+        import_fixparser.MDEntryType.CumulativeValueAdjustmentForLongPositions,
+        import_fixparser.MDEntryType.DailyValueAdjustmentForShortPositions,
+        import_fixparser.MDEntryType.CumulativeValueAdjustmentForShortPositions,
+        import_fixparser.MDEntryType.FixingPrice,
+        import_fixparser.MDEntryType.CashRate,
+        import_fixparser.MDEntryType.RecoveryRate,
+        import_fixparser.MDEntryType.RecoveryRateForLong,
+        import_fixparser.MDEntryType.RecoveryRateForShort,
+        import_fixparser.MDEntryType.MarketBid,
+        import_fixparser.MDEntryType.MarketOffer,
+        import_fixparser.MDEntryType.ShortSaleMinPrice,
+        import_fixparser.MDEntryType.PreviousClosingPrice,
+        import_fixparser.MDEntryType.ThresholdLimitPriceBanding,
+        import_fixparser.MDEntryType.DailyFinancingValue,
+        import_fixparser.MDEntryType.AccruedFinancingValue,
+        import_fixparser.MDEntryType.TWAP
+      ];
       const messageFields = [
         new import_fixparser.Field(import_fixparser.Fields.MsgType, import_fixparser.Messages.MarketDataRequest),
         new import_fixparser.Field(import_fixparser.Fields.SenderCompID, parser.sender),
@@ -344,6 +397,10 @@ var createMarketDataRequestHandler = (parser, pendingRequests) => {
       });
       const mdr = parser.createMessage(...messageFields);
       if (!parser.connected) {
+        parser.logger.log({
+          level: "error",
+          message: "Not connected. Cannot send market data request."
+        });
         return {
           content: [
             {
@@ -355,8 +412,16 @@ var createMarketDataRequestHandler = (parser, pendingRequests) => {
           isError: true
         };
       }
+      parser.logger.log({
+        level: "info",
+        message: `Sending market data request message: ${JSON.stringify(mdr?.toFIXJSON())}`
+      });
       parser.send(mdr);
       const fixData = await response;
+      parser.logger.log({
+        level: "info",
+        message: `Received market data response for request ID: ${args.mdReqID}`
+      });
       return {
         content: [
           {
@@ -405,6 +470,9 @@ var createGetStockGraphHandler = (marketDataPrices) => {
       const offerData = priceHistory.map((point) => point.offer);
       const spreadData = priceHistory.map((point) => point.spread);
       const volumeData = priceHistory.map((point) => point.volume);
+      const tradeData = priceHistory.map((point) => point.trade);
+      const vwapData = priceHistory.map((point) => point.vwap);
+      const twapData = priceHistory.map((point) => point.twap);
       const config = {
         type: "line",
         data: {
@@ -434,6 +502,30 @@ var createGetStockGraphHandler = (marketDataPrices) => {
               fill: false,
               tension: 0.4
             },
+            {
+              label: "Trade",
+              data: tradeData,
+              borderColor: "#ffc107",
+              backgroundColor: "rgba(255, 193, 7, 0.1)",
+              fill: false,
+              tension: 0.4
+            },
+            {
+              label: "VWAP",
+              data: vwapData,
+              borderColor: "#17a2b8",
+              backgroundColor: "rgba(23, 162, 184, 0.1)",
+              fill: false,
+              tension: 0.4
+            },
+            {
+              label: "TWAP",
+              data: twapData,
+              borderColor: "#6610f2",
+              backgroundColor: "rgba(102, 16, 242, 0.1)",
+              fill: false,
+              tension: 0.4
+            },
             {
               label: "Volume",
               data: volumeData,
@@ -479,7 +571,7 @@ var createGetStockGraphHandler = (marketDataPrices) => {
         content: [
           {
             type: "text",
-            text: `Error: ${error instanceof Error ? error.message : "Failed to generate chart"}`,
+            text: `Error: ${error instanceof Error ? error.message : "Failed to generate graph"}`,
             uri: "getStockGraph"
           }
         ],
@@ -517,7 +609,48 @@ var createGetStockPriceHistoryHandler = (marketDataPrices) => {
                   bid: point.bid,
                   offer: point.offer,
                   spread: point.spread,
-                  volume: point.volume
+                  volume: point.volume,
+                  trade: point.trade,
+                  indexValue: point.indexValue,
+                  openingPrice: point.openingPrice,
+                  closingPrice: point.closingPrice,
+                  settlementPrice: point.settlementPrice,
+                  tradingSessionHighPrice: point.tradingSessionHighPrice,
+                  tradingSessionLowPrice: point.tradingSessionLowPrice,
+                  vwap: point.vwap,
+                  imbalance: point.imbalance,
+                  openInterest: point.openInterest,
+                  compositeUnderlyingPrice: point.compositeUnderlyingPrice,
+                  simulatedSellPrice: point.simulatedSellPrice,
+                  simulatedBuyPrice: point.simulatedBuyPrice,
+                  marginRate: point.marginRate,
+                  midPrice: point.midPrice,
+                  emptyBook: point.emptyBook,
+                  settleHighPrice: point.settleHighPrice,
+                  settleLowPrice: point.settleLowPrice,
+                  priorSettlePrice: point.priorSettlePrice,
+                  sessionHighBid: point.sessionHighBid,
+                  sessionLowOffer: point.sessionLowOffer,
+                  earlyPrices: point.earlyPrices,
+                  auctionClearingPrice: point.auctionClearingPrice,
+                  swapValueFactor: point.swapValueFactor,
+                  dailyValueAdjustmentForLongPositions: point.dailyValueAdjustmentForLongPositions,
+                  cumulativeValueAdjustmentForLongPositions: point.cumulativeValueAdjustmentForLongPositions,
+                  dailyValueAdjustmentForShortPositions: point.dailyValueAdjustmentForShortPositions,
+                  cumulativeValueAdjustmentForShortPositions: point.cumulativeValueAdjustmentForShortPositions,
+                  fixingPrice: point.fixingPrice,
+                  cashRate: point.cashRate,
+                  recoveryRate: point.recoveryRate,
+                  recoveryRateForLong: point.recoveryRateForLong,
+                  recoveryRateForShort: point.recoveryRateForShort,
+                  marketBid: point.marketBid,
+                  marketOffer: point.marketOffer,
+                  shortSaleMinPrice: point.shortSaleMinPrice,
+                  previousClosingPrice: point.previousClosingPrice,
+                  thresholdLimitPriceBanding: point.thresholdLimitPriceBanding,
+                  dailyFinancingValue: point.dailyFinancingValue,
+                  accruedFinancingValue: point.accruedFinancingValue,
+                  twap: point.twap
                 }))
               },
               null,
@@ -532,7 +665,7 @@ var createGetStockPriceHistoryHandler = (marketDataPrices) => {
         content: [
           {
             type: "text",
-            text: `Error: ${error instanceof Error ? error.message : "Failed to get stock price history"}`,
+            text: `Error: ${error instanceof Error ? error.message : "Failed to get price history"}`,
             uri: "getStockPriceHistory"
           }
         ],
@@ -640,7 +773,7 @@ Parameters verified:
 - Symbol: ${args.symbol}
 - 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. Important: The user has to explicitly confirm before executeOrder is called!`,
             uri: "verifyOrder"
           }
         ]
@@ -841,52 +974,256 @@ var createToolHandlers = (parser, verifiedOrders, pendingRequests, marketDataPri
 
 // src/utils/messageHandler.ts
 var import_fixparser3 = require("fixparser");
+function getEnumValue(enumObj, name) {
+  return enumObj[name] || name;
+}
 function handleMessage(message, parser, pendingRequests, marketDataPrices, maxPriceHistory, onPriceUpdate) {
   parser.logger.log({
     level: "info",
     message: `MCP Server received message: ${message.messageType}: ${message.description}`
   });
   const msgType = message.messageType;
-  if (msgType === import_fixparser3.Messages.MarketDataSnapshotFullRefresh) {
+  if (msgType === import_fixparser3.Messages.MarketDataSnapshotFullRefresh || msgType === import_fixparser3.Messages.MarketDataIncrementalRefresh) {
     const symbol = message.getField(import_fixparser3.Fields.Symbol)?.value;
-    const entries = message.getField(import_fixparser3.Fields.NoMDEntries)?.value;
-    let bid = 0;
-    let offer = 0;
-    let volume = 0;
-    const entryTypes = message.getFields(import_fixparser3.Fields.MDEntryType);
-    const entryPrices = message.getFields(import_fixparser3.Fields.MDEntryPx);
-    const entrySizes = message.getFields(import_fixparser3.Fields.MDEntrySize);
-    if (entryTypes && entryPrices && entrySizes) {
-      for (let i = 0; i < entries; i++) {
-        const entryType = entryTypes[i]?.value;
-        const entryPrice = Number.parseFloat(entryPrices[i]?.value);
-        const entrySize = Number.parseFloat(entrySizes[i]?.value);
-        if (entryType === import_fixparser3.MDEntryType.Bid) {
-          bid = entryPrice;
-        } else if (entryType === import_fixparser3.MDEntryType.Offer) {
-          offer = entryPrice;
-        }
-        volume += entrySize;
-      }
-    }
-    const spread = offer - bid;
-    const timestamp = Date.now();
+    parser.logger.log({
+      level: "info",
+      message: `Processing market data for symbol: ${symbol}`
+    });
+    const fixJson = message.toFIXJSON();
+    const entries = fixJson.Body?.NoMDEntries || [];
+    parser.logger.log({
+      level: "info",
+      message: `Found ${entries.length} market data entries`
+    });
     const data = {
-      timestamp,
-      bid,
-      offer,
-      spread,
-      volume
+      timestamp: Date.now(),
+      bid: 0,
+      offer: 0,
+      spread: 0,
+      volume: 0,
+      trade: 0,
+      indexValue: 0,
+      openingPrice: 0,
+      closingPrice: 0,
+      settlementPrice: 0,
+      tradingSessionHighPrice: 0,
+      tradingSessionLowPrice: 0,
+      vwap: 0,
+      imbalance: 0,
+      openInterest: 0,
+      compositeUnderlyingPrice: 0,
+      simulatedSellPrice: 0,
+      simulatedBuyPrice: 0,
+      marginRate: 0,
+      midPrice: 0,
+      emptyBook: 0,
+      settleHighPrice: 0,
+      settleLowPrice: 0,
+      priorSettlePrice: 0,
+      sessionHighBid: 0,
+      sessionLowOffer: 0,
+      earlyPrices: 0,
+      auctionClearingPrice: 0,
+      swapValueFactor: 0,
+      dailyValueAdjustmentForLongPositions: 0,
+      cumulativeValueAdjustmentForLongPositions: 0,
+      dailyValueAdjustmentForShortPositions: 0,
+      cumulativeValueAdjustmentForShortPositions: 0,
+      fixingPrice: 0,
+      cashRate: 0,
+      recoveryRate: 0,
+      recoveryRateForLong: 0,
+      recoveryRateForShort: 0,
+      marketBid: 0,
+      marketOffer: 0,
+      shortSaleMinPrice: 0,
+      previousClosingPrice: 0,
+      thresholdLimitPriceBanding: 0,
+      dailyFinancingValue: 0,
+      accruedFinancingValue: 0,
+      twap: 0
     };
+    for (const entry of entries) {
+      const entryType = entry.MDEntryType;
+      const price = entry.MDEntryPx ? Number.parseFloat(entry.MDEntryPx) : 0;
+      const size = entry.MDEntrySize ? Number.parseFloat(entry.MDEntrySize) : 0;
+      if (entryType === import_fixparser3.MDEntryType.Bid || entryType === import_fixparser3.MDEntryType.Offer || entryType === import_fixparser3.MDEntryType.TradeVolume) {
+        parser.logger.log({
+          level: "info",
+          message: `Market Data Entry - Type: ${entryType}, Price: ${price}, Size: ${size}`
+        });
+      }
+      const enumValue = getEnumValue(import_fixparser3.MDEntryType, entryType);
+      switch (enumValue) {
+        case import_fixparser3.MDEntryType.Bid:
+          data.bid = price;
+          break;
+        case import_fixparser3.MDEntryType.Offer:
+          data.offer = price;
+          break;
+        case import_fixparser3.MDEntryType.Trade:
+          data.trade = price;
+          break;
+        case import_fixparser3.MDEntryType.IndexValue:
+          data.indexValue = price;
+          break;
+        case import_fixparser3.MDEntryType.OpeningPrice:
+          data.openingPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.ClosingPrice:
+          data.closingPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.SettlementPrice:
+          data.settlementPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.TradingSessionHighPrice:
+          data.tradingSessionHighPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.TradingSessionLowPrice:
+          data.tradingSessionLowPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.VWAP:
+          data.vwap = price;
+          break;
+        case import_fixparser3.MDEntryType.Imbalance:
+          data.imbalance = size;
+          break;
+        case import_fixparser3.MDEntryType.TradeVolume:
+          data.volume = size;
+          break;
+        case import_fixparser3.MDEntryType.OpenInterest:
+          data.openInterest = size;
+          break;
+        case import_fixparser3.MDEntryType.CompositeUnderlyingPrice:
+          data.compositeUnderlyingPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.SimulatedSellPrice:
+          data.simulatedSellPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.SimulatedBuyPrice:
+          data.simulatedBuyPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.MarginRate:
+          data.marginRate = price;
+          break;
+        case import_fixparser3.MDEntryType.MidPrice:
+          data.midPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.EmptyBook:
+          data.emptyBook = 1;
+          break;
+        case import_fixparser3.MDEntryType.SettleHighPrice:
+          data.settleHighPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.SettleLowPrice:
+          data.settleLowPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.PriorSettlePrice:
+          data.priorSettlePrice = price;
+          break;
+        case import_fixparser3.MDEntryType.SessionHighBid:
+          data.sessionHighBid = price;
+          break;
+        case import_fixparser3.MDEntryType.SessionLowOffer:
+          data.sessionLowOffer = price;
+          break;
+        case import_fixparser3.MDEntryType.EarlyPrices:
+          data.earlyPrices = price;
+          break;
+        case import_fixparser3.MDEntryType.AuctionClearingPrice:
+          data.auctionClearingPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.SwapValueFactor:
+          data.swapValueFactor = price;
+          break;
+        case import_fixparser3.MDEntryType.DailyValueAdjustmentForLongPositions:
+          data.dailyValueAdjustmentForLongPositions = price;
+          break;
+        case import_fixparser3.MDEntryType.CumulativeValueAdjustmentForLongPositions:
+          data.cumulativeValueAdjustmentForLongPositions = price;
+          break;
+        case import_fixparser3.MDEntryType.DailyValueAdjustmentForShortPositions:
+          data.dailyValueAdjustmentForShortPositions = price;
+          break;
+        case import_fixparser3.MDEntryType.CumulativeValueAdjustmentForShortPositions:
+          data.cumulativeValueAdjustmentForShortPositions = price;
+          break;
+        case import_fixparser3.MDEntryType.FixingPrice:
+          data.fixingPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.CashRate:
+          data.cashRate = price;
+          break;
+        case import_fixparser3.MDEntryType.RecoveryRate:
+          data.recoveryRate = price;
+          break;
+        case import_fixparser3.MDEntryType.RecoveryRateForLong:
+          data.recoveryRateForLong = price;
+          break;
+        case import_fixparser3.MDEntryType.RecoveryRateForShort:
+          data.recoveryRateForShort = price;
+          break;
+        case import_fixparser3.MDEntryType.MarketBid:
+          data.marketBid = price;
+          break;
+        case import_fixparser3.MDEntryType.MarketOffer:
+          data.marketOffer = price;
+          break;
+        case import_fixparser3.MDEntryType.ShortSaleMinPrice:
+          data.shortSaleMinPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.PreviousClosingPrice:
+          data.previousClosingPrice = price;
+          break;
+        case import_fixparser3.MDEntryType.ThresholdLimitPriceBanding:
+          data.thresholdLimitPriceBanding = price;
+          break;
+        case import_fixparser3.MDEntryType.DailyFinancingValue:
+          data.dailyFinancingValue = price;
+          break;
+        case import_fixparser3.MDEntryType.AccruedFinancingValue:
+          data.accruedFinancingValue = price;
+          break;
+        case import_fixparser3.MDEntryType.TWAP:
+          data.twap = price;
+          break;
+      }
+    }
+    data.spread = data.offer - data.bid;
+    console.log(">>>>>>>>>>>>>>>>>>>>", data);
     if (!marketDataPrices.has(symbol)) {
+      parser.logger.log({
+        level: "info",
+        message: `Creating new price history array for symbol: ${symbol}`
+      });
       marketDataPrices.set(symbol, []);
     }
     const prices = marketDataPrices.get(symbol);
     prices.push(data);
+    parser.logger.log({
+      level: "info",
+      message: `Updated price history for ${symbol}. Current size: ${prices.length}`
+    });
     if (prices.length > maxPriceHistory) {
       prices.splice(0, prices.length - maxPriceHistory);
+      parser.logger.log({
+        level: "info",
+        message: `Trimmed price history for ${symbol} to ${maxPriceHistory} entries`
+      });
     }
     onPriceUpdate?.(symbol, data);
+    const mdReqID = message.getField(import_fixparser3.Fields.MDReqID)?.value;
+    if (mdReqID) {
+      const callback = pendingRequests.get(mdReqID);
+      if (callback) {
+        callback(message);
+        pendingRequests.delete(mdReqID);
+        parser.logger.log({
+          level: "info",
+          message: `Resolved market data request for ID: ${mdReqID}`
+        });
+      }
+    }
   } else if (msgType === import_fixparser3.Messages.ExecutionReport) {
     const reqId = message.getField(import_fixparser3.Fields.ClOrdID)?.value;
     const callback = pendingRequests.get(reqId);
@@ -915,7 +1252,7 @@ var MCPLocal = class extends MCPBase {
    */
   marketDataPrices = /* @__PURE__ */ new Map();
   /**
-   * Maximum number of price points to store per symbol
+   * Maximum number of price history entries to keep per symbol
    * @private
    */
   MAX_PRICE_HISTORY = 1e5;
@@ -1024,6 +1361,39 @@ var import_streamableHttp = require("@modelcontextprotocol/sdk/server/streamable
 var import_types = require("@modelcontextprotocol/sdk/types.js");
 var import_zod2 = require("zod");
 var transports = {};
+function jsonSchemaToZod(schema) {
+  if (schema.type === "object") {
+    const shape = {};
+    for (const [key, prop] of Object.entries(schema.properties || {})) {
+      const propSchema = prop;
+      if (propSchema.type === "string") {
+        if (propSchema.enum) {
+          shape[key] = import_zod2.z.enum(propSchema.enum);
+        } else {
+          shape[key] = import_zod2.z.string();
+        }
+      } else if (propSchema.type === "number") {
+        shape[key] = import_zod2.z.number();
+      } else if (propSchema.type === "boolean") {
+        shape[key] = import_zod2.z.boolean();
+      } else if (propSchema.type === "array") {
+        if (propSchema.items.type === "string") {
+          shape[key] = import_zod2.z.array(import_zod2.z.string());
+        } else if (propSchema.items.type === "number") {
+          shape[key] = import_zod2.z.array(import_zod2.z.number());
+        } else if (propSchema.items.type === "boolean") {
+          shape[key] = import_zod2.z.array(import_zod2.z.boolean());
+        } else {
+          shape[key] = import_zod2.z.array(import_zod2.z.any());
+        }
+      } else {
+        shape[key] = import_zod2.z.any();
+      }
+    }
+    return shape;
+  }
+  return {};
+}
 var MCPRemote = class extends MCPBase {
   /**
    * Port number the server will listen on.
@@ -1066,7 +1436,7 @@ var MCPRemote = class extends MCPBase {
    */
   marketDataPrices = /* @__PURE__ */ new Map();
   /**
-   * Maximum number of price points to store per symbol
+   * Maximum number of price history entries to keep per symbol
    * @private
    */
   MAX_PRICE_HISTORY = 1e5;
@@ -1088,55 +1458,22 @@ var MCPRemote = class extends MCPBase {
           this.parser,
           this.pendingRequests,
           this.marketDataPrices,
-          this.MAX_PRICE_HISTORY,
-          (symbol, data) => {
-            this.mcpServer?.tool(
-              "priceUpdate",
-              {
-                description: "Price update notification",
-                schema: import_zod2.z.object({
-                  symbol: import_zod2.z.string(),
-                  timestamp: import_zod2.z.number(),
-                  bid: import_zod2.z.number(),
-                  offer: import_zod2.z.number(),
-                  spread: import_zod2.z.number(),
-                  volume: import_zod2.z.number()
-                })
-              },
-              () => ({
-                content: [
-                  {
-                    type: "text",
-                    text: JSON.stringify({ symbol, ...data })
-                  }
-                ]
-              })
-            );
-          }
+          this.MAX_PRICE_HISTORY
         );
+        this.logger?.log({
+          level: "info",
+          message: `Market Data Prices TEST: ${JSON.stringify(this.marketDataPrices)}`
+        });
       }
     });
     this.httpServer = (0, import_node_http.createServer)(async (req, res) => {
-      console.log(req.headers);
-      this.logger?.log({
-        level: "info",
-        message: `Incoming request: ${req.method} ${req.url}`
-      });
       if (!req.url || !req.method) {
-        this.logger?.log({
-          level: "error",
-          message: "Invalid request: missing URL or method"
-        });
         res.writeHead(400);
         res.end("Bad Request");
         return;
       }
       if (req.url === "/mcp") {
         const sessionId = req.headers["mcp-session-id"];
-        this.logger?.log({
-          level: "info",
-          message: `MCP request received. Session ID: ${sessionId || "none"}, headers: ${req.headers}`
-        });
         if (req.method === "POST") {
           const bodyChunks = [];
           req.on("data", (chunk) => {
@@ -1147,47 +1484,23 @@ var MCPRemote = class extends MCPBase {
             const body = Buffer.concat(bodyChunks).toString();
             try {
               parsed = JSON.parse(body);
-              this.logger?.log({
-                level: "info",
-                message: `Parsed request body: ${JSON.stringify(parsed)}`
-              });
             } catch (err) {
-              this.logger?.log({
-                level: "error",
-                message: `Failed to parse JSON body: ${err}`
-              });
               res.writeHead(400);
               res.end(JSON.stringify({ error: "Invalid JSON" }));
               return;
             }
             let transport;
             if (sessionId && transports[sessionId]) {
-              this.logger?.log({
-                level: "info",
-                message: `Using existing transport for session: ${sessionId}`
-              });
               transport = transports[sessionId];
             } else if (!sessionId && req.method === "POST" && (0, import_types.isInitializeRequest)(parsed)) {
-              this.logger?.log({
-                level: "info",
-                message: "Creating new transport for initialization request"
-              });
               transport = new import_streamableHttp.StreamableHTTPServerTransport({
                 sessionIdGenerator: () => (0, import_node_crypto.randomUUID)(),
                 onsessioninitialized: (sessionId2) => {
-                  this.logger?.log({
-                    level: "info",
-                    message: `New session initialized: ${sessionId2}`
-                  });
                   transports[sessionId2] = transport;
                 }
               });
               transport.onclose = () => {
                 if (transport.sessionId) {
-                  this.logger?.log({
-                    level: "info",
-                    message: `Session closed: ${transport.sessionId}`
-                  });
                   delete transports[transport.sessionId];
                 }
               };
@@ -1198,10 +1511,6 @@ var MCPRemote = class extends MCPBase {
               this.setupTools();
               await this.mcpServer.connect(transport);
             } else {
-              this.logger?.log({
-                level: "error",
-                message: "Invalid request: No valid session ID provided"
-              });
               res.writeHead(400, { "Content-Type": "application/json" });
               res.end(
                 JSON.stringify({
@@ -1217,10 +1526,6 @@ var MCPRemote = class extends MCPBase {
             }
             try {
               await transport.handleRequest(req, res, parsed);
-              this.logger?.log({
-                level: "info",
-                message: "Request handled successfully"
-              });
             } catch (error) {
               this.logger?.log({
                 level: "error",
@@ -1231,10 +1536,6 @@ var MCPRemote = class extends MCPBase {
           });
         } else if (req.method === "GET" || req.method === "DELETE") {
           if (!sessionId || !transports[sessionId]) {
-            this.logger?.log({
-              level: "error",
-              message: `Invalid session ID for ${req.method} request: ${sessionId}`
-            });
             res.writeHead(400);
             res.end("Invalid or missing session ID");
             return;
@@ -1242,10 +1543,6 @@ var MCPRemote = class extends MCPBase {
           const transport = transports[sessionId];
           try {
             await transport.handleRequest(req, res);
-            this.logger?.log({
-              level: "info",
-              message: `${req.method} request handled successfully for session: ${sessionId}`
-            });
           } catch (error) {
             this.logger?.log({
               level: "error",
@@ -1262,10 +1559,6 @@ var MCPRemote = class extends MCPBase {
           res.end("Method Not Allowed");
         }
       } else {
-        this.logger?.log({
-          level: "error",
-          message: `Not found: ${req.url}`
-        });
         res.writeHead(404);
         res.end("Not Found");
       }
@@ -1295,69 +1588,40 @@ var MCPRemote = class extends MCPBase {
       });
       return;
     }
-    this.mcpServer.tool(
-      "tools/list",
-      {
-        description: "List available tools",
-        schema: import_zod2.z.object({})
-      },
-      async () => {
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(
-                Object.entries(toolSchemas).map(([name, { description, schema }]) => ({
-                  name,
-                  description,
-                  inputSchema: schema
-                }))
-              )
-            }
-          ]
-        };
-      }
+    const toolHandlers = createToolHandlers(
+      this.parser,
+      this.verifiedOrders,
+      this.pendingRequests,
+      this.marketDataPrices
     );
-    this.mcpServer.tool(
-      "tools/call",
-      {
-        description: "Call a tool",
-        schema: import_zod2.z.object({
-          name: import_zod2.z.string(),
-          arguments: import_zod2.z.any(),
-          _meta: import_zod2.z.object({
-            progressToken: import_zod2.z.number()
-          }).optional()
-        })
-      },
-      async (request) => {
-        const { name, arguments: args } = request;
-        const toolHandlers = createToolHandlers(
-          this.parser,
-          this.verifiedOrders,
-          this.pendingRequests,
-          this.marketDataPrices
-        );
-        const handler = toolHandlers[name];
-        if (!handler) {
+    Object.entries(toolSchemas).forEach(([name, { description, schema }]) => {
+      this.mcpServer?.registerTool(
+        name,
+        {
+          description,
+          inputSchema: jsonSchemaToZod(schema)
+        },
+        async (args) => {
+          const handler = toolHandlers[name];
+          if (!handler) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Tool not found: ${name}`
+                }
+              ],
+              isError: true
+            };
+          }
+          const result = await handler(args);
           return {
-            content: [
-              {
-                type: "text",
-                text: `Tool not found: ${name}`,
-                uri: name
-              }
-            ],
-            isError: true
+            content: result.content,
+            isError: result.isError
           };
         }
-        const result = await handler(args);
-        return {
-          content: result.content,
-          isError: result.isError
-        };
-      }
-    );
+      );
+    });
   }
 };
 // Annotate the CommonJS export names for ESM import in node: