@nemesis-oss/binance-sdk 2.0.0 → 3.0.0

package/dist/tools/index.cjs

@@ -25,6 +25,7 @@ __export(tools_exports, {
   createFuturesToolkit: () => createFuturesToolkit,
   createPaperContext: () => createPaperContext,
   derivedTools: () => derivedTools,
+  executionTools: () => executionTools,
   getBufferedWsEvents: () => getBufferedWsEvents,
   marketDataTools: () => marketDataTools,
   paperTools: () => paperTools,
@@ -333,12 +334,331 @@ function derivedTools(client) {
   ];
 }
 
-// src/tools/market-data.tools.ts
+// src/tools/execution.tools.ts
 var import_zod5 = require("zod");
 
-// src/types/market.types.ts
+// src/tools/trading.tools.ts
 var import_zod4 = require("zod");
-var KlineIntervalSchema = import_zod4.z.enum([
+var symbol2 = import_zod4.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT");
+var optionalSymbol2 = import_zod4.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT").optional();
+var limit2 = import_zod4.z.number().int().positive().max(1e3).default(100);
+var startTime2 = import_zod4.z.number().int().positive().optional();
+var endTime2 = import_zod4.z.number().int().positive().optional();
+var side = import_zod4.z.enum(["BUY", "SELL"]);
+var positionSide = import_zod4.z.enum(["BOTH", "LONG", "SHORT"]).optional();
+var orderParamsSchema = import_zod4.z.object({
+  symbol: symbol2,
+  side,
+  type: import_zod4.z.enum(["LIMIT", "MARKET", "STOP", "STOP_MARKET", "TAKE_PROFIT", "TAKE_PROFIT_MARKET", "TRAILING_STOP_MARKET"]),
+  quantity: import_zod4.z.union([import_zod4.z.string(), import_zod4.z.number()]).describe("Order quantity in base asset"),
+  price: import_zod4.z.union([import_zod4.z.string(), import_zod4.z.number()]).optional().describe("Required for LIMIT and STOP/TAKE_PROFIT (limit-triggered) types"),
+  timeInForce: import_zod4.z.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
+  stopPrice: import_zod4.z.union([import_zod4.z.string(), import_zod4.z.number()]).optional().describe("Trigger price for STOP/STOP_MARKET/TAKE_PROFIT/TAKE_PROFIT_MARKET"),
+  reduceOnly: import_zod4.z.boolean().optional().describe("true = only reduces the position, never opens"),
+  positionSide,
+  newClientOrderId: import_zod4.z.string().optional(),
+  closePosition: import_zod4.z.boolean().optional().describe("Close the full position on trigger (mutually exclusive with quantity)"),
+  newOrderRespType: import_zod4.z.enum(["ACK", "RESULT"]).optional(),
+  priceProtect: import_zod4.z.boolean().optional(),
+  workingType: import_zod4.z.enum(["MARK_PRICE", "CONTRACT_PRICE"]).optional().describe("Trigger price basis; default CONTRACT_PRICE"),
+  callbackRate: import_zod4.z.union([import_zod4.z.string(), import_zod4.z.number()]).optional().describe("Percent callback for TRAILING_STOP_MARKET, e.g. 0.5"),
+  activationPrice: import_zod4.z.union([import_zod4.z.string(), import_zod4.z.number()]).optional().describe("Activation price for TRAILING_STOP_MARKET"),
+  selfTradePreventionMode: import_zod4.z.enum(["NONE", "EXPIRE_TAKER", "EXPIRE_MAKER", "EXPIRE_BOTH"]).optional(),
+  goodTillDate: import_zod4.z.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: import_zod4.z.object({ symbol: symbol2, orderId: import_zod4.z.number().int().positive().optional(), origClientOrderId: import_zod4.z.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: import_zod4.z.object({ symbol: symbol2, orderId: import_zod4.z.number().int().positive().optional(), origClientOrderId: import_zod4.z.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: import_zod4.z.object({ symbol: symbol2, orderId: import_zod4.z.number().int().positive().optional(), origClientOrderId: import_zod4.z.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: import_zod4.z.object({ symbol: optionalSymbol2 }),
+      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: import_zod4.z.object({ symbol: symbol2, orderId: import_zod4.z.number().int().positive().optional(), startTime: startTime2, endTime: endTime2, 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: "futures_cancel_all_orders",
+      description: "Cancel all open orders for a symbol. Signed.",
+      inputSchema: import_zod4.z.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: import_zod4.z.object({
+        symbol: symbol2,
+        side,
+        quantity: import_zod4.z.union([import_zod4.z.string(), import_zod4.z.number()]),
+        price: import_zod4.z.union([import_zod4.z.string(), import_zod4.z.number()]).optional(),
+        orderId: import_zod4.z.number().int().positive().optional(),
+        origClientOrderId: import_zod4.z.string().optional(),
+        stopPrice: import_zod4.z.union([import_zod4.z.string(), import_zod4.z.number()]).optional(),
+        timeInForce: import_zod4.z.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
+        positionSide,
+        newClientOrderId: import_zod4.z.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: import_zod4.z.object({ symbol: symbol2, startTime: startTime2, endTime: endTime2, limit: limit2 }),
+      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: import_zod4.z.object({ orders: import_zod4.z.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: import_zod4.z.object({
+        symbol: symbol2,
+        orderIdList: import_zod4.z.array(import_zod4.z.number().int().positive()).max(10).optional(),
+        origClientOrderIdList: import_zod4.z.array(import_zod4.z.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: import_zod4.z.object({ symbol: symbol2, leverage: import_zod4.z.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: import_zod4.z.object({ symbol: symbol2, marginType: import_zod4.z.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: import_zod4.z.object({ symbol: symbol2, amount: import_zod4.z.number().positive(), marginType: import_zod4.z.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: import_zod4.z.object({ symbol: symbol2, countdownTime: import_zod4.z.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: import_zod4.z.object({
+        algoType: import_zod4.z.enum(["CONDITIONAL", "VP"]),
+        symbol: symbol2,
+        side,
+        positionSide,
+        type: import_zod4.z.enum(["STOP_MARKET", "TAKE_PROFIT_MARKET", "LIMIT"]).describe("For CONDITIONAL: STOP_MARKET/TAKE_PROFIT_MARKET. For VP: LIMIT"),
+        quantity: import_zod4.z.union([import_zod4.z.string(), import_zod4.z.number()]),
+        triggerPrice: import_zod4.z.union([import_zod4.z.string(), import_zod4.z.number()]).optional().describe("Required for CONDITIONAL"),
+        price: import_zod4.z.union([import_zod4.z.string(), import_zod4.z.number()]).optional(),
+        timeInForce: import_zod4.z.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
+        workingType: import_zod4.z.enum(["MARK_PRICE", "CONTRACT_PRICE"]).optional(),
+        priceProtect: import_zod4.z.boolean().optional(),
+        reduceOnly: import_zod4.z.boolean().optional(),
+        closePosition: import_zod4.z.boolean().optional(),
+        urgency: import_zod4.z.enum(["LOW", "MEDIUM", "HIGH"]).optional().describe("Required for VP"),
+        clientAlgoId: import_zod4.z.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: import_zod4.z.object({ symbol: symbol2, algoId: import_zod4.z.number().int().positive().optional(), clientAlgoId: import_zod4.z.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: import_zod4.z.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: import_zod4.z.object({ symbol: symbol2, algoId: import_zod4.z.number().int().positive().optional(), clientAlgoId: import_zod4.z.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: import_zod4.z.object({ symbol: optionalSymbol2 }),
+      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: import_zod4.z.object({ symbol: symbol2, startTime: startTime2, endTime: endTime2, limit: limit2 }),
+      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: import_zod4.z.object({ fromAsset: import_zod4.z.string().optional(), toAsset: import_zod4.z.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: import_zod4.z.object({
+        fromAsset: import_zod4.z.string().min(1),
+        toAsset: import_zod4.z.string().min(1),
+        fromAmount: import_zod4.z.number().positive().optional(),
+        toAmount: import_zod4.z.number().positive().optional(),
+        validTime: import_zod4.z.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: import_zod4.z.object({ quoteId: import_zod4.z.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: import_zod4.z.object({ orderId: import_zod4.z.string().optional(), quoteId: import_zod4.z.string().optional() }),
+      handler: async ({ orderId, quoteId }) => textResult(await t.convertOrderStatus({ orderId, quoteId }))
+    }
+  ];
+}
+
+// src/tools/execution.tools.ts
+var backend = import_zod5.z.enum(["live", "paper"]).optional().describe("Execution backend for this call; default is the gateway's default backend");
+var intentId = import_zod5.z.string().min(1).optional().describe(
+  "Idempotency key. Re-submitting the same intentId returns the original execution instead of placing a second order. Recommended for any retry loop."
+);
+function executionTools(gateway, client) {
+  return [
+    {
+      name: "execution_place_order",
+      description: "Place an order through the execution gateway: idempotent (retry with the same intentId returns the original execution), reconciled on ambiguous failures, and routable to the live exchange or the paper simulator via `backend`. Paper orders need no API keys. MARKET and LIMIT types supported on paper.",
+      inputSchema: orderParamsSchema.extend({ intentId, backend }),
+      handler: async (args) => {
+        const { intentId: intent, backend: route } = args;
+        return textResult(
+          await gateway.placeOrder(
+            { ...args, intentId: intent, symbol: normalizeSymbol(args.symbol) },
+            { backend: route }
+          )
+        );
+      }
+    },
+    {
+      name: "execution_cancel_order",
+      description: "Cancel an order idempotently by exchange orderId, clientOrderId, or the intentId from execution_place_order. Cancels of already-gone orders resolve to a terminal CANCELED execution (never a thrown -2011).",
+      inputSchema: import_zod5.z.object({
+        symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+        orderId: import_zod5.z.number().int().positive().optional().describe("Exchange order id"),
+        origClientOrderId: import_zod5.z.string().optional().describe("Client order id (the reconciliation key)"),
+        intentId,
+        backend
+      }),
+      handler: async ({ symbol: symbol3, orderId, origClientOrderId, intentId: intent, backend: route }) => textResult(
+        await gateway.cancelOrder(
+          normalizeSymbol(symbol3),
+          { orderId, origClientOrderId, intentId: intent, backend: route }
+        )
+      )
+    },
+    {
+      name: "execution_get_order",
+      description: "Fetch an execution from the ledger by its intentId. When `backend` is omitted both ledgers are searched (paper first), so callers do not need to remember where an intent ran.",
+      inputSchema: import_zod5.z.object({ intentId: import_zod5.z.string().min(1), backend }),
+      handler: async ({ intentId: intent, backend: route }) => {
+        const execution = route ? gateway.getExecution(intent, route) : gateway.getExecution(intent, "paper") ?? gateway.getExecution(intent, "live");
+        if (!execution) throw new Error(`No execution for intentId ${intent}`);
+        return textResult(execution);
+      }
+    },
+    {
+      name: "execution_list_orders",
+      description: "List the execution ledger (most recent first) for a backend. Each entry carries status, fills, and reconciliation state. Paper and live ledgers are independent.",
+      inputSchema: import_zod5.z.object({ backend }),
+      handler: async ({ backend: route }) => textResult(gateway.listExecutions(route))
+    },
+    {
+      name: "execution_reconcile_order",
+      description: "Force a reconciliation pass for an intent whose outcome is unknown (e.g. after a timeout). Recovers the true state from the exchange (live) or simulator (paper) instead of guessing.",
+      inputSchema: import_zod5.z.object({ intentId: import_zod5.z.string().min(1), backend }),
+      handler: async ({ intentId: intent, backend: route }) => textResult(await gateway.reconcile(intent, route))
+    },
+    {
+      name: "execution_status",
+      description: "Snapshot of the execution environment: default backend, risk-gateway state (when a trading policy is configured), and the paper simulator account (balance, positions, unrealized PnL). Read-only, never places orders.",
+      inputSchema: import_zod5.z.object({}),
+      handler: async () => {
+        const risk = client?.getRiskStatus?.();
+        const paper = gateway.paperEngine.getAccountInfo();
+        return textResult({
+          defaultBackend: gateway.backend,
+          risk: risk ?? null,
+          paper: {
+            balance: paper.balance,
+            availableBalance: paper.availableBalance,
+            totalWalletBalance: paper.totalWalletBalance,
+            unrealizedPnl: paper.unrealizedPnl,
+            realizedPnl: paper.realizedPnl,
+            positions: Object.values(paper.positions).filter((p) => p.quantity > 0),
+            orderCount: paper.orders.length
+          }
+        });
+      }
+    }
+  ];
+}
+
+// src/tools/market-data.tools.ts
+var import_zod7 = require("zod");
+
+// src/types/market.types.ts
+var import_zod6 = require("zod");
+var KlineIntervalSchema = import_zod6.z.enum([
   "1m",
   "3m",
   "5m",
@@ -355,19 +675,19 @@ var KlineIntervalSchema = import_zod4.z.enum([
   "1w",
   "1M"
 ]);
-var RawKlineSchema = import_zod4.z.tuple([
-  import_zod4.z.number(),
-  import_zod4.z.string(),
-  import_zod4.z.string(),
-  import_zod4.z.string(),
-  import_zod4.z.string(),
-  import_zod4.z.string(),
-  import_zod4.z.number(),
-  import_zod4.z.string(),
-  import_zod4.z.number(),
-  import_zod4.z.string(),
-  import_zod4.z.string(),
-  import_zod4.z.string()
+var RawKlineSchema = import_zod6.z.tuple([
+  import_zod6.z.number(),
+  import_zod6.z.string(),
+  import_zod6.z.string(),
+  import_zod6.z.string(),
+  import_zod6.z.string(),
+  import_zod6.z.string(),
+  import_zod6.z.number(),
+  import_zod6.z.string(),
+  import_zod6.z.number(),
+  import_zod6.z.string(),
+  import_zod6.z.string(),
+  import_zod6.z.string()
 ]);
 var KlineSchema = RawKlineSchema.transform(
   ([openTime, open, high, low, close, volume, closeTime, quoteAssetVolume, trades, takerBuyBaseVolume, takerBuyQuoteVolume]) => ({
@@ -384,87 +704,87 @@ var KlineSchema = RawKlineSchema.transform(
     takerBuyQuoteVolume: Number(takerBuyQuoteVolume)
   })
 );
-var KlinesResponseSchema = import_zod4.z.array(KlineSchema);
-var TickerPriceSchema = import_zod4.z.object({
-  symbol: import_zod4.z.string(),
-  price: import_zod4.z.string().transform(Number),
-  time: import_zod4.z.number().optional()
+var KlinesResponseSchema = import_zod6.z.array(KlineSchema);
+var TickerPriceSchema = import_zod6.z.object({
+  symbol: import_zod6.z.string(),
+  price: import_zod6.z.string().transform(Number),
+  time: import_zod6.z.number().optional()
 });
-var Ticker24hrSchema = import_zod4.z.object({
-  symbol: import_zod4.z.string(),
-  priceChange: import_zod4.z.string().transform(Number),
-  priceChangePercent: import_zod4.z.string().transform(Number),
-  weightedAvgPrice: import_zod4.z.string().transform(Number),
-  lastPrice: import_zod4.z.string().transform(Number),
-  lastQty: import_zod4.z.string().transform(Number),
-  openPrice: import_zod4.z.string().transform(Number),
-  highPrice: import_zod4.z.string().transform(Number),
-  lowPrice: import_zod4.z.string().transform(Number),
-  volume: import_zod4.z.string().transform(Number),
-  quoteVolume: import_zod4.z.string().transform(Number),
-  openTime: import_zod4.z.number(),
-  closeTime: import_zod4.z.number(),
-  firstId: import_zod4.z.number(),
-  lastId: import_zod4.z.number(),
-  count: import_zod4.z.number()
+var Ticker24hrSchema = import_zod6.z.object({
+  symbol: import_zod6.z.string(),
+  priceChange: import_zod6.z.string().transform(Number),
+  priceChangePercent: import_zod6.z.string().transform(Number),
+  weightedAvgPrice: import_zod6.z.string().transform(Number),
+  lastPrice: import_zod6.z.string().transform(Number),
+  lastQty: import_zod6.z.string().transform(Number),
+  openPrice: import_zod6.z.string().transform(Number),
+  highPrice: import_zod6.z.string().transform(Number),
+  lowPrice: import_zod6.z.string().transform(Number),
+  volume: import_zod6.z.string().transform(Number),
+  quoteVolume: import_zod6.z.string().transform(Number),
+  openTime: import_zod6.z.number(),
+  closeTime: import_zod6.z.number(),
+  firstId: import_zod6.z.number(),
+  lastId: import_zod6.z.number(),
+  count: import_zod6.z.number()
 });
-var BookTickerSchema = import_zod4.z.object({
-  symbol: import_zod4.z.string(),
-  bidPrice: import_zod4.z.string().transform(Number),
-  bidQty: import_zod4.z.string().transform(Number),
-  askPrice: import_zod4.z.string().transform(Number),
-  askQty: import_zod4.z.string().transform(Number),
-  time: import_zod4.z.number().optional()
+var BookTickerSchema = import_zod6.z.object({
+  symbol: import_zod6.z.string(),
+  bidPrice: import_zod6.z.string().transform(Number),
+  bidQty: import_zod6.z.string().transform(Number),
+  askPrice: import_zod6.z.string().transform(Number),
+  askQty: import_zod6.z.string().transform(Number),
+  time: import_zod6.z.number().optional()
 });
-var DepthLevelSchema = import_zod4.z.tuple([import_zod4.z.string(), import_zod4.z.string()]).transform(([price, qty]) => ({ price: Number(price), qty: Number(qty) }));
-var DepthSnapshotSchema = import_zod4.z.object({
-  lastUpdateId: import_zod4.z.number(),
-  bids: import_zod4.z.array(DepthLevelSchema),
-  asks: import_zod4.z.array(DepthLevelSchema)
+var DepthLevelSchema = import_zod6.z.tuple([import_zod6.z.string(), import_zod6.z.string()]).transform(([price, qty]) => ({ price: Number(price), qty: Number(qty) }));
+var DepthSnapshotSchema = import_zod6.z.object({
+  lastUpdateId: import_zod6.z.number(),
+  bids: import_zod6.z.array(DepthLevelSchema),
+  asks: import_zod6.z.array(DepthLevelSchema)
 });
-var TradeSchema = import_zod4.z.object({
-  id: import_zod4.z.number(),
-  price: import_zod4.z.string().transform(Number),
-  qty: import_zod4.z.string().transform(Number),
-  quoteQty: import_zod4.z.string().transform(Number),
-  time: import_zod4.z.number(),
-  isBuyerMaker: import_zod4.z.boolean()
+var TradeSchema = import_zod6.z.object({
+  id: import_zod6.z.number(),
+  price: import_zod6.z.string().transform(Number),
+  qty: import_zod6.z.string().transform(Number),
+  quoteQty: import_zod6.z.string().transform(Number),
+  time: import_zod6.z.number(),
+  isBuyerMaker: import_zod6.z.boolean()
 });
-var TradesResponseSchema = import_zod4.z.array(TradeSchema);
-var AggTradeSchema = import_zod4.z.object({
-  a: import_zod4.z.number(),
-  p: import_zod4.z.string().transform(Number),
-  q: import_zod4.z.string().transform(Number),
-  f: import_zod4.z.number(),
-  l: import_zod4.z.number(),
-  T: import_zod4.z.number(),
-  m: import_zod4.z.boolean()
+var TradesResponseSchema = import_zod6.z.array(TradeSchema);
+var AggTradeSchema = import_zod6.z.object({
+  a: import_zod6.z.number(),
+  p: import_zod6.z.string().transform(Number),
+  q: import_zod6.z.string().transform(Number),
+  f: import_zod6.z.number(),
+  l: import_zod6.z.number(),
+  T: import_zod6.z.number(),
+  m: import_zod6.z.boolean()
 });
-var AggTradesResponseSchema = import_zod4.z.array(AggTradeSchema);
-var AvgPriceSchema = import_zod4.z.object({
-  mins: import_zod4.z.number(),
-  price: import_zod4.z.string().transform(Number)
+var AggTradesResponseSchema = import_zod6.z.array(AggTradeSchema);
+var AvgPriceSchema = import_zod6.z.object({
+  mins: import_zod6.z.number(),
+  price: import_zod6.z.string().transform(Number)
 });
-var ExchangeSymbolSchema = import_zod4.z.object({
-  symbol: import_zod4.z.string(),
-  status: import_zod4.z.string(),
-  baseAsset: import_zod4.z.string(),
-  quoteAsset: import_zod4.z.string()
+var ExchangeSymbolSchema = import_zod6.z.object({
+  symbol: import_zod6.z.string(),
+  status: import_zod6.z.string(),
+  baseAsset: import_zod6.z.string(),
+  quoteAsset: import_zod6.z.string()
 }).loose();
-var ExchangeInfoSchema = import_zod4.z.object({
-  timezone: import_zod4.z.string(),
-  serverTime: import_zod4.z.number(),
-  symbols: import_zod4.z.array(ExchangeSymbolSchema)
+var ExchangeInfoSchema = import_zod6.z.object({
+  timezone: import_zod6.z.string(),
+  serverTime: import_zod6.z.number(),
+  symbols: import_zod6.z.array(ExchangeSymbolSchema)
 }).loose();
 
 // src/tools/market-data.tools.ts
 var u = (s) => s.optional();
-var optSymbol = u(import_zod5.z.string().min(1)).describe("USD-M pair, e.g. BTCUSDT");
-var limitDefault = import_zod5.z.number().int().positive().max(1500).default(100);
-var startTime2 = import_zod5.z.number().int().positive().optional();
-var endTime2 = import_zod5.z.number().int().positive().optional();
-var period = import_zod5.z.enum(["5m", "15m", "30m", "1h", "2h", "4h", "6h", "12h", "1d"]).default("1h");
-var contractType = import_zod5.z.enum(["perpetual", "current_quarter", "next_quarter"]).default("perpetual");
+var optSymbol = u(import_zod7.z.string().min(1)).describe("USD-M pair, e.g. BTCUSDT");
+var limitDefault = import_zod7.z.number().int().positive().max(1500).default(100);
+var startTime3 = import_zod7.z.number().int().positive().optional();
+var endTime3 = import_zod7.z.number().int().positive().optional();
+var period = import_zod7.z.enum(["5m", "15m", "30m", "1h", "2h", "4h", "6h", "12h", "1d"]).default("1h");
+var contractType = import_zod7.z.enum(["perpetual", "current_quarter", "next_quarter"]).default("perpetual");
 function marketDataTools(client) {
   const m = client.futures.market;
   const d = client.futures.data;
@@ -472,65 +792,65 @@ function marketDataTools(client) {
     {
       name: "futures_ping",
       description: "Test connectivity to the Binance USD-M futures REST API. Returns empty object {} on success.",
-      inputSchema: import_zod5.z.object({}),
+      inputSchema: import_zod7.z.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: import_zod5.z.object({}),
+      inputSchema: import_zod7.z.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: import_zod5.z.object({}),
+      inputSchema: import_zod7.z.object({}),
       handler: async () => textResult(await m.exchangeInfo())
     },
     {
       name: "futures_ticker_price",
       description: "Get latest price for one symbol (v1).",
-      inputSchema: import_zod5.z.object({ symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      inputSchema: import_zod7.z.object({ symbol: import_zod7.z.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: import_zod5.z.object({ symbol: optSymbol }),
+      inputSchema: import_zod7.z.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: import_zod5.z.object({ symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      inputSchema: import_zod7.z.object({ symbol: import_zod7.z.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: import_zod5.z.object({ symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      inputSchema: import_zod7.z.object({ symbol: import_zod7.z.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: import_zod5.z.object({ symbol: optSymbol }),
+      inputSchema: import_zod7.z.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: import_zod5.z.object({
-        symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
-        limit: import_zod5.z.enum(["5", "10", "20", "50", "100", "500", "1000"]).default("100")
+      inputSchema: import_zod7.z.object({
+        symbol: import_zod7.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+        limit: import_zod7.z.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: import_zod5.z.object({
-        symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+      inputSchema: import_zod7.z.object({
+        symbol: import_zod7.z.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)))
@@ -538,184 +858,184 @@ function marketDataTools(client) {
     {
       name: "futures_historical_trades",
       description: "Get older trades for a symbol by fromId (older than recent).",
-      inputSchema: import_zod5.z.object({
-        symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+      inputSchema: import_zod7.z.object({
+        symbol: import_zod7.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
         limit: limitDefault.default(500),
-        fromId: import_zod5.z.number().int().positive().optional()
+        fromId: import_zod7.z.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: import_zod5.z.object({ symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), limit: limitDefault.default(500), startTime: startTime2, endTime: endTime2 }),
+      inputSchema: import_zod7.z.object({ symbol: import_zod7.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), limit: limitDefault.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: "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: import_zod5.z.object({ symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), interval: KlineIntervalSchema, limit: limitDefault.default(500), startTime: startTime2, endTime: endTime2 }),
+      inputSchema: import_zod7.z.object({ symbol: import_zod7.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), interval: KlineIntervalSchema, limit: limitDefault.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: "futures_continuous_klines",
       description: "Get klines for a continuous contract (perpetual, current_quarter, next_quarter) identified by base pair (e.g. BTCUSDT).",
-      inputSchema: import_zod5.z.object({
-        symbol: import_zod5.z.string().min(1).describe("Base pair, e.g. BTCUSDT"),
+      inputSchema: import_zod7.z.object({
+        symbol: import_zod7.z.string().min(1).describe("Base pair, e.g. BTCUSDT"),
         contractType,
         interval: KlineIntervalSchema,
         limit: limitDefault.default(500),
-        startTime: startTime2,
-        endTime: endTime2
+        startTime: startTime3,
+        endTime: endTime3
       }),
       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: import_zod5.z.object({ symbol: import_zod5.z.string().min(1).describe("Base pair, e.g. BTCUSDT"), interval: KlineIntervalSchema, limit: limitDefault.default(500), startTime: startTime2, endTime: endTime2 }),
+      inputSchema: import_zod7.z.object({ symbol: import_zod7.z.string().min(1).describe("Base pair, e.g. BTCUSDT"), interval: KlineIntervalSchema, limit: limitDefault.default(500), startTime: startTime3, endTime: endTime3 }),
       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: import_zod5.z.object({ symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), interval: KlineIntervalSchema, limit: limitDefault.default(500), startTime: startTime2, endTime: endTime2 }),
+      inputSchema: import_zod7.z.object({ symbol: import_zod7.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), interval: KlineIntervalSchema, limit: limitDefault.default(500), startTime: startTime3, endTime: endTime3 }),
       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: import_zod5.z.object({ symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      inputSchema: import_zod7.z.object({ symbol: import_zod7.z.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: import_zod5.z.object({ symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      inputSchema: import_zod7.z.object({ symbol: import_zod7.z.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: import_zod5.z.object({ symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), limit: limitDefault.default(100), startTime: startTime2, endTime: endTime2 }),
+      inputSchema: import_zod7.z.object({ symbol: import_zod7.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), limit: limitDefault.default(100), startTime: startTime3, endTime: endTime3 }),
       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: import_zod5.z.object({}),
+      inputSchema: import_zod7.z.object({}),
       handler: async () => textResult(await d.fundingInfo())
     },
     {
       name: "futures_open_interest",
       description: "Get the current total open interest for a symbol.",
-      inputSchema: import_zod5.z.object({ symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      inputSchema: import_zod7.z.object({ symbol: import_zod7.z.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: import_zod5.z.object({ symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), period, limit: limitDefault.default(30) }),
+      inputSchema: import_zod7.z.object({ symbol: import_zod7.z.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: import_zod5.z.object({ symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), period, limit: limitDefault.default(30) }),
+      inputSchema: import_zod7.z.object({ symbol: import_zod7.z.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: import_zod5.z.object({ symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), period, limit: limitDefault.default(30) }),
+      inputSchema: import_zod7.z.object({ symbol: import_zod7.z.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: import_zod5.z.object({ symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), period, limit: limitDefault.default(30) }),
+      inputSchema: import_zod7.z.object({ symbol: import_zod7.z.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: import_zod5.z.object({ symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), period, limit: limitDefault.default(30) }),
+      inputSchema: import_zod7.z.object({ symbol: import_zod7.z.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: import_zod5.z.object({
-        symbol: import_zod5.z.string().min(1).describe("Base pair, e.g. BTCUSDT"),
+      inputSchema: import_zod7.z.object({
+        symbol: import_zod7.z.string().min(1).describe("Base pair, e.g. BTCUSDT"),
         period,
         limit: limitDefault.default(30),
-        startTime: startTime2,
-        endTime: endTime2
+        startTime: startTime3,
+        endTime: endTime3
       }),
       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: import_zod5.z.object({ symbol: optSymbol.describe("Asset index symbol, e.g. ADAUSD") }),
+      inputSchema: import_zod7.z.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: import_zod5.z.object({ symbol: optSymbol }),
+      inputSchema: import_zod7.z.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: import_zod5.z.object({ symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BNBUSDT"), limit: limitDefault.default(100), startTime: startTime2, endTime: endTime2 }),
+      inputSchema: import_zod7.z.object({ symbol: import_zod7.z.string().min(1).describe("USD-M pair, e.g. BNBUSDT"), limit: limitDefault.default(100), startTime: startTime3, endTime: endTime3 }),
       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: import_zod5.z.object({ symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      inputSchema: import_zod7.z.object({ symbol: import_zod7.z.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: import_zod5.z.object({ symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), interval: KlineIntervalSchema, limit: limitDefault.default(500), startTime: startTime2, endTime: endTime2 }),
+      inputSchema: import_zod7.z.object({ symbol: import_zod7.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), interval: KlineIntervalSchema, limit: limitDefault.default(500), startTime: startTime3, endTime: endTime3 }),
       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: import_zod5.z.object({ symbol: import_zod5.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), limit: import_zod5.z.number().int().positive().default(1e3) }),
+      inputSchema: import_zod7.z.object({ symbol: import_zod7.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), limit: import_zod7.z.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: import_zod5.z.object({ symbol: import_zod5.z.string().min(1).describe("Base pair, e.g. BTCUSDT") }),
+      inputSchema: import_zod7.z.object({ symbol: import_zod7.z.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: import_zod5.z.object({ symbol: optSymbol }),
+      inputSchema: import_zod7.z.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: import_zod5.z.object({ symbol: optSymbol }),
+      inputSchema: import_zod7.z.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: import_zod5.z.object({
+      inputSchema: import_zod7.z.object({
         symbol: optSymbol,
-        autoCloseType: import_zod5.z.enum(["LIQUIDATION", "ADL"]).optional(),
-        startTime: startTime2,
-        endTime: endTime2,
+        autoCloseType: import_zod7.z.enum(["LIQUIDATION", "ADL"]).optional(),
+        startTime: startTime3,
+        endTime: endTime3,
         limit: limitDefault.default(50)
       }),
       handler: async ({ symbol: symbol3, autoCloseType, startTime: startTime5, endTime: endTime5, limit: limit4 }) => textResult(
@@ -733,7 +1053,7 @@ function marketDataTools(client) {
 }
 
 // src/tools/paper.tools.ts
-var import_zod6 = require("zod");
+var import_zod8 = require("zod");
 function createPaperContext(client, initialState = {}) {
   return {
     client,
@@ -751,7 +1071,7 @@ function paperTools(ctx) {
     {
       name: "paper_init",
       description: "Initialize paper-trading state (reset balances, positions, history). No API keys required.",
-      inputSchema: import_zod6.z.object({ balance: import_zod6.z.number().positive().default(1e4).describe("Starting USDT balance") }),
+      inputSchema: import_zod8.z.object({ balance: import_zod8.z.number().positive().default(1e4).describe("Starting USDT balance") }),
       handler: async ({ balance }) => {
         s.balance = balance;
         s.positions = [];
@@ -762,17 +1082,17 @@ function paperTools(ctx) {
     {
       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: import_zod6.z.object({}),
+      inputSchema: import_zod8.z.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: import_zod6.z.object({
-        symbol: import_zod6.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
-        side: import_zod6.z.enum(["LONG", "SHORT"]),
-        quantity: import_zod6.z.number().positive(),
-        price: import_zod6.z.number().positive().optional().describe("If omitted, uses live ticker price")
+      inputSchema: import_zod8.z.object({
+        symbol: import_zod8.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+        side: import_zod8.z.enum(["LONG", "SHORT"]),
+        quantity: import_zod8.z.number().positive(),
+        price: import_zod8.z.number().positive().optional().describe("If omitted, uses live ticker price")
       }),
       handler: async ({ symbol: symbol3, side: side3, quantity, price }) => {
         const sym = normalizeSymbol(symbol3);
@@ -786,10 +1106,10 @@ function paperTools(ctx) {
     {
       name: "paper_close_position",
       description: "Close a paper position by id (or symbol) and realize PnL at the live/last price.",
-      inputSchema: import_zod6.z.object({
-        id: import_zod6.z.string().optional().describe("Position id from paper_open_position"),
-        symbol: import_zod6.z.string().min(1).optional().describe("Close the position for this symbol"),
-        price: import_zod6.z.number().positive().optional().describe("If omitted, uses live ticker price")
+      inputSchema: import_zod8.z.object({
+        id: import_zod8.z.string().optional().describe("Position id from paper_open_position"),
+        symbol: import_zod8.z.string().min(1).optional().describe("Close the position for this symbol"),
+        price: import_zod8.z.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 ?? ""));
@@ -807,7 +1127,7 @@ function paperTools(ctx) {
     {
       name: "paper_positions",
       description: "List open paper positions with live unrealized PnL (marked to market).",
-      inputSchema: import_zod6.z.object({}),
+      inputSchema: import_zod8.z.object({}),
       handler: async () => {
         const out = await Promise.all(
           s.positions.map(async (p) => {
@@ -821,39 +1141,39 @@ function paperTools(ctx) {
     {
       name: "paper_history",
       description: "List paper-trading history of open/close events with realized PnL.",
-      inputSchema: import_zod6.z.object({}),
+      inputSchema: import_zod8.z.object({}),
       handler: async () => textResult(s.history)
     },
     {
       name: "paper_summary",
       description: "Summarize paper-trading state: balance, open positions, trade count.",
-      inputSchema: import_zod6.z.object({}),
+      inputSchema: import_zod8.z.object({}),
       handler: async () => textResult({ balance: s.balance, openPositions: s.positions.length, trades: s.history.length })
     }
   ];
 }
 
 // src/tools/spot.tools.ts
-var import_zod7 = require("zod");
-var spotSymbol = import_zod7.z.string().min(1).describe("Spot pair, e.g. BTCUSDT");
-var optionalSymbol2 = import_zod7.z.string().min(1).describe("Spot pair, e.g. BTCUSDT").optional();
-var limit2 = import_zod7.z.number().int().positive().max(1e3).default(100);
-var startTime3 = import_zod7.z.number().int().positive().optional();
-var endTime3 = import_zod7.z.number().int().positive().optional();
-var side = import_zod7.z.enum(["BUY", "SELL"]);
-var spotOrderParamsSchema = import_zod7.z.object({
+var import_zod9 = require("zod");
+var spotSymbol = import_zod9.z.string().min(1).describe("Spot pair, e.g. BTCUSDT");
+var optionalSymbol3 = import_zod9.z.string().min(1).describe("Spot pair, e.g. BTCUSDT").optional();
+var limit3 = import_zod9.z.number().int().positive().max(1e3).default(100);
+var startTime4 = import_zod9.z.number().int().positive().optional();
+var endTime4 = import_zod9.z.number().int().positive().optional();
+var side2 = import_zod9.z.enum(["BUY", "SELL"]);
+var spotOrderParamsSchema = import_zod9.z.object({
   symbol: spotSymbol,
-  side,
-  type: import_zod7.z.enum(["LIMIT", "MARKET", "LIMIT_MAKER", "STOP_LOSS", "STOP_LOSS_LIMIT", "TAKE_PROFIT", "TAKE_PROFIT_LIMIT"]),
-  quantity: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number()]).optional().describe("Base-asset quantity; omit if using quoteOrderQty"),
-  quoteOrderQty: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number()]).optional().describe("Quote-asset quantity (e.g. spend 100 USDT on a MARKET order)"),
-  price: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number()]).optional().describe("Required for LIMIT / STOP_LOSS_LIMIT / TAKE_PROFIT_LIMIT"),
-  stopPrice: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number()]).optional().describe("Trigger price for STOP_LOSS / TAKE_PROFIT variants"),
-  timeInForce: import_zod7.z.enum(["GTC", "IOC", "FOK"]).optional().describe("Required for LIMIT"),
-  newClientOrderId: import_zod7.z.string().optional(),
-  newOrderRespType: import_zod7.z.enum(["ACK", "RESULT", "FULL"]).optional(),
-  icebergQty: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number()]).optional(),
-  selfTradePreventionMode: import_zod7.z.enum(["NONE", "EXPIRE_TAKER", "EXPIRE_MAKER", "EXPIRE_BOTH"]).optional()
+  side: side2,
+  type: import_zod9.z.enum(["LIMIT", "MARKET", "LIMIT_MAKER", "STOP_LOSS", "STOP_LOSS_LIMIT", "TAKE_PROFIT", "TAKE_PROFIT_LIMIT"]),
+  quantity: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number()]).optional().describe("Base-asset quantity; omit if using quoteOrderQty"),
+  quoteOrderQty: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number()]).optional().describe("Quote-asset quantity (e.g. spend 100 USDT on a MARKET order)"),
+  price: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number()]).optional().describe("Required for LIMIT / STOP_LOSS_LIMIT / TAKE_PROFIT_LIMIT"),
+  stopPrice: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number()]).optional().describe("Trigger price for STOP_LOSS / TAKE_PROFIT variants"),
+  timeInForce: import_zod9.z.enum(["GTC", "IOC", "FOK"]).optional().describe("Required for LIMIT"),
+  newClientOrderId: import_zod9.z.string().optional(),
+  newOrderRespType: import_zod9.z.enum(["ACK", "RESULT", "FULL"]).optional(),
+  icebergQty: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number()]).optional(),
+  selfTradePreventionMode: import_zod9.z.enum(["NONE", "EXPIRE_TAKER", "EXPIRE_MAKER", "EXPIRE_BOTH"]).optional()
 });
 function spotTools(client) {
   const m = client.spot.market;
@@ -864,128 +1184,128 @@ function spotTools(client) {
     {
       name: "spot_ping",
       description: "Test connectivity to the Binance Spot REST API.",
-      inputSchema: import_zod7.z.object({}),
+      inputSchema: import_zod9.z.object({}),
       handler: async () => textResult(await m.ping())
     },
     {
       name: "spot_server_time",
       description: "Get the current Binance Spot server time in ms since epoch.",
-      inputSchema: import_zod7.z.object({}),
+      inputSchema: import_zod9.z.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: import_zod7.z.object({}),
+      inputSchema: import_zod9.z.object({}),
       handler: async () => textResult(await m.exchangeInfo())
     },
     {
       name: "spot_ticker_price",
       description: "Get the latest price for a Spot symbol.",
-      inputSchema: import_zod7.z.object({ symbol: spotSymbol }),
+      inputSchema: import_zod9.z.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: import_zod7.z.object({ symbol: spotSymbol }),
+      inputSchema: import_zod9.z.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: import_zod7.z.object({ symbol: spotSymbol }),
+      inputSchema: import_zod9.z.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: import_zod7.z.object({
+      inputSchema: import_zod9.z.object({
         symbol: spotSymbol,
-        limit: import_zod7.z.enum(["5", "10", "20", "50", "100", "500", "1000", "5000"]).default("100")
+        limit: import_zod9.z.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: import_zod7.z.object({ symbol: spotSymbol, limit: limit2.default(500) }),
+      inputSchema: import_zod9.z.object({ symbol: spotSymbol, limit: limit3.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: import_zod7.z.object({ symbol: spotSymbol, limit: limit2.default(500), fromId: import_zod7.z.number().int().positive().optional() }),
+      inputSchema: import_zod9.z.object({ symbol: spotSymbol, limit: limit3.default(500), fromId: import_zod9.z.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: import_zod7.z.object({ symbol: spotSymbol, limit: limit2.default(500), startTime: startTime3, endTime: endTime3 }),
+      inputSchema: import_zod9.z.object({ symbol: spotSymbol, limit: limit3.default(500), startTime: startTime4, endTime: endTime4 }),
       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: import_zod7.z.object({ symbol: spotSymbol, interval: KlineIntervalSchema, limit: limit2.default(500), startTime: startTime3, endTime: endTime3 }),
+      inputSchema: import_zod9.z.object({ symbol: spotSymbol, interval: KlineIntervalSchema, limit: limit3.default(500), startTime: startTime4, endTime: endTime4 }),
       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: import_zod7.z.object({ symbol: spotSymbol, interval: KlineIntervalSchema, limit: limit2.default(500), startTime: startTime3, endTime: endTime3 }),
+      inputSchema: import_zod9.z.object({ symbol: spotSymbol, interval: KlineIntervalSchema, limit: limit3.default(500), startTime: startTime4, endTime: endTime4 }),
       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: import_zod7.z.object({ symbol: spotSymbol }),
+      inputSchema: import_zod9.z.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: import_zod7.z.object({
-        symbol: optionalSymbol2,
-        windowSize: import_zod7.z.enum(["1d", "7d", "30d"]).optional()
+      inputSchema: import_zod9.z.object({
+        symbol: optionalSymbol3,
+        windowSize: import_zod9.z.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: import_zod7.z.object({ symbol: optionalSymbol2, timeZone: import_zod7.z.string().optional(), type: import_zod7.z.enum(["FULL", "MINI"]).optional() }),
+      inputSchema: import_zod9.z.object({ symbol: optionalSymbol3, timeZone: import_zod9.z.string().optional(), type: import_zod9.z.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: import_zod7.z.object({}),
+      inputSchema: import_zod9.z.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: import_zod7.z.object({ symbol: spotSymbol, orderId: import_zod7.z.number().int().positive().optional(), startTime: startTime3, endTime: endTime3, fromId: import_zod7.z.number().int().positive().optional(), limit: limit2.default(500) }),
+      inputSchema: import_zod9.z.object({ symbol: spotSymbol, orderId: import_zod9.z.number().int().positive().optional(), startTime: startTime4, endTime: endTime4, fromId: import_zod9.z.number().int().positive().optional(), limit: limit3.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: import_zod7.z.object({ symbol: spotSymbol, preventedMatchId: import_zod7.z.number().int().positive().optional(), orderId: import_zod7.z.number().int().positive().optional(), limit: limit2.default(500) }),
+      inputSchema: import_zod9.z.object({ symbol: spotSymbol, preventedMatchId: import_zod9.z.number().int().positive().optional(), orderId: import_zod9.z.number().int().positive().optional(), limit: limit3.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: import_zod7.z.object({ symbol: spotSymbol }),
+      inputSchema: import_zod9.z.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: import_zod7.z.object({}),
+      inputSchema: import_zod9.z.object({}),
       handler: async () => textResult(await a.rateLimitOrder())
     },
     // ---- Trading (signed) ----
@@ -1004,109 +1324,109 @@ function spotTools(client) {
     {
       name: "spot_get_order",
       description: "Query a specific Spot order by orderId or client order id. Signed.",
-      inputSchema: import_zod7.z.object({ symbol: spotSymbol, orderId: import_zod7.z.number().int().positive().optional(), origClientOrderId: import_zod7.z.string().optional() }),
+      inputSchema: import_zod9.z.object({ symbol: spotSymbol, orderId: import_zod9.z.number().int().positive().optional(), origClientOrderId: import_zod9.z.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: import_zod7.z.object({ symbol: spotSymbol, orderId: import_zod7.z.number().int().positive().optional(), origClientOrderId: import_zod7.z.string().optional(), newClientOrderId: import_zod7.z.string().optional() }),
+      inputSchema: import_zod9.z.object({ symbol: spotSymbol, orderId: import_zod9.z.number().int().positive().optional(), origClientOrderId: import_zod9.z.string().optional(), newClientOrderId: import_zod9.z.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: import_zod7.z.object({ symbol: optionalSymbol2 }),
+      inputSchema: import_zod9.z.object({ symbol: optionalSymbol3 }),
       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: import_zod7.z.object({ symbol: spotSymbol, orderId: import_zod7.z.number().int().positive().optional(), startTime: startTime3, endTime: endTime3, limit: limit2 }),
+      inputSchema: import_zod9.z.object({ symbol: spotSymbol, orderId: import_zod9.z.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: "spot_cancel_open_orders",
       description: "Cancel all open Spot orders for a symbol. Signed.",
-      inputSchema: import_zod7.z.object({ symbol: spotSymbol }),
+      inputSchema: import_zod9.z.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: import_zod7.z.object({
+      inputSchema: import_zod9.z.object({
         symbol: spotSymbol,
-        side,
-        type: import_zod7.z.enum(["LIMIT", "MARKET", "STOP_LOSS", "STOP_LOSS_LIMIT", "TAKE_PROFIT", "TAKE_PROFIT_LIMIT"]),
-        cancelReplaceMode: import_zod7.z.enum(["STOP_ON_FAILURE", "ALLOW_FAILURE"]).default("STOP_ON_FAILURE"),
-        cancelOrderId: import_zod7.z.number().int().positive().optional(),
-        cancelOrigClientOrderId: import_zod7.z.string().optional(),
-        cancelNewClientOrderId: import_zod7.z.string().optional(),
-        quantity: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number()]).optional(),
-        price: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number()]).optional(),
-        timeInForce: import_zod7.z.enum(["GTC", "IOC", "FOK"]).optional(),
-        newClientOrderId: import_zod7.z.string().optional()
+        side: side2,
+        type: import_zod9.z.enum(["LIMIT", "MARKET", "STOP_LOSS", "STOP_LOSS_LIMIT", "TAKE_PROFIT", "TAKE_PROFIT_LIMIT"]),
+        cancelReplaceMode: import_zod9.z.enum(["STOP_ON_FAILURE", "ALLOW_FAILURE"]).default("STOP_ON_FAILURE"),
+        cancelOrderId: import_zod9.z.number().int().positive().optional(),
+        cancelOrigClientOrderId: import_zod9.z.string().optional(),
+        cancelNewClientOrderId: import_zod9.z.string().optional(),
+        quantity: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number()]).optional(),
+        price: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number()]).optional(),
+        timeInForce: import_zod9.z.enum(["GTC", "IOC", "FOK"]).optional(),
+        newClientOrderId: import_zod9.z.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: import_zod7.z.object({
+      inputSchema: import_zod9.z.object({
         symbol: spotSymbol,
-        side,
-        quantity: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number()]).describe("Total base-asset quantity for both legs"),
-        price: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number()]).describe("Limit (take-profit) price"),
-        stopPrice: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number()]).describe("Stop-loss trigger price"),
-        stopLimitPrice: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number()]).optional().describe("Stop-loss limit price (defaults to stopPrice)"),
-        stopLimitTimeInForce: import_zod7.z.enum(["GTC", "IOC", "FOK"]).optional(),
-        listClientOrderId: import_zod7.z.string().optional(),
-        limitClientOrderId: import_zod7.z.string().optional(),
-        stopClientOrderId: import_zod7.z.string().optional()
+        side: side2,
+        quantity: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number()]).describe("Total base-asset quantity for both legs"),
+        price: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number()]).describe("Limit (take-profit) price"),
+        stopPrice: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number()]).describe("Stop-loss trigger price"),
+        stopLimitPrice: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number()]).optional().describe("Stop-loss limit price (defaults to stopPrice)"),
+        stopLimitTimeInForce: import_zod9.z.enum(["GTC", "IOC", "FOK"]).optional(),
+        listClientOrderId: import_zod9.z.string().optional(),
+        limitClientOrderId: import_zod9.z.string().optional(),
+        stopClientOrderId: import_zod9.z.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: import_zod7.z.object({ symbol: spotSymbol, orderListId: import_zod7.z.number().int().positive().optional(), listClientOrderId: import_zod7.z.string().optional(), newClientOrderId: import_zod7.z.string().optional() }),
+      inputSchema: import_zod9.z.object({ symbol: spotSymbol, orderListId: import_zod9.z.number().int().positive().optional(), listClientOrderId: import_zod9.z.string().optional(), newClientOrderId: import_zod9.z.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: import_zod7.z.object({ symbol: spotSymbol, orderListId: import_zod7.z.number().int().positive().optional(), origClientOrderId: import_zod7.z.string().optional() }),
+      inputSchema: import_zod9.z.object({ symbol: spotSymbol, orderListId: import_zod9.z.number().int().positive().optional(), origClientOrderId: import_zod9.z.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: import_zod7.z.object({}),
+      inputSchema: import_zod9.z.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: import_zod7.z.object({ symbol: spotSymbol, fromId: import_zod7.z.number().int().positive().optional(), startTime: startTime3, endTime: endTime3, limit: limit2 }),
+      inputSchema: import_zod9.z.object({ symbol: spotSymbol, fromId: import_zod9.z.number().int().positive().optional(), startTime: startTime4, endTime: endTime4, limit: limit3 }),
       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: import_zod7.z.object({ symbol: spotSymbol }),
+      inputSchema: import_zod9.z.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: import_zod7.z.object({}),
+      inputSchema: import_zod9.z.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: import_zod7.z.object({}),
+      inputSchema: import_zod9.z.object({}),
       handler: async () => {
         client.closeSpotUserStream();
         return textResult({ stopped: true });
@@ -1116,239 +1436,8 @@ function spotTools(client) {
   return tools;
 }
 
-// src/tools/trading.tools.ts
-var import_zod8 = require("zod");
-var symbol2 = import_zod8.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT");
-var optionalSymbol3 = import_zod8.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT").optional();
-var limit3 = import_zod8.z.number().int().positive().max(1e3).default(100);
-var startTime4 = import_zod8.z.number().int().positive().optional();
-var endTime4 = import_zod8.z.number().int().positive().optional();
-var side2 = import_zod8.z.enum(["BUY", "SELL"]);
-var positionSide = import_zod8.z.enum(["BOTH", "LONG", "SHORT"]).optional();
-var orderParamsSchema = import_zod8.z.object({
-  symbol: symbol2,
-  side: side2,
-  type: import_zod8.z.enum(["LIMIT", "MARKET", "STOP", "STOP_MARKET", "TAKE_PROFIT", "TAKE_PROFIT_MARKET", "TRAILING_STOP_MARKET"]),
-  quantity: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number()]).describe("Order quantity in base asset"),
-  price: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number()]).optional().describe("Required for LIMIT and STOP/TAKE_PROFIT (limit-triggered) types"),
-  timeInForce: import_zod8.z.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
-  stopPrice: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number()]).optional().describe("Trigger price for STOP/STOP_MARKET/TAKE_PROFIT/TAKE_PROFIT_MARKET"),
-  reduceOnly: import_zod8.z.boolean().optional().describe("true = only reduces the position, never opens"),
-  positionSide,
-  newClientOrderId: import_zod8.z.string().optional(),
-  closePosition: import_zod8.z.boolean().optional().describe("Close the full position on trigger (mutually exclusive with quantity)"),
-  newOrderRespType: import_zod8.z.enum(["ACK", "RESULT"]).optional(),
-  priceProtect: import_zod8.z.boolean().optional(),
-  workingType: import_zod8.z.enum(["MARK_PRICE", "CONTRACT_PRICE"]).optional().describe("Trigger price basis; default CONTRACT_PRICE"),
-  callbackRate: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number()]).optional().describe("Percent callback for TRAILING_STOP_MARKET, e.g. 0.5"),
-  activationPrice: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number()]).optional().describe("Activation price for TRAILING_STOP_MARKET"),
-  selfTradePreventionMode: import_zod8.z.enum(["NONE", "EXPIRE_TAKER", "EXPIRE_MAKER", "EXPIRE_BOTH"]).optional(),
-  goodTillDate: import_zod8.z.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: import_zod8.z.object({ symbol: symbol2, orderId: import_zod8.z.number().int().positive().optional(), origClientOrderId: import_zod8.z.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: import_zod8.z.object({ symbol: symbol2, orderId: import_zod8.z.number().int().positive().optional(), origClientOrderId: import_zod8.z.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: import_zod8.z.object({ symbol: symbol2, orderId: import_zod8.z.number().int().positive().optional(), origClientOrderId: import_zod8.z.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: import_zod8.z.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: import_zod8.z.object({ symbol: symbol2, orderId: import_zod8.z.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: import_zod8.z.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: import_zod8.z.object({
-        symbol: symbol2,
-        side: side2,
-        quantity: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number()]),
-        price: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number()]).optional(),
-        orderId: import_zod8.z.number().int().positive().optional(),
-        origClientOrderId: import_zod8.z.string().optional(),
-        stopPrice: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number()]).optional(),
-        timeInForce: import_zod8.z.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
-        positionSide,
-        newClientOrderId: import_zod8.z.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: import_zod8.z.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: import_zod8.z.object({ orders: import_zod8.z.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: import_zod8.z.object({
-        symbol: symbol2,
-        orderIdList: import_zod8.z.array(import_zod8.z.number().int().positive()).max(10).optional(),
-        origClientOrderIdList: import_zod8.z.array(import_zod8.z.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: import_zod8.z.object({ symbol: symbol2, leverage: import_zod8.z.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: import_zod8.z.object({ symbol: symbol2, marginType: import_zod8.z.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: import_zod8.z.object({ symbol: symbol2, amount: import_zod8.z.number().positive(), marginType: import_zod8.z.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: import_zod8.z.object({ symbol: symbol2, countdownTime: import_zod8.z.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: import_zod8.z.object({
-        algoType: import_zod8.z.enum(["CONDITIONAL", "VP"]),
-        symbol: symbol2,
-        side: side2,
-        positionSide,
-        type: import_zod8.z.enum(["STOP_MARKET", "TAKE_PROFIT_MARKET", "LIMIT"]).describe("For CONDITIONAL: STOP_MARKET/TAKE_PROFIT_MARKET. For VP: LIMIT"),
-        quantity: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number()]),
-        triggerPrice: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number()]).optional().describe("Required for CONDITIONAL"),
-        price: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number()]).optional(),
-        timeInForce: import_zod8.z.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
-        workingType: import_zod8.z.enum(["MARK_PRICE", "CONTRACT_PRICE"]).optional(),
-        priceProtect: import_zod8.z.boolean().optional(),
-        reduceOnly: import_zod8.z.boolean().optional(),
-        closePosition: import_zod8.z.boolean().optional(),
-        urgency: import_zod8.z.enum(["LOW", "MEDIUM", "HIGH"]).optional().describe("Required for VP"),
-        clientAlgoId: import_zod8.z.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: import_zod8.z.object({ symbol: symbol2, algoId: import_zod8.z.number().int().positive().optional(), clientAlgoId: import_zod8.z.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: import_zod8.z.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: import_zod8.z.object({ symbol: symbol2, algoId: import_zod8.z.number().int().positive().optional(), clientAlgoId: import_zod8.z.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: import_zod8.z.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: import_zod8.z.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: import_zod8.z.object({ fromAsset: import_zod8.z.string().optional(), toAsset: import_zod8.z.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: import_zod8.z.object({
-        fromAsset: import_zod8.z.string().min(1),
-        toAsset: import_zod8.z.string().min(1),
-        fromAmount: import_zod8.z.number().positive().optional(),
-        toAmount: import_zod8.z.number().positive().optional(),
-        validTime: import_zod8.z.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: import_zod8.z.object({ quoteId: import_zod8.z.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: import_zod8.z.object({ orderId: import_zod8.z.string().optional(), quoteId: import_zod8.z.string().optional() }),
-      handler: async ({ orderId, quoteId }) => textResult(await t.convertOrderStatus({ orderId, quoteId }))
-    }
-  ];
-}
-
 // src/tools/ws.tools.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 var buffers = /* @__PURE__ */ new Map();
 var MAX_BUFFER = 500;
 function bufferFor(client) {
@@ -1375,8 +1464,8 @@ function wsTools(client) {
     {
       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: import_zod9.z.object({
-        topics: import_zod9.z.array(import_zod9.z.string().min(1)).min(1).describe('Stream topics, e.g. ["btcusdt@aggTrade", "btcusdt@kline_1m"]')
+      inputSchema: import_zod10.z.object({
+        topics: import_zod10.z.array(import_zod10.z.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());
@@ -1388,7 +1477,7 @@ function wsTools(client) {
     {
       name: "futures_ws_unsubscribe",
       description: "Unsubscribe from previously subscribed market data streams.",
-      inputSchema: import_zod9.z.object({ topics: import_zod9.z.array(import_zod9.z.string().min(1)).min(1) }),
+      inputSchema: import_zod10.z.object({ topics: import_zod10.z.array(import_zod10.z.string().min(1)).min(1) }),
       handler: async ({ topics }) => {
         const normalized = topics.map((t) => t.trim().toLowerCase());
         client.futures.ws.unsubscribe(normalized);
@@ -1399,19 +1488,19 @@ function wsTools(client) {
     {
       name: "futures_ws_subscriptions",
       description: "List the currently subscribed WebSocket market streams for this client.",
-      inputSchema: import_zod9.z.object({}),
+      inputSchema: import_zod10.z.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: import_zod9.z.object({ limit: import_zod9.z.number().int().min(1).max(200).default(50) }),
+      inputSchema: import_zod10.z.object({ limit: import_zod10.z.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: import_zod9.z.object({}),
+      inputSchema: import_zod10.z.object({}),
       handler: async () => {
         clearBufferedWsEvents(client);
         return textResult({ cleared: true });
@@ -1420,13 +1509,13 @@ function wsTools(client) {
     {
       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: import_zod9.z.object({}),
+      inputSchema: import_zod10.z.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: import_zod9.z.object({}),
+      inputSchema: import_zod10.z.object({}),
       handler: async () => {
         client.closeUserStream();
         return textResult({ stopped: true });
@@ -1435,49 +1524,49 @@ function wsTools(client) {
     {
       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: import_zod9.z.object({
-        symbol: import_zod9.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
-        orderId: import_zod9.z.number().int().positive().optional(),
-        origClientOrderId: import_zod9.z.string().optional()
+      inputSchema: import_zod10.z.object({
+        symbol: import_zod10.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+        orderId: import_zod10.z.number().int().positive().optional(),
+        origClientOrderId: import_zod10.z.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: import_zod9.z.object({}),
+      inputSchema: import_zod10.z.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: import_zod9.z.object({ symbol: import_zod9.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT").optional() }),
+      inputSchema: import_zod10.z.object({ symbol: import_zod10.z.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: import_zod9.z.object({}),
+      inputSchema: import_zod10.z.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: import_zod9.z.object({ listenKey: import_zod9.z.string().min(1) }),
+      inputSchema: import_zod10.z.object({ listenKey: import_zod10.z.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: import_zod9.z.object({ symbol: import_zod9.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT").optional() }),
+      inputSchema: import_zod10.z.object({ symbol: import_zod10.z.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: import_zod9.z.object({
-        symbol: import_zod9.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
-        limit: import_zod9.z.enum(["5", "10", "20", "50", "100", "500", "1000"]).optional()
+      inputSchema: import_zod10.z.object({
+        symbol: import_zod10.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+        limit: import_zod10.z.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 }))
     }
@@ -1485,7 +1574,7 @@ function wsTools(client) {
 }
 
 // src/tools/index.ts
-function createFuturesToolkit(client) {
+function createFuturesToolkit(client, options = {}) {
   const market = marketDataTools(client);
   const account = accountTools(client);
   const trading = tradingTools(client);
@@ -1494,9 +1583,14 @@ function createFuturesToolkit(client) {
   const derived = derivedTools(client);
   const paperContext = createPaperContext(client);
   const paper = paperTools(paperContext);
+  const gateway = client.createExecutionGateway({
+    paper: options.paper,
+    defaultBackend: options.executionBackend
+  });
+  const execution = executionTools(gateway, client);
   return {
     client,
-    tools: [...market, ...account, ...trading, ...spot, ...ws, ...derived, ...paper],
+    tools: [...market, ...account, ...trading, ...spot, ...ws, ...derived, ...paper, ...execution],
     market,
     account,
     trading,
@@ -1504,7 +1598,9 @@ function createFuturesToolkit(client) {
     ws,
     derived,
     paper,
-    paperContext
+    paperContext,
+    execution,
+    gateway
   };
 }
 function toolkitToFormats(toolkit) {
@@ -1521,6 +1617,7 @@ function toolkitToFormats(toolkit) {
   createFuturesToolkit,
   createPaperContext,
   derivedTools,
+  executionTools,
   getBufferedWsEvents,
   marketDataTools,
   paperTools,