@aihubspot/agent-trade-mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,1658 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../core/src/errors.ts
+var AiHubError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "AiHubError";
+    this.code = code;
+  }
+};
+
+// ../core/src/credential.ts
+import { createHash } from "crypto";
+import keytar from "keytar";
+var SERVICE_NAME = "ai-hub-agent-trade";
+function validate(credentials) {
+  const apiKey = credentials.apiKey.trim();
+  const secretKey = credentials.secretKey.trim();
+  if (!apiKey || !secretKey) {
+    throw new AiHubError("AI_HUB_INVALID_CREDENTIAL", "API key and secret key must both be present.");
+  }
+  return { apiKey, secretKey };
+}
+function versionOf(credentials) {
+  return createHash("sha256").update(`${credentials.apiKey}\0${credentials.secretKey}`).digest("hex");
+}
+var CredentialStore = class {
+  async set(profile, credentials) {
+    const value = validate(credentials);
+    await keytar.setPassword(SERVICE_NAME, profile, JSON.stringify(value));
+    return { credentialRef: `keychain:${SERVICE_NAME}/${profile}`, credentialVersion: versionOf(value) };
+  }
+  async get(profile) {
+    const stored = await keytar.getPassword(SERVICE_NAME, profile);
+    if (!stored) return void 0;
+    let parsed;
+    try {
+      parsed = JSON.parse(stored);
+    } catch {
+      throw new AiHubError("AI_HUB_CREDENTIAL_INVALID", "Stored credentials are unreadable. Set credentials again.");
+    }
+    const credentials = validate(parsed);
+    return { ...credentials, credentialVersion: versionOf(credentials) };
+  }
+  async remove(profile) {
+    return keytar.deletePassword(SERVICE_NAME, profile);
+  }
+};
+
+// ../core/src/confirmation.ts
+import { createHash as createHash2, randomUUID } from "crypto";
+function stableJson(value) {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${stableJson(item)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function hash(input) {
+  return createHash2("sha256").update(stableJson({ action: input.action, payload: input.payload, context: input.context })).digest("hex");
+}
+var ConfirmationService = class {
+  constructor(ttlMs = 5 * 60 * 1e3, now = () => Date.now()) {
+    this.ttlMs = ttlMs;
+    this.now = now;
+  }
+  ttlMs;
+  now;
+  actions = /* @__PURE__ */ new Map();
+  prepare(input) {
+    const expiresAtMs = this.now() + this.ttlMs;
+    const confirmationId = randomUUID();
+    const requestHash = hash(input);
+    this.actions.set(confirmationId, { ...input, confirmationId, requestHash, expiresAtMs, consumed: false });
+    return {
+      confirmationId,
+      expiresAt: new Date(expiresAtMs).toISOString(),
+      requestHash,
+      action: input.action,
+      summary: input.summary,
+      requiresNewUserConfirmation: true,
+      nextStep: "Stop and wait for a new explicit user confirmation message. Do not call confirm_action from the same user instruction that prepared this request."
+    };
+  }
+  confirm(confirmationId, userConfirmation, context) {
+    if (typeof userConfirmation !== "string" || !userConfirmation.trim()) {
+      throw new AiHubError("AI_HUB_CONFIRMATION_REQUIRED", "A non-empty new explicit user confirmation message is required before a state-changing request can execute.");
+    }
+    const pending = this.actions.get(confirmationId);
+    if (!pending) throw new AiHubError("AI_HUB_CONFIRMATION_NOT_FOUND", "Confirmation was not found or has already been consumed.");
+    if (pending.consumed) throw new AiHubError("AI_HUB_CONFIRMATION_CONSUMED", "Confirmation has already been consumed.");
+    if (pending.expiresAtMs < this.now()) {
+      this.actions.delete(confirmationId);
+      throw new AiHubError("AI_HUB_CONFIRMATION_EXPIRED", "Confirmation has expired.");
+    }
+    if (stableJson(pending.context) !== stableJson(context)) {
+      this.actions.delete(confirmationId);
+      throw new AiHubError("AI_HUB_CONFIRMATION_CONTEXT_CHANGED", "Profile, OpenAPI base URL, configuration, or credentials changed after prepare.");
+    }
+    pending.consumed = true;
+    this.actions.delete(confirmationId);
+    return { action: pending.action, payload: pending.payload, requestHash: pending.requestHash };
+  }
+};
+
+// ../core/src/openapi.ts
+import { createHmac } from "crypto";
+function parseJsonPreservingLargeIntegers(raw) {
+  let transformed = "";
+  let inString = false;
+  let escaping = false;
+  let index = 0;
+  while (index < raw.length) {
+    const character = raw[index] ?? "";
+    if (inString) {
+      transformed += character;
+      if (escaping) escaping = false;
+      else if (character === "\\") escaping = true;
+      else if (character === '"') inString = false;
+      index += 1;
+      continue;
+    }
+    if (character === '"') {
+      inString = true;
+      transformed += character;
+      index += 1;
+      continue;
+    }
+    if (character !== "-" && (character < "0" || character > "9")) {
+      transformed += character;
+      index += 1;
+      continue;
+    }
+    let end = index + 1;
+    while (end < raw.length && /[0-9eE+.\-]/.test(raw[end] ?? "")) end += 1;
+    const token = raw.slice(index, end);
+    const absolute = token.startsWith("-") ? token.slice(1) : token;
+    if (/^\d+$/.test(token) && (absolute.length > 15 || Number(absolute) > Number.MAX_SAFE_INTEGER)) {
+      transformed += `"${token}"`;
+    } else {
+      transformed += token;
+    }
+    index = end;
+  }
+  return JSON.parse(transformed);
+}
+function queryString(values) {
+  const params = new URLSearchParams();
+  for (const [name, value] of Object.entries(values)) {
+    if (value !== void 0) params.append(name, String(value));
+  }
+  return params.toString();
+}
+function joinUrl(baseUrl, path, query) {
+  if (!path.startsWith("/")) throw new AiHubError("AI_HUB_INVALID_PATH", "OpenAPI paths must start with '/'.");
+  const url = `${baseUrl.replace(/\/+$/, "")}${path}`;
+  return query ? `${url}?${query}` : url;
+}
+function signRequest(timestamp, method, path, secretKey, query, body) {
+  const payload = `${timestamp}${method.toUpperCase()}${path}${query ? `?${query}` : ""}${body ?? ""}`;
+  return createHmac("sha256", secretKey).update(payload).digest("hex");
+}
+var AiHubSpotApi = class {
+  constructor(baseUrl, options = {}) {
+    this.baseUrl = baseUrl;
+    this.timeoutMs = options.timeoutMs ?? 15e3;
+    this.userAgent = options.userAgent ?? "ai-hub-agent-trade/0.1.0";
+  }
+  baseUrl;
+  timeoutMs;
+  userAgent;
+  time() {
+    return this.request("GET", "/sapi/v2/time");
+  }
+  ping() {
+    return this.request("GET", "/sapi/v2/ping");
+  }
+  symbols() {
+    return this.request("GET", "/sapi/v2/symbols");
+  }
+  ticker(params = {}) {
+    return this.request("GET", "/sapi/v2/ticker", { timeZone: params.timeZone ?? "UTC+08", symbol: params.symbol, symbols: params.symbols });
+  }
+  depth(symbol, limit = 20) {
+    return this.request("GET", "/sapi/v2/depth", { symbol, limit });
+  }
+  trades(symbol, limit = 100) {
+    return this.request("GET", "/sapi/v2/trades", { symbol, limit });
+  }
+  klines(params) {
+    return this.request("GET", "/sapi/v2/klines", {
+      symbol: params.symbol,
+      interval: params.interval,
+      startTime: params.startTime,
+      endTime: params.endTime,
+      timezone: params.timezone ?? "UTC+08",
+      limit: params.limit ?? 100
+    });
+  }
+  account(credentials) {
+    return this.request("GET", "/sapi/v2/account", {}, void 0, credentials);
+  }
+  getOrder(params, credentials) {
+    return this.request("GET", "/sapi/v2/order", params, void 0, credentials);
+  }
+  getOpenOrders(params, credentials) {
+    return this.request("GET", "/sapi/v2/openOrders", params, void 0, credentials);
+  }
+  getMyTrades(params, credentials) {
+    return this.request("GET", "/sapi/v2/myTrades", params, void 0, credentials);
+  }
+  placeOrder(params, credentials) {
+    const body = {
+      symbol: params.symbol,
+      volume: params.volume,
+      side: params.side,
+      type: params.type,
+      newClientOrderId: params.newClientOrderId
+    };
+    if (params.price) body.price = params.price;
+    if (params.timeInForce) body.timeInForce = params.timeInForce;
+    if (params.recvWindow) body.recvWindow = params.recvWindow;
+    return this.request("POST", "/sapi/v2/order", {}, body, credentials);
+  }
+  cancelOrder(params, credentials) {
+    const body = { symbol: params.symbol, orderId: params.orderId };
+    if (params.newClientOrderId) body.newClientOrderId = params.newClientOrderId;
+    return this.request("POST", "/sapi/v2/cancel", {}, body, credentials);
+  }
+  /**
+   * Signed endpoint adapter for Tool Registry entries whose OpenAPI payload is
+   * defined by the API document. Keep endpoint selection in the individual Tool
+   * definition; never expose this method directly through CLI or MCP.
+   */
+  signedGet(path, query, credentials) {
+    return this.request("GET", path, query, void 0, credentials);
+  }
+  signedPost(path, body, credentials) {
+    return this.request("POST", path, {}, body, credentials);
+  }
+  async request(method, path, query = {}, body, credentials) {
+    const encodedQuery = queryString(query);
+    const bodyString = body ? JSON.stringify(body) : void 0;
+    const headers = {
+      accept: "application/json",
+      "admin-language": "en_US",
+      "user-agent": this.userAgent
+    };
+    if (bodyString) headers["content-type"] = "application/json";
+    if (credentials) {
+      const timestamp = Date.now().toString();
+      headers["X-CH-APIKEY"] = credentials.apiKey;
+      headers["X-CH-TS"] = timestamp;
+      headers["X-CH-SIGN"] = signRequest(timestamp, method, path, credentials.secretKey, encodedQuery || void 0, bodyString);
+    }
+    let response;
+    try {
+      response = await fetch(joinUrl(this.baseUrl, path, encodedQuery), {
+        method,
+        headers,
+        body: bodyString,
+        redirect: "manual",
+        signal: AbortSignal.timeout(this.timeoutMs)
+      });
+    } catch (error) {
+      throw new AiHubError("AI_HUB_OPENAPI_NETWORK_ERROR", error instanceof Error ? error.message : "OpenAPI request failed.");
+    }
+    const raw = await response.text();
+    if (response.status >= 300 && response.status < 400) {
+      throw new AiHubError("AI_HUB_OPENAPI_REDIRECT_REJECTED", "OpenAPI returned a redirect, which is rejected for profile safety.");
+    }
+    if (!response.ok) {
+      throw new AiHubError("AI_HUB_OPENAPI_HTTP_ERROR", `OpenAPI returned HTTP ${response.status}.`);
+    }
+    try {
+      return parseJsonPreservingLargeIntegers(raw);
+    } catch {
+      throw new AiHubError("AI_HUB_OPENAPI_INVALID_RESPONSE", "OpenAPI returned a non-JSON response.");
+    }
+  }
+};
+
+// ../core/src/config.ts
+import { createHash as createHash3 } from "crypto";
+import { lookup } from "dns/promises";
+import { chmod, mkdir, readFile, rename, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { isIP } from "net";
+import { parse, stringify } from "smol-toml";
+var CONFIG_DIRECTORY = ".ai-hub";
+var CONFIG_FILENAME = "config.toml";
+var PROFILE_NAME = /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/;
+function configFilePath(home = homedir()) {
+  return join(home, CONFIG_DIRECTORY, CONFIG_FILENAME);
+}
+function validateProfileName(name) {
+  if (!PROFILE_NAME.test(name)) {
+    throw new AiHubError("AI_HUB_INVALID_PROFILE", "Profile names must be 1-64 letters, numbers, hyphens, or underscores.");
+  }
+  return name;
+}
+function blockedIp(address) {
+  if (isIP(address) === 4) {
+    const octets = address.split(".").map(Number);
+    const first = octets[0] ?? -1;
+    const second = octets[1] ?? -1;
+    return first === 0 || first === 10 || first === 127 || first >= 224 || first === 169 && second === 254 || first === 172 && second >= 16 && second <= 31 || first === 192 && second === 168;
+  }
+  const normalized = address.toLowerCase();
+  return normalized === "::" || normalized === "::1" || normalized.startsWith("fc") || normalized.startsWith("fd") || normalized.startsWith("fe8") || normalized.startsWith("fe9") || normalized.startsWith("fea") || normalized.startsWith("feb");
+}
+async function normalizeOpenApiBaseUrl(value) {
+  let url;
+  try {
+    url = new URL(value.trim());
+  } catch {
+    throw new AiHubError("AI_HUB_INVALID_OPENAPI_URL", "OpenAPI base URL must be a valid HTTPS URL.");
+  }
+  if (url.protocol !== "https:" || url.username || url.password || url.search || url.hash) {
+    throw new AiHubError("AI_HUB_INVALID_OPENAPI_URL", "OpenAPI base URL must be an HTTPS URL without credentials, query, or fragment.");
+  }
+  if (url.hostname.toLowerCase() === "localhost") {
+    throw new AiHubError("AI_HUB_UNSAFE_OPENAPI_URL", "Localhost is not allowed as an OpenAPI base URL.");
+  }
+  const records = isIP(url.hostname) ? [{ address: url.hostname }] : await lookup(url.hostname, { all: true, verbatim: true });
+  if (records.length === 0 || records.some((record) => blockedIp(record.address))) {
+    throw new AiHubError("AI_HUB_UNSAFE_OPENAPI_URL", "OpenAPI base URL must resolve only to public addresses.");
+  }
+  url.pathname = url.pathname.replace(/\/+$/, "");
+  return url.toString().replace(/\/$/, "");
+}
+function defaultConfig() {
+  return { version: 1, default_profile: "default", profiles: {} };
+}
+function parseConfig(text) {
+  let parsed;
+  try {
+    parsed = parse(text);
+  } catch (error) {
+    throw new AiHubError("AI_HUB_CONFIG_PARSE_ERROR", `Cannot parse config.toml: ${error instanceof Error ? error.message : "unknown error"}`);
+  }
+  const raw = parsed;
+  if (raw.version !== 1 || typeof raw.default_profile !== "string" || !raw.profiles || typeof raw.profiles !== "object") {
+    throw new AiHubError("AI_HUB_CONFIG_INVALID", "config.toml must contain version = 1, default_profile, and profiles.");
+  }
+  return raw;
+}
+function versionOf2(config, profileName) {
+  return createHash3("sha256").update(JSON.stringify({ version: config.version, profileName, profile: config.profiles[profileName] })).digest("hex");
+}
+var ConfigStore = class {
+  constructor(filePath = configFilePath()) {
+    this.filePath = filePath;
+  }
+  filePath;
+  async read() {
+    try {
+      return parseConfig(await readFile(this.filePath, "utf8"));
+    } catch (error) {
+      if (error.code === "ENOENT") return defaultConfig();
+      throw error;
+    }
+  }
+  async initialize() {
+    const config = await this.read();
+    const existing = Object.keys(config.profiles).length > 0;
+    if (!existing) await this.write(config);
+    return { created: !existing, path: this.filePath };
+  }
+  async setProfile(name, openApiBaseUrl) {
+    validateProfileName(name);
+    const config = await this.read();
+    const normalizedUrl = await normalizeOpenApiBaseUrl(openApiBaseUrl);
+    const existing = config.profiles[name];
+    config.profiles[name] = { openapi_base_url: normalizedUrl, ...existing?.credential_ref ? { credential_ref: existing.credential_ref } : {} };
+    if (Object.keys(config.profiles).length === 1) config.default_profile = name;
+    await this.write(config);
+    return this.resolveFrom(config, name);
+  }
+  async showProfile(requestedName) {
+    const config = await this.read();
+    return this.resolveFrom(config, requestedName ?? config.default_profile);
+  }
+  async removeProfile(name) {
+    validateProfileName(name);
+    const config = await this.read();
+    if (!config.profiles[name]) throw new AiHubError("AI_HUB_PROFILE_NOT_FOUND", `Profile "${name}" does not exist.`);
+    delete config.profiles[name];
+    if (config.default_profile === name) config.default_profile = Object.keys(config.profiles)[0] ?? "default";
+    await this.write(config);
+  }
+  async setCredentialRef(name, credentialRef) {
+    validateProfileName(name);
+    const config = await this.read();
+    const profile = config.profiles[name];
+    if (!profile) throw new AiHubError("AI_HUB_PROFILE_NOT_FOUND", `Profile "${name}" does not exist.`);
+    config.profiles[name] = { ...profile, credential_ref: credentialRef };
+    await this.write(config);
+    return this.resolveFrom(config, name);
+  }
+  resolveFrom(config, name) {
+    validateProfileName(name);
+    const profile = config.profiles[name];
+    if (!profile) throw new AiHubError("AI_HUB_PROFILE_NOT_FOUND", `Profile "${name}" does not exist.`);
+    return {
+      name,
+      openApiBaseUrl: profile.openapi_base_url,
+      credentialRef: profile.credential_ref,
+      configVersion: versionOf2(config, name)
+    };
+  }
+  async write(config) {
+    const directory = dirname(this.filePath);
+    await mkdir(directory, { recursive: true, mode: 448 });
+    await chmod(directory, 448);
+    const temporaryPath = `${this.filePath}.${process.pid}.tmp`;
+    await writeFile(temporaryPath, stringify(config), { mode: 384 });
+    await chmod(temporaryPath, 384);
+    await rename(temporaryPath, this.filePath);
+    await chmod(this.filePath, 384);
+  }
+};
+
+// ../core/src/tools/execution-context.ts
+async function createToolExecutionContext(profileName) {
+  const profile = await new ConfigStore().showProfile(profileName);
+  const credentials = await new CredentialStore().get(profile.name);
+  return { profile, credentials, api: new AiHubSpotApi(profile.openApiBaseUrl) };
+}
+function confirmationContext(context) {
+  if (!context.credentials) throw new AiHubError("AI_HUB_CREDENTIAL_NOT_CONFIGURED", `Credentials are not configured for profile "${context.profile.name}".`);
+  return {
+    profile: context.profile.name,
+    openApiBaseUrl: context.profile.openApiBaseUrl,
+    configVersion: context.profile.configVersion,
+    credentialVersion: context.credentials.credentialVersion
+  };
+}
+
+// ../core/src/tools/validation.ts
+function strictObject(input, allowedKeys) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "Tool input must be an object.");
+  }
+  const record = input;
+  for (const key of Object.keys(record)) {
+    if (!allowedKeys.includes(key)) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", `Unknown argument "${key}".`);
+  }
+  return record;
+}
+function requiredString(input, name) {
+  const value = input[name];
+  if (typeof value !== "string" || !value.trim()) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", `${name} is required.`);
+  return value.trim();
+}
+function optionalString(input, name) {
+  const value = input[name];
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || !value.trim()) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", `${name} must be a non-empty string.`);
+  return value.trim();
+}
+function optionalInteger(input, name, fallback, minimum, maximum) {
+  const value = input[name];
+  if (value === void 0) return fallback;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < minimum || value > maximum) {
+    throw new AiHubError("AI_HUB_INVALID_ARGUMENT", `${name} must be an integer between ${minimum} and ${maximum}.`);
+  }
+  return value;
+}
+
+// ../core/src/tools/account-tools.ts
+var accountTools = [
+  {
+    name: "spot_get_account",
+    title: "Get Spot Account",
+    description: "Get the signed account overview for the configured profile.",
+    cliPath: ["account", "get"],
+    module: "spot-account",
+    access: "signed",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", additionalProperties: false },
+    errorCodes: ["AI_HUB_CREDENTIAL_NOT_CONFIGURED", "AI_HUB_OPENAPI_NETWORK_ERROR", "AI_HUB_OPENAPI_HTTP_ERROR", "AI_HUB_OPENAPI_INVALID_RESPONSE"],
+    validate: (input) => strictObject(input, []),
+    handler: async (_input, context) => {
+      if (!context.credentials) throw new AiHubError("AI_HUB_CREDENTIAL_NOT_CONFIGURED", `Credentials are not configured for profile "${context.profile.name}".`);
+      return context.api.account(context.credentials);
+    }
+  }
+];
+
+// ../core/src/tools/tool-utils.ts
+import { randomUUID as randomUUID2 } from "crypto";
+var signedReadErrors = ["AI_HUB_INVALID_ARGUMENT", "AI_HUB_CREDENTIAL_NOT_CONFIGURED", "AI_HUB_OPENAPI_NETWORK_ERROR", "AI_HUB_OPENAPI_HTTP_ERROR", "AI_HUB_OPENAPI_INVALID_RESPONSE"];
+var writeErrors = [...signedReadErrors, "AI_HUB_WRITE_CONFIRMATION_REQUIRED", "AI_HUB_CONFIRMATION_REQUIRED", "AI_HUB_CONFIRMATION_EXPIRED", "AI_HUB_CONFIRMATION_CONTEXT_CHANGED", "AI_HUB_CONFIRMATION_NOT_FOUND"];
+function signed(context) {
+  if (!context.credentials) throw new AiHubError("AI_HUB_CREDENTIAL_NOT_CONFIGURED", `Credentials are not configured for profile "${context.profile.name}".`);
+  return context.credentials;
+}
+function positiveDecimal(input, name) {
+  const value = requiredString(input, name);
+  if (!/^(?:0|[1-9]\d*)(?:\.\d+)?$/.test(value) || !/[1-9]/.test(value.replace(".", ""))) {
+    throw new AiHubError("AI_HUB_INVALID_ARGUMENT", `${name} must be a positive decimal string.`);
+  }
+  return value;
+}
+function requiredEnum(input, name, allowed) {
+  const value = requiredString(input, name).toUpperCase();
+  if (!allowed.includes(value)) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", `${name} must be one of: ${allowed.join(", ")}.`);
+  return value;
+}
+function optionalBoolean(input, name) {
+  const value = input[name];
+  if (value === void 0) return void 0;
+  if (typeof value !== "boolean") throw new AiHubError("AI_HUB_INVALID_ARGUMENT", `${name} must be a boolean.`);
+  return value;
+}
+function optionalPositiveInteger(input, name, fallback, maximum = 1e3) {
+  const value = input[name];
+  if (value === void 0) return fallback;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1 || value > maximum) {
+    throw new AiHubError("AI_HUB_INVALID_ARGUMENT", `${name} must be an integer between 1 and ${maximum}.`);
+  }
+  return value;
+}
+function optionalClientOrderId(input) {
+  return optionalString(input, "newClientOrderId") ?? `agent_${randomUUID2().replaceAll("-", "").slice(0, 24)}`;
+}
+
+// ../core/src/tools/asset-tools.ts
+var accountTypes = ["1", "2", "3", "4", "5"];
+function accountType(value, name) {
+  const result2 = requiredString(value, name);
+  if (!accountTypes.includes(result2)) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", `${name} must be an account type from 1 to 5.`);
+  return result2;
+}
+function requiredTransfer(input) {
+  const value = strictObject(input, ["fromAccountType", "toAccountType", "symbol", "coinSymbol", "amount"]);
+  return { fromAccountType: accountType(value, "fromAccountType"), toAccountType: accountType(value, "toAccountType"), coinSymbol: requiredString(value, "coinSymbol"), amount: positiveDecimal(value, "amount"), ...optionalString(value, "symbol") ? { symbol: optionalString(value, "symbol") } : {} };
+}
+function transferQuery(input) {
+  const value = strictObject(input, ["fromAccountType", "toAccountType", "symbol", "coinSymbol", "page", "pageSize"]);
+  return { fromAccountType: accountType(value, "fromAccountType"), toAccountType: accountType(value, "toAccountType"), page: optionalPositiveInteger(value, "page", 1), pageSize: optionalPositiveInteger(value, "pageSize", 20, 100), ...optionalString(value, "symbol") ? { symbol: optionalString(value, "symbol") } : {}, ...optionalString(value, "coinSymbol") ? { coinSymbol: optionalString(value, "coinSymbol") } : {} };
+}
+function transferAccounts(input) {
+  const value = strictObject(input, ["coinSymbol", "amount", "fromAccount", "toAccount"]);
+  return { coinSymbol: requiredString(value, "coinSymbol"), amount: positiveDecimal(value, "amount"), fromAccount: requiredString(value, "fromAccount"), toAccount: requiredString(value, "toAccount") };
+}
+function transferAccountHistory(input) {
+  const value = strictObject(input, ["transferId", "coinSymbol", "fromAccount", "toAccount", "startTime", "endTime", "page", "limit"]);
+  const transferId = optionalString(value, "transferId");
+  if (!transferId && (!optionalString(value, "fromAccount") || !optionalString(value, "toAccount"))) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "fromAccount and toAccount are required when transferId is omitted.");
+  return { ...transferId ? { transferId } : {}, ...optionalString(value, "coinSymbol") ? { coinSymbol: optionalString(value, "coinSymbol") } : {}, ...optionalString(value, "fromAccount") ? { fromAccount: optionalString(value, "fromAccount") } : {}, ...optionalString(value, "toAccount") ? { toAccount: optionalString(value, "toAccount") } : {}, ...optionalString(value, "startTime") ? { startTime: optionalString(value, "startTime") } : {}, ...optionalString(value, "endTime") ? { endTime: optionalString(value, "endTime") } : {}, page: optionalPositiveInteger(value, "page", 1), limit: optionalPositiveInteger(value, "limit", 20, 100) };
+}
+function pagedDates(input) {
+  const value = strictObject(input, ["startTime", "endTime", "page", "pageSize"]);
+  return { ...optionalString(value, "startTime") ? { startTime: optionalString(value, "startTime") } : {}, ...optionalString(value, "endTime") ? { endTime: optionalString(value, "endTime") } : {}, page: optionalPositiveInteger(value, "page", 1), pageSize: optionalPositiveInteger(value, "pageSize", 20, 100) };
+}
+function coinOnly(input) {
+  const value = strictObject(input, ["mainCoinSymbol"]);
+  return { mainCoinSymbol: requiredString(value, "mainCoinSymbol") };
+}
+var assetTools = [
+  {
+    name: "account_transfer",
+    title: "Transfer Between Accounts",
+    description: "Transfer an asset between documented account types after confirmation.",
+    cliPath: ["account", "transfer"],
+    module: "spot-account",
+    access: "signed",
+    operation: "write",
+    riskLevel: "high",
+    inputSchema: { type: "object", properties: { coinSymbol: { type: "string" }, amount: { type: "string" }, fromAccount: { type: "string" }, toAccount: { type: "string" } }, required: ["coinSymbol", "amount", "fromAccount", "toAccount"], additionalProperties: false },
+    errorCodes: writeErrors,
+    validate: transferAccounts,
+    handler: (input, context) => context.api.signedPost("/sapi/v1/asset/transfer", input, signed(context)),
+    writeSummary: (input) => ({ action: "account_transfer", ...input })
+  },
+  {
+    name: "account_get_transfer_history",
+    title: "Get Account Transfer History",
+    description: "Query documented account transfer history.",
+    cliPath: ["account", "transfer-history"],
+    module: "spot-account",
+    access: "signed",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { transferId: { type: "string" }, coinSymbol: { type: "string" }, fromAccount: { type: "string" }, toAccount: { type: "string" }, startTime: { type: "string" }, endTime: { type: "string" }, page: { type: "integer" }, limit: { type: "integer" } }, additionalProperties: false },
+    errorCodes: signedReadErrors,
+    validate: transferAccountHistory,
+    handler: (input, context) => context.api.signedPost("/sapi/v1/asset/transferQuery", input, signed(context))
+  },
+  {
+    name: "wallet_universal_transfer",
+    title: "Universal Asset Transfer",
+    description: "Transfer between account types after confirmation.",
+    cliPath: ["wallet", "transfer"],
+    module: "spot-deposit-withdraw",
+    access: "signed",
+    operation: "write",
+    riskLevel: "high",
+    inputSchema: { type: "object", properties: { fromAccountType: { type: "string" }, toAccountType: { type: "string" }, symbol: { type: "string" }, coinSymbol: { type: "string" }, amount: { type: "string" } }, required: ["fromAccountType", "toAccountType", "coinSymbol", "amount"], additionalProperties: false },
+    errorCodes: writeErrors,
+    validate: requiredTransfer,
+    handler: (input, context) => context.api.signedPost("/sapi/v1/asset/universal_transfer", input, signed(context)),
+    writeSummary: (input) => ({ action: "universal_transfer", ...input })
+  },
+  {
+    name: "wallet_get_universal_transfer_history",
+    title: "Get Universal Transfer History",
+    description: "Query universal asset transfer history.",
+    cliPath: ["wallet", "transfer-history"],
+    module: "spot-deposit-withdraw",
+    access: "signed",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { fromAccountType: { type: "string" }, toAccountType: { type: "string" }, symbol: { type: "string" }, coinSymbol: { type: "string" }, page: { type: "integer" }, pageSize: { type: "integer" } }, required: ["fromAccountType", "toAccountType"], additionalProperties: false },
+    errorCodes: signedReadErrors,
+    validate: transferQuery,
+    handler: (input, context) => context.api.signedPost("/sapi/v1/asset/universal_transfer_query", input, signed(context))
+  },
+  {
+    name: "wallet_get_deposit_history",
+    title: "Get Deposit History",
+    description: "Query deposit history.",
+    cliPath: ["wallet", "deposit-history"],
+    module: "spot-deposit-withdraw",
+    access: "signed",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { startTime: { type: "string" }, endTime: { type: "string" }, page: { type: "integer" }, pageSize: { type: "integer" } }, additionalProperties: false },
+    errorCodes: signedReadErrors,
+    validate: pagedDates,
+    handler: (input, context) => context.api.signedPost("/sapi/v1/deposit/his_list", input, signed(context))
+  },
+  {
+    name: "wallet_get_deposit_address",
+    title: "Get Deposit Addresses",
+    description: "Query deposit address list for a main coin.",
+    cliPath: ["wallet", "deposit-address"],
+    module: "spot-deposit-withdraw",
+    access: "signed",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { mainCoinSymbol: { type: "string" } }, required: ["mainCoinSymbol"], additionalProperties: false },
+    errorCodes: signedReadErrors,
+    validate: coinOnly,
+    handler: (input, context) => context.api.signedPost("/sapi/v1/deposit/query_address", input, signed(context))
+  },
+  {
+    name: "wallet_get_withdraw_address",
+    title: "Get Withdraw Addresses",
+    description: "Query withdraw address list for a main coin.",
+    cliPath: ["wallet", "withdraw-address"],
+    module: "spot-deposit-withdraw",
+    access: "signed",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { mainCoinSymbol: { type: "string" }, trustType: { type: "string" }, addrType: { type: "string" } }, required: ["mainCoinSymbol"], additionalProperties: false },
+    errorCodes: signedReadErrors,
+    validate: (input) => {
+      const value = strictObject(input, ["mainCoinSymbol", "trustType", "addrType"]);
+      return { mainCoinSymbol: requiredString(value, "mainCoinSymbol"), ...optionalString(value, "trustType") ? { trustType: optionalString(value, "trustType") } : {}, ...optionalString(value, "addrType") ? { addrType: optionalString(value, "addrType") } : {} };
+    },
+    handler: (input, context) => context.api.signedPost("/sapi/v1/withdraw/address/query", input, signed(context))
+  },
+  {
+    name: "wallet_get_transferable_assets",
+    title: "Get Transferable Assets",
+    description: "Query assets transferable from one account type.",
+    cliPath: ["wallet", "transferable-assets"],
+    module: "spot-deposit-withdraw",
+    access: "signed",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { accountType: { type: "string" } }, required: ["accountType"], additionalProperties: false },
+    errorCodes: signedReadErrors,
+    validate: (input) => {
+      const value = strictObject(input, ["accountType"]);
+      return { accountType: accountType(value, "accountType") };
+    },
+    handler: (input, context) => context.api.signedPost("/sapi/v1/asset/account/by_type", input, signed(context))
+  },
+  {
+    name: "wallet_get_exchange_account",
+    title: "Get Exchange Account Assets",
+    description: "Query exchange account assets.",
+    cliPath: ["wallet", "exchange-account"],
+    module: "spot-deposit-withdraw",
+    access: "signed",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", additionalProperties: false },
+    errorCodes: signedReadErrors,
+    validate: (input) => {
+      strictObject(input, []);
+      return {};
+    },
+    handler: (_input, context) => context.api.signedPost("/sapi/v1/asset/exchange/account", {}, signed(context))
+  },
+  {
+    name: "wallet_create_withdraw",
+    title: "Create Withdrawal",
+    description: "Submit a withdrawal request after confirmation.",
+    cliPath: ["wallet", "withdraw"],
+    module: "spot-deposit-withdraw",
+    access: "signed",
+    operation: "write",
+    riskLevel: "high",
+    inputSchema: { type: "object", properties: { withdrawOrderId: { type: "string" }, symbol: { type: "string" }, amount: { type: "string" }, address: { type: "string" }, label: { type: "string" } }, required: ["withdrawOrderId", "symbol", "amount", "address"], additionalProperties: false },
+    errorCodes: writeErrors,
+    validate: (input) => {
+      const value = strictObject(input, ["withdrawOrderId", "symbol", "amount", "address", "label"]);
+      return { withdrawOrderId: requiredString(value, "withdrawOrderId"), symbol: requiredString(value, "symbol"), amount: positiveDecimal(value, "amount"), address: requiredString(value, "address"), ...optionalString(value, "label") ? { label: optionalString(value, "label") } : {} };
+    },
+    handler: (input, context) => context.api.signedPost("/sapi/v1/withdraw/apply", input, signed(context)),
+    writeSummary: (input) => {
+      const value = input;
+      return { action: "create_withdraw", withdrawOrderId: value.withdrawOrderId, symbol: value.symbol, amount: value.amount, address: value.address, label: value.label ?? null };
+    }
+  },
+  {
+    name: "wallet_get_withdraw_history",
+    title: "Get Withdrawal History",
+    description: "Query withdrawal request history.",
+    cliPath: ["wallet", "withdraw-history"],
+    module: "spot-deposit-withdraw",
+    access: "signed",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { withdrawId: { type: "string" }, withdrawOrderId: { type: "string" }, symbol: { type: "string" }, startTime: { type: "string" }, endTime: { type: "string" }, page: { type: "integer" } }, additionalProperties: false },
+    errorCodes: signedReadErrors,
+    validate: (input) => {
+      const value = strictObject(input, ["withdrawId", "withdrawOrderId", "symbol", "startTime", "endTime", "page"]);
+      return { ...optionalString(value, "withdrawId") ? { withdrawId: optionalString(value, "withdrawId") } : {}, ...optionalString(value, "withdrawOrderId") ? { withdrawOrderId: optionalString(value, "withdrawOrderId") } : {}, ...optionalString(value, "symbol") ? { symbol: optionalString(value, "symbol") } : {}, ...optionalString(value, "startTime") ? { startTime: optionalString(value, "startTime") } : {}, ...optionalString(value, "endTime") ? { endTime: optionalString(value, "endTime") } : {}, page: optionalPositiveInteger(value, "page", 1) };
+    },
+    handler: (input, context) => context.api.signedPost("/sapi/v1/withdraw/query", input, signed(context))
+  }
+];
+
+// ../core/src/tools/market-tools.ts
+var readErrors = ["AI_HUB_INVALID_ARGUMENT", "AI_HUB_OPENAPI_NETWORK_ERROR", "AI_HUB_OPENAPI_HTTP_ERROR", "AI_HUB_OPENAPI_INVALID_RESPONSE"];
+var marketTools = [
+  {
+    name: "market_ping",
+    title: "Test OpenAPI Connection",
+    description: "Test the configured tenant OpenAPI connection.",
+    cliPath: ["market", "ping"],
+    module: "spot-common",
+    access: "public",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", additionalProperties: false },
+    errorCodes: ["AI_HUB_OPENAPI_NETWORK_ERROR", "AI_HUB_OPENAPI_HTTP_ERROR", "AI_HUB_OPENAPI_INVALID_RESPONSE"],
+    validate: (input) => {
+      strictObject(input, []);
+      return {};
+    },
+    handler: (_input, context) => context.api.ping()
+  },
+  {
+    name: "market_get_server_time",
+    title: "Get Server Time",
+    description: "Get server time from the configured tenant OpenAPI.",
+    cliPath: ["market", "time"],
+    module: "spot-common",
+    access: "public",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", additionalProperties: false },
+    errorCodes: readErrors,
+    validate: (input) => strictObject(input, []),
+    handler: (_input, context) => context.api.time()
+  },
+  {
+    name: "market_get_symbols",
+    title: "Get Spot Symbols",
+    description: "Get spot symbols from the configured tenant OpenAPI.",
+    cliPath: ["market", "symbols"],
+    module: "spot-common",
+    access: "public",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", additionalProperties: false },
+    errorCodes: readErrors,
+    validate: (input) => strictObject(input, []),
+    handler: (_input, context) => context.api.symbols()
+  },
+  {
+    name: "market_get_ticker",
+    title: "Get Spot Ticker",
+    description: "Get spot ticker data. Pass symbol or symbols when filtering is needed.",
+    cliPath: ["market", "ticker"],
+    module: "spot-common",
+    access: "public",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, symbols: { type: "string" }, timeZone: { type: "string" } }, additionalProperties: false },
+    errorCodes: readErrors,
+    validate: (input) => {
+      const value = strictObject(input, ["symbol", "symbols", "timeZone"]);
+      return { symbol: optionalString(value, "symbol"), symbols: optionalString(value, "symbols"), timeZone: optionalString(value, "timeZone") };
+    },
+    handler: (input, context) => context.api.ticker(input)
+  },
+  {
+    name: "market_get_depth",
+    title: "Get Spot Depth",
+    description: "Get the spot order book for one symbol.",
+    cliPath: ["market", "depth"],
+    module: "spot-common",
+    access: "public",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, limit: { type: "integer", minimum: 1, maximum: 100 } }, required: ["symbol"], additionalProperties: false },
+    errorCodes: readErrors,
+    validate: (input) => {
+      const value = strictObject(input, ["symbol", "limit"]);
+      return { symbol: requiredString(value, "symbol"), limit: optionalInteger(value, "limit", 20, 1, 100) };
+    },
+    handler: (input, context) => {
+      const value = input;
+      return context.api.depth(value.symbol, value.limit);
+    }
+  },
+  {
+    name: "market_get_trades",
+    title: "Get Recent Spot Trades",
+    description: "Get recent spot trades for one symbol.",
+    cliPath: ["market", "trades"],
+    module: "spot-common",
+    access: "public",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, limit: { type: "integer", minimum: 1, maximum: 1e3 } }, required: ["symbol"], additionalProperties: false },
+    errorCodes: readErrors,
+    validate: (input) => {
+      const value = strictObject(input, ["symbol", "limit"]);
+      return { symbol: requiredString(value, "symbol"), limit: optionalInteger(value, "limit", 100, 1, 1e3) };
+    },
+    handler: (input, context) => {
+      const value = input;
+      return context.api.trades(value.symbol, value.limit);
+    }
+  },
+  {
+    name: "market_get_klines",
+    title: "Get Spot Klines",
+    description: "Get spot candlestick data for one symbol and interval.",
+    cliPath: ["market", "klines"],
+    module: "spot-common",
+    access: "public",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, interval: { type: "string" }, startTime: { type: "integer" }, endTime: { type: "integer" }, timezone: { type: "string" }, limit: { type: "integer", minimum: 1, maximum: 1e3 } }, required: ["symbol", "interval"], additionalProperties: false },
+    errorCodes: readErrors,
+    validate: (input) => {
+      const value = strictObject(input, ["symbol", "interval", "startTime", "endTime", "timezone", "limit"]);
+      const startTime = value.startTime === void 0 ? void 0 : optionalInteger(value, "startTime", 0, 0, Number.MAX_SAFE_INTEGER);
+      const endTime = value.endTime === void 0 ? void 0 : optionalInteger(value, "endTime", 0, 0, Number.MAX_SAFE_INTEGER);
+      return { symbol: requiredString(value, "symbol"), interval: requiredString(value, "interval"), startTime, endTime, timezone: optionalString(value, "timezone"), limit: optionalInteger(value, "limit", 100, 1, 1e3) };
+    },
+    handler: (input, context) => context.api.klines(input)
+  }
+];
+
+// ../core/src/tools/margin-tools.ts
+function validateMarginOrder(input) {
+  const value = strictObject(input, ["symbol", "volume", "side", "type", "price", "newClientOrderId", "isolated"]);
+  const type = requiredEnum(value, "type", ["LIMIT", "MARKET"]);
+  const price = optionalString(value, "price");
+  if (type === "LIMIT" && !price) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "price is required for LIMIT orders.");
+  if (type === "MARKET" && price) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "price is not allowed for MARKET orders.");
+  return { symbol: requiredString(value, "symbol"), volume: positiveDecimal(value, "volume"), side: requiredEnum(value, "side", ["BUY", "SELL"]), type, ...price ? { price } : {}, newClientOrderId: optionalClientOrderId(value), ...optionalBoolean(value, "isolated") !== void 0 ? { isolated: optionalBoolean(value, "isolated") } : {} };
+}
+function validateMarginOrderLookup(input) {
+  const value = strictObject(input, ["symbol", "orderId", "newClientOrderId", "isolated"]);
+  return { symbol: requiredString(value, "symbol"), orderId: requiredString(value, "orderId"), ...optionalString(value, "newClientOrderId") ? { newClientOrderId: optionalString(value, "newClientOrderId") } : {}, ...optionalBoolean(value, "isolated") !== void 0 ? { isolated: optionalBoolean(value, "isolated") } : {} };
+}
+function validateMarginOpenOrders(input) {
+  const value = strictObject(input, ["symbol", "limit", "isolated"]);
+  return { ...optionalString(value, "symbol") ? { symbol: optionalString(value, "symbol") } : {}, limit: optionalPositiveInteger(value, "limit", 100, 1e3), ...optionalBoolean(value, "isolated") !== void 0 ? { isolated: optionalBoolean(value, "isolated") } : {} };
+}
+function validateMarginTrades(input) {
+  const value = strictObject(input, ["symbol", "limit", "fromId"]);
+  return { symbol: requiredString(value, "symbol"), limit: optionalPositiveInteger(value, "limit", 100, 1e3), ...optionalString(value, "fromId") ? { fromId: optionalString(value, "fromId") } : {} };
+}
+var marginTools = [
+  {
+    name: "margin_get_order",
+    title: "Get Margin Order",
+    description: "Get one signed margin order from the v2 margin API.",
+    cliPath: ["margin", "order", "get"],
+    module: "spot-margin",
+    access: "signed",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, orderId: { type: "string" }, newClientOrderId: { type: "string" }, isolated: { type: "boolean" } }, required: ["symbol", "orderId"], additionalProperties: false },
+    errorCodes: signedReadErrors,
+    validate: validateMarginOrderLookup,
+    handler: (input, context) => context.api.signedGet("/sapi/v2/margin/order", input, signed(context))
+  },
+  {
+    name: "margin_get_open_orders",
+    title: "Get Open Margin Orders",
+    description: "Get signed open margin orders from the v2 margin API.",
+    cliPath: ["margin", "order", "open"],
+    module: "spot-margin",
+    access: "signed",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, limit: { type: "integer", minimum: 1, maximum: 1e3 }, isolated: { type: "boolean" } }, additionalProperties: false },
+    errorCodes: signedReadErrors,
+    validate: validateMarginOpenOrders,
+    handler: (input, context) => context.api.signedGet("/sapi/v2/margin/openOrders", input, signed(context))
+  },
+  {
+    name: "margin_get_fills",
+    title: "Get Margin Fills",
+    description: "Get signed margin trade history from the v2 margin API.",
+    cliPath: ["margin", "order", "fills"],
+    module: "spot-margin",
+    access: "signed",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, limit: { type: "integer", minimum: 1, maximum: 1e3 }, fromId: { type: "string" } }, required: ["symbol"], additionalProperties: false },
+    errorCodes: signedReadErrors,
+    validate: validateMarginTrades,
+    handler: (input, context) => context.api.signedGet("/sapi/v2/margin/myTrades", input, signed(context))
+  },
+  {
+    name: "margin_place_order",
+    title: "Place Margin Order",
+    description: "Create one v2 margin order after confirmation.",
+    cliPath: ["margin", "order", "place"],
+    module: "spot-margin",
+    access: "signed",
+    operation: "write",
+    riskLevel: "high",
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, volume: { type: "string" }, side: { type: "string", enum: ["BUY", "SELL"] }, type: { type: "string", enum: ["LIMIT", "MARKET"] }, price: { type: "string" }, newClientOrderId: { type: "string" }, isolated: { type: "boolean" } }, required: ["symbol", "volume", "side", "type"], additionalProperties: false },
+    errorCodes: writeErrors,
+    validate: validateMarginOrder,
+    handler: (input, context) => context.api.signedPost("/sapi/v2/margin/order", input, signed(context)),
+    writeSummary: (input) => {
+      const value = input;
+      return { action: "margin_place_order", symbol: value.symbol, side: value.side, type: value.type, volume: value.volume, price: value.price ?? null, isolated: value.isolated ?? false, newClientOrderId: value.newClientOrderId };
+    }
+  },
+  {
+    name: "margin_cancel_order",
+    title: "Cancel Margin Order",
+    description: "Cancel one v2 margin order after confirmation.",
+    cliPath: ["margin", "order", "cancel"],
+    module: "spot-margin",
+    access: "signed",
+    operation: "write",
+    riskLevel: "high",
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, orderId: { type: "string" }, newClientOrderId: { type: "string" }, isolated: { type: "boolean" } }, required: ["symbol", "orderId"], additionalProperties: false },
+    errorCodes: writeErrors,
+    validate: validateMarginOrderLookup,
+    handler: (input, context) => context.api.signedPost("/sapi/v2/margin/cancel", input, signed(context)),
+    writeSummary: (input) => {
+      const value = input;
+      return { action: "margin_cancel_order", symbol: value.symbol, orderId: value.orderId, isolated: value.isolated ?? false, newClientOrderId: value.newClientOrderId ?? null };
+    }
+  }
+];
+
+// ../core/src/tools/order-tools.ts
+import { randomUUID as randomUUID3 } from "crypto";
+var signedReadErrors2 = ["AI_HUB_INVALID_ARGUMENT", "AI_HUB_CREDENTIAL_NOT_CONFIGURED", "AI_HUB_OPENAPI_NETWORK_ERROR", "AI_HUB_OPENAPI_HTTP_ERROR", "AI_HUB_OPENAPI_INVALID_RESPONSE"];
+var writeErrors2 = [...signedReadErrors2, "AI_HUB_WRITE_CONFIRMATION_REQUIRED", "AI_HUB_CONFIRMATION_REQUIRED", "AI_HUB_CONFIRMATION_EXPIRED", "AI_HUB_CONFIRMATION_CONTEXT_CHANGED", "AI_HUB_CONFIRMATION_NOT_FOUND"];
+var decimal = /^(?:0|[1-9]\d*)(?:\.\d+)?$/;
+function positiveDecimal2(value, name) {
+  const raw = requiredString(value, name);
+  if (!decimal.test(raw) || !/[1-9]/.test(raw.replace(".", ""))) {
+    throw new AiHubError("AI_HUB_INVALID_ARGUMENT", `${name} must be a positive decimal string.`);
+  }
+  return raw;
+}
+function signed2(context) {
+  if (!context.credentials) throw new AiHubError("AI_HUB_CREDENTIAL_NOT_CONFIGURED", `Credentials are not configured for profile "${context.profile.name}".`);
+  return context.credentials;
+}
+function orderSide(value) {
+  const side = requiredString(value, "side").toUpperCase();
+  if (side !== "BUY" && side !== "SELL") throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "side must be BUY or SELL.");
+  return side;
+}
+function orderType(value) {
+  const type = requiredString(value, "type").toUpperCase();
+  if (type !== "LIMIT" && type !== "MARKET") throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "type must be LIMIT or MARKET.");
+  return type;
+}
+function clientOrderId(value) {
+  const supplied = optionalString(value, "newClientOrderId");
+  if (supplied) return supplied;
+  return `agent_${randomUUID3().replaceAll("-", "").slice(0, 24)}`;
+}
+function validatePlaceOrder(input) {
+  const value = strictObject(input, ["symbol", "volume", "side", "type", "price", "timeInForce", "newClientOrderId", "recvWindow"]);
+  const type = orderType(value);
+  const price = optionalString(value, "price");
+  if (type === "LIMIT" && !price) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "price is required for LIMIT orders.");
+  if (type === "MARKET" && price) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "price is not allowed for MARKET orders.");
+  const timeInForce = optionalString(value, "timeInForce")?.toUpperCase();
+  if (timeInForce && !["GTC", "IOC", "FOK"].includes(timeInForce)) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "timeInForce must be GTC, IOC, or FOK.");
+  return {
+    symbol: requiredString(value, "symbol"),
+    volume: positiveDecimal2(value, "volume"),
+    side: orderSide(value),
+    type,
+    ...price ? { price } : {},
+    ...timeInForce ? { timeInForce } : {},
+    newClientOrderId: clientOrderId(value),
+    ...optionalString(value, "recvWindow") ? { recvWindow: optionalString(value, "recvWindow") } : {}
+  };
+}
+function validateCancelOrder(input) {
+  const value = strictObject(input, ["symbol", "orderId", "newClientOrderId"]);
+  return { symbol: requiredString(value, "symbol"), orderId: requiredString(value, "orderId"), ...optionalString(value, "newClientOrderId") ? { newClientOrderId: optionalString(value, "newClientOrderId") } : {} };
+}
+function validateTestOrder(input) {
+  const value = strictObject(input, ["symbol", "volume", "side", "type", "price", "newClientOrderId", "recvWindow"]);
+  const type = orderType(value);
+  const price = optionalString(value, "price");
+  if (type === "LIMIT" && !price) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "price is required for LIMIT orders.");
+  if (type === "MARKET" && price) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "price is not allowed for MARKET orders.");
+  return { symbol: requiredString(value, "symbol"), volume: positiveDecimal2(value, "volume"), side: orderSide(value), type, ...price ? { price } : {}, ...optionalString(value, "newClientOrderId") ? { newClientOrderId: optionalString(value, "newClientOrderId") } : {}, ...optionalString(value, "recvWindow") ? { recvWindow: optionalString(value, "recvWindow") } : {} };
+}
+function validateBatchOrders(input) {
+  const value = strictObject(input, ["symbol", "orders"]);
+  const orders = value.orders;
+  if (!Array.isArray(orders) || orders.length < 1 || orders.length > 10) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "orders must contain between 1 and 10 orders.");
+  const normalized = orders.map((item, index) => {
+    if (!item || typeof item !== "object" || Array.isArray(item)) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", `orders[${index}] must be an object.`);
+    const order = item;
+    const price = optionalString(order, "price");
+    const volume = positiveDecimal2(order, "volume");
+    const side = orderSide(order);
+    const batchType = requiredEnum(order, "batchType", ["LIMIT", "MARKET"]);
+    if (batchType === "LIMIT" && !price) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", `orders[${index}].price is required for LIMIT.`);
+    if (batchType === "MARKET" && price) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", `orders[${index}].price is not allowed for MARKET.`);
+    return { volume, side, batchType, ...price ? { price } : {} };
+  });
+  return { symbol: requiredString(value, "symbol"), orders: normalized };
+}
+function validateBatchCancel(input) {
+  const value = strictObject(input, ["symbol", "orderIds"]);
+  if (!Array.isArray(value.orderIds) || value.orderIds.length < 1 || value.orderIds.length > 10 || value.orderIds.some((id) => typeof id !== "string" || !id.trim())) {
+    throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "orderIds must contain between 1 and 10 non-empty order ID strings.");
+  }
+  return { symbol: requiredString(value, "symbol"), orderIds: value.orderIds.map((id) => id.trim()) };
+}
+var orderTools = [
+  {
+    name: "spot_test_order",
+    title: "Test Spot Order",
+    description: "Validate one LIMIT or MARKET spot order without sending it to the matching engine.",
+    cliPath: ["spot", "order", "test"],
+    module: "spot-order",
+    access: "signed",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, volume: { type: "string" }, side: { type: "string", enum: ["BUY", "SELL"] }, type: { type: "string", enum: ["LIMIT", "MARKET"] }, price: { type: "string" }, newClientOrderId: { type: "string" }, recvWindow: { type: "string" } }, required: ["symbol", "volume", "side", "type"], additionalProperties: false },
+    errorCodes: signedReadErrors2,
+    validate: validateTestOrder,
+    handler: (input, context) => context.api.signedPost("/sapi/v2/order/test", input, signed2(context))
+  },
+  {
+    name: "spot_get_order",
+    title: "Get Spot Order",
+    description: "Get one signed spot order by symbol and order ID.",
+    cliPath: ["spot", "order", "get"],
+    module: "spot-order",
+    access: "signed",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, orderId: { type: "string" }, newClientOrderId: { type: "string" } }, required: ["symbol", "orderId"], additionalProperties: false },
+    errorCodes: signedReadErrors2,
+    validate: (input) => {
+      const value = strictObject(input, ["symbol", "orderId", "newClientOrderId"]);
+      return { symbol: requiredString(value, "symbol"), orderId: requiredString(value, "orderId"), newClientOrderId: optionalString(value, "newClientOrderId") };
+    },
+    handler: (input, context) => context.api.getOrder(input, signed2(context))
+  },
+  {
+    name: "spot_batch_place_orders",
+    title: "Batch Place Spot Orders",
+    description: "Create up to 10 spot orders after confirmation.",
+    cliPath: ["spot", "order", "batch-place"],
+    module: "spot-order",
+    access: "signed",
+    operation: "write",
+    riskLevel: "high",
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, orders: { type: "array" } }, required: ["symbol", "orders"], additionalProperties: false },
+    errorCodes: writeErrors2,
+    validate: validateBatchOrders,
+    handler: (input, context) => context.api.signedPost("/sapi/v2/batchOrders", input, signed2(context)),
+    writeSummary: (input) => {
+      const value = input;
+      return { action: "batch_place_orders", symbol: value.symbol, orderCount: value.orders.length, orders: value.orders };
+    }
+  },
+  {
+    name: "spot_batch_cancel_orders",
+    title: "Batch Cancel Spot Orders",
+    description: "Cancel up to 10 spot orders after confirmation.",
+    cliPath: ["spot", "order", "batch-cancel"],
+    module: "spot-order",
+    access: "signed",
+    operation: "write",
+    riskLevel: "high",
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, orderIds: { type: "array" } }, required: ["symbol", "orderIds"], additionalProperties: false },
+    errorCodes: writeErrors2,
+    validate: validateBatchCancel,
+    handler: (input, context) => context.api.signedPost("/sapi/v2/batchCancel", input, signed2(context)),
+    writeSummary: (input) => {
+      const value = input;
+      return { action: "batch_cancel_orders", symbol: value.symbol, orderIds: value.orderIds };
+    }
+  },
+  {
+    name: "spot_get_open_orders",
+    title: "Get Open Spot Orders",
+    description: "Get current signed spot orders.",
+    cliPath: ["spot", "order", "open"],
+    module: "spot-order",
+    access: "signed",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, limit: { type: "integer", minimum: 1, maximum: 1e3 } }, additionalProperties: false },
+    errorCodes: signedReadErrors2,
+    validate: (input) => {
+      const value = strictObject(input, ["symbol", "limit"]);
+      return { symbol: optionalString(value, "symbol"), limit: optionalInteger(value, "limit", 100, 1, 1e3) };
+    },
+    handler: (input, context) => context.api.getOpenOrders(input, signed2(context))
+  },
+  {
+    name: "spot_get_fills",
+    title: "Get Spot Fills",
+    description: "Get signed spot fills for one symbol.",
+    cliPath: ["spot", "order", "fills"],
+    module: "spot-order",
+    access: "signed",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, limit: { type: "integer", minimum: 1, maximum: 1e3 }, fromId: { type: "string" } }, required: ["symbol"], additionalProperties: false },
+    errorCodes: signedReadErrors2,
+    validate: (input) => {
+      const value = strictObject(input, ["symbol", "limit", "fromId"]);
+      return { symbol: requiredString(value, "symbol"), limit: optionalInteger(value, "limit", 100, 1, 1e3), fromId: optionalString(value, "fromId") };
+    },
+    handler: (input, context) => context.api.getMyTrades(input, signed2(context))
+  },
+  {
+    name: "spot_place_order",
+    title: "Place Spot Order",
+    description: "Create one LIMIT or MARKET spot order after confirmation.",
+    cliPath: ["spot", "order", "place"],
+    module: "spot-order",
+    access: "signed",
+    operation: "write",
+    riskLevel: "high",
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, volume: { type: "string" }, side: { type: "string", enum: ["BUY", "SELL"] }, type: { type: "string", enum: ["LIMIT", "MARKET"] }, price: { type: "string" }, timeInForce: { type: "string", enum: ["GTC", "IOC", "FOK"] }, newClientOrderId: { type: "string" }, recvWindow: { type: "string" } }, required: ["symbol", "volume", "side", "type"], additionalProperties: false },
+    errorCodes: writeErrors2,
+    validate: validatePlaceOrder,
+    handler: (input, context) => context.api.placeOrder(input, signed2(context)),
+    writeSummary: (input) => {
+      const value = input;
+      return { action: "place_order", symbol: value.symbol, side: value.side, type: value.type, volume: value.volume, price: value.price ?? null, timeInForce: value.timeInForce ?? null, newClientOrderId: value.newClientOrderId };
+    }
+  },
+  {
+    name: "spot_cancel_order",
+    title: "Cancel Spot Order",
+    description: "Cancel one spot order after confirmation.",
+    cliPath: ["spot", "order", "cancel"],
+    module: "spot-order",
+    access: "signed",
+    operation: "write",
+    riskLevel: "high",
+    inputSchema: { type: "object", properties: { symbol: { type: "string" }, orderId: { type: "string" }, newClientOrderId: { type: "string" } }, required: ["symbol", "orderId"], additionalProperties: false },
+    errorCodes: writeErrors2,
+    validate: validateCancelOrder,
+    handler: (input, context) => context.api.cancelOrder(input, signed2(context)),
+    writeSummary: (input) => {
+      const value = input;
+      return { action: "cancel_order", symbol: value.symbol, orderId: value.orderId, newClientOrderId: value.newClientOrderId ?? null };
+    }
+  }
+];
+
+// ../core/src/tools/sub-account-tools.ts
+function fields(input, allowed, required = []) {
+  const value = strictObject(input, allowed);
+  const result2 = {};
+  for (const name of required) result2[name] = requiredString(value, name);
+  for (const name of allowed) if (!required.includes(name) && optionalString(value, name)) result2[name] = optionalString(value, name);
+  return result2;
+}
+function pages(value) {
+  return { page: optionalPositiveInteger(value, "page", 1), pageSize: optionalPositiveInteger(value, "pageSize", 20, 100) };
+}
+function transfer(value, requireSubUid) {
+  const result2 = { coinSymbol: requiredString(value, "coinSymbol"), amount: positiveDecimal(value, "amount") };
+  if (requireSubUid) result2.subUid = requiredString(value, "subUid");
+  return result2;
+}
+var subAccountTools = [
+  {
+    name: "sub_account_list",
+    title: "List Sub-accounts",
+    description: "Get enabled sub-accounts under the main account.",
+    cliPath: ["sub-account", "list"],
+    module: "spot-sub-account",
+    access: "signed",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", additionalProperties: false },
+    errorCodes: signedReadErrors,
+    validate: (input) => {
+      strictObject(input, []);
+      return {};
+    },
+    handler: (_input, context) => context.api.signedPost("/sapi/v1/sub_user/get_sub_user_List", {}, signed(context))
+  },
+  {
+    name: "sub_account_create",
+    title: "Create Sub-account",
+    description: "Create a virtual sub-account after confirmation.",
+    cliPath: ["sub-account", "create"],
+    module: "spot-sub-account",
+    access: "signed",
+    operation: "write",
+    riskLevel: "high",
+    inputSchema: { type: "object", properties: { subUserEmail: { type: "string", maxLength: 5 } }, required: ["subUserEmail"], additionalProperties: false },
+    errorCodes: writeErrors,
+    validate: (input) => {
+      const value = fields(input, ["subUserEmail"], ["subUserEmail"]);
+      if (String(value.subUserEmail).length > 5) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "subUserEmail must be at most 5 characters.");
+      return value;
+    },
+    handler: (input, context) => context.api.signedPost("/sapi/v1/sub_user/create_sub_user", input, signed(context)),
+    writeSummary: (input) => ({ action: "create_sub_account", subUserEmail: input.subUserEmail })
+  },
+  {
+    name: "sub_account_update_trading_status",
+    title: "Update Sub-account Trading Status",
+    description: "Enable or disable a sub-account capability after confirmation.",
+    cliPath: ["sub-account", "set-trading-status"],
+    module: "spot-sub-account",
+    access: "signed",
+    operation: "write",
+    riskLevel: "high",
+    inputSchema: { type: "object", properties: { subUid: { type: "string" }, type: { type: "string", enum: ["lever", "etf", "deposit"] }, status: { type: "string", enum: ["0", "1"] } }, required: ["subUid", "type", "status"], additionalProperties: false },
+    errorCodes: writeErrors,
+    validate: (input) => {
+      const value = fields(input, ["subUid", "type", "status"], ["subUid", "type", "status"]);
+      if (!["lever", "etf", "deposit"].includes(String(value.type)) || !["0", "1"].includes(String(value.status))) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "type or status is invalid.");
+      return value;
+    },
+    handler: (input, context) => context.api.signedPost("/sapi/v1/sub_user/update_trade_status", input, signed(context)),
+    writeSummary: (input) => ({ action: "update_sub_account_trading_status", ...input })
+  },
+  {
+    name: "sub_account_get_api_key_ips",
+    title: "Get Sub-account API Key IPs",
+    description: "Get a sub-account API key whitelist.",
+    cliPath: ["sub-account", "api-key", "list"],
+    module: "spot-sub-account",
+    access: "signed",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { subUid: { type: "string" } }, required: ["subUid"], additionalProperties: false },
+    errorCodes: signedReadErrors,
+    validate: (input) => fields(input, ["subUid"], ["subUid"]),
+    handler: (input, context) => context.api.signedPost("/sapi/v1/sub_user/sub_account_api/list", input, signed(context))
+  },
+  {
+    name: "sub_account_update_api_key_ips",
+    title: "Update Sub-account API Key IPs",
+    description: "Update a sub-account API key IP whitelist after confirmation.",
+    cliPath: ["sub-account", "api-key", "set-ip"],
+    module: "spot-sub-account",
+    access: "signed",
+    operation: "write",
+    riskLevel: "high",
+    inputSchema: { type: "object", properties: { subUid: { type: "string" }, subAccountApiKey: { type: "string" }, status: { type: "string", enum: ["1", "2"] }, ipAddress: { type: "string" } }, required: ["subUid", "subAccountApiKey", "status"], additionalProperties: false },
+    errorCodes: writeErrors,
+    validate: (input) => {
+      const value = fields(input, ["subUid", "subAccountApiKey", "status", "ipAddress"], ["subUid", "subAccountApiKey", "status"]);
+      if (!["1", "2"].includes(String(value.status))) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "status must be 1 or 2.");
+      if (value.status === "2" && !value.ipAddress) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "ipAddress is required when status is 2.");
+      return value;
+    },
+    handler: (input, context) => context.api.signedPost("/sapi/v1/sub_user/sub_account_api/update_ip", input, signed(context)),
+    writeSummary: (input) => ({ action: "update_sub_account_api_key_ips", ...input })
+  },
+  {
+    name: "sub_account_delete_api_key",
+    title: "Delete Sub-account API Key",
+    description: "Delete a sub-account API key after confirmation.",
+    cliPath: ["sub-account", "api-key", "delete"],
+    module: "spot-sub-account",
+    access: "signed",
+    operation: "write",
+    riskLevel: "high",
+    inputSchema: { type: "object", properties: { subUid: { type: "string" }, subAccountApiKey: { type: "string" } }, required: ["subUid", "subAccountApiKey"], additionalProperties: false },
+    errorCodes: writeErrors,
+    validate: (input) => fields(input, ["subUid", "subAccountApiKey"], ["subUid", "subAccountApiKey"]),
+    handler: (input, context) => context.api.signedPost("/sapi/v1/sub_user/sub_account_api/delete", input, signed(context)),
+    writeSummary: (input) => ({ action: "delete_sub_account_api_key", ...input })
+  },
+  {
+    name: "sub_account_get_assets",
+    title: "Get Sub-account Assets",
+    description: "Query sub-account assets by account type.",
+    cliPath: ["sub-account", "assets"],
+    module: "spot-sub-account",
+    access: "signed",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { subUid: { type: "string" }, accountType: { type: "string" }, type: { type: "string" } }, required: ["subUid", "accountType"], additionalProperties: false },
+    errorCodes: signedReadErrors,
+    validate: (input) => fields(input, ["subUid", "accountType", "type"], ["subUid", "accountType"]),
+    handler: (input, context) => context.api.signedPost("/sapi/v1/sub_user/asset/account", input, signed(context))
+  },
+  {
+    name: "sub_account_root_transfer",
+    title: "Transfer Between Root and Sub-account",
+    description: "Transfer assets between a root and sub-account after confirmation.",
+    cliPath: ["sub-account", "root-transfer"],
+    module: "spot-sub-account",
+    access: "signed",
+    operation: "write",
+    riskLevel: "high",
+    inputSchema: { type: "object", properties: { subUid: { type: "string" }, coinSymbol: { type: "string" }, amount: { type: "string" }, type: { type: "string" } }, required: ["subUid", "coinSymbol", "amount", "type"], additionalProperties: false },
+    errorCodes: writeErrors,
+    validate: (input) => {
+      const value = strictObject(input, ["subUid", "coinSymbol", "amount", "type"]);
+      return { ...transfer(value, true), type: requiredString(value, "type") };
+    },
+    handler: (input, context) => context.api.signedPost("/sapi/v1/sub_user/asset/root_transfer", input, signed(context)),
+    writeSummary: (input) => ({ action: "sub_account_root_transfer", ...input })
+  },
+  {
+    name: "sub_account_get_root_transfer_history",
+    title: "Get Root/Sub Transfer History",
+    description: "Query root and sub-account transfer history.",
+    cliPath: ["sub-account", "root-transfer-history"],
+    module: "spot-sub-account",
+    access: "signed",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { subUid: { type: "string" }, coinSymbol: { type: "string" }, page: { type: "integer" }, pageSize: { type: "integer" } }, required: ["subUid", "coinSymbol"], additionalProperties: false },
+    errorCodes: signedReadErrors,
+    validate: (input) => {
+      const value = strictObject(input, ["subUid", "coinSymbol", "page", "pageSize"]);
+      return { subUid: requiredString(value, "subUid"), coinSymbol: requiredString(value, "coinSymbol"), ...pages(value) };
+    },
+    handler: (input, context) => context.api.signedPost("/sapi/v1/sub_user/asset/root_transfer_query", input, signed(context))
+  },
+  {
+    name: "sub_account_internal_transfer",
+    title: "Transfer Within Sub-account",
+    description: "Transfer assets between a sub-account's internal account types after confirmation.",
+    cliPath: ["sub-account", "internal-transfer"],
+    module: "spot-sub-account",
+    access: "signed",
+    operation: "write",
+    riskLevel: "high",
+    inputSchema: { type: "object", properties: { subUid: { type: "string" }, coinSymbol: { type: "string" }, amount: { type: "string" }, type: { type: "string" }, accountType: { type: "string" }, symbol: { type: "string" } }, required: ["subUid", "coinSymbol", "amount", "type", "accountType"], additionalProperties: false },
+    errorCodes: writeErrors,
+    validate: (input) => {
+      const value = strictObject(input, ["subUid", "coinSymbol", "amount", "type", "accountType", "symbol"]);
+      return { ...transfer(value, true), type: requiredString(value, "type"), accountType: requiredString(value, "accountType"), ...optionalString(value, "symbol") ? { symbol: optionalString(value, "symbol") } : {} };
+    },
+    handler: (input, context) => context.api.signedPost("/sapi/v1/sub_user/asset/transfer", input, signed(context)),
+    writeSummary: (input) => ({ action: "sub_account_internal_transfer", ...input })
+  },
+  {
+    name: "sub_account_get_internal_transfer_history",
+    title: "Get Sub-account Internal Transfer History",
+    description: "Query internal sub-account transfer history.",
+    cliPath: ["sub-account", "internal-transfer-history"],
+    module: "spot-sub-account",
+    access: "signed",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { subUid: { type: "string" }, type: { type: "string" }, accountType: { type: "string" }, coinSymbol: { type: "string" }, page: { type: "integer" }, pageSize: { type: "integer" } }, required: ["subUid", "type", "accountType", "coinSymbol"], additionalProperties: false },
+    errorCodes: signedReadErrors,
+    validate: (input) => {
+      const value = strictObject(input, ["subUid", "type", "accountType", "coinSymbol", "page", "pageSize"]);
+      return { subUid: requiredString(value, "subUid"), type: requiredString(value, "type"), accountType: requiredString(value, "accountType"), coinSymbol: requiredString(value, "coinSymbol"), ...pages(value) };
+    },
+    handler: (input, context) => context.api.signedPost("/sapi/v1/sub_user/asset/transfer_query", input, signed(context))
+  },
+  {
+    name: "sub_account_transfer_to_parent",
+    title: "Transfer From Sub-account to Parent",
+    description: "Transfer assets to the parent account after confirmation.",
+    cliPath: ["sub-account", "transfer-to-parent"],
+    module: "spot-sub-account",
+    access: "signed",
+    operation: "write",
+    riskLevel: "high",
+    inputSchema: { type: "object", properties: { coinSymbol: { type: "string" }, amount: { type: "string" } }, required: ["coinSymbol", "amount"], additionalProperties: false },
+    errorCodes: writeErrors,
+    validate: (input) => {
+      const value = strictObject(input, ["coinSymbol", "amount"]);
+      return transfer(value, false);
+    },
+    handler: (input, context) => context.api.signedPost("/sapi/v1/asset/subaccount/transfer", input, signed(context)),
+    writeSummary: (input) => ({ action: "sub_account_transfer_to_parent", ...input })
+  },
+  {
+    name: "sub_account_get_parent_transfer_history",
+    title: "Get Parent Transfer History",
+    description: "Query transfers between this sub-account and its parent.",
+    cliPath: ["sub-account", "parent-transfer-history"],
+    module: "spot-sub-account",
+    access: "signed",
+    operation: "read",
+    riskLevel: "low",
+    inputSchema: { type: "object", properties: { coinSymbol: { type: "string" }, page: { type: "integer" }, pageSize: { type: "integer" } }, required: ["coinSymbol"], additionalProperties: false },
+    errorCodes: signedReadErrors,
+    validate: (input) => {
+      const value = strictObject(input, ["coinSymbol", "page", "pageSize"]);
+      return { coinSymbol: requiredString(value, "coinSymbol"), ...pages(value) };
+    },
+    handler: (input, context) => context.api.signedPost("/sapi/v1/asset/subaccount/transfer_query", input, signed(context))
+  }
+];
+
+// ../core/src/tools/tool-registry.ts
+var allTools = [...marketTools, ...accountTools, ...orderTools, ...marginTools, ...assetTools, ...subAccountTools];
+var ToolRegistry = class {
+  toolsByName = /* @__PURE__ */ new Map();
+  toolsByCliPath = /* @__PURE__ */ new Map();
+  constructor(tools = allTools) {
+    for (const tool of tools) {
+      const path = tool.cliPath.join(" ");
+      if (this.toolsByName.has(tool.name) || this.toolsByCliPath.has(path)) {
+        throw new AiHubError("AI_HUB_TOOL_DUPLICATE", `Duplicate tool registration: ${tool.name}.`);
+      }
+      this.toolsByName.set(tool.name, tool);
+      this.toolsByCliPath.set(path, tool);
+    }
+  }
+  list(options = {}) {
+    return [...this.toolsByName.values()].filter((tool) => !options.readOnly || tool.operation === "read");
+  }
+  byName(name, options = {}) {
+    const tool = this.toolsByName.get(name);
+    if (!tool || options.readOnly && tool.operation !== "read") {
+      throw new AiHubError("AI_HUB_TOOL_NOT_AVAILABLE", `Tool "${name}" is not available in this server session.`);
+    }
+    return tool;
+  }
+  byCliPath(path, options = {}) {
+    const tool = this.toolsByCliPath.get(path.join(" "));
+    if (!tool || options.readOnly && tool.operation !== "read") {
+      throw new AiHubError("AI_HUB_TOOL_NOT_AVAILABLE", `Command "${path.join(" ")}" is not available.`);
+    }
+    return tool;
+  }
+  async execute(name, input, context, options = {}) {
+    const tool = this.byName(name, options);
+    if (tool.operation === "write") throw new AiHubError("AI_HUB_WRITE_CONFIRMATION_REQUIRED", `Tool "${name}" must be executed through confirmation.`);
+    const validInput = tool.validate(input);
+    return tool.handler(validInput, context);
+  }
+  prepareWrite(name, input, context, confirmations) {
+    const tool = this.byName(name);
+    if (tool.operation !== "write" || !tool.writeSummary) throw new AiHubError("AI_HUB_TOOL_NOT_WRITE", `Tool "${name}" is not a confirmable write Tool.`);
+    const validInput = tool.validate(input);
+    return confirmations.prepare({
+      action: tool.name,
+      payload: validInput,
+      context: confirmationContext(context),
+      summary: tool.writeSummary(validInput)
+    });
+  }
+  async executeConfirmed(action, payload, context) {
+    const tool = this.byName(action);
+    if (tool.operation !== "write") throw new AiHubError("AI_HUB_TOOL_NOT_WRITE", `Tool "${action}" is not a write Tool.`);
+    const validInput = tool.validate(payload);
+    return tool.handler(validInput, context);
+  }
+  capabilities(context, options = {}) {
+    return this.list(options).map((tool) => ({
+      name: tool.name,
+      module: tool.module,
+      operation: tool.operation,
+      riskLevel: tool.riskLevel,
+      status: tool.access === "signed" && !context.credentials ? "requires_auth" : "enabled"
+    }));
+  }
+};
+function createToolRegistry() {
+  return new ToolRegistry();
+}
+
+// ../core/src/tools/write-executor.ts
+var ToolWriteExecutor = class {
+  constructor(registry, confirmations = new ConfirmationService()) {
+    this.registry = registry;
+    this.confirmations = confirmations;
+  }
+  registry;
+  confirmations;
+  prepare(name, input, context) {
+    return this.registry.prepareWrite(name, input, context, this.confirmations);
+  }
+  async confirm(confirmationId, userConfirmation, context) {
+    const pending = this.confirmations.confirm(confirmationId, userConfirmation, confirmationContext(context));
+    try {
+      return await this.registry.executeConfirmed(pending.action, pending.payload, context);
+    } catch (error) {
+      if (error instanceof AiHubError && error.code === "AI_HUB_OPENAPI_NETWORK_ERROR") {
+        throw new AiHubError("AI_HUB_WRITE_RESULT_UNKNOWN", "The request may have reached OpenAPI. Do not retry automatically; query by client order ID before taking another action.");
+      }
+      throw error;
+    }
+  }
+};
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+var CAPABILITIES_TOOL = "system_get_capabilities";
+var CONFIRM_ACTION_TOOL = "confirm_action";
+function result(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+}
+function errorResult(error) {
+  const payload = error instanceof AiHubError ? { code: error.code, message: error.message } : { code: "AI_HUB_UNEXPECTED_ERROR", message: error instanceof Error ? error.message : "Unexpected error" };
+  return { isError: true, content: [{ type: "text", text: JSON.stringify({ ok: false, ...payload }) }] };
+}
+function toMcpTool(tool) {
+  return {
+    name: tool.name,
+    title: tool.title,
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+    annotations: {
+      readOnlyHint: tool.operation === "read",
+      destructiveHint: tool.riskLevel === "high",
+      idempotentHint: tool.operation === "read",
+      openWorldHint: true
+    }
+  };
+}
+function prepareToolName(tool) {
+  const [prefix, ...rest] = tool.name.split("_");
+  return `${prefix ?? "spot"}_prepare_${rest.join("_")}`;
+}
+function toPrepareMcpTool(tool) {
+  return {
+    ...toMcpTool(tool),
+    name: prepareToolName(tool),
+    title: `Prepare ${tool.title}`,
+    description: `Validate and preview this state-changing request. It does not call OpenAPI. Stop after this call and wait for a NEW explicit user confirmation message before calling ${CONFIRM_ACTION_TOOL}.`,
+    annotations: { readOnlyHint: false, destructiveHint: tool.riskLevel === "high", idempotentHint: true, openWorldHint: false }
+  };
+}
+function createServer(profileName, readOnly) {
+  const registry = createToolRegistry();
+  const writeExecutor = new ToolWriteExecutor(registry);
+  const server = new Server(
+    { name: "ai-hub-agent-trade", version: "0.1.0" },
+    {
+      capabilities: { tools: {} },
+      instructions: "For every state-changing action, call only a spot_prepare_* tool first and show its exact summary to the user. Stop and wait for a new, explicit user confirmation message. Only then call confirm_action with that new message verbatim in userConfirmation. Never call prepare and confirm consecutively for one user instruction; never infer confirmation from prior intent, silence, or an Agent-generated message."
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: CAPABILITIES_TOOL,
+        title: "Server Capabilities Snapshot",
+        description: "Return the available local profile and Tool Registry capability snapshot.",
+        inputSchema: { type: "object", additionalProperties: false },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+      },
+      ...registry.list({ readOnly }).flatMap((tool) => tool.operation === "write" ? [toPrepareMcpTool(tool)] : [toMcpTool(tool)]),
+      ...readOnly ? [] : [{
+        name: CONFIRM_ACTION_TOOL,
+        title: "Confirm Prepared Action",
+        description: "Execute one previously prepared state-changing action exactly once, only after a new explicit user confirmation message received after the preview.",
+        inputSchema: { type: "object", properties: { confirmationId: { type: "string" }, userConfirmation: { type: "string", minLength: 1, description: "The new explicit user confirmation message received after the prepare preview. Do not generate or infer this text." } }, required: ["confirmationId", "userConfirmation"], additionalProperties: false },
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false }
+      }]
+    ]
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    try {
+      const context = await createToolExecutionContext(profileName);
+      if (request.params.name === CAPABILITIES_TOOL) {
+        return result({
+          ok: true,
+          data: {
+            profile: { name: context.profile.name, host: new URL(context.profile.openApiBaseUrl).host, configVersion: context.profile.configVersion },
+            readOnly,
+            capabilities: registry.capabilities(context, { readOnly })
+          }
+        });
+      }
+      if (request.params.name === CONFIRM_ACTION_TOOL) {
+        const input = request.params.arguments ?? {};
+        if (typeof input.confirmationId !== "string" || typeof input.userConfirmation !== "string" || !input.userConfirmation.trim()) {
+          throw new AiHubError("AI_HUB_INVALID_ARGUMENT", "confirmationId and a non-empty userConfirmation are required.");
+        }
+        return result({ ok: true, data: await writeExecutor.confirm(input.confirmationId, input.userConfirmation, context) });
+      }
+      const preparedTool = registry.list({ readOnly: false }).find((tool) => tool.operation === "write" && prepareToolName(tool) === request.params.name);
+      if (preparedTool) {
+        return result({ ok: true, data: writeExecutor.prepare(preparedTool.name, request.params.arguments ?? {}, context) });
+      }
+      const data = await registry.execute(request.params.name, request.params.arguments ?? {}, context, { readOnly });
+      return result({ ok: true, data });
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  return server;
+}
+
+// src/index.ts
+function readOption(args, option) {
+  const index = args.indexOf(option);
+  if (index < 0) return void 0;
+  const value = args[index + 1];
+  if (!value || value.startsWith("--")) throw new AiHubError("AI_HUB_INVALID_ARGUMENT", `${option} requires a value.`);
+  return value;
+}
+async function main(argv) {
+  const profileName = readOption(argv, "--profile");
+  const readOnly = argv.includes("--read-only");
+  const server = createServer(profileName, readOnly);
+  await server.connect(new StdioServerTransport());
+}
+main(process.argv.slice(2)).catch((error) => {
+  const payload = error instanceof AiHubError ? { code: error.code, message: error.message } : { code: "AI_HUB_UNEXPECTED_ERROR", message: error instanceof Error ? error.message : "Unexpected error" };
+  process.stderr.write(`${JSON.stringify(payload)}
+`);
+  process.exitCode = 1;
+});
+export {
+  main
+};