fixparser-plugin-mcp 9.1.7-544294dd → 9.1.7-57d70bb1

package/types/MCPBase.d.ts

@@ -0,0 +1,49 @@
+import type { IFIXParser, Logger } from 'fixparser';
+import type { IPlugin } from 'fixparser-common';
+import type { VerifiedOrder } from './schemas';
+import type { MarketDataPrices, PendingRequests } from './utils/messageHandler';
+export declare abstract class MCPBase implements IPlugin<IFIXParser> {
+    /**
+     * Optional logger instance for diagnostics and output.
+     * @protected
+     */
+    protected logger: Logger | undefined;
+    /**
+     * FIXParser instance, set during plugin register().
+     * @protected
+     */
+    protected parser: IFIXParser | undefined;
+    /**
+     * Called when server is setup and listening.
+     * @protected
+     */
+    protected onReady: (() => void) | undefined;
+    /**
+     * Map to store verified orders before execution
+     * @protected
+     */
+    protected verifiedOrders: Map<string, VerifiedOrder>;
+    /**
+     * Map to store pending market data requests
+     * @protected
+     */
+    protected pendingRequests: PendingRequests;
+    /**
+     * Map to store market data prices
+     * @protected
+     */
+    protected marketDataPrices: MarketDataPrices;
+    /**
+     * Maximum number of price history entries to keep per symbol
+     * @protected
+     */
+    protected readonly MAX_PRICE_HISTORY = 100000;
+    constructor({
+        logger,
+        onReady,
+    }: {
+        logger?: Logger;
+        onReady?: () => void;
+    });
+    abstract register(parser: IFIXParser): Promise<void>;
+}

package/types/MCPLocal.d.ts

@@ -1,13 +1,39 @@
-import { type IFIXParser } from 'fixparser';
-import type { IPlugin } from 'fixparser-common';
+import type { IFIXParser, Message } from 'fixparser';
+import { MCPBase } from './MCPBase';
 import type { PluginOptions } from './PluginOptions';
-export declare class MCPLocal implements IPlugin<IFIXParser> {
-    private logger;
-    private parser;
+import type { VerifiedOrder } from './schemas';
+export declare class MCPLocal extends MCPBase {
+    /**
+     * Map to store verified orders before execution
+     * @private
+     */
+    protected verifiedOrders: Map<string, VerifiedOrder>;
+    /**
+     * Map to store pending requests and their callbacks
+     * @private
+     */
+    protected pendingRequests: Map<string, (data: Message) => void>;
+    /**
+     * Map to store market data prices for each symbol
+     * @private
+     */
+    protected marketDataPrices: Map<
+        string,
+        Array<{
+            timestamp: number;
+            bid: number;
+            offer: number;
+            spread: number;
+            volume: number;
+        }>
+    >;
+    /**
+     * Maximum number of price points to store per symbol
+     * @private
+     */
+    protected readonly MAX_PRICE_HISTORY = 100000;
     private server;
     private transport;
-    private onReady;
-    private pendingRequests;
     constructor({ logger, onReady }: PluginOptions);
     register(parser: IFIXParser): Promise<void>;
     private addWorkflows;

package/types/MCPRemote.d.ts

@@ -1,60 +1,66 @@
-import { type IFIXParser, type Logger } from 'fixparser';
-import type { IPlugin } from 'fixparser-common';
-export type PluginOptions = {
+import type { IFIXParser, Message } from 'fixparser';
+import { MCPBase } from './MCPBase';
+import type { PluginOptions } from './PluginOptions';
+import type { VerifiedOrder } from './schemas';
+export type RemotePluginOptions = PluginOptions & {
     port: number;
-    logger?: Logger;
-    onReady: () => void;
 };
-export declare class MCPRemote implements IPlugin<IFIXParser> {
+export declare class MCPRemote extends MCPBase {
     /**
      * Port number the server will listen on.
      * @private
      */
     private port;
     /**
-     * Optional logger instance for diagnostics and output.
+     * Node.js HTTP server instance created internally.
      * @private
      */
-    private logger;
+    private httpServer;
     /**
-     * FIXParser instance, set during plugin register().
+     * MCP server instance handling MCP protocol logic.
      * @private
      */
-    private parser;
+    private mcpServer;
     /**
-     * Node.js HTTP server instance created internally.
+     * Optional name of the plugin/server instance.
      * @private
      */
-    private server;
+    private serverName;
     /**
-     * MCP server instance handling MCP protocol logic.
+     * Optional version string of the plugin/server.
      * @private
      */
-    private mcpServer;
+    private serverVersion;
     /**
-     * Optional name of the plugin/server instance.
+     * Map to store verified orders before execution
      * @private
      */
-    private name;
+    protected verifiedOrders: Map<string, VerifiedOrder>;
     /**
-     * Optional version string of the plugin/server.
+     * Map to store pending requests and their callbacks
      * @private
      */
-    private version;
+    protected pendingRequests: Map<string, (data: Message) => void>;
     /**
-     * Called when server is setup and listening.
+     * Map to store market data prices for each symbol
      * @private
      */
-    private onReady;
+    protected marketDataPrices: Map<
+        string,
+        Array<{
+            timestamp: number;
+            bid: number;
+            offer: number;
+            spread: number;
+            volume: number;
+        }>
+    >;
     /**
-     * A map of pending market data requests, keyed by MDReqID.
-     * Each entry contains a resolver function that is called when the corresponding
-     * FIX Message is received.
+     * Maximum number of price points to store per symbol
      * @private
-     * @type {Map<string, (data: Message) => void>}
      */
-    private pendingRequests;
-    constructor({ port, logger, onReady }: PluginOptions);
+    protected readonly MAX_PRICE_HISTORY = 100000;
+    constructor({ port, logger, onReady }: RemotePluginOptions);
     register(parser: IFIXParser): Promise<void>;
-    private addWorkflows;
+    private setupTools;
 }

package/types/schemas/index.d.ts

@@ -0,0 +1,15 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+export interface VerifiedOrder {
+    clOrdID: string;
+    handlInst: string;
+    quantity: number;
+    price: number;
+    ordType: string;
+    side: string;
+    symbol: string;
+    timeInForce: string;
+}
+export type ToolHandler = (args: any) => Promise<CallToolResult>;
+export interface ToolHandlers {
+    [key: string]: ToolHandler;
+}

package/types/schemas/schemas.d.ts

@@ -0,0 +1,168 @@
+export declare const toolSchemas: {
+    parse: {
+        description: string;
+        schema: {
+            type: string;
+            properties: {
+                fixString: {
+                    type: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    parseToJSON: {
+        description: string;
+        schema: {
+            type: string;
+            properties: {
+                fixString: {
+                    type: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    verifyOrder: {
+        description: string;
+        schema: {
+            type: string;
+            properties: {
+                clOrdID: {
+                    type: string;
+                };
+                handlInst: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                quantity: {
+                    type: string;
+                };
+                price: {
+                    type: string;
+                };
+                ordType: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                side: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                symbol: {
+                    type: string;
+                };
+                timeInForce: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    executeOrder: {
+        description: string;
+        schema: {
+            type: string;
+            properties: {
+                clOrdID: {
+                    type: string;
+                };
+                handlInst: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                quantity: {
+                    type: string;
+                };
+                price: {
+                    type: string;
+                };
+                ordType: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                side: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                symbol: {
+                    type: string;
+                };
+                timeInForce: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    marketDataRequest: {
+        description: string;
+        schema: {
+            type: string;
+            properties: {
+                mdUpdateType: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                symbols: {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                };
+                mdReqID: {
+                    type: string;
+                };
+                subscriptionRequestType: {
+                    type: string;
+                    enum: string[];
+                    description: string;
+                };
+                mdEntryTypes: {
+                    type: string;
+                    items: {
+                        type: string;
+                        enum: string[];
+                    };
+                    description: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    getStockGraph: {
+        description: string;
+        schema: {
+            type: string;
+            properties: {
+                symbol: {
+                    type: string;
+                };
+            };
+            required: string[];
+        };
+    };
+    getStockPriceHistory: {
+        description: string;
+        schema: {
+            type: string;
+            properties: {
+                symbol: {
+                    type: string;
+                };
+            };
+            required: string[];
+        };
+    };
+};

package/types/tools/index.d.ts

@@ -0,0 +1,17 @@
+import type { IFIXParser, Message } from 'fixparser';
+import type { ToolHandlers, VerifiedOrder } from '../schemas';
+export declare const createToolHandlers: (
+    parser: IFIXParser,
+    verifiedOrders: Map<string, VerifiedOrder>,
+    pendingRequests: Map<string, (data: Message) => void>,
+    marketDataPrices: Map<
+        string,
+        {
+            timestamp: number;
+            bid: number;
+            offer: number;
+            spread: number;
+            volume: number;
+        }[]
+    >,
+) => ToolHandlers;

package/types/tools/marketData.d.ts

@@ -0,0 +1,40 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { type IFIXParser, type Message } from 'fixparser';
+export declare const createMarketDataRequestHandler: (
+    parser: IFIXParser,
+    pendingRequests: Map<string, (data: Message) => void>,
+) => (args: {
+    mdUpdateType: string;
+    symbols: string[];
+    mdReqID: string;
+    subscriptionRequestType: string;
+    mdEntryTypes?: string[];
+}) => Promise<CallToolResult>;
+export declare const createGetStockGraphHandler: (
+    marketDataPrices: Map<
+        string,
+        Array<{
+            timestamp: number;
+            bid: number;
+            offer: number;
+            spread: number;
+            volume: number;
+        }>
+    >,
+) => (args: {
+    symbol: string;
+}) => Promise<CallToolResult>;
+export declare const createGetStockPriceHistoryHandler: (
+    marketDataPrices: Map<
+        string,
+        Array<{
+            timestamp: number;
+            bid: number;
+            offer: number;
+            spread: number;
+            volume: number;
+        }>
+    >,
+) => (args: {
+    symbol: string;
+}) => Promise<CallToolResult>;

package/types/tools/order.d.ts

@@ -0,0 +1,12 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { type IFIXParser, type Message } from 'fixparser';
+import type { VerifiedOrder } from '../schemas';
+export declare const createVerifyOrderHandler: (
+    parser: IFIXParser,
+    verifiedOrders: Map<string, VerifiedOrder>,
+) => (args: VerifiedOrder) => Promise<CallToolResult>;
+export declare const createExecuteOrderHandler: (
+    parser: IFIXParser,
+    verifiedOrders: Map<string, VerifiedOrder>,
+    pendingRequests: Map<string, (data: Message) => void>,
+) => (args: VerifiedOrder) => Promise<CallToolResult>;

package/types/tools/parse.d.ts

@@ -0,0 +1,5 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { IFIXParser } from 'fixparser';
+export declare const createParseHandler: (parser: IFIXParser) => (args: {
+    fixString: string;
+}) => Promise<CallToolResult>;

package/types/tools/parseToJSON.d.ts

@@ -0,0 +1,5 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { IFIXParser } from 'fixparser';
+export declare const createParseToJSONHandler: (parser: IFIXParser) => (args: {
+    fixString: string;
+}) => Promise<CallToolResult>;

package/types/utils/messageHandler.d.ts

@@ -0,0 +1,18 @@
+import { type IFIXParser, type Message } from 'fixparser';
+export type MarketDataEntry = {
+    timestamp: number;
+    bid: number;
+    offer: number;
+    spread: number;
+    volume: number;
+};
+export type MarketDataPrices = Map<string, MarketDataEntry[]>;
+export type PendingRequests = Map<string, (data: Message) => void>;
+export declare function handleMessage(
+    message: Message,
+    parser: IFIXParser,
+    pendingRequests: PendingRequests,
+    marketDataPrices: MarketDataPrices,
+    maxPriceHistory: number,
+    onPriceUpdate?: (symbol: string, data: MarketDataEntry) => void,
+): void;