openmm-mcp

Instructions

Implementation Reference

• src/tools/strategy.ts:166-201 (handler)

  Main handler implementation of stop_strategy tool - validates exchange/symbol, gets connector, cancels all open orders, and returns status with cancelled order count

  server.tool(
    'stop_strategy',
    'Cancel all open orders for a trading pair, effectively stopping any running grid strategy',
    {
      exchange: ExchangeParam,
      symbol: SymbolParam,
    },
    async ({ exchange, symbol }) => {
      const validExchange = validateExchange(exchange);
      const validSymbol = validateSymbol(symbol);
  
      const connector = await getConnectorSafe(exchange);
      const openOrders = await connector.getOpenOrders(validSymbol);
      const result = await connector.cancelAllOrders(validSymbol);
  
      return {
        content: [
          {
            type: 'text' as const,
            text: JSON.stringify(
              {
                status: 'stopped',
                cancelledOrders: openOrders.length,
                result,
                exchange: validExchange,
                symbol: validSymbol,
                timestamp: new Date().toISOString(),
              },
              null,
              2
            ),
          },
        ],
      };
    }
  );

• src/utils/validators.ts:3-7 (schema)

  Zod schema definitions for ExchangeParam and SymbolParam used as input validation for stop_strategy

  export const ExchangeParam = z
    .string()
    .describe('Exchange to query. Supported: mexc, gateio, bitget, kraken');
  
  export const SymbolParam = z.string().describe('Trading pair symbol (e.g., BTC/USDT, INDY/USDT)');

• src/worker.ts:27-37 (registration)

  Registration of stop_strategy in the server card capabilities list for discovery

  tools: [
    { name: 'get_ticker' },
    { name: 'get_orderbook' },
    { name: 'get_trades' },
    { name: 'get_balance' },
    { name: 'list_orders' },
    { name: 'create_order' },
    { name: 'cancel_order' },
    { name: 'cancel_all_orders' },
    { name: 'start_grid_strategy' },
    { name: 'stop_strategy' },

• src/tools/index.ts:8-14 (registration)

  Entry point that registers all tool groups including registerStrategyTools which contains stop_strategy

  export function registerTools(server: McpServer): void {
    registerMarketDataTools(server);
    registerAccountTools(server);
    registerTradingTools(server);
    registerCardanoTools(server);
    registerStrategyTools(server);
  }

• src/tools/strategy.ts:57-201 (helper)

  Helper function that registers all strategy-related tools (start_grid_strategy, stop_strategy, get_strategy_status) with the MCP server

  export function registerStrategyTools(server: McpServer): void {
    server.tool(
      'start_grid_strategy',
      'Calculate and optionally place grid trading orders around the current price',
      {
        exchange: ExchangeParam,
        symbol: SymbolParam,
        levels: z.number().min(1).max(10).default(5).describe('Grid levels per side (default: 5)'),
        spacing: z
          .number()
          .min(0.001)
          .max(0.5)
          .default(0.02)
          .describe('Base spacing as decimal (default: 0.02 = 2%)'),
        orderSize: z
          .number()
          .positive()
          .default(50)
          .describe('Base order size in quote currency (default: 50)'),
        spacingModel: z.enum(['linear', 'geometric']).default('linear').describe('Spacing model'),
        spacingFactor: z
          .number()
          .positive()
          .default(1.3)
          .describe('Factor for geometric spacing (default: 1.3)'),
        sizeModel: z.enum(['flat', 'pyramidal']).default('flat').describe('Size model'),
        dryRun: z
          .boolean()
          .default(true)
          .describe('Preview grid without placing orders (default: true)'),
      },
      async ({
        exchange,
        symbol,
        levels,
        spacing,
        orderSize,
        spacingModel,
        spacingFactor,
        sizeModel,
        dryRun,
      }) => {
        const validExchange = validateExchange(exchange);
        const validSymbol = validateSymbol(symbol);
  
        const connector = await getConnectorSafe(exchange);
        const ticker = await connector.getTicker(validSymbol);
        const centerPrice = ticker.last;
  
        const grid = calculateGridLevels(
          centerPrice,
          levels,
          spacing,
          spacingModel,
          spacingFactor,
          orderSize,
          sizeModel
        );
  
        const placedOrders: any[] = [];
        if (!dryRun) {
          for (const level of grid) {
            const order = await connector.createOrder(
              validSymbol,
              'limit',
              level.side,
              level.orderSize,
              level.price
            );
            placedOrders.push(order);
          }
        }
  
        return {
          content: [
            {
              type: 'text' as const,
              text: JSON.stringify(
                {
                  status: dryRun ? 'preview' : 'active',
                  centerPrice,
                  config: { levels, spacing, spacingModel, spacingFactor, orderSize, sizeModel },
                  grid: grid.map((l) => ({
                    side: l.side,
                    price: l.price,
                    amount: l.orderSize,
                    valueQuote: l.price * l.orderSize,
                  })),
                  totalOrders: grid.length,
                  totalBuyValue: grid
                    .filter((l) => l.side === 'buy')
                    .reduce((s, l) => s + l.price * l.orderSize, 0),
                  totalSellValue: grid
                    .filter((l) => l.side === 'sell')
                    .reduce((s, l) => s + l.price * l.orderSize, 0),
                  ...(dryRun ? {} : { placedOrders }),
                  exchange: validExchange,
                  symbol: validSymbol,
                  timestamp: new Date().toISOString(),
                },
                null,
                2
              ),
            },
          ],
        };
      }
    );
  
    server.tool(
      'stop_strategy',
      'Cancel all open orders for a trading pair, effectively stopping any running grid strategy',
      {
        exchange: ExchangeParam,
        symbol: SymbolParam,
      },
      async ({ exchange, symbol }) => {
        const validExchange = validateExchange(exchange);
        const validSymbol = validateSymbol(symbol);
  
        const connector = await getConnectorSafe(exchange);
        const openOrders = await connector.getOpenOrders(validSymbol);
        const result = await connector.cancelAllOrders(validSymbol);
  
        return {
          content: [
            {
              type: 'text' as const,
              text: JSON.stringify(
                {
                  status: 'stopped',
                  cancelledOrders: openOrders.length,
                  result,
                  exchange: validExchange,
                  symbol: validSymbol,
                  timestamp: new Date().toISOString(),
                },
                null,
                2
              ),
            },
          ],
        };
      }
    );