toobit-trade-cli 1.0.0 → 1.0.2

package/dist/index.js

@@ -1,13 +1,2206 @@
 #!/usr/bin/env node
 
-// src/index.ts
-import {
-  loadConfig,
-  ToobitRestClient,
-  createToolRunner,
-  toToolErrorPayload,
-  configFilePath as configFilePath2
-} from "@toobit_agent/agent-toobitkit-core";
+// ../core/dist/index.js
+import { createHmac } from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync, existsSync as existsSync2 } from "fs";
+import { join as join2, dirname } from "path";
+import { homedir as homedir2 } from "os";
+import { parse, stringify } from "smol-toml";
+function getTimestamp() {
+  return Date.now();
+}
+function signToobitPayload(queryString, secretKey) {
+  return createHmac("sha256", secretKey).update(queryString).digest("hex");
+}
+var ToobitMcpError = class extends Error {
+  type;
+  code;
+  suggestion;
+  endpoint;
+  constructor(type, message, options) {
+    super(message, options?.cause ? { cause: options.cause } : void 0);
+    this.name = type;
+    this.type = type;
+    this.code = options?.code;
+    this.suggestion = options?.suggestion;
+    this.endpoint = options?.endpoint;
+  }
+};
+var ConfigError = class extends ToobitMcpError {
+  constructor(message, suggestion) {
+    super("ConfigError", message, { suggestion });
+  }
+};
+var ValidationError = class extends ToobitMcpError {
+  constructor(message, suggestion) {
+    super("ValidationError", message, { suggestion });
+  }
+};
+var RateLimitError = class extends ToobitMcpError {
+  constructor(message, suggestion, endpoint) {
+    super("RateLimitError", message, { suggestion, endpoint });
+  }
+};
+var AuthenticationError = class extends ToobitMcpError {
+  constructor(message, suggestion, endpoint) {
+    super("AuthenticationError", message, { suggestion, endpoint });
+  }
+};
+var ToobitApiError = class extends ToobitMcpError {
+  constructor(message, options) {
+    super("ToobitApiError", message, options);
+  }
+};
+var NetworkError = class extends ToobitMcpError {
+  constructor(message, endpoint, cause) {
+    super("NetworkError", message, {
+      endpoint,
+      cause,
+      suggestion: "Please check network connectivity and retry the request in a few seconds."
+    });
+  }
+};
+function toToolErrorPayload(error, fallbackEndpoint) {
+  if (error instanceof ToobitMcpError) {
+    return {
+      error: true,
+      type: error.type,
+      code: error.code,
+      message: error.message,
+      suggestion: error.suggestion,
+      endpoint: error.endpoint ?? fallbackEndpoint,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    error: true,
+    type: "InternalError",
+    message,
+    suggestion: "Unexpected server error. Check tool arguments and retry.",
+    endpoint: fallbackEndpoint,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+var RateLimiter = class {
+  buckets = /* @__PURE__ */ new Map();
+  maxWaitMs;
+  constructor(maxWaitMs = 3e4) {
+    this.maxWaitMs = maxWaitMs;
+  }
+  async consume(config, amount = 1) {
+    const bucket = this.getBucket(config);
+    this.refill(bucket);
+    if (bucket.tokens >= amount) {
+      bucket.tokens -= amount;
+      return;
+    }
+    const missing = amount - bucket.tokens;
+    const secondsToWait = missing / bucket.refillPerSecond;
+    const waitMs = Math.ceil(secondsToWait * 1e3);
+    if (waitMs > this.maxWaitMs) {
+      throw new RateLimitError(
+        `Client-side rate limit reached for ${config.key}. Required wait ${waitMs}ms exceeds allowed max ${this.maxWaitMs}ms.`,
+        "Reduce tool call frequency or retry later."
+      );
+    }
+    await sleep(waitMs);
+    this.refill(bucket);
+    if (bucket.tokens < amount) {
+      throw new RateLimitError(
+        `Rate limiter failed to acquire enough tokens for ${config.key}.`
+      );
+    }
+    bucket.tokens -= amount;
+  }
+  getBucket(config) {
+    const existing = this.buckets.get(config.key);
+    if (existing) {
+      if (existing.capacity !== config.capacity || existing.refillPerSecond !== config.refillPerSecond) {
+        existing.capacity = config.capacity;
+        existing.refillPerSecond = config.refillPerSecond;
+        existing.tokens = Math.min(existing.tokens, config.capacity);
+      }
+      return existing;
+    }
+    const now = Date.now();
+    const created = {
+      tokens: config.capacity,
+      lastRefillMs: now,
+      capacity: config.capacity,
+      refillPerSecond: config.refillPerSecond
+    };
+    this.buckets.set(config.key, created);
+    return created;
+  }
+  refill(bucket) {
+    const now = Date.now();
+    const elapsedMs = now - bucket.lastRefillMs;
+    if (elapsedMs <= 0) return;
+    const refillTokens = elapsedMs / 1e3 * bucket.refillPerSecond;
+    bucket.tokens = Math.min(bucket.capacity, bucket.tokens + refillTokens);
+    bucket.lastRefillMs = now;
+  }
+};
+var TOOBIT_CODE_BEHAVIORS = {
+  "-1000": { retry: true, suggestion: "Unknown error. Retry after a delay." },
+  "-1001": { retry: true, suggestion: "Disconnected / internal error. Retry." },
+  "-1003": { retry: true, suggestion: "Too many requests. Back off and retry." },
+  "-1006": { retry: true, suggestion: "Unexpected response. Retry later." },
+  "-1007": { retry: true, suggestion: "Timeout. Retry after a delay." },
+  "-1016": { retry: true, suggestion: "Service shutting down. Retry later." },
+  "-1002": { retry: false, suggestion: "Unauthorized. Check API key permissions." },
+  "-1015": { retry: false, suggestion: "Too many orders. Reduce order frequency." },
+  "-1020": { retry: false, suggestion: "Unsupported operation." },
+  "-1021": { retry: false, suggestion: "Invalid timestamp. Check system clock sync." },
+  "-1022": { retry: false, suggestion: "Invalid signature. Check API key and secret." },
+  "-2010": { retry: false, suggestion: "New order rejected. Check order parameters." },
+  "-2011": { retry: false, suggestion: "Cancel rejected. Order may already be filled." },
+  "-2013": { retry: false, suggestion: "Order does not exist." },
+  "-2014": { retry: false, suggestion: "Bad API key format." },
+  "-2015": { retry: false, suggestion: "Invalid API key, IP, or permission." },
+  "-2017": { retry: false, suggestion: "API key expired. Generate a new one." },
+  "-1130": { retry: false, suggestion: "Invalid symbol format. Futures endpoints require BTC-SWAP-USDT format; spot endpoints use BTCUSDT." },
+  "-1107": { retry: false, suggestion: "API key is missing or malformed. Check X-BB-APIKEY header." }
+};
+function isDefined(value) {
+  return value !== void 0 && value !== null;
+}
+function stringifyQueryValue(value) {
+  if (Array.isArray(value)) return value.map(String).join(",");
+  return String(value);
+}
+function buildQueryString(query) {
+  if (!query) return "";
+  const entries = Object.entries(query).filter(([, v]) => isDefined(v));
+  if (entries.length === 0) return "";
+  return entries.map(([k, v]) => `${k}=${stringifyQueryValue(v)}`).join("&");
+}
+var ToobitRestClient = class {
+  config;
+  rateLimiter = new RateLimiter();
+  constructor(config) {
+    this.config = config;
+  }
+  async publicGet(path4, query, rateLimit) {
+    return this.request({ method: "GET", path: path4, auth: "public", query, rateLimit });
+  }
+  async privateGet(path4, query, rateLimit) {
+    return this.request({ method: "GET", path: path4, auth: "private", query, rateLimit });
+  }
+  async privatePost(path4, body, rateLimit) {
+    return this.request({ method: "POST", path: path4, auth: "private", body, rateLimit });
+  }
+  async privateDelete(path4, query, rateLimit) {
+    return this.request({ method: "DELETE", path: path4, auth: "private", query, rateLimit });
+  }
+  async request(config) {
+    if (config.rateLimit) {
+      await this.rateLimiter.consume(config.rateLimit);
+    }
+    const timestamp = getTimestamp();
+    let allParams = { ...config.query ?? {} };
+    const isBodyMethod = config.method === "POST" || config.method === "PUT";
+    if (config.body) {
+      Object.assign(allParams, config.body);
+    }
+    if (config.auth === "private") {
+      if (!this.config.hasAuth) {
+        throw new ConfigError(
+          "Private endpoint requires API credentials.",
+          "Configure TOOBIT_API_KEY and TOOBIT_SECRET_KEY."
+        );
+      }
+      allParams.timestamp = String(timestamp);
+      const signPayload = buildQueryString(allParams);
+      const signature = signToobitPayload(signPayload, this.config.secretKey);
+      allParams.signature = signature;
+    }
+    const paramString = buildQueryString(allParams);
+    let url;
+    let fetchBody;
+    if (isBodyMethod && config.auth === "private") {
+      url = `${this.config.baseUrl}${config.path}`;
+      fetchBody = paramString || void 0;
+    } else {
+      const requestPath = paramString ? `${config.path}?${paramString}` : config.path;
+      url = `${this.config.baseUrl}${requestPath}`;
+      fetchBody = void 0;
+    }
+    const headers = new Headers({
+      Accept: "application/json"
+    });
+    if (isBodyMethod) {
+      headers.set("Content-Type", "application/x-www-form-urlencoded");
+    }
+    if (this.config.userAgent) {
+      headers.set("User-Agent", this.config.userAgent);
+    }
+    if (config.auth === "private" && this.config.apiKey) {
+      headers.set("X-BB-APIKEY", this.config.apiKey);
+    }
+    let response;
+    try {
+      response = await fetch(url, {
+        method: config.method,
+        headers,
+        body: fetchBody,
+        signal: AbortSignal.timeout(this.config.timeoutMs)
+      });
+    } catch (error) {
+      throw new NetworkError(
+        `Failed to call Toobit endpoint ${config.method} ${config.path}.`,
+        `${config.method} ${config.path}`,
+        error
+      );
+    }
+    const rawText = await response.text();
+    let parsed;
+    try {
+      parsed = rawText ? JSON.parse(rawText) : {};
+    } catch (error) {
+      if (!response.ok) {
+        const preview = rawText.slice(0, 160).replace(/\s+/g, " ").trim();
+        throw new ToobitApiError(
+          `HTTP ${response.status} from Toobit: ${preview || "Non-JSON response"}`,
+          { code: String(response.status), endpoint: `${config.method} ${config.path}` }
+        );
+      }
+      throw new NetworkError(
+        `Toobit returned non-JSON response for ${config.method} ${config.path}.`,
+        `${config.method} ${config.path}`,
+        error
+      );
+    }
+    if (response.status === 429) {
+      throw new RateLimitError(
+        "Rate limited by Toobit. Back off and retry.",
+        "Reduce request frequency.",
+        `${config.method} ${config.path}`
+      );
+    }
+    const responseCode = parsed.code;
+    const responseMsg = parsed.msg || void 0;
+    const endpoint = `${config.method} ${config.path}`;
+    const hasBusinessCode = responseCode !== void 0 && responseCode !== 0;
+    if (hasBusinessCode) {
+      const codeStr = String(responseCode);
+      const message = responseMsg || "Toobit API request failed.";
+      const behavior = TOOBIT_CODE_BEHAVIORS[codeStr];
+      if (codeStr === "-1002" || codeStr === "-1022" || codeStr === "-1107" || codeStr === "-2014" || codeStr === "-2015" || codeStr === "-2017") {
+        throw new AuthenticationError(
+          message,
+          behavior?.suggestion ?? "Check API key, secret key and permissions.",
+          endpoint
+        );
+      }
+      if (codeStr === "-1003") {
+        throw new RateLimitError(message, "Too many requests. Back off.", endpoint);
+      }
+      throw new ToobitApiError(message, {
+        code: codeStr,
+        endpoint,
+        suggestion: behavior?.suggestion
+      });
+    }
+    if (!response.ok) {
+      const rawMsg = responseMsg ?? "Unknown error";
+      let suggestion;
+      if (/symbol|paramter|parameter/i.test(rawMsg)) {
+        const isFuturesPath = /futures|fundingRate|openInterest|markPrice|contract|longShort|insurance|riskLimit/i.test(config.path);
+        suggestion = isFuturesPath ? "Futures endpoints require contract symbol format, e.g. BTC-SWAP-USDT instead of BTCUSDT." : "Spot endpoints require symbol format like BTCUSDT.";
+      }
+      throw new ToobitApiError(
+        `HTTP ${response.status} from Toobit: ${rawMsg}`,
+        { code: String(response.status), endpoint, suggestion }
+      );
+    }
+    return {
+      endpoint: `${config.method} ${config.path}`,
+      requestTime: (/* @__PURE__ */ new Date()).toISOString(),
+      data: parsed,
+      raw: parsed
+    };
+  }
+};
+var TOOBIT_API_BASE_URL = "https://api.toobit.com";
+var DEFAULT_SOURCE_TAG = "MCP";
+var MODULES = [
+  "market",
+  "spot",
+  "futures",
+  "account"
+];
+var DEFAULT_MODULES = ["spot", "futures", "account"];
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+  return value;
+}
+function readString(args, key) {
+  const value = args[key];
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string") throw new ValidationError(`Parameter "${key}" must be a string.`);
+  return value;
+}
+function readNumber(args, key) {
+  const value = args[key];
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "number" || Number.isNaN(value)) throw new ValidationError(`Parameter "${key}" must be a number.`);
+  return value;
+}
+function requireString(args, key) {
+  const value = readString(args, key);
+  if (!value || value.length === 0) throw new ValidationError(`Missing required parameter "${key}".`);
+  return value;
+}
+function compactObject(object) {
+  const next = {};
+  for (const [key, value] of Object.entries(object)) {
+    if (value !== void 0 && value !== null) next[key] = value;
+  }
+  return next;
+}
+var TOOBIT_CANDLE_BARS = [
+  "1m",
+  "3m",
+  "5m",
+  "15m",
+  "30m",
+  "1h",
+  "2h",
+  "4h",
+  "6h",
+  "8h",
+  "12h",
+  "1d",
+  "3d",
+  "1w",
+  "1M"
+];
+function publicRateLimit(key, rps = 20) {
+  return { key: `public:${key}`, capacity: rps, refillPerSecond: rps };
+}
+function privateRateLimit(key, rps = 10) {
+  return { key: `private:${key}`, capacity: rps, refillPerSecond: rps };
+}
+function normalize(response) {
+  return { endpoint: response.endpoint, requestTime: response.requestTime, data: response.data };
+}
+function registerAccountTools() {
+  return [
+    {
+      name: "account_get_info",
+      module: "account",
+      description: "Get spot account information (balances for all assets). Private endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: { type: "object", properties: {} },
+      handler: async (_rawArgs, context) => {
+        const response = await context.client.privateGet(
+          "/api/v1/account",
+          {},
+          privateRateLimit("account_get_info", 20)
+        );
+        return normalize(response);
+      }
+    },
+    {
+      name: "account_get_balance_flow",
+      module: "account",
+      description: "Get account balance flow (ledger). Private endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          accountType: { type: "number", description: "1=coin, 2=contract" },
+          tokenId: { type: "string" },
+          fromFlowId: { type: "string" },
+          endFlowId: { type: "string" },
+          startTime: { type: "number" },
+          endTime: { type: "number" },
+          limit: { type: "number" }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/api/v1/account/balanceFlow",
+          compactObject({
+            accountType: readNumber(args, "accountType"),
+            tokenId: readString(args, "tokenId"),
+            fromFlowId: readString(args, "fromFlowId"),
+            endFlowId: readString(args, "endFlowId"),
+            startTime: readNumber(args, "startTime"),
+            endTime: readNumber(args, "endTime"),
+            limit: readNumber(args, "limit")
+          }),
+          privateRateLimit("account_get_balance_flow", 20)
+        );
+        return normalize(response);
+      }
+    },
+    {
+      name: "account_get_sub_accounts",
+      module: "account",
+      description: "Get sub-account list. Private endpoint. Rate limit: 10 req/s.",
+      isWrite: false,
+      inputSchema: { type: "object", properties: {} },
+      handler: async (_rawArgs, context) => {
+        const response = await context.client.privateGet(
+          "/api/v1/account/subAccount",
+          {},
+          privateRateLimit("account_get_sub_accounts", 10)
+        );
+        return normalize(response);
+      }
+    },
+    {
+      name: "account_sub_transfer",
+      module: "account",
+      description: "Transfer funds between main and sub accounts. [CAUTION] Private endpoint. Rate limit: 5 req/s.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          fromAccountType: { type: "number", description: "1=coin, 2=contract" },
+          toAccountType: { type: "number", description: "1=coin, 2=contract" },
+          tokenId: { type: "string", description: "e.g. USDT" },
+          amount: { type: "string" },
+          subAccountId: { type: "string" }
+        },
+        required: ["tokenId", "amount"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privatePost(
+          "/api/v1/subAccount/transfer",
+          compactObject({
+            fromAccountType: readNumber(args, "fromAccountType"),
+            toAccountType: readNumber(args, "toAccountType"),
+            tokenId: requireString(args, "tokenId"),
+            amount: requireString(args, "amount"),
+            subAccountId: readString(args, "subAccountId")
+          }),
+          privateRateLimit("account_sub_transfer", 5)
+        );
+        return normalize(response);
+      }
+    },
+    {
+      name: "account_check_api_key",
+      module: "account",
+      description: "Check API key type and permissions. Private endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: { type: "object", properties: {} },
+      handler: async (_rawArgs, context) => {
+        const response = await context.client.privateGet(
+          "/api/v1/account/checkApiKey",
+          {},
+          privateRateLimit("account_check_api_key", 20)
+        );
+        return normalize(response);
+      }
+    },
+    {
+      name: "account_withdraw",
+      module: "account",
+      description: "Submit a withdrawal request. [CAUTION] Moves real funds. Private endpoint. Rate limit: 5 req/s.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          tokenId: { type: "string", description: "e.g. USDT" },
+          address: { type: "string" },
+          addressExt: { type: "string", description: "Memo/tag if required" },
+          chainType: { type: "string" },
+          withdrawQuantity: { type: "string" },
+          clientOrderId: { type: "string" }
+        },
+        required: ["tokenId", "address", "chainType", "withdrawQuantity"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privatePost(
+          "/api/v1/account/withdraw",
+          compactObject({
+            tokenId: requireString(args, "tokenId"),
+            address: requireString(args, "address"),
+            addressExt: readString(args, "addressExt"),
+            chainType: requireString(args, "chainType"),
+            withdrawQuantity: requireString(args, "withdrawQuantity"),
+            clientOrderId: readString(args, "clientOrderId")
+          }),
+          privateRateLimit("account_withdraw", 5)
+        );
+        return normalize(response);
+      }
+    },
+    {
+      name: "account_get_withdraw_orders",
+      module: "account",
+      description: "Get withdrawal records. Private endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          tokenId: { type: "string" },
+          startTime: { type: "number" },
+          endTime: { type: "number" },
+          fromId: { type: "string" },
+          limit: { type: "number" }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/api/v1/account/withdrawOrders",
+          compactObject({
+            tokenId: readString(args, "tokenId"),
+            startTime: readNumber(args, "startTime"),
+            endTime: readNumber(args, "endTime"),
+            fromId: readString(args, "fromId"),
+            limit: readNumber(args, "limit")
+          }),
+          privateRateLimit("account_get_withdraw_orders", 20)
+        );
+        return normalize(response);
+      }
+    },
+    {
+      name: "account_get_deposit_address",
+      module: "account",
+      description: "Get deposit address for a token. Private endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          tokenId: { type: "string", description: "e.g. USDT" },
+          chainType: { type: "string" }
+        },
+        required: ["tokenId"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/api/v1/account/deposit/address",
+          compactObject({
+            tokenId: requireString(args, "tokenId"),
+            chainType: readString(args, "chainType")
+          }),
+          privateRateLimit("account_get_deposit_address", 20)
+        );
+        return normalize(response);
+      }
+    },
+    {
+      name: "account_get_deposit_orders",
+      module: "account",
+      description: "Get deposit records. Private endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          tokenId: { type: "string" },
+          startTime: { type: "number" },
+          endTime: { type: "number" },
+          fromId: { type: "string" },
+          limit: { type: "number" }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/api/v1/account/depositOrders",
+          compactObject({
+            tokenId: readString(args, "tokenId"),
+            startTime: readNumber(args, "startTime"),
+            endTime: readNumber(args, "endTime"),
+            fromId: readString(args, "fromId"),
+            limit: readNumber(args, "limit")
+          }),
+          privateRateLimit("account_get_deposit_orders", 20)
+        );
+        return normalize(response);
+      }
+    }
+  ];
+}
+function registerAuditTools() {
+  return [
+    {
+      name: "trade_get_history",
+      module: "account",
+      description: "Read local audit log entries from ~/.toobit/logs/. Returns recent tool call records. No API call.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          date: { type: "string", description: "Date in YYYY-MM-DD format. Defaults to today." },
+          limit: { type: "number", description: "Max entries to return (default 50)" }
+        }
+      },
+      handler: async (rawArgs) => {
+        const args = asRecord(rawArgs);
+        const dateStr = readString(args, "date") ?? (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+        const limit = readNumber(args, "limit") ?? 50;
+        const logPath = path.join(os.homedir(), ".toobit", "logs", `trade-${dateStr}.log`);
+        if (!fs.existsSync(logPath)) {
+          return { endpoint: "local", requestTime: (/* @__PURE__ */ new Date()).toISOString(), data: [] };
+        }
+        const lines = fs.readFileSync(logPath, "utf-8").trim().split("\n").filter(Boolean);
+        const entries = lines.slice(-limit).map((line) => {
+          try {
+            return JSON.parse(line);
+          } catch {
+            return { raw: line };
+          }
+        });
+        return { endpoint: "local", requestTime: (/* @__PURE__ */ new Date()).toISOString(), data: entries };
+      }
+    }
+  ];
+}
+function normalize2(response) {
+  return { endpoint: response.endpoint, requestTime: response.requestTime, data: response.data };
+}
+function registerFuturesTools() {
+  return [
+    {
+      name: "futures_place_order",
+      module: "futures",
+      description: "Place a USDT-M futures order. [CAUTION] Executes real trades. Private endpoint. Rate limit: 20 req/s.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "e.g. BTCUSDT" },
+          side: { type: "string", enum: ["BUY_OPEN", "SELL_OPEN", "BUY_CLOSE", "SELL_CLOSE"] },
+          orderType: { type: "string", enum: ["LIMIT", "MARKET"], description: "Order type" },
+          quantity: { type: "string", description: "Order quantity (contracts)" },
+          price: { type: "string", description: "Required for LIMIT" },
+          leverage: { type: "string", description: "Leverage, e.g. 10" },
+          clientOrderId: { type: "string" },
+          priceType: { type: "string", enum: ["INPUT", "OPPONENT", "QUEUE", "OVER", "MARKET"], description: "Price type for trigger orders" },
+          triggerPrice: { type: "string", description: "Trigger price for conditional orders" },
+          timeInForce: { type: "string", enum: ["GTC", "IOC", "FOK", "LIMIT_MAKER"] }
+        },
+        required: ["symbol", "side", "orderType", "quantity"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privatePost(
+          "/api/v1/futures/order",
+          compactObject({
+            symbol: requireString(args, "symbol"),
+            side: requireString(args, "side"),
+            orderType: requireString(args, "orderType"),
+            quantity: requireString(args, "quantity"),
+            price: readString(args, "price"),
+            leverage: readString(args, "leverage"),
+            clientOrderId: readString(args, "clientOrderId"),
+            priceType: readString(args, "priceType"),
+            triggerPrice: readString(args, "triggerPrice"),
+            timeInForce: readString(args, "timeInForce")
+          }),
+          privateRateLimit("futures_place_order", 20)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_batch_orders",
+      module: "futures",
+      description: "[CAUTION] Batch place futures orders. Private endpoint. Rate limit: 20 req/s.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          orders: {
+            type: "array",
+            description: "Array of order objects",
+            items: { type: "object" }
+          }
+        },
+        required: ["orders"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const orders = args.orders;
+        if (!Array.isArray(orders) || orders.length === 0) throw new Error("orders must be a non-empty array.");
+        const response = await context.client.privatePost(
+          "/api/v1/futures/batchOrders",
+          orders,
+          privateRateLimit("futures_batch_orders", 20)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_cancel_order",
+      module: "futures",
+      description: "Cancel a futures order. Private endpoint. Rate limit: 20 req/s.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          orderId: { type: "string" },
+          clientOrderId: { type: "string" },
+          orderType: { type: "string", description: "LIMIT or condition type" }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateDelete(
+          "/api/v1/futures/order",
+          compactObject({
+            orderId: readString(args, "orderId"),
+            clientOrderId: readString(args, "clientOrderId"),
+            orderType: readString(args, "orderType")
+          }),
+          privateRateLimit("futures_cancel_order", 20)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_cancel_all_orders",
+      module: "futures",
+      description: "Cancel all futures open orders for a symbol. [CAUTION] Private endpoint. Rate limit: 10 req/s.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "e.g. BTCUSDT" }
+        },
+        required: ["symbol"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateDelete(
+          "/api/v1/futures/batchOrders",
+          { symbol: requireString(args, "symbol") },
+          privateRateLimit("futures_cancel_all_orders", 10)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_cancel_order_by_ids",
+      module: "futures",
+      description: "Batch cancel futures orders by IDs. Private endpoint. Rate limit: 20 req/s.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          orderIds: { type: "string", description: "Comma-separated order IDs" }
+        },
+        required: ["orderIds"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateDelete(
+          "/api/v1/futures/cancelOrderByIds",
+          { orderIds: requireString(args, "orderIds") },
+          privateRateLimit("futures_cancel_order_by_ids", 20)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_amend_order",
+      module: "futures",
+      description: "Modify a futures order (price/quantity). Private endpoint. Rate limit: 20 req/s.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          orderId: { type: "string" },
+          quantity: { type: "string" },
+          price: { type: "string" }
+        },
+        required: ["orderId"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privatePost(
+          "/api/v1/futures/order/update",
+          compactObject({
+            orderId: requireString(args, "orderId"),
+            quantity: readString(args, "quantity"),
+            price: readString(args, "price")
+          }),
+          privateRateLimit("futures_amend_order", 20)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_get_order",
+      module: "futures",
+      description: "Get details of a single futures order. Private endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          orderId: { type: "string" },
+          clientOrderId: { type: "string" },
+          orderType: { type: "string" }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/api/v1/futures/order",
+          compactObject({
+            orderId: readString(args, "orderId"),
+            clientOrderId: readString(args, "clientOrderId"),
+            orderType: readString(args, "orderType")
+          }),
+          privateRateLimit("futures_get_order", 20)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_get_open_orders",
+      module: "futures",
+      description: "Get current open futures orders. Private endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string" },
+          orderId: { type: "string" },
+          orderType: { type: "string" },
+          limit: { type: "number" }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/api/v1/futures/openOrders",
+          compactObject({
+            symbol: readString(args, "symbol"),
+            orderId: readString(args, "orderId"),
+            orderType: readString(args, "orderType"),
+            limit: readNumber(args, "limit")
+          }),
+          privateRateLimit("futures_get_open_orders", 20)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_get_history_orders",
+      module: "futures",
+      description: "Get futures order history. Private endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string" },
+          orderId: { type: "string" },
+          orderType: { type: "string" },
+          startTime: { type: "number" },
+          endTime: { type: "number" },
+          limit: { type: "number" }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/api/v1/futures/historyOrders",
+          compactObject({
+            symbol: readString(args, "symbol"),
+            orderId: readString(args, "orderId"),
+            orderType: readString(args, "orderType"),
+            startTime: readNumber(args, "startTime"),
+            endTime: readNumber(args, "endTime"),
+            limit: readNumber(args, "limit")
+          }),
+          privateRateLimit("futures_get_history_orders", 20)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_get_positions",
+      module: "futures",
+      description: "Get current futures positions. Private endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "Omit for all positions" }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/api/v1/futures/positions",
+          compactObject({ symbol: readString(args, "symbol") }),
+          privateRateLimit("futures_get_positions", 20)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_get_history_positions",
+      module: "futures",
+      description: "Get futures closed position history. Private endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string" },
+          startTime: { type: "number" },
+          endTime: { type: "number" },
+          limit: { type: "number" }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/api/v1/futures/historyPositions",
+          compactObject({
+            symbol: readString(args, "symbol"),
+            startTime: readNumber(args, "startTime"),
+            endTime: readNumber(args, "endTime"),
+            limit: readNumber(args, "limit")
+          }),
+          privateRateLimit("futures_get_history_positions", 20)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_set_leverage",
+      module: "futures",
+      description: "Set leverage for a futures symbol. [CAUTION] Private endpoint. Rate limit: 10 req/s.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "e.g. BTCUSDT" },
+          leverage: { type: "number", description: "Leverage value, e.g. 10" }
+        },
+        required: ["symbol", "leverage"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privatePost(
+          "/api/v1/futures/leverage",
+          compactObject({
+            symbol: requireString(args, "symbol"),
+            leverage: readNumber(args, "leverage")
+          }),
+          privateRateLimit("futures_set_leverage", 10)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_get_leverage",
+      module: "futures",
+      description: "Get current leverage and position mode for a futures symbol. Private endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "e.g. BTCUSDT" }
+        },
+        required: ["symbol"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/api/v1/futures/accountLeverage",
+          { symbol: requireString(args, "symbol") },
+          privateRateLimit("futures_get_leverage", 20)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_set_margin_type",
+      module: "futures",
+      description: "Switch between cross and isolated margin mode. [CAUTION] Private endpoint. Rate limit: 10 req/s.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "e.g. BTCUSDT" },
+          marginType: { type: "string", enum: ["1", "2"], description: "1=cross, 2=isolated" }
+        },
+        required: ["symbol", "marginType"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privatePost(
+          "/api/v1/futures/marginType",
+          compactObject({
+            symbol: requireString(args, "symbol"),
+            marginType: requireString(args, "marginType")
+          }),
+          privateRateLimit("futures_set_margin_type", 10)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_set_trading_stop",
+      module: "futures",
+      description: "Set take-profit/stop-loss for a futures position. [CAUTION] Private endpoint. Rate limit: 10 req/s.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string" },
+          side: { type: "string", enum: ["LONG", "SHORT"] },
+          stopLossPrice: { type: "string" },
+          takeProfitPrice: { type: "string" }
+        },
+        required: ["symbol", "side"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privatePost(
+          "/api/v1/futures/position/trading-stop",
+          compactObject({
+            symbol: requireString(args, "symbol"),
+            side: requireString(args, "side"),
+            stopLossPrice: readString(args, "stopLossPrice"),
+            takeProfitPrice: readString(args, "takeProfitPrice")
+          }),
+          privateRateLimit("futures_set_trading_stop", 10)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_flash_close",
+      module: "futures",
+      description: "Flash close a futures position (market close). [CAUTION] Private endpoint. Rate limit: 10 req/s.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string" },
+          side: { type: "string", enum: ["LONG", "SHORT"] }
+        },
+        required: ["symbol", "side"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privatePost(
+          "/api/v1/futures/flashClose",
+          compactObject({
+            symbol: requireString(args, "symbol"),
+            side: requireString(args, "side")
+          }),
+          privateRateLimit("futures_flash_close", 10)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_reverse_position",
+      module: "futures",
+      description: "Reverse a futures position (one-click reverse). [CAUTION] Private endpoint. Rate limit: 10 req/s.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string" },
+          side: { type: "string", enum: ["LONG", "SHORT"], description: "Current position side to reverse" }
+        },
+        required: ["symbol", "side"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privatePost(
+          "/api/v1/futures/reversePosition",
+          compactObject({
+            symbol: requireString(args, "symbol"),
+            side: requireString(args, "side")
+          }),
+          privateRateLimit("futures_reverse_position", 10)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_adjust_margin",
+      module: "futures",
+      description: "Adjust isolated margin for a position. [CAUTION] Private endpoint. Rate limit: 10 req/s.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string" },
+          side: { type: "string", enum: ["LONG", "SHORT"] },
+          amount: { type: "string", description: "Positive=add, negative=reduce" }
+        },
+        required: ["symbol", "side", "amount"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privatePost(
+          "/api/v1/futures/positionMargin",
+          compactObject({
+            symbol: requireString(args, "symbol"),
+            side: requireString(args, "side"),
+            amount: requireString(args, "amount")
+          }),
+          privateRateLimit("futures_adjust_margin", 10)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_get_fills",
+      module: "futures",
+      description: "Get futures trade history (fills). Private endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string" },
+          startTime: { type: "number" },
+          endTime: { type: "number" },
+          fromId: { type: "string" },
+          limit: { type: "number" }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/api/v1/futures/userTrades",
+          compactObject({
+            symbol: readString(args, "symbol"),
+            startTime: readNumber(args, "startTime"),
+            endTime: readNumber(args, "endTime"),
+            fromId: readString(args, "fromId"),
+            limit: readNumber(args, "limit")
+          }),
+          privateRateLimit("futures_get_fills", 20)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_get_balance",
+      module: "futures",
+      description: "Get futures account balance. Private endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: { type: "object", properties: {} },
+      handler: async (_rawArgs, context) => {
+        const response = await context.client.privateGet(
+          "/api/v1/futures/balance",
+          {},
+          privateRateLimit("futures_get_balance", 20)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_get_commission_rate",
+      module: "futures",
+      description: "Get futures commission rate for a symbol. Private endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "e.g. BTCUSDT" }
+        },
+        required: ["symbol"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/api/v1/futures/commissionRate",
+          { symbol: requireString(args, "symbol") },
+          privateRateLimit("futures_get_commission_rate", 20)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_get_today_pnl",
+      module: "futures",
+      description: "Get today's realized PnL for futures. Private endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: { type: "object", properties: {} },
+      handler: async (_rawArgs, context) => {
+        const response = await context.client.privateGet(
+          "/api/v1/futures/todayPnl",
+          {},
+          privateRateLimit("futures_get_today_pnl", 20)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_get_balance_flow",
+      module: "futures",
+      description: "Get futures balance flow (ledger). Private endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string" },
+          startTime: { type: "number" },
+          endTime: { type: "number" },
+          limit: { type: "number" },
+          fromId: { type: "string" }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/api/v1/futures/balanceFlow",
+          compactObject({
+            symbol: readString(args, "symbol"),
+            startTime: readNumber(args, "startTime"),
+            endTime: readNumber(args, "endTime"),
+            limit: readNumber(args, "limit"),
+            fromId: readString(args, "fromId")
+          }),
+          privateRateLimit("futures_get_balance_flow", 20)
+        );
+        return normalize2(response);
+      }
+    },
+    {
+      name: "futures_auto_add_margin",
+      module: "futures",
+      description: "Enable/disable auto add margin for isolated positions. [CAUTION] Private endpoint. Rate limit: 10 req/s.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string" },
+          side: { type: "string", enum: ["LONG", "SHORT"] },
+          autoAddMargin: { type: "string", enum: ["true", "false"] }
+        },
+        required: ["symbol", "side", "autoAddMargin"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privatePost(
+          "/api/v1/futures/autoAddMargin",
+          compactObject({
+            symbol: requireString(args, "symbol"),
+            side: requireString(args, "side"),
+            autoAddMargin: requireString(args, "autoAddMargin")
+          }),
+          privateRateLimit("futures_auto_add_margin", 10)
+        );
+        return normalize2(response);
+      }
+    }
+  ];
+}
+function readPositiveInt(args, key) {
+  const value = readNumber(args, key);
+  if (value !== void 0 && value < 1) {
+    throw new ValidationError(`Parameter "${key}" must be a positive integer.`);
+  }
+  return value;
+}
+function normalize3(response) {
+  return { endpoint: response.endpoint, requestTime: response.requestTime, data: response.data };
+}
+function registerMarketTools() {
+  return [
+    {
+      name: "market_get_server_time",
+      module: "market",
+      description: "Get Toobit server time. Public endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: { type: "object", properties: {} },
+      handler: async (_rawArgs, context) => {
+        const response = await context.client.publicGet("/api/v1/time", {}, publicRateLimit("market_get_server_time", 20));
+        return normalize3(response);
+      }
+    },
+    {
+      name: "market_get_exchange_info",
+      module: "market",
+      description: "Get exchange info including trading rules, symbol list, rate limits. Public endpoint. Rate limit: 10 req/s.",
+      isWrite: false,
+      inputSchema: { type: "object", properties: {} },
+      handler: async (_rawArgs, context) => {
+        const response = await context.client.publicGet("/api/v1/exchangeInfo", {}, publicRateLimit("market_get_exchange_info", 10));
+        return normalize3(response);
+      }
+    },
+    {
+      name: "market_get_depth",
+      module: "market",
+      description: "Get order book depth for a symbol. Public endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "e.g. BTCUSDT" },
+          limit: { type: "number", description: "Depth per side, default 100, max 100" }
+        },
+        required: ["symbol"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/quote/v1/depth",
+          compactObject({ symbol: requireString(args, "symbol"), limit: readPositiveInt(args, "limit") }),
+          publicRateLimit("market_get_depth", 20)
+        );
+        return normalize3(response);
+      }
+    },
+    {
+      name: "market_get_merged_depth",
+      module: "market",
+      description: "Get merged order book depth for a symbol. Public endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "e.g. BTCUSDT" },
+          scale: { type: "number", description: "Price merge precision" },
+          limit: { type: "number", description: "Default 40, max 100" }
+        },
+        required: ["symbol"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/quote/v1/depth/merged",
+          compactObject({ symbol: requireString(args, "symbol"), scale: readNumber(args, "scale"), limit: readPositiveInt(args, "limit") }),
+          publicRateLimit("market_get_merged_depth", 20)
+        );
+        return normalize3(response);
+      }
+    },
+    {
+      name: "market_get_trades",
+      module: "market",
+      description: "Get recent trades for a symbol. Default 60 records, max 60. Public endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "e.g. BTCUSDT" },
+          limit: { type: "number", description: "Default 60, max 60" }
+        },
+        required: ["symbol"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/quote/v1/trades",
+          compactObject({ symbol: requireString(args, "symbol"), limit: readPositiveInt(args, "limit") }),
+          publicRateLimit("market_get_trades", 20)
+        );
+        return normalize3(response);
+      }
+    },
+    {
+      name: "market_get_klines",
+      module: "market",
+      description: "Get candlestick (OHLCV) data for a symbol. Public endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "e.g. BTCUSDT" },
+          interval: { type: "string", enum: [...TOOBIT_CANDLE_BARS], description: "K-line interval, e.g. 1m, 1h, 1d" },
+          startTime: { type: "number", description: "Start time in ms" },
+          endTime: { type: "number", description: "End time in ms" },
+          limit: { type: "number", description: "Default 500, max 1000" }
+        },
+        required: ["symbol", "interval"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/quote/v1/klines",
+          compactObject({
+            symbol: requireString(args, "symbol"),
+            interval: requireString(args, "interval"),
+            startTime: readNumber(args, "startTime"),
+            endTime: readNumber(args, "endTime"),
+            limit: readPositiveInt(args, "limit")
+          }),
+          publicRateLimit("market_get_klines", 20)
+        );
+        return normalize3(response);
+      }
+    },
+    {
+      name: "market_get_ticker_24hr",
+      module: "market",
+      description: "Get 24h price change statistics for a spot symbol. Omitting symbol returns ALL symbols (900+). Always specify a symbol unless you need the full list. Public endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "e.g. BTCUSDT. Omit for all symbols (warning: 900+ results)." }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/quote/v1/ticker/24hr",
+          compactObject({ symbol: readString(args, "symbol") }),
+          publicRateLimit("market_get_ticker_24hr", 20)
+        );
+        return normalize3(response);
+      }
+    },
+    {
+      name: "market_get_ticker_price",
+      module: "market",
+      description: "Get latest price for a spot symbol. Omitting symbol returns ALL symbols (900+), which may consume many tokens. Always specify a symbol unless you need the full list. Public endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "e.g. BTCUSDT. Omit for all symbols (warning: 900+ results)." }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/quote/v1/ticker/price",
+          compactObject({ symbol: readString(args, "symbol") }),
+          publicRateLimit("market_get_ticker_price", 20)
+        );
+        return normalize3(response);
+      }
+    },
+    {
+      name: "market_get_book_ticker",
+      module: "market",
+      description: "Get best bid/ask price for a spot symbol. Omitting symbol returns ALL symbols. Always specify a symbol unless you need the full list. Public endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "e.g. BTCUSDT. Omit for all symbols (warning: 900+ results)." }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/quote/v1/ticker/bookTicker",
+          compactObject({ symbol: readString(args, "symbol") }),
+          publicRateLimit("market_get_book_ticker", 20)
+        );
+        return normalize3(response);
+      }
+    },
+    {
+      name: "market_get_index_klines",
+      module: "market",
+      description: "Get index K-line data. Public endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "e.g. BTCUSDT" },
+          interval: { type: "string", enum: [...TOOBIT_CANDLE_BARS] },
+          startTime: { type: "number" },
+          endTime: { type: "number" },
+          limit: { type: "number", description: "Default 500, max 1000" }
+        },
+        required: ["symbol", "interval"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/quote/v1/index/klines",
+          compactObject({
+            symbol: requireString(args, "symbol"),
+            interval: requireString(args, "interval"),
+            startTime: readNumber(args, "startTime"),
+            endTime: readNumber(args, "endTime"),
+            limit: readPositiveInt(args, "limit")
+          }),
+          publicRateLimit("market_get_index_klines", 20)
+        );
+        return normalize3(response);
+      }
+    },
+    {
+      name: "market_get_mark_price",
+      module: "market",
+      description: "Get latest mark price for a futures symbol. Requires contract symbol format. Public endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "Futures contract symbol, e.g. BTC-SWAP-USDT. Omit for all." }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/quote/v1/markPrice",
+          compactObject({ symbol: readString(args, "symbol") }),
+          publicRateLimit("market_get_mark_price", 20)
+        );
+        return normalize3(response);
+      }
+    },
+    {
+      name: "market_get_mark_price_klines",
+      module: "market",
+      description: "Get mark price K-line data. Requires contract symbol format. Public endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "Futures contract symbol, e.g. BTC-SWAP-USDT" },
+          interval: { type: "string", enum: [...TOOBIT_CANDLE_BARS] },
+          startTime: { type: "number" },
+          endTime: { type: "number" },
+          limit: { type: "number" }
+        },
+        required: ["symbol", "interval"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/quote/v1/markPrice/klines",
+          compactObject({
+            symbol: requireString(args, "symbol"),
+            interval: requireString(args, "interval"),
+            startTime: readNumber(args, "startTime"),
+            endTime: readNumber(args, "endTime"),
+            limit: readPositiveInt(args, "limit")
+          }),
+          publicRateLimit("market_get_mark_price_klines", 20)
+        );
+        return normalize3(response);
+      }
+    },
+    {
+      name: "market_get_funding_rate",
+      module: "market",
+      description: "Get current funding rate for a futures symbol. Requires contract symbol format. Public endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "Futures contract symbol, e.g. BTC-SWAP-USDT. Omit for all." }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/api/v1/futures/fundingRate",
+          compactObject({ symbol: readString(args, "symbol") }),
+          publicRateLimit("market_get_funding_rate", 20)
+        );
+        return normalize3(response);
+      }
+    },
+    {
+      name: "market_get_funding_rate_history",
+      module: "market",
+      description: "Get historical funding rates for a futures symbol. Requires contract symbol format. Public endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "Futures contract symbol, e.g. BTC-SWAP-USDT" },
+          startTime: { type: "number" },
+          endTime: { type: "number" },
+          limit: { type: "number", description: "Default 100, max 1000" }
+        },
+        required: ["symbol"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/api/v1/futures/historyFundingRate",
+          compactObject({
+            symbol: requireString(args, "symbol"),
+            startTime: readNumber(args, "startTime"),
+            endTime: readNumber(args, "endTime"),
+            limit: readPositiveInt(args, "limit")
+          }),
+          publicRateLimit("market_get_funding_rate_history", 20)
+        );
+        return normalize3(response);
+      }
+    },
+    {
+      name: "market_get_open_interest",
+      module: "market",
+      description: "Get total open interest for a futures symbol. Requires contract symbol format. Public endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "Futures contract symbol, e.g. BTC-SWAP-USDT. Omit for all." }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/quote/v1/openInterest",
+          compactObject({ symbol: readString(args, "symbol") }),
+          publicRateLimit("market_get_open_interest", 20)
+        );
+        return normalize3(response);
+      }
+    },
+    {
+      name: "market_get_long_short_ratio",
+      module: "market",
+      description: "Get global long/short account ratio. Public endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "Futures contract symbol, e.g. BTC-SWAP-USDT" },
+          period: { type: "string", description: "e.g. 5m, 15m, 30m, 1h, 2h, 4h, 6h, 12h, 1d" },
+          startTime: { type: "number" },
+          endTime: { type: "number" },
+          limit: { type: "number" }
+        },
+        required: ["symbol", "period"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/quote/v1/globalLongShortAccountRatio",
+          compactObject({
+            symbol: requireString(args, "symbol"),
+            period: requireString(args, "period"),
+            startTime: readNumber(args, "startTime"),
+            endTime: readNumber(args, "endTime"),
+            limit: readPositiveInt(args, "limit")
+          }),
+          publicRateLimit("market_get_long_short_ratio", 20)
+        );
+        return normalize3(response);
+      }
+    },
+    {
+      name: "market_get_contract_ticker_24hr",
+      module: "market",
+      description: "Get 24h price change statistics for a futures contract. Requires contract symbol format. Public endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "Futures contract symbol, e.g. BTC-SWAP-USDT. Omit for all." }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/quote/v1/contract/ticker/24hr",
+          compactObject({ symbol: readString(args, "symbol") }),
+          publicRateLimit("market_get_contract_ticker_24hr", 20)
+        );
+        return normalize3(response);
+      }
+    },
+    {
+      name: "market_get_contract_ticker_price",
+      module: "market",
+      description: "Get latest price for a futures contract. Supports both spot (BTCUSDT) and contract (BTC-SWAP-USDT) symbol formats. Public endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "e.g. BTC-SWAP-USDT or BTCUSDT. Omit for all." }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/quote/v1/contract/ticker/price",
+          compactObject({ symbol: readString(args, "symbol") }),
+          publicRateLimit("market_get_contract_ticker_price", 20)
+        );
+        return normalize3(response);
+      }
+    },
+    {
+      name: "market_get_index_price",
+      module: "market",
+      description: "Get index price for a futures symbol. Public endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "e.g. BTCUSDT. Omit for all." }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/quote/v1/index",
+          compactObject({ symbol: readString(args, "symbol") }),
+          publicRateLimit("market_get_index_price", 20)
+        );
+        return normalize3(response);
+      }
+    },
+    {
+      name: "market_get_insurance_fund",
+      module: "market",
+      description: "Get insurance fund balance for a futures symbol. Requires contract symbol format. Public endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "Futures contract symbol, e.g. BTC-SWAP-USDT" }
+        },
+        required: ["symbol"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/api/v1/futures/insuranceBySymbol",
+          { symbol: requireString(args, "symbol") },
+          publicRateLimit("market_get_insurance_fund", 20)
+        );
+        return normalize3(response);
+      }
+    },
+    {
+      name: "market_get_risk_limits",
+      module: "market",
+      description: "Get risk limits configuration for a futures symbol. Requires contract symbol format. Public endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "Futures contract symbol, e.g. BTC-SWAP-USDT" }
+        },
+        required: ["symbol"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/api/v1/futures/riskLimits",
+          { symbol: requireString(args, "symbol") },
+          publicRateLimit("market_get_risk_limits", 20)
+        );
+        return normalize3(response);
+      }
+    }
+  ];
+}
+function normalize4(response) {
+  return { endpoint: response.endpoint, requestTime: response.requestTime, data: response.data };
+}
+function registerSpotTradeTools() {
+  return [
+    {
+      name: "spot_place_order",
+      module: "spot",
+      description: "Place a spot order (LIMIT, MARKET, LIMIT_MAKER). [CAUTION] Executes real trades. Private endpoint. Rate limit: 50 req/s.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "e.g. BTCUSDT" },
+          side: { type: "string", enum: ["BUY", "SELL"] },
+          type: { type: "string", enum: ["LIMIT", "MARKET", "LIMIT_MAKER"], description: "Order type" },
+          quantity: { type: "string", description: "Order quantity" },
+          price: { type: "string", description: "Order price (required for LIMIT)" },
+          newClientOrderId: { type: "string", description: "Client order ID" },
+          timeInForce: { type: "string", enum: ["GTC", "IOC", "FOK"], description: "Default GTC" }
+        },
+        required: ["symbol", "side", "type", "quantity"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privatePost(
+          "/api/v1/spot/order",
+          compactObject({
+            symbol: requireString(args, "symbol"),
+            side: requireString(args, "side"),
+            type: requireString(args, "type"),
+            quantity: requireString(args, "quantity"),
+            price: readString(args, "price"),
+            newClientOrderId: readString(args, "newClientOrderId"),
+            timeInForce: readString(args, "timeInForce")
+          }),
+          privateRateLimit("spot_place_order", 50)
+        );
+        return normalize4(response);
+      }
+    },
+    {
+      name: "spot_place_order_test",
+      module: "spot",
+      description: "Test spot order placement without actually submitting. Private endpoint. Rate limit: 50 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "e.g. BTCUSDT" },
+          side: { type: "string", enum: ["BUY", "SELL"] },
+          type: { type: "string", enum: ["LIMIT", "MARKET", "LIMIT_MAKER"] },
+          quantity: { type: "string" },
+          price: { type: "string" }
+        },
+        required: ["symbol", "side", "type", "quantity"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privatePost(
+          "/api/v1/spot/orderTest",
+          compactObject({
+            symbol: requireString(args, "symbol"),
+            side: requireString(args, "side"),
+            type: requireString(args, "type"),
+            quantity: requireString(args, "quantity"),
+            price: readString(args, "price")
+          }),
+          privateRateLimit("spot_place_order_test", 50)
+        );
+        return normalize4(response);
+      }
+    },
+    {
+      name: "spot_batch_orders",
+      module: "spot",
+      description: "[CAUTION] Batch place spot orders. Private endpoint. Rate limit: 50 req/s.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          orders: {
+            type: "array",
+            description: "Array of orders: [{symbol, side, type, quantity, price?, newClientOrderId?, timeInForce?}]",
+            items: { type: "object" }
+          }
+        },
+        required: ["orders"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const orders = args.orders;
+        if (!Array.isArray(orders) || orders.length === 0) throw new Error("orders must be a non-empty array.");
+        const response = await context.client.privatePost(
+          "/api/v1/spot/batchOrders",
+          orders,
+          privateRateLimit("spot_batch_orders", 50)
+        );
+        return normalize4(response);
+      }
+    },
+    {
+      name: "spot_cancel_order",
+      module: "spot",
+      description: "Cancel a spot order by orderId or clientOrderId. Private endpoint. Rate limit: 50 req/s.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          orderId: { type: "string", description: "Order ID" },
+          clientOrderId: { type: "string", description: "Client order ID" }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateDelete(
+          "/api/v1/spot/order",
+          compactObject({
+            orderId: readString(args, "orderId"),
+            clientOrderId: readString(args, "clientOrderId")
+          }),
+          privateRateLimit("spot_cancel_order", 50)
+        );
+        return normalize4(response);
+      }
+    },
+    {
+      name: "spot_cancel_open_orders",
+      module: "spot",
+      description: "Cancel all open spot orders for a symbol. [CAUTION] Private endpoint. Rate limit: 10 req/s.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string", description: "e.g. BTCUSDT. Omit for all symbols." }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateDelete(
+          "/api/v1/spot/openOrders",
+          compactObject({ symbol: readString(args, "symbol") }),
+          privateRateLimit("spot_cancel_open_orders", 10)
+        );
+        return normalize4(response);
+      }
+    },
+    {
+      name: "spot_cancel_order_by_ids",
+      module: "spot",
+      description: "Batch cancel spot orders by IDs. [CAUTION] Private endpoint. Rate limit: 50 req/s.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          orderIds: { type: "string", description: "Comma-separated order IDs" }
+        },
+        required: ["orderIds"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateDelete(
+          "/api/v1/spot/cancelOrderByIds",
+          { orderIds: requireString(args, "orderIds") },
+          privateRateLimit("spot_cancel_order_by_ids", 50)
+        );
+        return normalize4(response);
+      }
+    },
+    {
+      name: "spot_get_order",
+      module: "spot",
+      description: "Get details of a single spot order. Private endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          orderId: { type: "string" },
+          clientOrderId: { type: "string" }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/api/v1/spot/order",
+          compactObject({ orderId: readString(args, "orderId"), clientOrderId: readString(args, "clientOrderId") }),
+          privateRateLimit("spot_get_order", 20)
+        );
+        return normalize4(response);
+      }
+    },
+    {
+      name: "spot_get_open_orders",
+      module: "spot",
+      description: "Get current open spot orders. Private endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string" },
+          orderId: { type: "string", description: "Filter orders >= this ID" },
+          limit: { type: "number", description: "Default 500, max 1000" }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/api/v1/spot/openOrders",
+          compactObject({ symbol: readString(args, "symbol"), orderId: readString(args, "orderId"), limit: readNumber(args, "limit") }),
+          privateRateLimit("spot_get_open_orders", 20)
+        );
+        return normalize4(response);
+      }
+    },
+    {
+      name: "spot_get_trade_orders",
+      module: "spot",
+      description: "Get all spot orders (history). Private endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string" },
+          orderId: { type: "string" },
+          startTime: { type: "number" },
+          endTime: { type: "number" },
+          limit: { type: "number", description: "Default 500, max 1000" }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/api/v1/spot/tradeOrders",
+          compactObject({
+            symbol: readString(args, "symbol"),
+            orderId: readString(args, "orderId"),
+            startTime: readNumber(args, "startTime"),
+            endTime: readNumber(args, "endTime"),
+            limit: readNumber(args, "limit")
+          }),
+          privateRateLimit("spot_get_trade_orders", 20)
+        );
+        return normalize4(response);
+      }
+    },
+    {
+      name: "spot_get_fills",
+      module: "spot",
+      description: "Get spot trade history (fills). Private endpoint. Rate limit: 20 req/s.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          symbol: { type: "string" },
+          fromId: { type: "string" },
+          toId: { type: "string" },
+          startTime: { type: "number" },
+          endTime: { type: "number" },
+          limit: { type: "number", description: "Default 500, max 1000" }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/api/v1/account/trades",
+          compactObject({
+            symbol: readString(args, "symbol"),
+            fromId: readString(args, "fromId"),
+            toId: readString(args, "toId"),
+            startTime: readNumber(args, "startTime"),
+            endTime: readNumber(args, "endTime"),
+            limit: readNumber(args, "limit")
+          }),
+          privateRateLimit("spot_get_fills", 20)
+        );
+        return normalize4(response);
+      }
+    }
+  ];
+}
+function allToolSpecs() {
+  return [
+    ...registerMarketTools(),
+    ...registerSpotTradeTools(),
+    ...registerFuturesTools(),
+    ...registerAccountTools(),
+    ...registerAuditTools()
+  ];
+}
+function createToolRunner(client, config) {
+  const fullConfig = { ...config, modules: [...MODULES] };
+  const tools = allToolSpecs();
+  const toolMap = new Map(tools.map((t) => [t.name, t]));
+  return async (toolName, args) => {
+    const tool = toolMap.get(toolName);
+    if (!tool) throw new Error(`Unknown tool: ${toolName}`);
+    if (config.readOnly && tool.isWrite) {
+      throw new Error(`Tool "${toolName}" is a write operation and is blocked in read-only mode.`);
+    }
+    const result = await tool.handler(args, { config: fullConfig, client });
+    return result;
+  };
+}
+function configFilePath() {
+  return join2(homedir2(), ".toobit", "config.toml");
+}
+function readFullConfig() {
+  const path4 = configFilePath();
+  if (!existsSync2(path4)) return { profiles: {} };
+  const raw = readFileSync2(path4, "utf-8");
+  return parse(raw);
+}
+function readTomlProfile(profileName) {
+  const config = readFullConfig();
+  const name = profileName ?? config.default_profile ?? "default";
+  return config.profiles?.[name] ?? {};
+}
+function writeFullConfig(config) {
+  const path4 = configFilePath();
+  const dir = dirname(path4);
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(path4, stringify(config), "utf-8");
+}
+function parseModuleList(rawModules) {
+  if (!rawModules || rawModules.trim().length === 0) {
+    return [...DEFAULT_MODULES];
+  }
+  const trimmed = rawModules.trim().toLowerCase();
+  if (trimmed === "all") {
+    return [...MODULES];
+  }
+  const requested = trimmed.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+  if (requested.length === 0) {
+    return [...DEFAULT_MODULES];
+  }
+  const deduped = /* @__PURE__ */ new Set();
+  for (const moduleId of requested) {
+    if (!MODULES.includes(moduleId)) {
+      throw new ConfigError(
+        `Unknown module "${moduleId}".`,
+        `Use one of: ${MODULES.join(", ")}, or "all".`
+      );
+    }
+    deduped.add(moduleId);
+  }
+  return Array.from(deduped);
+}
+function loadConfig(cli) {
+  const toml = readTomlProfile(cli.profile);
+  const apiKey = process.env.TOOBIT_API_KEY?.trim() ?? toml.api_key;
+  const secretKey = process.env.TOOBIT_SECRET_KEY?.trim() ?? toml.secret_key;
+  const hasAuth = Boolean(apiKey && secretKey);
+  const partialAuth = Boolean(apiKey) || Boolean(secretKey);
+  if (partialAuth && !hasAuth) {
+    throw new ConfigError(
+      "Partial API credentials detected.",
+      "Set TOOBIT_API_KEY and TOOBIT_SECRET_KEY together (env vars or config.toml profile)."
+    );
+  }
+  const rawBaseUrl = process.env.TOOBIT_API_BASE_URL?.trim() ?? toml.base_url ?? TOOBIT_API_BASE_URL;
+  if (!rawBaseUrl.startsWith("http://") && !rawBaseUrl.startsWith("https://")) {
+    throw new ConfigError(
+      `Invalid base URL "${rawBaseUrl}".`,
+      "TOOBIT_API_BASE_URL must start with http:// or https://"
+    );
+  }
+  const baseUrl = rawBaseUrl.replace(/\/+$/, "");
+  const rawTimeout = process.env.TOOBIT_TIMEOUT_MS ? Number(process.env.TOOBIT_TIMEOUT_MS) : toml.timeout_ms ?? 15e3;
+  if (!Number.isFinite(rawTimeout) || rawTimeout <= 0) {
+    throw new ConfigError(
+      `Invalid timeout value "${rawTimeout}".`,
+      "Set TOOBIT_TIMEOUT_MS as a positive integer in milliseconds."
+    );
+  }
+  return {
+    apiKey,
+    secretKey,
+    hasAuth,
+    baseUrl,
+    timeoutMs: Math.floor(rawTimeout),
+    modules: parseModuleList(cli.modules),
+    readOnly: cli.readOnly,
+    userAgent: cli.userAgent,
+    sourceTag: cli.sourceTag ?? DEFAULT_SOURCE_TAG
+  };
+}
+var CLIENT_NAMES = {
+  "claude-desktop": "Claude Desktop",
+  cursor: "Cursor",
+  windsurf: "Windsurf",
+  vscode: "VS Code",
+  "claude-code": "Claude Code CLI"
+};
+var SUPPORTED_CLIENTS = Object.keys(CLIENT_NAMES);
 
 // src/parser.ts
 import { parseArgs } from "util";
@@ -91,11 +2284,58 @@ function parseCli(argv = process.argv.slice(2)) {
 }
 
 // src/formatter.ts
+function extractRows(value) {
+  if (Array.isArray(value)) return value;
+  if (typeof value === "object" && value !== null) {
+    const entries = Object.values(value);
+    for (const v of entries) {
+      if (Array.isArray(v)) return v;
+    }
+  }
+  return null;
+}
 function formatJson(data, json) {
   if (json) return JSON.stringify(data, null, 2);
   if (data === null || data === void 0) return "No data.";
   if (typeof data !== "object") return String(data);
-  return JSON.stringify(data, null, 2);
+  const record = data;
+  const inner = record.data ?? record;
+  const rows = extractRows(inner);
+  if (rows) {
+    if (rows.length === 0) return "No data.";
+    if (typeof rows[0] === "object" && rows[0] !== null) {
+      return formatTable(rows);
+    }
+    return rows.map(String).join("\n");
+  }
+  if (typeof inner === "object" && inner !== null) {
+    return formatKv(inner);
+  }
+  return String(inner);
+}
+function formatKv(data) {
+  const entries = Object.entries(data).filter(([, v]) => v !== void 0 && v !== null);
+  if (entries.length === 0) return "No data.";
+  const maxKey = Math.max(...entries.map(([k]) => k.length));
+  return entries.map(([k, v]) => {
+    if (typeof v === "object") return `${k.padEnd(maxKey)}  ${JSON.stringify(v)}`;
+    return `${k.padEnd(maxKey)}  ${String(v)}`;
+  }).join("\n");
+}
+function formatTable(rows, columns) {
+  if (rows.length === 0) return "No data.";
+  const keys = columns ?? Object.keys(rows[0]);
+  const widths = keys.map(
+    (k) => Math.max(k.length, ...rows.map((r) => String(r[k] ?? "").length))
+  );
+  const header = keys.map((k, i) => k.padEnd(widths[i])).join("  ");
+  const separator = widths.map((w) => "-".repeat(w)).join("  ");
+  const body = rows.map(
+    (row) => keys.map((k, i) => String(row[k] ?? "").padEnd(widths[i])).join("  ")
+  ).join("\n");
+  return `${header}
+${separator}
+${body}`;
 }
 
 // src/commands/market.ts
@@ -158,9 +2398,18 @@ async function handleMarketCommand(cli, run) {
     case "long-short-ratio":
       result = await run("market_get_long_short_ratio", { symbol: f.symbol, period: f.period ?? "1h" });
       break;
+    case "contract-ticker-price":
+      result = await run("market_get_contract_ticker_price", { symbol: f.symbol });
+      break;
+    case "insurance-fund":
+      result = await run("market_get_insurance_fund", { symbol: f.symbol });
+      break;
+    case "risk-limits":
+      result = await run("market_get_risk_limits", { symbol: f.symbol });
+      break;
     default:
       process.stdout.write(`Unknown market subcommand: ${cli.subcommand}
-Available: time, info, ticker, ticker-24hr, depth, trades, klines, candles, book-ticker, mark-price, funding-rate, funding-rate-history, open-interest, index, contract-ticker, long-short-ratio
+Available: time, info, ticker, ticker-24hr, depth, trades, klines, candles, book-ticker, mark-price, funding-rate, funding-rate-history, open-interest, index, contract-ticker, contract-ticker-price, long-short-ratio, insurance-fund, risk-limits
 `);
       return;
   }
@@ -345,11 +2594,6 @@ Available: balance, info, balance-flow, sub-accounts, check-api-key, deposit-add
 
 // src/commands/config.ts
 import * as readline from "readline";
-import {
-  configFilePath,
-  readFullConfig,
-  writeFullConfig
-} from "@toobit_agent/agent-toobitkit-core";
 function prompt(question) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((resolve) => {
@@ -429,7 +2673,7 @@ Commands:
   config       Configuration management (init, show, list)
 
 Global Options:
-  --profile <name>   Profile from ${configFilePath2()}
+  --profile <name>   Profile from ${configFilePath()}
   --json             Output raw JSON
   --read-only        Disable write operations
   --help             Show this help