@nemesis-oss/binance-sdk 1.0.0

package/dist/tools/index.js

@@ -0,0 +1,1494 @@
+// src/tools/account.tools.ts
+import { z as z2 } from "zod";
+
+// src/tools/types.ts
+import { z } from "zod";
+function normalizeSymbol(value) {
+  return String(value ?? "").trim().toUpperCase();
+}
+function toJsonSchema(inputSchema) {
+  return z.toJSONSchema(inputSchema, { target: "json" });
+}
+function toOpenAITool(tool) {
+  return {
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: toJsonSchema(tool.inputSchema)
+    }
+  };
+}
+function toAnthropicTool(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    input_schema: toJsonSchema(tool.inputSchema)
+  };
+}
+function toMCPTool(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    inputSchema: toJsonSchema(tool.inputSchema)
+  };
+}
+function toToolList(tools, format) {
+  const adapter = format === "openai" ? toOpenAITool : format === "anthropic" ? toAnthropicTool : toMCPTool;
+  return tools.map(adapter);
+}
+function textResult(data) {
+  return JSON.stringify(data, null, 2);
+}
+
+// src/tools/account.tools.ts
+var optionalSymbol = z2.string().min(1).describe("USD-M pair, e.g. BTCUSDT").optional();
+var limit = z2.number().int().positive().max(1e3).default(100);
+var startTime = z2.number().int().positive().optional();
+var endTime = z2.number().int().positive().optional();
+function accountTools(client) {
+  const a = client.futures.account;
+  return [
+    {
+      name: "futures_balance",
+      description: "Get futures account balances (v3): asset, wallet balance, unrealized profit, margin balance, available balance (signed).",
+      inputSchema: z2.object({}),
+      handler: async () => textResult(await a.balanceV3())
+    },
+    {
+      name: "futures_account",
+      description: "Get full account information (v3): total wallet/margin balance, unrealized profit, available balance, assets & positions (signed).",
+      inputSchema: z2.object({}),
+      handler: async () => textResult(await a.accountV3())
+    },
+    {
+      name: "futures_balance_v2",
+      description: "Get futures account balance (v2 legacy) per asset (signed).",
+      inputSchema: z2.object({}),
+      handler: async () => textResult(await a.balance())
+    },
+    {
+      name: "futures_account_v2",
+      description: "Get futures account information (v2 legacy) (signed).",
+      inputSchema: z2.object({}),
+      handler: async () => textResult(await a.account())
+    },
+    {
+      name: "futures_position_risk",
+      description: "Get current open positions (v3): symbol, side, size, entry price, mark price, liquidation price, leverage, unrealized PnL, margin (signed).",
+      inputSchema: z2.object({ symbol: optionalSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await a.positionRiskV3(symbol3 ? normalizeSymbol(symbol3) : void 0))
+    },
+    {
+      name: "futures_income_history",
+      description: "Get futures income history (realized PnL, funding fees, commissions, transfers, insurance clearing). incomeType examples: TRANSFER, REALIZED_PNL, FUNDING_FEE, COMMISSION, INSURANCE_CLEAR, REFERRAL_KICKBACK (signed).",
+      inputSchema: z2.object({ symbol: optionalSymbol, incomeType: z2.string().optional().describe("e.g. TRANSFER, REALIZED_PNL, FUNDING_FEE, COMMISSION"), startTime, endTime, limit: limit.default(100) }),
+      handler: async ({ symbol: symbol3, incomeType, startTime: startTime5, endTime: endTime5, limit: limit4 }) => textResult(await a.incomeHistory({ symbol: symbol3 ? normalizeSymbol(symbol3) : void 0, incomeType, startTime: startTime5, endTime: endTime5, limit: Number(limit4) }))
+    },
+    {
+      name: "futures_user_trades",
+      description: "Get account trade list (filled trades) for a symbol with optional time range (signed).",
+      inputSchema: z2.object({ symbol: z2.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), startTime, endTime, limit: limit.default(100), fromId: z2.number().int().positive().optional() }),
+      handler: async ({ symbol: symbol3, startTime: startTime5, endTime: endTime5, limit: limit4, fromId }) => textResult(await a.userTrades({ symbol: normalizeSymbol(symbol3), startTime: startTime5, endTime: endTime5, limit: Number(limit4), fromId }))
+    },
+    {
+      name: "futures_leverage_brackets",
+      description: "Get notional and leverage brackets for one symbol or all: tier caps, maintenance margin rate, max leverage (signed).",
+      inputSchema: z2.object({ symbol: optionalSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await a.leverageBrackets(symbol3 ? normalizeSymbol(symbol3) : void 0))
+    },
+    {
+      name: "futures_commission_rate",
+      description: "Get user commission rate (taker & maker fee) for a symbol (signed).",
+      inputSchema: z2.object({ symbol: z2.string().min(1).describe("USD-M pair, e.g. ETHUSDT") }),
+      handler: async ({ symbol: symbol3 }) => textResult(await a.commissionRate(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "futures_multi_assets_mode",
+      description: "Get current multi-assets margin mode status (signed).",
+      inputSchema: z2.object({}),
+      handler: async () => textResult(await a.multiAssetsMargin())
+    },
+    {
+      name: "futures_set_multi_assets_mode",
+      description: "Enable or disable multi-assets mode (signed; 7-day cooldown between toggles).",
+      inputSchema: z2.object({ enabled: z2.boolean().describe("true to enable, false to disable") }),
+      handler: async ({ enabled }) => textResult(await a.setMultiAssetsMargin(enabled))
+    },
+    {
+      name: "futures_fee_burn_status",
+      description: "Get BNB fee burn status for futures trades (signed).",
+      inputSchema: z2.object({}),
+      handler: async () => textResult(await a.feeBurnStatus())
+    },
+    {
+      name: "futures_set_fee_burn",
+      description: "Toggle BNB fee burn on futures trades (signed).",
+      inputSchema: z2.object({ enabled: z2.boolean().describe("true to enable fee burn") }),
+      handler: async ({ enabled }) => textResult(await a.setFeeBurnStatus(enabled))
+    },
+    {
+      name: "futures_position_mode",
+      description: "Get current position mode: one-way (BOTH) or hedge mode (LONG/SHORT) (signed).",
+      inputSchema: z2.object({}),
+      handler: async () => textResult(await a.positionMode())
+    },
+    {
+      name: "futures_set_position_mode",
+      description: "Change position mode: hedgeMode true = dual side (hedge), false = one-way (signed; 30-day cooldown).",
+      inputSchema: z2.object({ hedgeMode: z2.boolean().describe("true = hedge mode, false = one-way") }),
+      handler: async ({ hedgeMode }) => textResult(await a.setPositionMode(hedgeMode))
+    },
+    {
+      name: "futures_api_trading_status",
+      description: "Get futures trading quantitative rules indicators and disable intervals (signed).",
+      inputSchema: z2.object({}),
+      handler: async () => textResult(await a.apiTradingStatus())
+    },
+    {
+      name: "futures_position_margin_history",
+      description: "Get isolated position margin change history. type: 1 = add margin, 2 = reduce margin (signed).",
+      inputSchema: z2.object({ symbol: z2.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), type: z2.enum(["1", "2"]).describe("1 = add margin, 2 = reduce margin"), startTime, endTime, limit: limit.default(50) }),
+      handler: async ({ symbol: symbol3, type, startTime: startTime5, endTime: endTime5, limit: limit4 }) => textResult(await a.positionMarginHistory({ symbol: normalizeSymbol(symbol3), type: Number(type), startTime: startTime5, endTime: endTime5, limit: Number(limit4) }))
+    },
+    {
+      name: "futures_rate_limit_order",
+      description: "Query the current user order rate limit usage (signed).",
+      inputSchema: z2.object({}),
+      handler: async () => textResult(await a.rateLimitOrder())
+    },
+    {
+      name: "futures_request_order_download",
+      description: "Request a futures order-history download (async, 7-day window). Returns a downloadId (signed).",
+      inputSchema: z2.object({ symbol: optionalSymbol, startTime, endTime }),
+      handler: async ({ symbol: symbol3, startTime: startTime5, endTime: endTime5 }) => textResult(await a.requestOrderDownload({ symbol: symbol3 ? normalizeSymbol(symbol3) : void 0, startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_order_download_status",
+      description: "Get the futures order-history download link by downloadId (signed).",
+      inputSchema: z2.object({ downloadId: z2.string().min(1) }),
+      handler: async ({ downloadId }) => textResult(await a.getOrderDownloadStatus(downloadId))
+    },
+    {
+      name: "futures_request_trade_download",
+      description: "Request a futures trade-history download (async, 7-day window). Returns a downloadId (signed).",
+      inputSchema: z2.object({ symbol: optionalSymbol, startTime, endTime }),
+      handler: async ({ symbol: symbol3, startTime: startTime5, endTime: endTime5 }) => textResult(await a.requestTradeDownload({ symbol: symbol3 ? normalizeSymbol(symbol3) : void 0, startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_trade_download_status",
+      description: "Get the futures trade-history download link by downloadId (signed).",
+      inputSchema: z2.object({ downloadId: z2.string().min(1) }),
+      handler: async ({ downloadId }) => textResult(await a.getTradeDownloadStatus(downloadId))
+    },
+    {
+      name: "futures_account_config",
+      description: "Get futures account configuration: fee tier, trading permissions, dual-side position setting (signed).",
+      inputSchema: z2.object({}),
+      handler: async () => textResult(await a.accountConfig())
+    },
+    {
+      name: "futures_portfolio_margin_account_info",
+      description: "Get Portfolio Margin account info for an asset: cross margin balance and liability (signed).",
+      inputSchema: z2.object({ asset: z2.string().min(1).describe("Asset, e.g. USDT") }),
+      handler: async ({ asset }) => textResult(await a.pmAccountInfo(asset))
+    },
+    {
+      name: "futures_request_income_download",
+      description: "Request a futures income/transaction-history download (async). Returns a downloadId (signed).",
+      inputSchema: z2.object({ startTime: startTime.unwrap(), endTime: endTime.unwrap() }),
+      handler: async ({ startTime: startTime5, endTime: endTime5 }) => textResult(await a.requestIncomeDownload({ startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_income_download_status",
+      description: "Get the futures income/transaction-history download link by downloadId (signed).",
+      inputSchema: z2.object({ downloadId: z2.string().min(1) }),
+      handler: async ({ downloadId }) => textResult(await a.getIncomeDownloadStatus(downloadId))
+    }
+  ];
+}
+
+// src/tools/derived.tools.ts
+import { z as z3 } from "zod";
+var symbol = z3.string().min(1).describe("USD-M pair, e.g. BTCUSDT");
+function derivedTools(client) {
+  const ops = client.futures.ops;
+  return [
+    {
+      name: "futures_symbol_rules",
+      description: "Get the tradeable rules for a symbol in one call: tick size, step size, min/max quantity, market-order lot bounds and minimum notional, flattened out of exchangeInfo filters. Call this before sizing or pricing any order.",
+      inputSchema: z3.object({ symbol, refresh: z3.boolean().default(false).describe("Bypass the 60s cache") }),
+      handler: async ({ symbol: s, refresh }) => textResult(await ops.symbolRules(normalizeSymbol(s), { refresh }))
+    },
+    {
+      name: "futures_quantize",
+      description: "Round a price to the symbol's tick size and a quantity to its step size, returning exchange-ready strings. Use this instead of rounding numbers yourself \u2014 Binance rejects off-tick prices (-1111).",
+      inputSchema: z3.object({
+        symbol,
+        price: z3.number().positive().optional(),
+        quantity: z3.number().positive().optional(),
+        marketOrder: z3.boolean().default(false).describe("Use MARKET_LOT_SIZE bounds instead of LOT_SIZE")
+      }),
+      handler: async ({ symbol: s, price, quantity, marketOrder }) => textResult(await ops.quantize(normalizeSymbol(s), { price, quantity, marketOrder }))
+    },
+    {
+      name: "futures_size_position",
+      description: "Convert a risk budget into an exchange-ready order quantity. Given a stop price and either riskAmount (quote currency) or riskPct (percent of available balance), returns the quantity rounded down to the symbol step size, plus the notional, required margin and every constraint that failed (min notional, lot bounds, wrong-side stop). Never increases risk to satisfy a minimum \u2014 it reports instead.",
+      inputSchema: z3.object({
+        symbol,
+        side: z3.enum(["BUY", "SELL"]),
+        stopPrice: z3.number().positive().describe("Protective stop price"),
+        entryPrice: z3.number().positive().optional().describe("Defaults to current mark price"),
+        riskAmount: z3.number().positive().optional().describe("Quote-currency amount to risk, e.g. 50 USDT"),
+        riskPct: z3.number().positive().max(100).optional().describe("Percent of available balance to risk (signed call)"),
+        leverage: z3.number().int().min(1).max(125).optional().describe("Used to report required margin"),
+        marketOrder: z3.boolean().default(false)
+      }),
+      handler: async (args) => textResult(await ops.sizePosition({ ...args, symbol: normalizeSymbol(args.symbol) }))
+    },
+    {
+      name: "futures_close_position",
+      description: "Flatten an open position with a reduce-only market order. Reads the current position, derives the closing side from its sign, and automatically uses reduceOnly in one-way mode vs positionSide in hedge mode (Binance rejects the wrong one). Set dryRun to preview the order without sending it. Signed, destructive.",
+      inputSchema: z3.object({
+        symbol,
+        positionSide: z3.enum(["BOTH", "LONG", "SHORT"]).optional().describe("Required when hedge mode has both sides open"),
+        portion: z3.number().positive().max(1).default(1).describe("Fraction of the position to close, e.g. 0.5 for half"),
+        dryRun: z3.boolean().default(false)
+      }),
+      handler: async (args) => textResult(await ops.closePosition({ ...args, symbol: normalizeSymbol(args.symbol) }))
+    },
+    {
+      name: "futures_market_snapshot",
+      description: "One-call market picture for a symbol: 24h stats, mark/index price with funding, open interest and long/short positioning. Replaces four separate primitive calls; individual feeds degrade to an error field rather than failing the whole snapshot.",
+      inputSchema: z3.object({
+        symbol,
+        period: z3.enum(["5m", "15m", "30m", "1h", "2h", "4h", "6h", "12h", "1d"]).default("1h")
+      }),
+      handler: async ({ symbol: s, period: period2 }) => textResult(await ops.marketSnapshot(normalizeSymbol(s), { period: period2 }))
+    },
+    {
+      name: "futures_account_overview",
+      description: "One-call account picture: funded balances, open positions only (zero-size entries filtered out), working orders, and totals for unrealized PnL and gross notional. Signed.",
+      inputSchema: z3.object({}),
+      handler: async () => textResult(await ops.accountOverview())
+    },
+    {
+      name: "futures_place_bracket_order",
+      description: "Place an entry order together with its protective stop-loss and optional take-profit, with all prices quantized to the symbol tick. Returns each leg separately; if a protective leg fails the response is flagged protectionComplete=false and the entry is NOT auto-cancelled (it may already have filled). Signed, destructive.",
+      inputSchema: z3.object({
+        symbol,
+        side: z3.enum(["BUY", "SELL"]),
+        quantity: z3.union([z3.string(), z3.number()]),
+        entryPrice: z3.number().positive().optional().describe("Omit for a MARKET entry"),
+        stopLossPrice: z3.number().positive(),
+        takeProfitPrice: z3.number().positive().optional(),
+        positionSide: z3.enum(["BOTH", "LONG", "SHORT"]).optional(),
+        workingType: z3.enum(["MARK_PRICE", "CONTRACT_PRICE"]).default("MARK_PRICE")
+      }),
+      handler: async (args) => textResult(await ops.placeBracketOrder({ ...args, symbol: normalizeSymbol(args.symbol) }))
+    }
+  ];
+}
+
+// src/tools/market-data.tools.ts
+import { z as z5 } from "zod";
+
+// src/types/market.types.ts
+import { z as z4 } from "zod";
+var KlineIntervalSchema = z4.enum([
+  "1m",
+  "3m",
+  "5m",
+  "15m",
+  "30m",
+  "1h",
+  "2h",
+  "4h",
+  "6h",
+  "8h",
+  "12h",
+  "1d",
+  "3d",
+  "1w",
+  "1M"
+]);
+var RawKlineSchema = z4.tuple([
+  z4.number(),
+  z4.string(),
+  z4.string(),
+  z4.string(),
+  z4.string(),
+  z4.string(),
+  z4.number(),
+  z4.string(),
+  z4.number(),
+  z4.string(),
+  z4.string(),
+  z4.string()
+]);
+var KlineSchema = RawKlineSchema.transform(
+  ([openTime, open, high, low, close, volume, closeTime, quoteAssetVolume, trades, takerBuyBaseVolume, takerBuyQuoteVolume]) => ({
+    openTime,
+    open: Number(open),
+    high: Number(high),
+    low: Number(low),
+    close: Number(close),
+    volume: Number(volume),
+    closeTime,
+    quoteAssetVolume: Number(quoteAssetVolume),
+    trades,
+    takerBuyBaseVolume: Number(takerBuyBaseVolume),
+    takerBuyQuoteVolume: Number(takerBuyQuoteVolume)
+  })
+);
+var KlinesResponseSchema = z4.array(KlineSchema);
+var TickerPriceSchema = z4.object({
+  symbol: z4.string(),
+  price: z4.string().transform(Number),
+  time: z4.number().optional()
+});
+var Ticker24hrSchema = z4.object({
+  symbol: z4.string(),
+  priceChange: z4.string().transform(Number),
+  priceChangePercent: z4.string().transform(Number),
+  weightedAvgPrice: z4.string().transform(Number),
+  lastPrice: z4.string().transform(Number),
+  lastQty: z4.string().transform(Number),
+  openPrice: z4.string().transform(Number),
+  highPrice: z4.string().transform(Number),
+  lowPrice: z4.string().transform(Number),
+  volume: z4.string().transform(Number),
+  quoteVolume: z4.string().transform(Number),
+  openTime: z4.number(),
+  closeTime: z4.number(),
+  firstId: z4.number(),
+  lastId: z4.number(),
+  count: z4.number()
+});
+var BookTickerSchema = z4.object({
+  symbol: z4.string(),
+  bidPrice: z4.string().transform(Number),
+  bidQty: z4.string().transform(Number),
+  askPrice: z4.string().transform(Number),
+  askQty: z4.string().transform(Number),
+  time: z4.number().optional()
+});
+var DepthLevelSchema = z4.tuple([z4.string(), z4.string()]).transform(([price, qty]) => ({ price: Number(price), qty: Number(qty) }));
+var DepthSnapshotSchema = z4.object({
+  lastUpdateId: z4.number(),
+  bids: z4.array(DepthLevelSchema),
+  asks: z4.array(DepthLevelSchema)
+});
+var TradeSchema = z4.object({
+  id: z4.number(),
+  price: z4.string().transform(Number),
+  qty: z4.string().transform(Number),
+  quoteQty: z4.string().transform(Number),
+  time: z4.number(),
+  isBuyerMaker: z4.boolean()
+});
+var TradesResponseSchema = z4.array(TradeSchema);
+var AggTradeSchema = z4.object({
+  a: z4.number(),
+  p: z4.string().transform(Number),
+  q: z4.string().transform(Number),
+  f: z4.number(),
+  l: z4.number(),
+  T: z4.number(),
+  m: z4.boolean()
+});
+var AggTradesResponseSchema = z4.array(AggTradeSchema);
+var AvgPriceSchema = z4.object({
+  mins: z4.number(),
+  price: z4.string().transform(Number)
+});
+var ExchangeSymbolSchema = z4.object({
+  symbol: z4.string(),
+  status: z4.string(),
+  baseAsset: z4.string(),
+  quoteAsset: z4.string()
+}).loose();
+var ExchangeInfoSchema = z4.object({
+  timezone: z4.string(),
+  serverTime: z4.number(),
+  symbols: z4.array(ExchangeSymbolSchema)
+}).loose();
+
+// src/tools/market-data.tools.ts
+var u = (s) => s.optional();
+var optSymbol = u(z5.string().min(1)).describe("USD-M pair, e.g. BTCUSDT");
+var limitDefault = z5.number().int().positive().max(1500).default(100);
+var startTime2 = z5.number().int().positive().optional();
+var endTime2 = z5.number().int().positive().optional();
+var period = z5.enum(["5m", "15m", "30m", "1h", "2h", "4h", "6h", "12h", "1d"]).default("1h");
+var contractType = z5.enum(["perpetual", "current_quarter", "next_quarter"]).default("perpetual");
+function marketDataTools(client) {
+  const m = client.futures.market;
+  const d = client.futures.data;
+  const tools = [
+    {
+      name: "futures_ping",
+      description: "Test connectivity to the Binance USD-M futures REST API. Returns empty object {} on success.",
+      inputSchema: z5.object({}),
+      handler: async () => textResult(await m.ping())
+    },
+    {
+      name: "futures_server_time",
+      description: "Get the current Binance USD-M futures server time in milliseconds since epoch.",
+      inputSchema: z5.object({}),
+      handler: async () => textResult(await m.serverTime())
+    },
+    {
+      name: "futures_exchange_info",
+      description: "Get exchange trading rules and symbol metadata: contract type, status, base/quote assets, price/quantity filters, tick size, step size, notional and leverage brackets, delivery dates.",
+      inputSchema: z5.object({}),
+      handler: async () => textResult(await m.exchangeInfo())
+    },
+    {
+      name: "futures_ticker_price",
+      description: "Get latest price for one symbol (v1).",
+      inputSchema: z5.object({ symbol: z5.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      handler: async ({ symbol: symbol3 }) => textResult(await m.tickerPrice(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "futures_ticker_price_v2",
+      description: "Get latest price for one symbol, or for all symbols when symbol is omitted (v2 endpoint). Use all-symbols mode for market overviews.",
+      inputSchema: z5.object({ symbol: optSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await m.tickerPriceV2(symbol3 ? normalizeSymbol(symbol3) : void 0))
+    },
+    {
+      name: "futures_ticker_24hr",
+      description: "Get 24-hour rolling price change statistics for a symbol: price change %, high, low, volume, quote volume, open interest.",
+      inputSchema: z5.object({ symbol: z5.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      handler: async ({ symbol: symbol3 }) => textResult(await m.ticker24hr(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "futures_book_ticker",
+      description: "Get best bid/ask (top of book) for a single symbol (v1).",
+      inputSchema: z5.object({ symbol: z5.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      handler: async ({ symbol: symbol3 }) => textResult(await m.bookTicker(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "futures_book_ticker_v2",
+      description: "Get best bid/ask (top of book) for one symbol, or all symbols when omitted (v2 endpoint).",
+      inputSchema: z5.object({ symbol: optSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await m.bookTickerV2(symbol3 ? normalizeSymbol(symbol3) : void 0))
+    },
+    {
+      name: "futures_order_book",
+      description: "Get order book depth for a symbol. Limits: 5, 10, 20, 50, 100, 500, 1000.",
+      inputSchema: z5.object({
+        symbol: z5.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+        limit: z5.enum(["5", "10", "20", "50", "100", "500", "1000"]).default("100")
+      }),
+      handler: async ({ symbol: symbol3, limit: limit4 }) => textResult(await m.depth(normalizeSymbol(symbol3), Number(limit4)))
+    },
+    {
+      name: "futures_recent_trades",
+      description: "Get the most recent executed trades for a symbol (public endpoint).",
+      inputSchema: z5.object({
+        symbol: z5.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+        limit: limitDefault.default(500)
+      }),
+      handler: async ({ symbol: symbol3, limit: limit4 }) => textResult(await m.trades(normalizeSymbol(symbol3), Number(limit4)))
+    },
+    {
+      name: "futures_historical_trades",
+      description: "Get older trades for a symbol by fromId (older than recent).",
+      inputSchema: z5.object({
+        symbol: z5.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+        limit: limitDefault.default(500),
+        fromId: z5.number().int().positive().optional()
+      }),
+      handler: async ({ symbol: symbol3, limit: limit4, fromId }) => textResult(await m.historicalTrades(normalizeSymbol(symbol3), { limit: Number(limit4), fromId }))
+    },
+    {
+      name: "futures_agg_trades",
+      description: "Get compressed/aggregate trades for a symbol within an optional time window. Each entry aggregates trades with the same price and side.",
+      inputSchema: z5.object({ symbol: z5.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), limit: limitDefault.default(500), startTime: startTime2, endTime: endTime2 }),
+      handler: async ({ symbol: symbol3, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await m.aggTrades(normalizeSymbol(symbol3), { limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_klines",
+      description: "Get candlestick (OHLCV) data for a symbol. Intervals: 1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,1M. Max 1500 per request.",
+      inputSchema: z5.object({ symbol: z5.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), interval: KlineIntervalSchema, limit: limitDefault.default(500), startTime: startTime2, endTime: endTime2 }),
+      handler: async ({ symbol: symbol3, interval, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await m.klines(normalizeSymbol(symbol3), interval, { limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_continuous_klines",
+      description: "Get klines for a continuous contract (perpetual, current_quarter, next_quarter) identified by base pair (e.g. BTCUSDT).",
+      inputSchema: z5.object({
+        symbol: z5.string().min(1).describe("Base pair, e.g. BTCUSDT"),
+        contractType,
+        interval: KlineIntervalSchema,
+        limit: limitDefault.default(500),
+        startTime: startTime2,
+        endTime: endTime2
+      }),
+      handler: async ({ symbol: symbol3, contractType: contractType2, interval, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await m.continuousKlines(normalizeSymbol(symbol3), contractType2, interval, { limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_index_price_klines",
+      description: "Get index price candlesticks for a pair (e.g. BTCUSDT index).",
+      inputSchema: z5.object({ symbol: z5.string().min(1).describe("Base pair, e.g. BTCUSDT"), interval: KlineIntervalSchema, limit: limitDefault.default(500), startTime: startTime2, endTime: endTime2 }),
+      handler: async ({ symbol: symbol3, interval, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await m.indexPriceKlines(normalizeSymbol(symbol3), interval, { limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_mark_price_klines",
+      description: "Get mark price candlesticks for a symbol.",
+      inputSchema: z5.object({ symbol: z5.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), interval: KlineIntervalSchema, limit: limitDefault.default(500), startTime: startTime2, endTime: endTime2 }),
+      handler: async ({ symbol: symbol3, interval, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await m.markPriceKlines(normalizeSymbol(symbol3), interval, { limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_trading_day_ticker",
+      description: "Get the trading-day ticker (v1: rolling window stats by symbol, including open, close, high, low, volume, closeTime).",
+      inputSchema: z5.object({ symbol: z5.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      handler: async ({ symbol: symbol3 }) => textResult(await m.tradingDayTicker(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "futures_mark_price",
+      description: "Get mark price, index price, estimated settle price, last funding rate, next funding time and interest rate for a symbol.",
+      inputSchema: z5.object({ symbol: z5.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      handler: async ({ symbol: symbol3 }) => textResult(await d.premiumIndex(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "futures_funding_rate_history",
+      description: "Get historical funding rates for a symbol.",
+      inputSchema: z5.object({ symbol: z5.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), limit: limitDefault.default(100), startTime: startTime2, endTime: endTime2 }),
+      handler: async ({ symbol: symbol3, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await d.fundingRateHistory(normalizeSymbol(symbol3), { limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_funding_info",
+      description: "Get funding rate configuration for all symbols with adjusted funding cap/floor or interval (e.g. under extreme volatility).",
+      inputSchema: z5.object({}),
+      handler: async () => textResult(await d.fundingInfo())
+    },
+    {
+      name: "futures_open_interest",
+      description: "Get the current total open interest for a symbol.",
+      inputSchema: z5.object({ symbol: z5.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      handler: async ({ symbol: symbol3 }) => textResult(await d.openInterest(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "futures_open_interest_hist",
+      description: "Get historical open interest statistics per period.",
+      inputSchema: z5.object({ symbol: z5.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), period, limit: limitDefault.default(30) }),
+      handler: async ({ symbol: symbol3, period: period2, limit: limit4 }) => textResult(await d.openInterestHist(normalizeSymbol(symbol3), period2, Number(limit4)))
+    },
+    {
+      name: "futures_top_long_short_account_ratio",
+      description: "Get top trader long/short account ratio (number of accounts) for a symbol.",
+      inputSchema: z5.object({ symbol: z5.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), period, limit: limitDefault.default(30) }),
+      handler: async ({ symbol: symbol3, period: period2, limit: limit4 }) => textResult(await d.topLongShortAccountRatio(normalizeSymbol(symbol3), period2, Number(limit4)))
+    },
+    {
+      name: "futures_top_long_short_position_ratio",
+      description: "Get top trader long/short position ratio (accounts with net positions) for a symbol.",
+      inputSchema: z5.object({ symbol: z5.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), period, limit: limitDefault.default(30) }),
+      handler: async ({ symbol: symbol3, period: period2, limit: limit4 }) => textResult(await d.topLongShortPositionRatio(normalizeSymbol(symbol3), period2, Number(limit4)))
+    },
+    {
+      name: "futures_global_long_short_ratio",
+      description: "Get global long/short account ratio for a symbol (all accounts).",
+      inputSchema: z5.object({ symbol: z5.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), period, limit: limitDefault.default(30) }),
+      handler: async ({ symbol: symbol3, period: period2, limit: limit4 }) => textResult(await d.globalLongShortAccountRatio(normalizeSymbol(symbol3), period2, Number(limit4)))
+    },
+    {
+      name: "futures_taker_long_short_ratio",
+      description: "Get taker buy/sell volume ratio for a symbol.",
+      inputSchema: z5.object({ symbol: z5.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), period, limit: limitDefault.default(30) }),
+      handler: async ({ symbol: symbol3, period: period2, limit: limit4 }) => textResult(await d.takerLongShortRatio(normalizeSymbol(symbol3), period2, Number(limit4)))
+    },
+    {
+      name: "futures_basis",
+      description: "Get basis data (spot-futures spread, mark price - index price) for a pair and contract type.",
+      inputSchema: z5.object({
+        symbol: z5.string().min(1).describe("Base pair, e.g. BTCUSDT"),
+        period,
+        limit: limitDefault.default(30),
+        startTime: startTime2,
+        endTime: endTime2
+      }),
+      handler: async ({ symbol: symbol3, period: period2, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await d.basis(normalizeSymbol(symbol3), period2, { limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_asset_index",
+      description: "Get multi-assets mode asset index (collateral price) for one asset or all assets.",
+      inputSchema: z5.object({ symbol: optSymbol.describe("Asset index symbol, e.g. ADAUSD") }),
+      handler: async ({ symbol: symbol3 }) => textResult(await d.assetIndex(symbol3 ? normalizeSymbol(symbol3) : void 0))
+    },
+    {
+      name: "futures_composite_index_info",
+      description: "Get composite index symbol information (e.g. DEFIUSDT) with constituent weights.",
+      inputSchema: z5.object({ symbol: optSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await d.compositeIndexInfo(symbol3 ? normalizeSymbol(symbol3) : void 0))
+    },
+    {
+      name: "futures_insurance_balance",
+      description: "Get insurance fund balance snapshots for a symbol.",
+      inputSchema: z5.object({ symbol: z5.string().min(1).describe("USD-M pair, e.g. BNBUSDT"), limit: limitDefault.default(100), startTime: startTime2, endTime: endTime2 }),
+      handler: async ({ symbol: symbol3, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await d.insuranceFundBalance({ symbol: normalizeSymbol(symbol3), limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_index_price_constituents",
+      description: "Get the index price constituents (exchange weights) for a symbol.",
+      inputSchema: z5.object({ symbol: z5.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      handler: async ({ symbol: symbol3 }) => textResult(await d.indexPriceConstituents(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "futures_premium_index_klines",
+      description: "Get premium index candlesticks for a symbol (mark price premium over index price).",
+      inputSchema: z5.object({ symbol: z5.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), interval: KlineIntervalSchema, limit: limitDefault.default(500), startTime: startTime2, endTime: endTime2 }),
+      handler: async ({ symbol: symbol3, interval, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await m.premiumIndexKlines(normalizeSymbol(symbol3), interval, { limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_rpi_depth",
+      description: "Get the RPI (Retail Price Improvement) order book depth for a symbol.",
+      inputSchema: z5.object({ symbol: z5.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), limit: z5.number().int().positive().default(1e3) }),
+      handler: async ({ symbol: symbol3, limit: limit4 }) => textResult(await m.rpiDepth(normalizeSymbol(symbol3), Number(limit4)))
+    },
+    {
+      name: "futures_delivery_price",
+      description: "Get historical quarterly contract settlement/delivery prices for a pair.",
+      inputSchema: z5.object({ symbol: z5.string().min(1).describe("Base pair, e.g. BTCUSDT") }),
+      handler: async ({ symbol: symbol3 }) => textResult(await d.deliveryPrice(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "futures_symbol_adl_risk",
+      description: "Get the auto-deleveraging (ADL) risk level for one symbol or all symbols on the account (signed).",
+      inputSchema: z5.object({ symbol: optSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await d.symbolAdlRisk(symbol3 ? normalizeSymbol(symbol3) : void 0))
+    },
+    {
+      name: "futures_adl_quantile",
+      description: "Get the position ADL (auto-deleveraging) quantile estimation for one symbol or all symbols (signed).",
+      inputSchema: z5.object({ symbol: optSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await d.adlQuantile(symbol3 ? normalizeSymbol(symbol3) : void 0))
+    },
+    {
+      name: "futures_force_orders",
+      description: "Get the user's force-liquidation orders (LIQUIDATION) and ADL orders for a symbol or all symbols (signed).",
+      inputSchema: z5.object({
+        symbol: optSymbol,
+        autoCloseType: z5.enum(["LIQUIDATION", "ADL"]).optional(),
+        startTime: startTime2,
+        endTime: endTime2,
+        limit: limitDefault.default(50)
+      }),
+      handler: async ({ symbol: symbol3, autoCloseType, startTime: startTime5, endTime: endTime5, limit: limit4 }) => textResult(
+        await d.forceOrders({
+          symbol: symbol3 ? normalizeSymbol(symbol3) : void 0,
+          autoCloseType,
+          startTime: startTime5,
+          endTime: endTime5,
+          limit: Number(limit4)
+        })
+      )
+    }
+  ];
+  return tools;
+}
+
+// src/tools/paper.tools.ts
+import { z as z6 } from "zod";
+function createPaperContext(client, initialState = {}) {
+  return {
+    client,
+    state: { balance: initialState.balance ?? 1e4, positions: initialState.positions ?? [], history: initialState.history ?? [] }
+  };
+}
+function pnl(position, price) {
+  const direction = position.side === "LONG" ? 1 : -1;
+  return (price - position.entryPrice) * position.quantity * direction;
+}
+function paperTools(ctx) {
+  const s = ctx.state;
+  const t = ctx.client.futures.market;
+  return [
+    {
+      name: "paper_init",
+      description: "Initialize paper-trading state (reset balances, positions, history). No API keys required.",
+      inputSchema: z6.object({ balance: z6.number().positive().default(1e4).describe("Starting USDT balance") }),
+      handler: async ({ balance }) => {
+        s.balance = balance;
+        s.positions = [];
+        s.history = [];
+        return textResult(s);
+      }
+    },
+    {
+      name: "paper_balance",
+      description: "Get current paper-trading balance and open-position equity (uses live market prices if an open position exists). No API keys required.",
+      inputSchema: z6.object({}),
+      handler: async () => textResult(s)
+    },
+    {
+      name: "paper_open_position",
+      description: "Open an in-memory paper position at the live ticker price (or a fixed price). No API keys required.",
+      inputSchema: z6.object({
+        symbol: z6.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+        side: z6.enum(["LONG", "SHORT"]),
+        quantity: z6.number().positive(),
+        price: z6.number().positive().optional().describe("If omitted, uses live ticker price")
+      }),
+      handler: async ({ symbol: symbol3, side: side3, quantity, price }) => {
+        const sym = normalizeSymbol(symbol3);
+        const market = price ?? Number((await t.tickerPrice(sym)).price);
+        const position = { id: Date.now().toString(), symbol: sym, side: side3, quantity, entryPrice: market, openedAt: (/* @__PURE__ */ new Date()).toISOString() };
+        s.positions.push(position);
+        s.history.push({ type: "open", ...position });
+        return textResult(position);
+      }
+    },
+    {
+      name: "paper_close_position",
+      description: "Close a paper position by id (or symbol) and realize PnL at the live/last price.",
+      inputSchema: z6.object({
+        id: z6.string().optional().describe("Position id from paper_open_position"),
+        symbol: z6.string().min(1).optional().describe("Close the position for this symbol"),
+        price: z6.number().positive().optional().describe("If omitted, uses live ticker price")
+      }),
+      handler: async ({ id, symbol: symbol3, price }) => {
+        const idx = s.positions.findIndex((p) => id ? p.id === id : normalizeSymbol(p.symbol) === normalizeSymbol(symbol3 ?? ""));
+        if (idx === -1) throw new Error("paper position not found");
+        const position = s.positions[idx];
+        const market = price ?? Number((await t.tickerPrice(position.symbol)).price);
+        const realizedPnl = pnl(position, market);
+        s.balance += realizedPnl;
+        const closed = { type: "close", ...position, exitPrice: market, realizedPnl, closedAt: (/* @__PURE__ */ new Date()).toISOString() };
+        s.positions.splice(idx, 1);
+        s.history.push(closed);
+        return textResult(closed);
+      }
+    },
+    {
+      name: "paper_positions",
+      description: "List open paper positions with live unrealized PnL (marked to market).",
+      inputSchema: z6.object({}),
+      handler: async () => {
+        const out = await Promise.all(
+          s.positions.map(async (p) => {
+            const price = Number((await t.tickerPrice(p.symbol)).price);
+            return { ...p, markPrice: price, unrealizedPnl: pnl(p, price) };
+          })
+        );
+        return textResult(out);
+      }
+    },
+    {
+      name: "paper_history",
+      description: "List paper-trading history of open/close events with realized PnL.",
+      inputSchema: z6.object({}),
+      handler: async () => textResult(s.history)
+    },
+    {
+      name: "paper_summary",
+      description: "Summarize paper-trading state: balance, open positions, trade count.",
+      inputSchema: z6.object({}),
+      handler: async () => textResult({ balance: s.balance, openPositions: s.positions.length, trades: s.history.length })
+    }
+  ];
+}
+
+// src/tools/spot.tools.ts
+import { z as z7 } from "zod";
+var spotSymbol = z7.string().min(1).describe("Spot pair, e.g. BTCUSDT");
+var optionalSymbol2 = z7.string().min(1).describe("Spot pair, e.g. BTCUSDT").optional();
+var limit2 = z7.number().int().positive().max(1e3).default(100);
+var startTime3 = z7.number().int().positive().optional();
+var endTime3 = z7.number().int().positive().optional();
+var side = z7.enum(["BUY", "SELL"]);
+var spotOrderParamsSchema = z7.object({
+  symbol: spotSymbol,
+  side,
+  type: z7.enum(["LIMIT", "MARKET", "LIMIT_MAKER", "STOP_LOSS", "STOP_LOSS_LIMIT", "TAKE_PROFIT", "TAKE_PROFIT_LIMIT"]),
+  quantity: z7.union([z7.string(), z7.number()]).optional().describe("Base-asset quantity; omit if using quoteOrderQty"),
+  quoteOrderQty: z7.union([z7.string(), z7.number()]).optional().describe("Quote-asset quantity (e.g. spend 100 USDT on a MARKET order)"),
+  price: z7.union([z7.string(), z7.number()]).optional().describe("Required for LIMIT / STOP_LOSS_LIMIT / TAKE_PROFIT_LIMIT"),
+  stopPrice: z7.union([z7.string(), z7.number()]).optional().describe("Trigger price for STOP_LOSS / TAKE_PROFIT variants"),
+  timeInForce: z7.enum(["GTC", "IOC", "FOK"]).optional().describe("Required for LIMIT"),
+  newClientOrderId: z7.string().optional(),
+  newOrderRespType: z7.enum(["ACK", "RESULT", "FULL"]).optional(),
+  icebergQty: z7.union([z7.string(), z7.number()]).optional(),
+  selfTradePreventionMode: z7.enum(["NONE", "EXPIRE_TAKER", "EXPIRE_MAKER", "EXPIRE_BOTH"]).optional()
+});
+function spotTools(client) {
+  const m = client.spot.market;
+  const a = client.spot.account;
+  const t = client.spot.trading;
+  const tools = [
+    // ---- Market data (public) ----
+    {
+      name: "spot_ping",
+      description: "Test connectivity to the Binance Spot REST API.",
+      inputSchema: z7.object({}),
+      handler: async () => textResult(await m.ping())
+    },
+    {
+      name: "spot_server_time",
+      description: "Get the current Binance Spot server time in ms since epoch.",
+      inputSchema: z7.object({}),
+      handler: async () => textResult(await m.serverTime())
+    },
+    {
+      name: "spot_exchange_info",
+      description: "Get Spot exchange trading rules and symbol metadata (status, base/quote assets, filters, permissions).",
+      inputSchema: z7.object({}),
+      handler: async () => textResult(await m.exchangeInfo())
+    },
+    {
+      name: "spot_ticker_price",
+      description: "Get the latest price for a Spot symbol.",
+      inputSchema: z7.object({ symbol: spotSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await m.tickerPrice(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "spot_ticker_24hr",
+      description: "Get 24-hour rolling price change statistics for a Spot symbol.",
+      inputSchema: z7.object({ symbol: spotSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await m.ticker24hr(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "spot_book_ticker",
+      description: "Get the best bid/ask (top of book) for a Spot symbol.",
+      inputSchema: z7.object({ symbol: spotSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await m.bookTicker(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "spot_order_book",
+      description: "Get the Spot order book depth for a symbol (limits 5/10/20/50/100/500/1000/5000).",
+      inputSchema: z7.object({
+        symbol: spotSymbol,
+        limit: z7.enum(["5", "10", "20", "50", "100", "500", "1000", "5000"]).default("100")
+      }),
+      handler: async ({ symbol: symbol3, limit: limit4 }) => textResult(await m.depth(normalizeSymbol(symbol3), Number(limit4)))
+    },
+    {
+      name: "spot_recent_trades",
+      description: "Get the most recent executed trades for a Spot symbol.",
+      inputSchema: z7.object({ symbol: spotSymbol, limit: limit2.default(500) }),
+      handler: async ({ symbol: symbol3, limit: limit4 }) => textResult(await m.trades(normalizeSymbol(symbol3), Number(limit4)))
+    },
+    {
+      name: "spot_historical_trades",
+      description: "Get older Spot trades for a symbol by fromId.",
+      inputSchema: z7.object({ symbol: spotSymbol, limit: limit2.default(500), fromId: z7.number().int().positive().optional() }),
+      handler: async ({ symbol: symbol3, limit: limit4, fromId }) => textResult(await m.historicalTrades(normalizeSymbol(symbol3), { limit: Number(limit4), fromId }))
+    },
+    {
+      name: "spot_agg_trades",
+      description: "Get compressed/aggregate Spot trades for a symbol within an optional time window.",
+      inputSchema: z7.object({ symbol: spotSymbol, limit: limit2.default(500), startTime: startTime3, endTime: endTime3 }),
+      handler: async ({ symbol: symbol3, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await m.aggTrades(normalizeSymbol(symbol3), { limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "spot_klines",
+      description: "Get Spot candlesticks (OHLCV). Intervals 1m\u20261M; max 1000 per request.",
+      inputSchema: z7.object({ symbol: spotSymbol, interval: KlineIntervalSchema, limit: limit2.default(500), startTime: startTime3, endTime: endTime3 }),
+      handler: async ({ symbol: symbol3, interval, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await m.klines(normalizeSymbol(symbol3), interval, { limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "spot_ui_klines",
+      description: "Get Spot candlesticks via the optimized uiKlines endpoint (same shape as spot_klines).",
+      inputSchema: z7.object({ symbol: spotSymbol, interval: KlineIntervalSchema, limit: limit2.default(500), startTime: startTime3, endTime: endTime3 }),
+      handler: async ({ symbol: symbol3, interval, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await m.uiKlines(normalizeSymbol(symbol3), interval, { limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "spot_avg_price",
+      description: "Get the current average price (5-minute rolling average) for a Spot symbol.",
+      inputSchema: z7.object({ symbol: spotSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await m.avgPrice(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "spot_rolling_window_ticker",
+      description: "Get rolling-window price change statistics (1d/7d/30d). Omit symbol for all symbols.",
+      inputSchema: z7.object({
+        symbol: optionalSymbol2,
+        windowSize: z7.enum(["1d", "7d", "30d"]).optional()
+      }),
+      handler: async ({ symbol: symbol3, windowSize }) => textResult(await m.rollingWindowTicker(symbol3 ? normalizeSymbol(symbol3) : void 0, windowSize))
+    },
+    {
+      name: "spot_trading_day_ticker",
+      description: "Get the Spot trading-day ticker (open/close/high/low/volume by UTC day). Omit symbol for all symbols.",
+      inputSchema: z7.object({ symbol: optionalSymbol2, timeZone: z7.string().optional(), type: z7.enum(["FULL", "MINI"]).optional() }),
+      handler: async ({ symbol: symbol3, timeZone, type }) => textResult(await m.tradingDayTicker(symbol3 ? normalizeSymbol(symbol3) : void 0, { timeZone, type }))
+    },
+    // ---- Account (signed) ----
+    {
+      name: "spot_account",
+      description: "Get the Spot account: balances (free/locked), commissions, permissions (signed).",
+      inputSchema: z7.object({}),
+      handler: async () => textResult(await a.account())
+    },
+    {
+      name: "spot_my_trades",
+      description: "Get the Spot account trade list (filled trades) for a symbol with optional time range (signed).",
+      inputSchema: z7.object({ symbol: spotSymbol, orderId: z7.number().int().positive().optional(), startTime: startTime3, endTime: endTime3, fromId: z7.number().int().positive().optional(), limit: limit2.default(500) }),
+      handler: async ({ symbol: symbol3, orderId, startTime: startTime5, endTime: endTime5, fromId, limit: limit4 }) => textResult(await a.myTrades(normalizeSymbol(symbol3), { orderId, startTime: startTime5, endTime: endTime5, fromId, limit: Number(limit4) }))
+    },
+    {
+      name: "spot_my_prevented_matches",
+      description: "Get Spot orders that were expired by the self-trade-prevention (STP) mechanism (signed).",
+      inputSchema: z7.object({ symbol: spotSymbol, preventedMatchId: z7.number().int().positive().optional(), orderId: z7.number().int().positive().optional(), limit: limit2.default(500) }),
+      handler: async ({ symbol: symbol3, preventedMatchId, orderId, limit: limit4 }) => textResult(await a.myPreventedMatches(normalizeSymbol(symbol3), { preventedMatchId, orderId, limit: Number(limit4) }))
+    },
+    {
+      name: "spot_account_commission",
+      description: "Get the Spot account commission rates for a symbol (signed).",
+      inputSchema: z7.object({ symbol: spotSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await a.accountCommission(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "spot_rate_limit_order",
+      description: "Query the current Spot order rate limit usage (signed).",
+      inputSchema: z7.object({}),
+      handler: async () => textResult(await a.rateLimitOrder())
+    },
+    // ---- Trading (signed) ----
+    {
+      name: "spot_new_order",
+      description: "Place a new Spot order. Types: LIMIT, MARKET, LIMIT_MAKER, STOP_LOSS, STOP_LOSS_LIMIT, TAKE_PROFIT, TAKE_PROFIT_LIMIT. For MARKET orders use quantity OR quoteOrderQty. Signed.",
+      inputSchema: spotOrderParamsSchema,
+      handler: async (args) => textResult(await t.createOrder({ ...args, symbol: normalizeSymbol(args.symbol) }))
+    },
+    {
+      name: "spot_test_order",
+      description: "Validate a Spot order without submitting it. Signed.",
+      inputSchema: spotOrderParamsSchema,
+      handler: async (args) => textResult(await t.testOrder({ ...args, symbol: normalizeSymbol(args.symbol) }))
+    },
+    {
+      name: "spot_get_order",
+      description: "Query a specific Spot order by orderId or client order id. Signed.",
+      inputSchema: z7.object({ symbol: spotSymbol, orderId: z7.number().int().positive().optional(), origClientOrderId: z7.string().optional() }),
+      handler: async ({ symbol: symbol3, orderId, origClientOrderId }) => textResult(await t.getOrder(normalizeSymbol(symbol3), { orderId, origClientOrderId }))
+    },
+    {
+      name: "spot_cancel_order",
+      description: "Cancel a specific open Spot order by orderId or client order id. Signed.",
+      inputSchema: z7.object({ symbol: spotSymbol, orderId: z7.number().int().positive().optional(), origClientOrderId: z7.string().optional(), newClientOrderId: z7.string().optional() }),
+      handler: async ({ symbol: symbol3, orderId, origClientOrderId, newClientOrderId }) => textResult(await t.cancelOrder(normalizeSymbol(symbol3), { orderId, origClientOrderId, newClientOrderId }))
+    },
+    {
+      name: "spot_open_orders",
+      description: "Get all current open Spot orders, for one symbol or all symbols. Signed.",
+      inputSchema: z7.object({ symbol: optionalSymbol2 }),
+      handler: async ({ symbol: symbol3 }) => textResult(await t.getOpenOrders(symbol3 ? normalizeSymbol(symbol3) : void 0))
+    },
+    {
+      name: "spot_all_orders",
+      description: "Get historical Spot orders for a symbol with optional time range. Signed.",
+      inputSchema: z7.object({ symbol: spotSymbol, orderId: z7.number().int().positive().optional(), startTime: startTime3, endTime: endTime3, limit: limit2 }),
+      handler: async ({ symbol: symbol3, orderId, startTime: startTime5, endTime: endTime5, limit: limit4 }) => textResult(await t.getAllOrders(normalizeSymbol(symbol3), { orderId, startTime: startTime5, endTime: endTime5, limit: limit4 }))
+    },
+    {
+      name: "spot_cancel_open_orders",
+      description: "Cancel all open Spot orders for a symbol. Signed.",
+      inputSchema: z7.object({ symbol: spotSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await t.cancelOpenOrders(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "spot_cancel_replace_order",
+      description: "Cancel an existing Spot order and place a new one on the same symbol (cancel-replace). Signed.",
+      inputSchema: z7.object({
+        symbol: spotSymbol,
+        side,
+        type: z7.enum(["LIMIT", "MARKET", "STOP_LOSS", "STOP_LOSS_LIMIT", "TAKE_PROFIT", "TAKE_PROFIT_LIMIT"]),
+        cancelReplaceMode: z7.enum(["STOP_ON_FAILURE", "ALLOW_FAILURE"]).default("STOP_ON_FAILURE"),
+        cancelOrderId: z7.number().int().positive().optional(),
+        cancelOrigClientOrderId: z7.string().optional(),
+        cancelNewClientOrderId: z7.string().optional(),
+        quantity: z7.union([z7.string(), z7.number()]).optional(),
+        price: z7.union([z7.string(), z7.number()]).optional(),
+        timeInForce: z7.enum(["GTC", "IOC", "FOK"]).optional(),
+        newClientOrderId: z7.string().optional()
+      }),
+      handler: async (args) => textResult(await t.cancelReplaceOrder({ ...args, symbol: normalizeSymbol(args.symbol) }))
+    },
+    {
+      name: "spot_new_oco_order",
+      description: "Place a new Spot OCO (one-cancels-other) order: a stop-loss limit + a limit-maker take-profit. Signed.",
+      inputSchema: z7.object({
+        symbol: spotSymbol,
+        side,
+        quantity: z7.union([z7.string(), z7.number()]).describe("Total base-asset quantity for both legs"),
+        price: z7.union([z7.string(), z7.number()]).describe("Limit (take-profit) price"),
+        stopPrice: z7.union([z7.string(), z7.number()]).describe("Stop-loss trigger price"),
+        stopLimitPrice: z7.union([z7.string(), z7.number()]).optional().describe("Stop-loss limit price (defaults to stopPrice)"),
+        stopLimitTimeInForce: z7.enum(["GTC", "IOC", "FOK"]).optional(),
+        listClientOrderId: z7.string().optional(),
+        limitClientOrderId: z7.string().optional(),
+        stopClientOrderId: z7.string().optional()
+      }),
+      handler: async (args) => textResult(await t.createOCOOrder({ ...args, symbol: normalizeSymbol(args.symbol) }))
+    },
+    {
+      name: "spot_cancel_oco_order",
+      description: "Cancel an entire Spot OCO order list by orderListId or listClientOrderId. Signed.",
+      inputSchema: z7.object({ symbol: spotSymbol, orderListId: z7.number().int().positive().optional(), listClientOrderId: z7.string().optional(), newClientOrderId: z7.string().optional() }),
+      handler: async ({ symbol: symbol3, orderListId, listClientOrderId, newClientOrderId }) => textResult(await t.cancelOCOOrder(normalizeSymbol(symbol3), { orderListId, listClientOrderId, newClientOrderId }))
+    },
+    {
+      name: "spot_get_oco_order",
+      description: "Query a Spot OCO order list by orderListId or listClientOrderId. Signed.",
+      inputSchema: z7.object({ symbol: spotSymbol, orderListId: z7.number().int().positive().optional(), origClientOrderId: z7.string().optional() }),
+      handler: async ({ symbol: symbol3, orderListId, origClientOrderId }) => textResult(await t.getOCOOrder(normalizeSymbol(symbol3), { orderListId, origClientOrderId }))
+    },
+    {
+      name: "spot_open_oco_orders",
+      description: "Get all current open Spot OCO order lists. Signed.",
+      inputSchema: z7.object({}),
+      handler: async () => textResult(await t.getOpenOCOOrders())
+    },
+    {
+      name: "spot_all_oco_orders",
+      description: "Get historical Spot OCO order lists for a symbol with optional time range. Signed.",
+      inputSchema: z7.object({ symbol: spotSymbol, fromId: z7.number().int().positive().optional(), startTime: startTime3, endTime: endTime3, limit: limit2 }),
+      handler: async ({ symbol: symbol3, fromId, startTime: startTime5, endTime: endTime5, limit: limit4 }) => textResult(await t.getAllOCOOrders(normalizeSymbol(symbol3), { fromId, startTime: startTime5, endTime: endTime5, limit: limit4 }))
+    },
+    {
+      name: "spot_cancel_open_oco_orders",
+      description: "Cancel all open Spot OCO order lists for a symbol. Signed.",
+      inputSchema: z7.object({ symbol: spotSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await t.cancelOpenOCOOrders(normalizeSymbol(symbol3)))
+    },
+    // ---- User data stream (signed) ----
+    {
+      name: "spot_ws_start_user_stream",
+      description: "Start the Spot user data stream: creates a listenKey, connects the private WebSocket, and begins keep-alive. Emits executionReport, outboundAccountPosition, balanceUpdate, listStatus.",
+      inputSchema: z7.object({}),
+      handler: async () => textResult({ listenKey: await client.startSpotUserStream() })
+    },
+    {
+      name: "spot_ws_stop_user_stream",
+      description: "Stop the Spot user data stream: closes the private WebSocket and invalidates the listenKey.",
+      inputSchema: z7.object({}),
+      handler: async () => {
+        client.closeSpotUserStream();
+        return textResult({ stopped: true });
+      }
+    }
+  ];
+  return tools;
+}
+
+// src/tools/trading.tools.ts
+import { z as z8 } from "zod";
+var symbol2 = z8.string().min(1).describe("USD-M pair, e.g. BTCUSDT");
+var optionalSymbol3 = z8.string().min(1).describe("USD-M pair, e.g. BTCUSDT").optional();
+var limit3 = z8.number().int().positive().max(1e3).default(100);
+var startTime4 = z8.number().int().positive().optional();
+var endTime4 = z8.number().int().positive().optional();
+var side2 = z8.enum(["BUY", "SELL"]);
+var positionSide = z8.enum(["BOTH", "LONG", "SHORT"]).optional();
+var orderParamsSchema = z8.object({
+  symbol: symbol2,
+  side: side2,
+  type: z8.enum(["LIMIT", "MARKET", "STOP", "STOP_MARKET", "TAKE_PROFIT", "TAKE_PROFIT_MARKET", "TRAILING_STOP_MARKET"]),
+  quantity: z8.union([z8.string(), z8.number()]).describe("Order quantity in base asset"),
+  price: z8.union([z8.string(), z8.number()]).optional().describe("Required for LIMIT and STOP/TAKE_PROFIT (limit-triggered) types"),
+  timeInForce: z8.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
+  stopPrice: z8.union([z8.string(), z8.number()]).optional().describe("Trigger price for STOP/STOP_MARKET/TAKE_PROFIT/TAKE_PROFIT_MARKET"),
+  reduceOnly: z8.boolean().optional().describe("true = only reduces the position, never opens"),
+  positionSide,
+  newClientOrderId: z8.string().optional(),
+  closePosition: z8.boolean().optional().describe("Close the full position on trigger (mutually exclusive with quantity)"),
+  newOrderRespType: z8.enum(["ACK", "RESULT"]).optional(),
+  priceProtect: z8.boolean().optional(),
+  workingType: z8.enum(["MARK_PRICE", "CONTRACT_PRICE"]).optional().describe("Trigger price basis; default CONTRACT_PRICE"),
+  callbackRate: z8.union([z8.string(), z8.number()]).optional().describe("Percent callback for TRAILING_STOP_MARKET, e.g. 0.5"),
+  activationPrice: z8.union([z8.string(), z8.number()]).optional().describe("Activation price for TRAILING_STOP_MARKET"),
+  selfTradePreventionMode: z8.enum(["NONE", "EXPIRE_TAKER", "EXPIRE_MAKER", "EXPIRE_BOTH"]).optional(),
+  goodTillDate: z8.number().int().optional().describe("Timestamp when a GTD order expires")
+});
+function tradingTools(client) {
+  const t = client.futures.trading;
+  return [
+    {
+      name: "futures_new_order",
+      description: "Place a new futures order. Types: LIMIT, MARKET, STOP, STOP_MARKET, TAKE_PROFIT, TAKE_PROFIT_MARKET, TRAILING_STOP_MARKET. Use STOP_MARKET as the take-profit/stop-loss trigger and LIMIT for the actual fill. Signed.",
+      inputSchema: orderParamsSchema,
+      handler: async (args) => textResult(await t.createOrder({ ...args, symbol: normalizeSymbol(args.symbol) }))
+    },
+    {
+      name: "futures_test_order",
+      description: "Validate a new order without submitting it. Returns 200 on success; use to validate fields and margin before real orders. Signed.",
+      inputSchema: orderParamsSchema,
+      handler: async (args) => textResult(await t.createTestOrder({ ...args, symbol: normalizeSymbol(args.symbol) }))
+    },
+    {
+      name: "futures_get_order",
+      description: "Query a specific order by orderId or client order id. Signed.",
+      inputSchema: z8.object({ symbol: symbol2, orderId: z8.number().int().positive().optional(), origClientOrderId: z8.string().optional() }),
+      handler: async ({ symbol: symbol3, orderId, origClientOrderId }) => textResult(await t.getOrder(normalizeSymbol(symbol3), { orderId, origClientOrderId }))
+    },
+    {
+      name: "futures_cancel_order",
+      description: "Cancel a specific open order by orderId or client order id. Signed.",
+      inputSchema: z8.object({ symbol: symbol2, orderId: z8.number().int().positive().optional(), origClientOrderId: z8.string().optional() }),
+      handler: async ({ symbol: symbol3, orderId, origClientOrderId }) => textResult(await t.cancelOrder(normalizeSymbol(symbol3), { orderId, origClientOrderId }))
+    },
+    {
+      name: "futures_get_open_order",
+      description: "Query a current open order (must exist in the open order book). Signed.",
+      inputSchema: z8.object({ symbol: symbol2, orderId: z8.number().int().positive().optional(), origClientOrderId: z8.string().optional() }),
+      handler: async ({ symbol: symbol3, orderId, origClientOrderId }) => textResult(await t.getCurrentOrder(normalizeSymbol(symbol3), { orderId, origClientOrderId }))
+    },
+    {
+      name: "futures_open_orders",
+      description: "Get all current open orders, for one symbol or all symbols. Signed.",
+      inputSchema: z8.object({ symbol: optionalSymbol3 }),
+      handler: async ({ symbol: symbol3 }) => textResult(await t.getOpenOrders(symbol3 ? normalizeSymbol(symbol3) : void 0))
+    },
+    {
+      name: "futures_all_orders",
+      description: "Get historical orders for a symbol with optional time range (last 7 days by default). Signed.",
+      inputSchema: z8.object({ symbol: symbol2, orderId: z8.number().int().positive().optional(), startTime: startTime4, endTime: endTime4, limit: limit3 }),
+      handler: async ({ symbol: symbol3, orderId, startTime: startTime5, endTime: endTime5, limit: limit4 }) => textResult(await t.getAllOrders(normalizeSymbol(symbol3), { orderId, startTime: startTime5, endTime: endTime5, limit: limit4 }))
+    },
+    {
+      name: "futures_cancel_all_orders",
+      description: "Cancel all open orders for a symbol. Signed.",
+      inputSchema: z8.object({ symbol: symbol2 }),
+      handler: async ({ symbol: symbol3 }) => textResult(await t.cancelAllOpenOrders(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "futures_modify_order",
+      description: "Modify an open order (price/quantity/stopPrice). Cannot modify when position side is BOTH and closePosition is true. Signed.",
+      inputSchema: z8.object({
+        symbol: symbol2,
+        side: side2,
+        quantity: z8.union([z8.string(), z8.number()]),
+        price: z8.union([z8.string(), z8.number()]).optional(),
+        orderId: z8.number().int().positive().optional(),
+        origClientOrderId: z8.string().optional(),
+        stopPrice: z8.union([z8.string(), z8.number()]).optional(),
+        timeInForce: z8.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
+        positionSide,
+        newClientOrderId: z8.string().optional()
+      }),
+      handler: async (args) => textResult(await t.modifyOrder({ ...args, symbol: normalizeSymbol(args.symbol) }))
+    },
+    {
+      name: "futures_order_modify_history",
+      description: "Get order modification history for a symbol. Signed.",
+      inputSchema: z8.object({ symbol: symbol2, startTime: startTime4, endTime: endTime4, limit: limit3 }),
+      handler: async ({ symbol: symbol3, startTime: startTime5, endTime: endTime5, limit: limit4 }) => textResult(await t.getOrderModifyHistory(normalizeSymbol(symbol3), { startTime: startTime5, endTime: endTime5, limit: limit4 }))
+    },
+    {
+      name: "futures_batch_orders",
+      description: "Place up to 5 orders in one request (array of order objects, max 30 per minute per symbol). Signed.",
+      inputSchema: z8.object({ orders: z8.array(orderParamsSchema).min(1).max(5) }),
+      handler: async (args) => {
+        const mapped = args.orders.map((o) => ({ ...o, symbol: normalizeSymbol(o.symbol) }));
+        return textResult(await t.createBatchOrders(mapped));
+      }
+    },
+    {
+      name: "futures_cancel_batch_orders",
+      description: "Cancel multiple orders at once (up to 10 by orderId list or client order id list). Signed.",
+      inputSchema: z8.object({
+        symbol: symbol2,
+        orderIdList: z8.array(z8.number().int().positive()).max(10).optional(),
+        origClientOrderIdList: z8.array(z8.string()).max(10).optional()
+      }),
+      handler: async ({ symbol: symbol3, orderIdList, origClientOrderIdList }) => textResult(await t.cancelBatchOrders(normalizeSymbol(symbol3), { orderIdList, origClientOrderIdList }))
+    },
+    {
+      name: "futures_set_leverage",
+      description: "Change initial leverage for a symbol (1-125, within bracket). Signed.",
+      inputSchema: z8.object({ symbol: symbol2, leverage: z8.number().int().min(1).max(125) }),
+      handler: async ({ symbol: symbol3, leverage }) => textResult(await t.setLeverage(normalizeSymbol(symbol3), leverage))
+    },
+    {
+      name: "futures_set_margin_type",
+      description: "Change margin type for a symbol: isolated or cross. Only allowed when no open position for the symbol. Signed.",
+      inputSchema: z8.object({ symbol: symbol2, marginType: z8.enum(["isolated", "cross"]) }),
+      handler: async ({ symbol: symbol3, marginType }) => textResult(await t.setMarginType(normalizeSymbol(symbol3), marginType))
+    },
+    {
+      name: "futures_modify_position_margin",
+      description: "Add or reduce isolated position margin. marginType: 1 = add margin, 2 = reduce margin. Signed.",
+      inputSchema: z8.object({ symbol: symbol2, amount: z8.number().positive(), marginType: z8.enum(["1", "2"]).describe("1 = add margin, 2 = reduce margin") }),
+      handler: async ({ symbol: symbol3, amount, marginType }) => textResult(await t.modifyPositionMargin(normalizeSymbol(symbol3), amount, Number(marginType)))
+    },
+    {
+      name: "futures_countdown_cancel_all",
+      description: "Auto-cancel all open orders for a symbol after countdownTime ms (0 = cancel the countdown). Emergency circuit breaker. Signed.",
+      inputSchema: z8.object({ symbol: symbol2, countdownTime: z8.number().int().min(100).max(6e4) }),
+      handler: async ({ symbol: symbol3, countdownTime }) => textResult(await t.setCountdownCancelAll(normalizeSymbol(symbol3), countdownTime))
+    },
+    {
+      name: "futures_new_algo_order",
+      description: "Place a conditional algo order (CONDITIONAL or VP). CONDITIONAL supports STOP_MARKET/TAKE_PROFIT_MARKET types with triggerPrice; VP is a volume-participation order with urgency and quantity. Signed.",
+      inputSchema: z8.object({
+        algoType: z8.enum(["CONDITIONAL", "VP"]),
+        symbol: symbol2,
+        side: side2,
+        positionSide,
+        type: z8.enum(["STOP_MARKET", "TAKE_PROFIT_MARKET", "LIMIT"]).describe("For CONDITIONAL: STOP_MARKET/TAKE_PROFIT_MARKET. For VP: LIMIT"),
+        quantity: z8.union([z8.string(), z8.number()]),
+        triggerPrice: z8.union([z8.string(), z8.number()]).optional().describe("Required for CONDITIONAL"),
+        price: z8.union([z8.string(), z8.number()]).optional(),
+        timeInForce: z8.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
+        workingType: z8.enum(["MARK_PRICE", "CONTRACT_PRICE"]).optional(),
+        priceProtect: z8.boolean().optional(),
+        reduceOnly: z8.boolean().optional(),
+        closePosition: z8.boolean().optional(),
+        urgency: z8.enum(["LOW", "MEDIUM", "HIGH"]).optional().describe("Required for VP"),
+        clientAlgoId: z8.string().optional()
+      }),
+      handler: async (args) => textResult(await t.createAlgoOrder({ ...args, symbol: normalizeSymbol(args.symbol) }))
+    },
+    {
+      name: "futures_cancel_algo_order",
+      description: "Cancel an open algo order by algoId or clientAlgoId. Signed.",
+      inputSchema: z8.object({ symbol: symbol2, algoId: z8.number().int().positive().optional(), clientAlgoId: z8.string().optional() }),
+      handler: async ({ symbol: symbol3, algoId, clientAlgoId }) => textResult(await t.cancelAlgoOrder(normalizeSymbol(symbol3), { algoId, clientAlgoId }))
+    },
+    {
+      name: "futures_cancel_all_algo_orders",
+      description: "Cancel all open algo orders for a symbol. Signed.",
+      inputSchema: z8.object({ symbol: symbol2 }),
+      handler: async ({ symbol: symbol3 }) => textResult(await t.cancelAllOpenAlgoOrders(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "futures_get_algo_order",
+      description: "Query an algo order by algoId or clientAlgoId. Signed.",
+      inputSchema: z8.object({ symbol: symbol2, algoId: z8.number().int().positive().optional(), clientAlgoId: z8.string().optional() }),
+      handler: async ({ symbol: symbol3, algoId, clientAlgoId }) => textResult(await t.getAlgoOrder(normalizeSymbol(symbol3), { algoId, clientAlgoId }))
+    },
+    {
+      name: "futures_open_algo_orders",
+      description: "Get all current open algo orders, optionally filtered by symbol. Signed.",
+      inputSchema: z8.object({ symbol: optionalSymbol3 }),
+      handler: async ({ symbol: symbol3 }) => textResult(await t.getOpenAlgoOrders(symbol3 ? normalizeSymbol(symbol3) : void 0))
+    },
+    {
+      name: "futures_all_algo_orders",
+      description: "Get historical algo orders for a symbol with optional time range. Signed.",
+      inputSchema: z8.object({ symbol: symbol2, startTime: startTime4, endTime: endTime4, limit: limit3 }),
+      handler: async ({ symbol: symbol3, startTime: startTime5, endTime: endTime5, limit: limit4 }) => textResult(await t.getAllAlgoOrders(normalizeSymbol(symbol3), { startTime: startTime5, endTime: endTime5, limit: limit4 }))
+    },
+    {
+      name: "futures_convert_exchange_info",
+      description: "List asset pairs eligible for futures Convert, optionally filtered by fromAsset/toAsset.",
+      inputSchema: z8.object({ fromAsset: z8.string().optional(), toAsset: z8.string().optional() }),
+      handler: async ({ fromAsset, toAsset }) => textResult(await t.convertExchangeInfo({ fromAsset, toAsset }))
+    },
+    {
+      name: "futures_convert_get_quote",
+      description: "Request a Convert quote between two assets (quote expires quickly; accept with futures_convert_accept_quote). Signed.",
+      inputSchema: z8.object({
+        fromAsset: z8.string().min(1),
+        toAsset: z8.string().min(1),
+        fromAmount: z8.number().positive().optional(),
+        toAmount: z8.number().positive().optional(),
+        validTime: z8.enum(["10s", "30s", "1m", "2m"]).optional()
+      }),
+      handler: async (args) => textResult(await t.convertGetQuote(args))
+    },
+    {
+      name: "futures_convert_accept_quote",
+      description: "Accept a previously requested Convert quote by quoteId. Signed.",
+      inputSchema: z8.object({ quoteId: z8.string().min(1) }),
+      handler: async ({ quoteId }) => textResult(await t.convertAcceptQuote(quoteId))
+    },
+    {
+      name: "futures_convert_order_status",
+      description: "Query the status of a Convert order by orderId or quoteId. Signed.",
+      inputSchema: z8.object({ orderId: z8.string().optional(), quoteId: z8.string().optional() }),
+      handler: async ({ orderId, quoteId }) => textResult(await t.convertOrderStatus({ orderId, quoteId }))
+    }
+  ];
+}
+
+// src/tools/ws.tools.ts
+import { z as z9 } from "zod";
+var buffers = /* @__PURE__ */ new Map();
+var MAX_BUFFER = 500;
+function bufferFor(client) {
+  let buffer = buffers.get(client);
+  if (!buffer) {
+    buffer = { subscriptions: /* @__PURE__ */ new Set(), events: [] };
+    buffers.set(client, buffer);
+    client.futures.ws.on("message", (stream, payload) => {
+      buffer.events.push({ stream, payload, ts: Date.now() });
+      if (buffer.events.length > MAX_BUFFER) buffer.events.splice(0, buffer.events.length - MAX_BUFFER);
+    });
+  }
+  return buffer;
+}
+function getBufferedWsEvents(client, limit4 = 50) {
+  return bufferFor(client).events.slice(-limit4);
+}
+function clearBufferedWsEvents(client) {
+  bufferFor(client).events = [];
+}
+function wsTools(client) {
+  const buffer = bufferFor(client);
+  return [
+    {
+      name: "futures_ws_subscribe",
+      description: "Subscribe to real-time market data streams. Topic format: <symbol>@<stream>, e.g. btcusdt@aggTrade, btcusdt@kline_1m, btcusdt@depth20, btcusdt@markPrice@1s, btcusdt@bookTicker, btcusdt@ticker, btcusdt@miniTicker, btcusdt@forceOrder, or all-market topics !ticker@arr, !bookTicker, !markPrice@arr, !forceOrder@arr, !miniTicker@arr. Multiple topics can be passed at once.",
+      inputSchema: z9.object({
+        topics: z9.array(z9.string().min(1)).min(1).describe('Stream topics, e.g. ["btcusdt@aggTrade", "btcusdt@kline_1m"]')
+      }),
+      handler: async ({ topics }) => {
+        const normalized = topics.map((t) => t.trim().toLowerCase());
+        client.futures.ws.subscribe(normalized);
+        normalized.forEach((t) => buffer.subscriptions.add(t));
+        return textResult({ subscribed: normalized, active: [...buffer.subscriptions] });
+      }
+    },
+    {
+      name: "futures_ws_unsubscribe",
+      description: "Unsubscribe from previously subscribed market data streams.",
+      inputSchema: z9.object({ topics: z9.array(z9.string().min(1)).min(1) }),
+      handler: async ({ topics }) => {
+        const normalized = topics.map((t) => t.trim().toLowerCase());
+        client.futures.ws.unsubscribe(normalized);
+        normalized.forEach((t) => buffer.subscriptions.delete(t));
+        return textResult({ unsubscribed: normalized, active: [...buffer.subscriptions] });
+      }
+    },
+    {
+      name: "futures_ws_subscriptions",
+      description: "List the currently subscribed WebSocket market streams for this client.",
+      inputSchema: z9.object({}),
+      handler: async () => textResult({ active: [...buffer.subscriptions] })
+    },
+    {
+      name: "futures_ws_events",
+      description: "Read the buffered real-time payloads received since the last read for the subscribed streams (aggregate trades, klines, depth deltas, mark price, book tickers, tickers, force orders). Payloads are parsed; depth deltas must be applied to a snapshot from futures_order_book.",
+      inputSchema: z9.object({ limit: z9.number().int().min(1).max(200).default(50) }),
+      handler: async ({ limit: limit4 }) => textResult(getBufferedWsEvents(client, limit4))
+    },
+    {
+      name: "futures_ws_clear_events",
+      description: "Clear the buffered WebSocket events so the next read only returns new payloads.",
+      inputSchema: z9.object({}),
+      handler: async () => {
+        clearBufferedWsEvents(client);
+        return textResult({ cleared: true });
+      }
+    },
+    {
+      name: "futures_ws_start_user_stream",
+      description: "Start the user data stream: creates a listenKey, connects the private WebSocket, and begins a 30-minute keep-alive. Emits private events (ACCOUNT_UPDATE, ORDER_TRADE_UPDATE, MARGIN_CALL, ACCOUNT_CONFIG_UPDATE, listenKeyExpired) that the application can consume from the client.",
+      inputSchema: z9.object({}),
+      handler: async () => textResult({ listenKey: await client.startUserStream() })
+    },
+    {
+      name: "futures_ws_stop_user_stream",
+      description: "Stop the user data stream: closes the private WebSocket and invalidates the listenKey.",
+      inputSchema: z9.object({}),
+      handler: async () => {
+        client.closeUserStream();
+        return textResult({ stopped: true });
+      }
+    },
+    {
+      name: "futures_ws_api_order_status",
+      description: "Query an order via the signed WebSocket API (order.status) \u2014 lower-latency alternative to futures_get_order.",
+      inputSchema: z9.object({
+        symbol: z9.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+        orderId: z9.number().int().positive().optional(),
+        origClientOrderId: z9.string().optional()
+      }),
+      handler: async ({ symbol: symbol3, orderId, origClientOrderId }) => textResult(await client.futures.wsApi.orderStatus({ symbol: normalizeSymbol(symbol3), orderId, origClientOrderId }))
+    },
+    {
+      name: "futures_ws_api_account_status",
+      description: "Get account info via the signed WebSocket API (account.status).",
+      inputSchema: z9.object({}),
+      handler: async () => textResult(await client.futures.wsApi.accountStatus())
+    },
+    {
+      name: "futures_ws_api_account_position",
+      description: "Get current positions via the signed WebSocket API (account.position).",
+      inputSchema: z9.object({ symbol: z9.string().min(1).describe("USD-M pair, e.g. BTCUSDT").optional() }),
+      handler: async ({ symbol: symbol3 }) => textResult(await client.futures.wsApi.accountPosition(symbol3 ? { symbol: normalizeSymbol(symbol3) } : {}))
+    },
+    {
+      name: "futures_ws_api_user_data_stream_start",
+      description: "Create a listenKey via the signed WebSocket API (userDataStream.start) \u2014 no REST call required.",
+      inputSchema: z9.object({}),
+      handler: async () => textResult(await client.futures.wsApi.userDataStreamStart())
+    },
+    {
+      name: "futures_ws_api_user_data_stream_stop",
+      description: "Invalidate a listenKey via the signed WebSocket API (userDataStream.stop).",
+      inputSchema: z9.object({ listenKey: z9.string().min(1) }),
+      handler: async ({ listenKey }) => textResult(await client.futures.wsApi.userDataStreamStop(listenKey))
+    },
+    {
+      name: "futures_ws_api_ticker_price",
+      description: "Get latest price via the unsigned WebSocket API (ticker.price); omit symbol for all symbols.",
+      inputSchema: z9.object({ symbol: z9.string().min(1).describe("USD-M pair, e.g. BTCUSDT").optional() }),
+      handler: async ({ symbol: symbol3 }) => textResult(await client.futures.wsApi.tickerPrice(symbol3 ? { symbol: normalizeSymbol(symbol3) } : {}))
+    },
+    {
+      name: "futures_ws_api_order_book",
+      description: "Get order-book depth via the unsigned WebSocket API (depth).",
+      inputSchema: z9.object({
+        symbol: z9.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+        limit: z9.enum(["5", "10", "20", "50", "100", "500", "1000"]).optional()
+      }),
+      handler: async ({ symbol: symbol3, limit: limit4 }) => textResult(await client.futures.wsApi.depth({ symbol: normalizeSymbol(symbol3), limit: limit4 }))
+    }
+  ];
+}
+
+// src/tools/index.ts
+function createFuturesToolkit(client) {
+  const market = marketDataTools(client);
+  const account = accountTools(client);
+  const trading = tradingTools(client);
+  const spot = spotTools(client);
+  const ws = wsTools(client);
+  const derived = derivedTools(client);
+  const paperContext = createPaperContext(client);
+  const paper = paperTools(paperContext);
+  return {
+    client,
+    tools: [...market, ...account, ...trading, ...spot, ...ws, ...derived, ...paper],
+    market,
+    account,
+    trading,
+    spot,
+    ws,
+    derived,
+    paper,
+    paperContext
+  };
+}
+function toolkitToFormats(toolkit) {
+  return {
+    openai: toToolList(toolkit.tools, "openai"),
+    anthropic: toToolList(toolkit.tools, "anthropic"),
+    mcp: toToolList(toolkit.tools, "mcp")
+  };
+}
+export {
+  accountTools,
+  clearBufferedWsEvents,
+  createFuturesToolkit,
+  createPaperContext,
+  derivedTools,
+  getBufferedWsEvents,
+  marketDataTools,
+  paperTools,
+  spotTools,
+  textResult,
+  toAnthropicTool,
+  toJsonSchema,
+  toMCPTool,
+  toOpenAITool,
+  toToolList,
+  toolkitToFormats,
+  tradingTools,
+  wsTools
+};
+//# sourceMappingURL=index.js.map