fixparser-plugin-mcp 9.1.6-da9cb1d7 → 9.1.7-27ef5b7b

package/build/esm/MCPLocal.mjs

@@ -0,0 +1,697 @@
+// src/MCPLocal.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  GetPromptRequestSchema,
+  ListPromptsRequestSchema,
+  ListResourcesRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import {
+  Field,
+  Fields,
+  HandlInst,
+  MDEntryType,
+  Messages,
+  OrdType,
+  SubscriptionRequestType,
+  TimeInForce
+} from "fixparser";
+var parseInputSchema = {
+  type: "object",
+  properties: {
+    fixString: {
+      type: "string",
+      description: "FIX message string to parse"
+    }
+  },
+  required: ["fixString"]
+};
+var parseToJSONInputSchema = {
+  type: "object",
+  properties: {
+    fixString: {
+      type: "string",
+      description: "FIX message string to parse"
+    }
+  },
+  required: ["fixString"]
+};
+var newOrderSingleInputSchema = {
+  type: "object",
+  properties: {
+    clOrdID: {
+      type: "string",
+      description: "Client Order ID"
+    },
+    handlInst: {
+      type: "string",
+      enum: ["1", "2", "3"],
+      default: HandlInst.AutomatedExecutionNoIntervention,
+      description: "Handling instruction"
+    },
+    quantity: {
+      type: "number",
+      description: "Order quantity"
+    },
+    price: {
+      type: "number",
+      description: "Order price"
+    },
+    ordType: {
+      type: "string",
+      enum: [
+        "1",
+        "2",
+        "3",
+        "4",
+        "5",
+        "6",
+        "7",
+        "8",
+        "9",
+        "A",
+        "B",
+        "C",
+        "D",
+        "E",
+        "F",
+        "G",
+        "H",
+        "I",
+        "J",
+        "K",
+        "L",
+        "M",
+        "P",
+        "Q",
+        "R",
+        "S"
+      ],
+      default: OrdType.Market,
+      description: "Order type"
+    },
+    side: {
+      type: "string",
+      enum: ["1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H"],
+      description: "Order side (1=Buy, 2=Sell)"
+    },
+    symbol: {
+      type: "string",
+      description: "Trading symbol"
+    },
+    timeInForce: {
+      type: "string",
+      enum: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C"],
+      default: TimeInForce.Day,
+      description: "Time in force"
+    }
+  },
+  required: ["clOrdID", "quantity", "price", "side", "symbol"]
+};
+var marketDataRequestInputSchema = {
+  type: "object",
+  properties: {
+    mdUpdateType: {
+      type: "string",
+      enum: ["0", "1"],
+      default: "0",
+      description: "Market data update type"
+    },
+    symbol: {
+      type: "string",
+      description: "Trading symbol"
+    },
+    mdReqID: {
+      type: "string",
+      description: "Market data request ID"
+    },
+    subscriptionRequestType: {
+      type: "string",
+      enum: ["0", "1", "2"],
+      default: SubscriptionRequestType.SnapshotAndUpdates,
+      description: "Subscription request type"
+    },
+    mdEntryType: {
+      type: "string",
+      enum: [
+        "0",
+        "1",
+        "2",
+        "3",
+        "4",
+        "5",
+        "6",
+        "7",
+        "8",
+        "9",
+        "A",
+        "B",
+        "C",
+        "D",
+        "E",
+        "F",
+        "G",
+        "H",
+        "J",
+        "K",
+        "L",
+        "M",
+        "N",
+        "O",
+        "P",
+        "Q",
+        "S",
+        "R",
+        "T",
+        "U",
+        "V",
+        "W",
+        "X",
+        "Y",
+        "Z",
+        "a",
+        "b",
+        "c",
+        "d",
+        "e",
+        "g",
+        "h",
+        "i",
+        "t"
+      ],
+      default: MDEntryType.Bid,
+      description: "Market data entry type"
+    }
+  },
+  required: ["symbol", "mdReqID"]
+};
+var MCPLocal = class {
+  logger;
+  parser;
+  server = new Server(
+    {
+      name: "fixparser",
+      version: "1.0.0"
+    },
+    {
+      capabilities: {
+        tools: {},
+        prompts: {},
+        resources: {}
+      }
+    }
+  );
+  transport = new StdioServerTransport();
+  onReady = void 0;
+  pendingRequests = /* @__PURE__ */ new Map();
+  constructor({ logger, onReady }) {
+    if (logger) this.logger = logger;
+    if (onReady) this.onReady = onReady;
+  }
+  async register(parser) {
+    this.parser = parser;
+    this.parser.addOnMessageCallback((message) => {
+      this.logger?.log({
+        level: "info",
+        message: `FIXParser (MCP): (${parser.protocol?.toUpperCase()}): << received ${message.description}`
+      });
+      const msgType = message.messageType;
+      if (msgType === Messages.MarketDataSnapshotFullRefresh || msgType === Messages.ExecutionReport) {
+        const idField = msgType === Messages.MarketDataSnapshotFullRefresh ? message.getField(Fields.MDReqID) : message.getField(Fields.ClOrdID);
+        if (idField) {
+          const id = idField.value;
+          if (typeof id === "string" || typeof id === "number") {
+            const callback = this.pendingRequests.get(String(id));
+            if (callback) {
+              callback(message);
+              this.pendingRequests.delete(String(id));
+            }
+          }
+        }
+      }
+    });
+    this.logger = parser.logger;
+    this.addWorkflows();
+    await this.server.connect(this.transport);
+    if (this.onReady) {
+      this.onReady();
+    }
+  }
+  addWorkflows() {
+    if (!this.parser) {
+      this.logger?.log({
+        level: "error",
+        message: "FIXParser (MCP): -- FIXParser instance not initialized. Ignoring setup of workflows..."
+      });
+      return;
+    }
+    if (!this.server) {
+      this.logger?.log({
+        level: "error",
+        message: "FIXParser (MCP): -- MCP Server not initialized. Ignoring setup of workflows..."
+      });
+      return;
+    }
+    const validateArgs = (args, schema) => {
+      const result = {};
+      for (const [key, propSchema] of Object.entries(schema.properties || {})) {
+        const prop = propSchema;
+        const value = args?.[key];
+        if (prop.required && (value === void 0 || value === null)) {
+          throw new Error(`Required property '${key}' is missing`);
+        }
+        if (value !== void 0) {
+          result[key] = value;
+        } else if (prop.default !== void 0) {
+          result[key] = prop.default;
+        }
+      }
+      return result;
+    };
+    this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
+      return {
+        resources: []
+      };
+    });
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      return {
+        tools: [
+          {
+            name: "parse",
+            description: "Parses a FIX message and describes it in plain language",
+            inputSchema: parseInputSchema
+          },
+          {
+            name: "parseToJSON",
+            description: "Parses a FIX message into JSON",
+            inputSchema: parseToJSONInputSchema
+          },
+          {
+            name: "newOrderSingle",
+            description: "Creates and sends a New Order Single",
+            inputSchema: newOrderSingleInputSchema
+          },
+          {
+            name: "marketDataRequest",
+            description: "Sends a request for Market Data with the given symbol",
+            inputSchema: marketDataRequestInputSchema
+          }
+        ]
+      };
+    });
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      switch (name) {
+        case "parse": {
+          try {
+            const { fixString } = validateArgs(args, parseInputSchema);
+            const parsedMessage = this.parser?.parse(fixString);
+            if (!parsedMessage || parsedMessage.length === 0) {
+              return {
+                isError: true,
+                content: [{ type: "text", text: "Error: Failed to parse FIX string" }]
+              };
+            }
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Parsed FIX message: ${fixString} (placeholder implementation)`
+                }
+              ]
+            };
+          } catch (error) {
+            return {
+              isError: true,
+              content: [
+                {
+                  type: "text",
+                  text: `Error: ${error instanceof Error ? error.message : "Failed to parse FIX string"}`
+                }
+              ]
+            };
+          }
+        }
+        case "parseToJSON": {
+          try {
+            const { fixString } = validateArgs(args, parseToJSONInputSchema);
+            const parsedMessage = this.parser?.parse(fixString);
+            if (!parsedMessage || parsedMessage.length === 0) {
+              return {
+                isError: true,
+                content: [{ type: "text", text: "Error: Failed to parse FIX string" }]
+              };
+            }
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({ fixString, parsed: "placeholder" })
+                }
+              ]
+            };
+          } catch (error) {
+            return {
+              isError: true,
+              content: [
+                {
+                  type: "text",
+                  text: `Error: ${error instanceof Error ? error.message : "Failed to parse FIX string"}`
+                }
+              ]
+            };
+          }
+        }
+        case "newOrderSingle": {
+          try {
+            const { clOrdID, handlInst, quantity, price, ordType, side, symbol, timeInForce } = validateArgs(args, newOrderSingleInputSchema);
+            const response = new Promise((resolve) => {
+              this.pendingRequests.set(clOrdID, resolve);
+            });
+            const order = this.parser?.createMessage(
+              new Field(Fields.MsgType, Messages.NewOrderSingle),
+              new Field(Fields.MsgSeqNum, this.parser?.getNextTargetMsgSeqNum()),
+              new Field(Fields.SenderCompID, this.parser?.sender),
+              new Field(Fields.TargetCompID, this.parser?.target),
+              new Field(Fields.SendingTime, this.parser?.getTimestamp()),
+              new Field(Fields.ClOrdID, clOrdID),
+              new Field(Fields.Side, side),
+              new Field(Fields.Symbol, symbol),
+              new Field(Fields.OrderQty, quantity),
+              new Field(Fields.Price, price),
+              new Field(Fields.OrdType, ordType),
+              new Field(Fields.HandlInst, handlInst),
+              new Field(Fields.TimeInForce, timeInForce),
+              new Field(Fields.TransactTime, this.parser?.getTimestamp())
+            );
+            if (!this.parser?.connected) {
+              this.logger?.log({
+                level: "error",
+                message: "FIXParser (MCP): -- Not connected. Ignoring message."
+              });
+              return {
+                isError: true,
+                content: [
+                  {
+                    type: "text",
+                    text: "Error: Not connected. Ignoring message."
+                  }
+                ]
+              };
+            }
+            this.parser?.send(order);
+            this.logger?.log({
+              level: "info",
+              message: `FIXParser (MCP): (${this.parser?.protocol?.toUpperCase()}): >> sent ${order?.description}`
+            });
+            const fixData = await response;
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Execution Report for order ${clOrdID}: ${JSON.stringify(fixData.toFIXJSON())}`
+                }
+              ]
+            };
+          } catch (error) {
+            return {
+              isError: true,
+              content: [
+                {
+                  type: "text",
+                  text: `Error: ${error instanceof Error ? error.message : "Failed to create order"}`
+                }
+              ]
+            };
+          }
+        }
+        case "marketDataRequest": {
+          try {
+            const { mdUpdateType, symbol, mdReqID, subscriptionRequestType, mdEntryType } = validateArgs(
+              args,
+              marketDataRequestInputSchema
+            );
+            const response = new Promise((resolve) => {
+              this.pendingRequests.set(mdReqID, resolve);
+            });
+            const marketDataRequest = this.parser?.createMessage(
+              new Field(Fields.MsgType, Messages.MarketDataRequest),
+              new Field(Fields.SenderCompID, this.parser?.sender),
+              new Field(Fields.MsgSeqNum, this.parser?.getNextTargetMsgSeqNum()),
+              new Field(Fields.TargetCompID, this.parser?.target),
+              new Field(Fields.SendingTime, this.parser?.getTimestamp()),
+              new Field(Fields.MarketDepth, 0),
+              new Field(Fields.MDUpdateType, mdUpdateType),
+              new Field(Fields.NoRelatedSym, 1),
+              new Field(Fields.Symbol, symbol),
+              new Field(Fields.MDReqID, mdReqID),
+              new Field(Fields.SubscriptionRequestType, subscriptionRequestType),
+              new Field(Fields.NoMDEntryTypes, 1),
+              new Field(Fields.MDEntryType, mdEntryType)
+            );
+            if (!this.parser?.connected) {
+              this.logger?.log({
+                level: "error",
+                message: "FIXParser (MCP): -- Not connected. Ignoring message."
+              });
+              return {
+                isError: true,
+                content: [
+                  {
+                    type: "text",
+                    text: "Error: Not connected. Ignoring message."
+                  }
+                ]
+              };
+            }
+            this.parser?.send(marketDataRequest);
+            this.logger?.log({
+              level: "info",
+              message: `FIXParser (MCP): (${this.parser?.protocol?.toUpperCase()}): >> sent ${marketDataRequest?.description}`
+            });
+            const fixData = await response;
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Market data for ${symbol}: ${JSON.stringify(fixData.toFIXJSON())}`
+                }
+              ]
+            };
+          } catch (error) {
+            return {
+              isError: true,
+              content: [
+                {
+                  type: "text",
+                  text: `Error: ${error instanceof Error ? error.message : "Failed to request market data"}`
+                }
+              ]
+            };
+          }
+        }
+        default:
+          throw new Error(`Unknown tool: ${name}`);
+      }
+    });
+    this.server.setRequestHandler(ListPromptsRequestSchema, async () => {
+      return {
+        prompts: [
+          {
+            name: "parse",
+            description: "Parses a FIX message and describes it in plain language",
+            arguments: [
+              {
+                name: "fixString",
+                description: "FIX message string to parse",
+                required: true
+              }
+            ]
+          },
+          {
+            name: "parseToJSON",
+            description: "Parses a FIX message into JSON",
+            arguments: [
+              {
+                name: "fixString",
+                description: "FIX message string to parse",
+                required: true
+              }
+            ]
+          },
+          {
+            name: "newOrderSingle",
+            description: "Creates and sends a New Order Single",
+            arguments: [
+              {
+                name: "clOrdID",
+                description: "Client Order ID",
+                required: true
+              },
+              {
+                name: "handlInst",
+                description: "Handling instruction",
+                required: false
+              },
+              {
+                name: "quantity",
+                description: "Order quantity",
+                required: true
+              },
+              {
+                name: "price",
+                description: "Order price",
+                required: true
+              },
+              {
+                name: "ordType",
+                description: "Order type",
+                required: false
+              },
+              {
+                name: "side",
+                description: "Order side (1=Buy, 2=Sell)",
+                required: true
+              },
+              {
+                name: "symbol",
+                description: "Trading symbol",
+                required: true
+              },
+              {
+                name: "timeInForce",
+                description: "Time in force",
+                required: false
+              }
+            ]
+          },
+          {
+            name: "marketDataRequest",
+            description: "Sends a request for Market Data with the given symbol",
+            arguments: [
+              {
+                name: "mdUpdateType",
+                description: "Market data update type",
+                required: false
+              },
+              {
+                name: "symbol",
+                description: "Trading symbol",
+                required: true
+              },
+              {
+                name: "mdReqID",
+                description: "Market data request ID",
+                required: true
+              },
+              {
+                name: "subscriptionRequestType",
+                description: "Subscription request type",
+                required: false
+              },
+              {
+                name: "mdEntryType",
+                description: "Market data entry type",
+                required: false
+              }
+            ]
+          }
+        ]
+      };
+    });
+    this.server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+      const { name, arguments: args } = request.params;
+      switch (name) {
+        case "parse": {
+          const fixString = args?.fixString || "";
+          return {
+            messages: [
+              {
+                role: "user",
+                content: {
+                  type: "text",
+                  text: `Please parse and explain this FIX message: ${fixString}`
+                }
+              }
+            ]
+          };
+        }
+        case "parseToJSON": {
+          const fixString = args?.fixString || "";
+          return {
+            messages: [
+              {
+                role: "user",
+                content: {
+                  type: "text",
+                  text: `Please parse the FIX message to JSON: ${fixString}`
+                }
+              }
+            ]
+          };
+        }
+        case "newOrderSingle": {
+          const { clOrdID, handlInst, quantity, price, ordType, side, symbol, timeInForce } = args || {};
+          return {
+            messages: [
+              {
+                role: "user",
+                content: {
+                  type: "text",
+                  text: [
+                    "Create a New Order Single FIX message with the following parameters:",
+                    `- ClOrdID: ${clOrdID}`,
+                    `- HandlInst: ${handlInst ?? "default"}`,
+                    `- Quantity: ${quantity}`,
+                    `- Price: ${price}`,
+                    `- OrdType: ${ordType ?? "default (Market)"}`,
+                    `- Side: ${side}`,
+                    `- Symbol: ${symbol}`,
+                    `- TimeInForce: ${timeInForce ?? "default (Day)"}`,
+                    "",
+                    "Format the response as a JSON object with FIX tag numbers as keys and their corresponding values."
+                  ].join("\n")
+                }
+              }
+            ]
+          };
+        }
+        case "marketDataRequest": {
+          const { mdUpdateType, symbol, mdReqID, subscriptionRequestType, mdEntryType } = args || {};
+          return {
+            messages: [
+              {
+                role: "user",
+                content: {
+                  type: "text",
+                  text: [
+                    "Create a Market Data Request FIX message with the following parameters:",
+                    `- MDUpdateType: ${mdUpdateType ?? "default (0 = FullRefresh)"}`,
+                    `- Symbol: ${symbol}`,
+                    `- MDReqID: ${mdReqID}`,
+                    `- SubscriptionRequestType: ${subscriptionRequestType ?? "default (0 = Snapshot + Updates)"}`,
+                    `- MDEntryType: ${mdEntryType ?? "default (0 = Bid)"}`,
+                    "",
+                    "Format the response as a JSON object with FIX tag numbers as keys and their corresponding values."
+                  ].join("\n")
+                }
+              }
+            ]
+          };
+        }
+        default:
+          throw new Error(`Unknown prompt: ${name}`);
+      }
+    });
+    process.on("SIGINT", async () => {
+      await this.server.close();
+      process.exit(0);
+    });
+  }
+};
+export {
+  MCPLocal
+};
+//# sourceMappingURL=MCPLocal.mjs.map