@nuno1026/bithumb-mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,3567 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { parseArgs } from "util";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// ../core/dist/index.js
+import { createHash, createHmac, randomUUID } from "crypto";
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { readFileSync, writeFileSync, mkdirSync, existsSync as existsSync2 } from "fs";
+import { join as join2, dirname } from "path";
+import { homedir as homedir2 } from "os";
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/error.js
+function getLineColFromPtr(string, ptr) {
+  let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
+  return [lines.length, lines.pop().length + 1];
+}
+function makeCodeBlock(string, line, column) {
+  let lines = string.split(/\r\n|\n|\r/g);
+  let codeblock = "";
+  let numberLen = (Math.log10(line + 1) | 0) + 1;
+  for (let i = line - 1; i <= line + 1; i++) {
+    let l = lines[i - 1];
+    if (!l)
+      continue;
+    codeblock += i.toString().padEnd(numberLen, " ");
+    codeblock += ":  ";
+    codeblock += l;
+    codeblock += "\n";
+    if (i === line) {
+      codeblock += " ".repeat(numberLen + column + 2);
+      codeblock += "^\n";
+    }
+  }
+  return codeblock;
+}
+var TomlError = class extends Error {
+  line;
+  column;
+  codeblock;
+  constructor(message, options) {
+    const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+    const codeblock = makeCodeBlock(options.toml, line, column);
+    super(`Invalid TOML document: ${message}
+
+${codeblock}`, options);
+    this.line = line;
+    this.column = column;
+    this.codeblock = codeblock;
+  }
+};
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/util.js
+function isEscaped(str, ptr) {
+  let i = 0;
+  while (str[ptr - ++i] === "\\")
+    ;
+  return --i && i % 2;
+}
+function indexOfNewline(str, start = 0, end = str.length) {
+  let idx = str.indexOf("\n", start);
+  if (str[idx - 1] === "\r")
+    idx--;
+  return idx <= end ? idx : -1;
+}
+function skipComment(str, ptr) {
+  for (let i = ptr; i < str.length; i++) {
+    let c = str[i];
+    if (c === "\n")
+      return i;
+    if (c === "\r" && str[i + 1] === "\n")
+      return i + 1;
+    if (c < " " && c !== "	" || c === "\x7F") {
+      throw new TomlError("control characters are not allowed in comments", {
+        toml: str,
+        ptr
+      });
+    }
+  }
+  return str.length;
+}
+function skipVoid(str, ptr, banNewLines, banComments) {
+  let c;
+  while (1) {
+    while ((c = str[ptr]) === " " || c === "	" || !banNewLines && (c === "\n" || c === "\r" && str[ptr + 1] === "\n"))
+      ptr++;
+    if (banComments || c !== "#")
+      break;
+    ptr = skipComment(str, ptr);
+  }
+  return ptr;
+}
+function skipUntil(str, ptr, sep, end, banNewLines = false) {
+  if (!end) {
+    ptr = indexOfNewline(str, ptr);
+    return ptr < 0 ? str.length : ptr;
+  }
+  for (let i = ptr; i < str.length; i++) {
+    let c = str[i];
+    if (c === "#") {
+      i = indexOfNewline(str, i);
+    } else if (c === sep) {
+      return i + 1;
+    } else if (c === end || banNewLines && (c === "\n" || c === "\r" && str[i + 1] === "\n")) {
+      return i;
+    }
+  }
+  throw new TomlError("cannot find end of structure", {
+    toml: str,
+    ptr
+  });
+}
+function getStringEnd(str, seek) {
+  let first = str[seek];
+  let target = first === str[seek + 1] && str[seek + 1] === str[seek + 2] ? str.slice(seek, seek + 3) : first;
+  seek += target.length - 1;
+  do
+    seek = str.indexOf(target, ++seek);
+  while (seek > -1 && first !== "'" && isEscaped(str, seek));
+  if (seek > -1) {
+    seek += target.length;
+    if (target.length > 1) {
+      if (str[seek] === first)
+        seek++;
+      if (str[seek] === first)
+        seek++;
+    }
+  }
+  return seek;
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/date.js
+var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
+var TomlDate = class _TomlDate extends Date {
+  #hasDate = false;
+  #hasTime = false;
+  #offset = null;
+  constructor(date) {
+    let hasDate = true;
+    let hasTime = true;
+    let offset = "Z";
+    if (typeof date === "string") {
+      let match = date.match(DATE_TIME_RE);
+      if (match) {
+        if (!match[1]) {
+          hasDate = false;
+          date = `0000-01-01T${date}`;
+        }
+        hasTime = !!match[2];
+        hasTime && date[10] === " " && (date = date.replace(" ", "T"));
+        if (match[2] && +match[2] > 23) {
+          date = "";
+        } else {
+          offset = match[3] || null;
+          date = date.toUpperCase();
+          if (!offset && hasTime)
+            date += "Z";
+        }
+      } else {
+        date = "";
+      }
+    }
+    super(date);
+    if (!isNaN(this.getTime())) {
+      this.#hasDate = hasDate;
+      this.#hasTime = hasTime;
+      this.#offset = offset;
+    }
+  }
+  isDateTime() {
+    return this.#hasDate && this.#hasTime;
+  }
+  isLocal() {
+    return !this.#hasDate || !this.#hasTime || !this.#offset;
+  }
+  isDate() {
+    return this.#hasDate && !this.#hasTime;
+  }
+  isTime() {
+    return this.#hasTime && !this.#hasDate;
+  }
+  isValid() {
+    return this.#hasDate || this.#hasTime;
+  }
+  toISOString() {
+    let iso = super.toISOString();
+    if (this.isDate())
+      return iso.slice(0, 10);
+    if (this.isTime())
+      return iso.slice(11, 23);
+    if (this.#offset === null)
+      return iso.slice(0, -1);
+    if (this.#offset === "Z")
+      return iso;
+    let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+    offset = this.#offset[0] === "-" ? offset : -offset;
+    let offsetDate = new Date(this.getTime() - offset * 6e4);
+    return offsetDate.toISOString().slice(0, -1) + this.#offset;
+  }
+  static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+    let date = new _TomlDate(jsDate);
+    date.#offset = offset;
+    return date;
+  }
+  static wrapAsLocalDateTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalDate(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasTime = false;
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasDate = false;
+    date.#offset = null;
+    return date;
+  }
+};
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/primitive.js
+var INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
+var FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
+var LEADING_ZERO = /^[+-]?0[0-9_]/;
+var ESCAPE_REGEX = /^[0-9a-f]{2,8}$/i;
+var ESC_MAP = {
+  b: "\b",
+  t: "	",
+  n: "\n",
+  f: "\f",
+  r: "\r",
+  e: "\x1B",
+  '"': '"',
+  "\\": "\\"
+};
+function parseString(str, ptr = 0, endPtr = str.length) {
+  let isLiteral = str[ptr] === "'";
+  let isMultiline = str[ptr++] === str[ptr] && str[ptr] === str[ptr + 1];
+  if (isMultiline) {
+    endPtr -= 2;
+    if (str[ptr += 2] === "\r")
+      ptr++;
+    if (str[ptr] === "\n")
+      ptr++;
+  }
+  let tmp = 0;
+  let isEscape;
+  let parsed = "";
+  let sliceStart = ptr;
+  while (ptr < endPtr - 1) {
+    let c = str[ptr++];
+    if (c === "\n" || c === "\r" && str[ptr] === "\n") {
+      if (!isMultiline) {
+        throw new TomlError("newlines are not allowed in strings", {
+          toml: str,
+          ptr: ptr - 1
+        });
+      }
+    } else if (c < " " && c !== "	" || c === "\x7F") {
+      throw new TomlError("control characters are not allowed in strings", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    }
+    if (isEscape) {
+      isEscape = false;
+      if (c === "x" || c === "u" || c === "U") {
+        let code = str.slice(ptr, ptr += c === "x" ? 2 : c === "u" ? 4 : 8);
+        if (!ESCAPE_REGEX.test(code)) {
+          throw new TomlError("invalid unicode escape", {
+            toml: str,
+            ptr: tmp
+          });
+        }
+        try {
+          parsed += String.fromCodePoint(parseInt(code, 16));
+        } catch {
+          throw new TomlError("invalid unicode escape", {
+            toml: str,
+            ptr: tmp
+          });
+        }
+      } else if (isMultiline && (c === "\n" || c === " " || c === "	" || c === "\r")) {
+        ptr = skipVoid(str, ptr - 1, true);
+        if (str[ptr] !== "\n" && str[ptr] !== "\r") {
+          throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
+            toml: str,
+            ptr: tmp
+          });
+        }
+        ptr = skipVoid(str, ptr);
+      } else if (c in ESC_MAP) {
+        parsed += ESC_MAP[c];
+      } else {
+        throw new TomlError("unrecognized escape sequence", {
+          toml: str,
+          ptr: tmp
+        });
+      }
+      sliceStart = ptr;
+    } else if (!isLiteral && c === "\\") {
+      tmp = ptr - 1;
+      isEscape = true;
+      parsed += str.slice(sliceStart, tmp);
+    }
+  }
+  return parsed + str.slice(sliceStart, endPtr - 1);
+}
+function parseValue(value, toml, ptr, integersAsBigInt) {
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  if (value === "-inf")
+    return -Infinity;
+  if (value === "inf" || value === "+inf")
+    return Infinity;
+  if (value === "nan" || value === "+nan" || value === "-nan")
+    return NaN;
+  if (value === "-0")
+    return integersAsBigInt ? 0n : 0;
+  let isInt = INT_REGEX.test(value);
+  if (isInt || FLOAT_REGEX.test(value)) {
+    if (LEADING_ZERO.test(value)) {
+      throw new TomlError("leading zeroes are not allowed", {
+        toml,
+        ptr
+      });
+    }
+    value = value.replace(/_/g, "");
+    let numeric = +value;
+    if (isNaN(numeric)) {
+      throw new TomlError("invalid number", {
+        toml,
+        ptr
+      });
+    }
+    if (isInt) {
+      if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
+        throw new TomlError("integer value cannot be represented losslessly", {
+          toml,
+          ptr
+        });
+      }
+      if (isInt || integersAsBigInt === true)
+        numeric = BigInt(value);
+    }
+    return numeric;
+  }
+  const date = new TomlDate(value);
+  if (!date.isValid()) {
+    throw new TomlError("invalid value", {
+      toml,
+      ptr
+    });
+  }
+  return date;
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/extract.js
+function sliceAndTrimEndOf(str, startPtr, endPtr) {
+  let value = str.slice(startPtr, endPtr);
+  let commentIdx = value.indexOf("#");
+  if (commentIdx > -1) {
+    skipComment(str, commentIdx);
+    value = value.slice(0, commentIdx);
+  }
+  return [value.trimEnd(), commentIdx];
+}
+function extractValue(str, ptr, end, depth, integersAsBigInt) {
+  if (depth === 0) {
+    throw new TomlError("document contains excessively nested structures. aborting.", {
+      toml: str,
+      ptr
+    });
+  }
+  let c = str[ptr];
+  if (c === "[" || c === "{") {
+    let [value, endPtr2] = c === "[" ? parseArray(str, ptr, depth, integersAsBigInt) : parseInlineTable(str, ptr, depth, integersAsBigInt);
+    if (end) {
+      endPtr2 = skipVoid(str, endPtr2);
+      if (str[endPtr2] === ",")
+        endPtr2++;
+      else if (str[endPtr2] !== end) {
+        throw new TomlError("expected comma or end of structure", {
+          toml: str,
+          ptr: endPtr2
+        });
+      }
+    }
+    return [value, endPtr2];
+  }
+  let endPtr;
+  if (c === '"' || c === "'") {
+    endPtr = getStringEnd(str, ptr);
+    let parsed = parseString(str, ptr, endPtr);
+    if (end) {
+      endPtr = skipVoid(str, endPtr);
+      if (str[endPtr] && str[endPtr] !== "," && str[endPtr] !== end && str[endPtr] !== "\n" && str[endPtr] !== "\r") {
+        throw new TomlError("unexpected character encountered", {
+          toml: str,
+          ptr: endPtr
+        });
+      }
+      endPtr += +(str[endPtr] === ",");
+    }
+    return [parsed, endPtr];
+  }
+  endPtr = skipUntil(str, ptr, ",", end);
+  let slice = sliceAndTrimEndOf(str, ptr, endPtr - +(str[endPtr - 1] === ","));
+  if (!slice[0]) {
+    throw new TomlError("incomplete key-value declaration: no value specified", {
+      toml: str,
+      ptr
+    });
+  }
+  if (end && slice[1] > -1) {
+    endPtr = skipVoid(str, ptr + slice[1]);
+    endPtr += +(str[endPtr] === ",");
+  }
+  return [
+    parseValue(slice[0], str, ptr, integersAsBigInt),
+    endPtr
+  ];
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/struct.js
+var KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
+function parseKey(str, ptr, end = "=") {
+  let dot = ptr - 1;
+  let parsed = [];
+  let endPtr = str.indexOf(end, ptr);
+  if (endPtr < 0) {
+    throw new TomlError("incomplete key-value: cannot find end of key", {
+      toml: str,
+      ptr
+    });
+  }
+  do {
+    let c = str[ptr = ++dot];
+    if (c !== " " && c !== "	") {
+      if (c === '"' || c === "'") {
+        if (c === str[ptr + 1] && c === str[ptr + 2]) {
+          throw new TomlError("multiline strings are not allowed in keys", {
+            toml: str,
+            ptr
+          });
+        }
+        let eos = getStringEnd(str, ptr);
+        if (eos < 0) {
+          throw new TomlError("unfinished string encountered", {
+            toml: str,
+            ptr
+          });
+        }
+        dot = str.indexOf(".", eos);
+        let strEnd = str.slice(eos, dot < 0 || dot > endPtr ? endPtr : dot);
+        let newLine = indexOfNewline(strEnd);
+        if (newLine > -1) {
+          throw new TomlError("newlines are not allowed in keys", {
+            toml: str,
+            ptr: ptr + dot + newLine
+          });
+        }
+        if (strEnd.trimStart()) {
+          throw new TomlError("found extra tokens after the string part", {
+            toml: str,
+            ptr: eos
+          });
+        }
+        if (endPtr < eos) {
+          endPtr = str.indexOf(end, eos);
+          if (endPtr < 0) {
+            throw new TomlError("incomplete key-value: cannot find end of key", {
+              toml: str,
+              ptr
+            });
+          }
+        }
+        parsed.push(parseString(str, ptr, eos));
+      } else {
+        dot = str.indexOf(".", ptr);
+        let part = str.slice(ptr, dot < 0 || dot > endPtr ? endPtr : dot);
+        if (!KEY_PART_RE.test(part)) {
+          throw new TomlError("only letter, numbers, dashes and underscores are allowed in keys", {
+            toml: str,
+            ptr
+          });
+        }
+        parsed.push(part.trimEnd());
+      }
+    }
+  } while (dot + 1 && dot < endPtr);
+  return [parsed, skipVoid(str, endPtr + 1, true, true)];
+}
+function parseInlineTable(str, ptr, depth, integersAsBigInt) {
+  let res = {};
+  let seen = /* @__PURE__ */ new Set();
+  let c;
+  ptr++;
+  while ((c = str[ptr++]) !== "}" && c) {
+    if (c === ",") {
+      throw new TomlError("expected value, found comma", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    } else if (c === "#")
+      ptr = skipComment(str, ptr);
+    else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
+      let k;
+      let t = res;
+      let hasOwn = false;
+      let [key, keyEndPtr] = parseKey(str, ptr - 1);
+      for (let i = 0; i < key.length; i++) {
+        if (i)
+          t = hasOwn ? t[k] : t[k] = {};
+        k = key[i];
+        if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
+          throw new TomlError("trying to redefine an already defined value", {
+            toml: str,
+            ptr
+          });
+        }
+        if (!hasOwn && k === "__proto__") {
+          Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        }
+      }
+      if (hasOwn) {
+        throw new TomlError("trying to redefine an already defined value", {
+          toml: str,
+          ptr
+        });
+      }
+      let [value, valueEndPtr] = extractValue(str, keyEndPtr, "}", depth - 1, integersAsBigInt);
+      seen.add(value);
+      t[k] = value;
+      ptr = valueEndPtr;
+    }
+  }
+  if (!c) {
+    throw new TomlError("unfinished table encountered", {
+      toml: str,
+      ptr
+    });
+  }
+  return [res, ptr];
+}
+function parseArray(str, ptr, depth, integersAsBigInt) {
+  let res = [];
+  let c;
+  ptr++;
+  while ((c = str[ptr++]) !== "]" && c) {
+    if (c === ",") {
+      throw new TomlError("expected value, found comma", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    } else if (c === "#")
+      ptr = skipComment(str, ptr);
+    else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
+      let e = extractValue(str, ptr - 1, "]", depth - 1, integersAsBigInt);
+      res.push(e[0]);
+      ptr = e[1];
+    }
+  }
+  if (!c) {
+    throw new TomlError("unfinished array encountered", {
+      toml: str,
+      ptr
+    });
+  }
+  return [res, ptr];
+}
+
+// ../../node_modules/.pnpm/smol-toml@1.6.1/node_modules/smol-toml/dist/parse.js
+function peekTable(key, table, meta, type) {
+  let t = table;
+  let m = meta;
+  let k;
+  let hasOwn = false;
+  let state;
+  for (let i = 0; i < key.length; i++) {
+    if (i) {
+      t = hasOwn ? t[k] : t[k] = {};
+      m = (state = m[k]).c;
+      if (type === 0 && (state.t === 1 || state.t === 2)) {
+        return null;
+      }
+      if (state.t === 2) {
+        let l = t.length - 1;
+        t = t[l];
+        m = m[l].c;
+      }
+    }
+    k = key[i];
+    if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) {
+      return null;
+    }
+    if (!hasOwn) {
+      if (k === "__proto__") {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
+      }
+      m[k] = {
+        t: i < key.length - 1 && type === 2 ? 3 : type,
+        d: false,
+        i: 0,
+        c: {}
+      };
+    }
+  }
+  state = m[k];
+  if (state.t !== type && !(type === 1 && state.t === 3)) {
+    return null;
+  }
+  if (type === 2) {
+    if (!state.d) {
+      state.d = true;
+      t[k] = [];
+    }
+    t[k].push(t = {});
+    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: {} };
+  }
+  if (state.d) {
+    return null;
+  }
+  state.d = true;
+  if (type === 1) {
+    t = hasOwn ? t[k] : t[k] = {};
+  } else if (type === 0 && hasOwn) {
+    return null;
+  }
+  return [k, t, state.c];
+}
+function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
+  let res = {};
+  let meta = {};
+  let tbl = res;
+  let m = meta;
+  for (let ptr = skipVoid(toml, 0); ptr < toml.length; ) {
+    if (toml[ptr] === "[") {
+      let isTableArray = toml[++ptr] === "[";
+      let k = parseKey(toml, ptr += +isTableArray, "]");
+      if (isTableArray) {
+        if (toml[k[1] - 1] !== "]") {
+          throw new TomlError("expected end of table declaration", {
+            toml,
+            ptr: k[1] - 1
+          });
+        }
+        k[1]++;
+      }
+      let p = peekTable(
+        k[0],
+        res,
+        meta,
+        isTableArray ? 2 : 1
+        /* Type.EXPLICIT */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr
+        });
+      }
+      m = p[2];
+      tbl = p[1];
+      ptr = k[1];
+    } else {
+      let k = parseKey(toml, ptr);
+      let p = peekTable(
+        k[0],
+        tbl,
+        m,
+        0
+        /* Type.DOTTED */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr
+        });
+      }
+      let v = extractValue(toml, k[1], void 0, maxDepth, integersAsBigInt);
+      p[1][p[0]] = v[0];
+      ptr = v[1];
+    }
+    ptr = skipVoid(toml, ptr, true);
+    if (toml[ptr] && toml[ptr] !== "\n" && toml[ptr] !== "\r") {
+      throw new TomlError("each key-value declaration must be followed by an end-of-line", {
+        toml,
+        ptr
+      });
+    }
+    ptr = skipVoid(toml, ptr);
+  }
+  return res;
+}
+
+// ../core/dist/index.js
+import { mkdirSync as mkdirSync2, appendFileSync } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join3 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join4 } from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os2 from "os";
+import { execFileSync } from "child_process";
+function base64url(input) {
+  const buf = typeof input === "string" ? Buffer.from(input) : input;
+  return buf.toString("base64url");
+}
+function hashQuery(queryString) {
+  return createHash("sha512").update(queryString, "utf8").digest("hex");
+}
+function createJwt(payload, secretKey) {
+  const header = { alg: "HS256", typ: "JWT" };
+  const headerB64 = base64url(JSON.stringify(header));
+  const payloadB64 = base64url(JSON.stringify(payload));
+  const signature = createHmac("sha256", secretKey).update(`${headerB64}.${payloadB64}`).digest("base64url");
+  return `${headerB64}.${payloadB64}.${signature}`;
+}
+function signRequest(accessKey, secretKey, queryString) {
+  const payload = {
+    access_key: accessKey,
+    nonce: randomUUID(),
+    timestamp: Date.now()
+  };
+  if (queryString && queryString.length > 0) {
+    payload.query_hash = hashQuery(queryString);
+    payload.query_hash_alg = "SHA512";
+  }
+  return createJwt(payload, secretKey);
+}
+var BithumbMcpError = 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 BithumbMcpError {
+  constructor(message, suggestion) {
+    super("ConfigError", message, { suggestion });
+  }
+};
+var ValidationError = class extends BithumbMcpError {
+  constructor(message, suggestion) {
+    super("ValidationError", message, { suggestion });
+  }
+};
+var RateLimitError = class extends BithumbMcpError {
+  constructor(message, suggestion, endpoint) {
+    super("RateLimitError", message, { suggestion, endpoint });
+  }
+};
+var AuthenticationError = class extends BithumbMcpError {
+  constructor(message, suggestion, endpoint) {
+    super("AuthenticationError", message, { suggestion, endpoint });
+  }
+};
+var BithumbApiError = class extends BithumbMcpError {
+  constructor(message, options) {
+    super("BithumbApiError", message, options);
+  }
+};
+var NetworkError = class extends BithumbMcpError {
+  constructor(message, endpoint, cause) {
+    super("NetworkError", message, {
+      endpoint,
+      cause,
+      suggestion: "Check network connectivity and try again."
+    });
+  }
+};
+function toToolErrorPayload(error) {
+  if (error instanceof BithumbMcpError) {
+    return {
+      error: true,
+      type: error.type,
+      code: error.code,
+      message: error.message,
+      suggestion: error.suggestion,
+      endpoint: error.endpoint,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const message = error instanceof Error ? error.message : "An unexpected error occurred.";
+  return {
+    error: true,
+    type: "InternalError",
+    message,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+var RateLimiter = class {
+  buckets = /* @__PURE__ */ new Map();
+  cleanupMs;
+  verbose;
+  lastCleanup;
+  constructor(cleanupMs = 3e4, verbose = false) {
+    this.cleanupMs = cleanupMs;
+    this.verbose = verbose;
+    this.lastCleanup = Date.now();
+  }
+  async consume(config, amount = 1) {
+    this.maybeCleanup();
+    const bucket = this.getBucket(config);
+    this.refill(bucket);
+    if (bucket.tokens >= amount) {
+      bucket.tokens -= amount;
+      return;
+    }
+    const deficit = amount - bucket.tokens;
+    const waitMs = Math.ceil(deficit / bucket.refillPerSecond * 1e3);
+    if (waitMs > 1e4) {
+      throw new RateLimitError(
+        `Rate limit exceeded for "${config.key}". Need ${deficit.toFixed(1)} tokens, wait ~${waitMs}ms.`,
+        "Reduce request frequency or wait."
+      );
+    }
+    if (this.verbose) {
+      process.stderr.write(
+        `[rate-limiter] ${config.key}: waiting ${waitMs}ms for ${deficit.toFixed(1)} tokens
+`
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, waitMs));
+    this.refill(bucket);
+    if (bucket.tokens >= amount) {
+      bucket.tokens -= amount;
+      return;
+    }
+    throw new RateLimitError(
+      `Rate limit exceeded for "${config.key}" after waiting.`,
+      "Reduce request frequency."
+    );
+  }
+  getBucket(config) {
+    let bucket = this.buckets.get(config.key);
+    if (!bucket) {
+      bucket = {
+        tokens: config.capacity,
+        capacity: config.capacity,
+        refillPerSecond: config.refillPerSecond,
+        lastRefill: Date.now()
+      };
+      this.buckets.set(config.key, bucket);
+    }
+    return bucket;
+  }
+  refill(bucket) {
+    const now = Date.now();
+    const elapsed = (now - bucket.lastRefill) / 1e3;
+    if (elapsed <= 0) return;
+    bucket.tokens = Math.min(
+      bucket.capacity,
+      bucket.tokens + elapsed * bucket.refillPerSecond
+    );
+    bucket.lastRefill = now;
+  }
+  maybeCleanup() {
+    const now = Date.now();
+    if (now - this.lastCleanup < this.cleanupMs) return;
+    this.lastCleanup = now;
+    for (const [key, bucket] of this.buckets) {
+      const idle = (now - bucket.lastRefill) / 1e3;
+      if (idle > 60 && bucket.tokens >= bucket.capacity) {
+        this.buckets.delete(key);
+      }
+    }
+  }
+};
+function isDefined(value) {
+  return value !== void 0 && value !== null;
+}
+function buildQueryString(query) {
+  if (!query) return "";
+  const entries = Object.entries(query).filter(([, v]) => isDefined(v));
+  if (entries.length === 0) return "";
+  const parts = [];
+  for (const [key, value] of entries) {
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        const item = value[i];
+        if (item && typeof item === "object" && !Array.isArray(item)) {
+          for (const [subKey, subVal] of Object.entries(item)) {
+            parts.push(
+              `${encodeURIComponent(key)}[${i}][${encodeURIComponent(subKey)}]=${encodeURIComponent(String(subVal))}`
+            );
+          }
+        } else {
+          parts.push(
+            `${encodeURIComponent(key)}[]=${encodeURIComponent(String(item))}`
+          );
+        }
+      }
+    } else {
+      parts.push(
+        `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`
+      );
+    }
+  }
+  return parts.join("&");
+}
+function buildHashString(query, body) {
+  const source = body ?? query;
+  if (!source) return "";
+  const entries = Object.entries(source).filter(([, v]) => isDefined(v));
+  if (entries.length === 0) return "";
+  const parts = [];
+  for (const [key, value] of entries) {
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        const item = value[i];
+        if (item && typeof item === "object" && !Array.isArray(item)) {
+          for (const [subKey, subVal] of Object.entries(item)) {
+            parts.push(`${key}[${i}][${subKey}]=${String(subVal)}`);
+          }
+        } else {
+          parts.push(`${key}[]=${String(item)}`);
+        }
+      }
+    } else {
+      parts.push(`${key}=${String(value)}`);
+    }
+  }
+  return parts.join("&");
+}
+function vlog(message) {
+  process.stderr.write(`[verbose] ${message}
+`);
+}
+var BithumbRestClient = class {
+  config;
+  rateLimiter;
+  constructor(config) {
+    this.config = config;
+    this.rateLimiter = new RateLimiter(3e4, config.verbose);
+  }
+  async publicGet(path3, query, rateLimit) {
+    return this.request({
+      method: "GET",
+      path: path3,
+      auth: "public",
+      query,
+      rateLimit
+    });
+  }
+  async privateGet(path3, query, rateLimit) {
+    return this.request({
+      method: "GET",
+      path: path3,
+      auth: "private",
+      query,
+      rateLimit
+    });
+  }
+  async privatePost(path3, body, rateLimit) {
+    return this.request({
+      method: "POST",
+      path: path3,
+      auth: "private",
+      body,
+      rateLimit
+    });
+  }
+  async privateDelete(path3, query, rateLimit) {
+    return this.request({
+      method: "DELETE",
+      path: path3,
+      auth: "private",
+      query,
+      rateLimit
+    });
+  }
+  // ─── Core request ────────────────────────────────────────────────
+  async request(reqConfig) {
+    const queryString = buildQueryString(reqConfig.query);
+    const requestPath = queryString.length > 0 ? `${reqConfig.path}?${queryString}` : reqConfig.path;
+    const url = `${this.config.baseUrl}${requestPath}`;
+    if (this.config.verbose) vlog(`\u2192 ${reqConfig.method} ${url}`);
+    if (reqConfig.rateLimit) await this.rateLimiter.consume(reqConfig.rateLimit);
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    };
+    if (reqConfig.auth === "private") {
+      if (!this.config.hasAuth || !this.config.accessKey || !this.config.secretKey) {
+        throw new ConfigError(
+          "Private endpoint requires API credentials.",
+          "Set BITHUMB_ACCESS_KEY and BITHUMB_SECRET_KEY."
+        );
+      }
+      const hashStr = buildHashString(reqConfig.query, reqConfig.body);
+      const token = signRequest(
+        this.config.accessKey,
+        this.config.secretKey,
+        hashStr
+      );
+      headers["Authorization"] = `Bearer ${token}`;
+    }
+    const t0 = Date.now();
+    let response;
+    try {
+      const fetchOptions = {
+        method: reqConfig.method,
+        headers,
+        signal: AbortSignal.timeout(this.config.timeoutMs)
+      };
+      if (reqConfig.body && reqConfig.method === "POST") {
+        fetchOptions.body = JSON.stringify(reqConfig.body);
+      }
+      response = await fetch(url, fetchOptions);
+    } catch (error) {
+      if (this.config.verbose) {
+        vlog(`\u2717 NetworkError after ${Date.now() - t0}ms`);
+      }
+      throw new NetworkError(
+        `Failed to call ${reqConfig.method} ${reqConfig.path}.`,
+        `${reqConfig.method} ${reqConfig.path}`,
+        error
+      );
+    }
+    const rawText = await response.text();
+    const elapsed = Date.now() - t0;
+    if (this.config.verbose) {
+      vlog(`\u2190 ${response.status} | ${rawText.length}B | ${elapsed}ms`);
+    }
+    let parsed;
+    try {
+      parsed = rawText ? JSON.parse(rawText) : null;
+    } catch {
+      throw new NetworkError(
+        `Non-JSON response from ${reqConfig.method} ${reqConfig.path}.`,
+        `${reqConfig.method} ${reqConfig.path}`
+      );
+    }
+    if (parsed && typeof parsed === "object" && "error" in parsed) {
+      const errResp = parsed;
+      const errName = errResp.error?.name ?? "unknown";
+      const errMsg = errResp.error?.message ?? "Unknown error";
+      const endpoint = `${reqConfig.method} ${reqConfig.path}`;
+      if (response.status === 401 || errName === "unauthorized") {
+        throw new AuthenticationError(
+          errMsg,
+          "Check BITHUMB_ACCESS_KEY and BITHUMB_SECRET_KEY.",
+          endpoint
+        );
+      }
+      if (response.status === 429) {
+        throw new RateLimitError(
+          errMsg,
+          "Reduce request frequency.",
+          endpoint
+        );
+      }
+      throw new BithumbApiError(errMsg, { code: errName, endpoint });
+    }
+    if (!response.ok) {
+      throw new BithumbApiError(`HTTP ${response.status}`, {
+        code: String(response.status),
+        endpoint: `${reqConfig.method} ${reqConfig.path}`
+      });
+    }
+    return {
+      endpoint: `${reqConfig.method} ${reqConfig.path}`,
+      requestTime: (/* @__PURE__ */ new Date()).toISOString(),
+      data: parsed
+    };
+  }
+};
+function asRecord(args) {
+  if (args && typeof args === "object" && !Array.isArray(args)) {
+    return args;
+  }
+  return {};
+}
+function readString(args, key) {
+  const v = args[key];
+  if (v === void 0 || v === null || v === "") return void 0;
+  return String(v);
+}
+function readNumber(args, key) {
+  const v = args[key];
+  if (v === void 0 || v === null || v === "") return void 0;
+  const n = Number(v);
+  if (!Number.isFinite(n)) return void 0;
+  return n;
+}
+function readBoolean(args, key) {
+  const v = args[key];
+  if (v === void 0 || v === null) return void 0;
+  if (typeof v === "boolean") return v;
+  if (v === "true" || v === "1") return true;
+  if (v === "false" || v === "0") return false;
+  return void 0;
+}
+function readStringArray(args, key) {
+  const v = args[key];
+  if (v === void 0 || v === null) return void 0;
+  if (Array.isArray(v)) return v.map(String);
+  if (typeof v === "string") {
+    return v.split(",").map((s) => s.trim()).filter(Boolean);
+  }
+  return void 0;
+}
+function requireString(args, key) {
+  const v = readString(args, key);
+  if (!v) {
+    throw new ValidationError(
+      `Missing required parameter "${key}".`,
+      `Provide a non-empty "${key}" string.`
+    );
+  }
+  return v;
+}
+function compactObject(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value !== void 0 && value !== null) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function normalizeResponse(data) {
+  if (data === null || data === void 0) return {};
+  return data;
+}
+function publicRateLimit(key, rps = 150) {
+  return { key: `public:${key}`, capacity: rps, refillPerSecond: rps };
+}
+function privateRateLimit(key, rps = 140) {
+  return { key: `private:${key}`, capacity: rps, refillPerSecond: rps };
+}
+function orderRateLimit(key, rps = 10) {
+  return { key: `order:${key}`, capacity: rps, refillPerSecond: rps };
+}
+function registerMarketTools() {
+  return [
+    // ── 1. market_get_markets ──────────────────────────────────────
+    {
+      name: "market_get_markets",
+      module: "market",
+      description: "\uBE57\uC378 \uAC70\uB798 \uAC00\uB2A5\uD55C \uB9C8\uCF13(\uAC70\uB798 \uD398\uC5B4) \uBAA9\uB85D\uC744 \uC870\uD68C\uD569\uB2C8\uB2E4. Get all available trading pairs on Bithumb.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          isDetails: {
+            type: "boolean",
+            description: "Include detailed market info"
+          }
+        },
+        required: []
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/v1/market/all",
+          compactObject({ isDetails: readBoolean(args, "isDetails") }),
+          publicRateLimit("market_get_markets")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 2. market_get_ticker ───────────────────────────────────────
+    {
+      name: "market_get_ticker",
+      module: "market",
+      description: "\uD604\uC7AC\uAC00(Ticker) \uC815\uBCF4\uB97C \uC870\uD68C\uD569\uB2C8\uB2E4. Get current price ticker for specified markets.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          markets: {
+            type: "string",
+            description: "Comma-separated market codes, e.g. KRW-BTC,KRW-ETH"
+          }
+        },
+        required: ["markets"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/v1/ticker",
+          compactObject({ markets: requireString(args, "markets") }),
+          publicRateLimit("market_get_ticker")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 3. market_get_orderbook ────────────────────────────────────
+    {
+      name: "market_get_orderbook",
+      module: "market",
+      description: "\uD638\uAC00(Orderbook) \uC815\uBCF4\uB97C \uC870\uD68C\uD569\uB2C8\uB2E4. Get orderbook (bids/asks) for specified markets.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          markets: {
+            type: "string",
+            description: "Comma-separated market codes, e.g. KRW-BTC,KRW-ETH"
+          }
+        },
+        required: ["markets"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/v1/orderbook",
+          compactObject({ markets: requireString(args, "markets") }),
+          publicRateLimit("market_get_orderbook")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 4. market_get_trades ───────────────────────────────────────
+    {
+      name: "market_get_trades",
+      module: "market",
+      description: "\uCD5C\uADFC \uCCB4\uACB0 \uB0B4\uC5ED\uC744 \uC870\uD68C\uD569\uB2C8\uB2E4. Get recent trades for a market.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          market: {
+            type: "string",
+            description: "Market code, e.g. KRW-BTC"
+          },
+          to: {
+            type: "string",
+            description: "Return trades before this timestamp (exclusive)"
+          },
+          count: {
+            type: "number",
+            description: "Number of trades to return (1-500)"
+          },
+          cursor: {
+            type: "string",
+            description: "Pagination cursor from previous response"
+          },
+          daysAgo: {
+            type: "number",
+            description: "Filter trades from N days ago (1-7)"
+          }
+        },
+        required: ["market"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/v1/trades/ticks",
+          compactObject({
+            market: requireString(args, "market"),
+            to: readString(args, "to"),
+            count: readNumber(args, "count"),
+            cursor: readString(args, "cursor"),
+            daysAgo: readNumber(args, "daysAgo")
+          }),
+          publicRateLimit("market_get_trades")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 5. market_get_candles_minutes ──────────────────────────────
+    {
+      name: "market_get_candles_minutes",
+      module: "market",
+      description: "\uBD84(minute) \uCE94\uB4E4\uC744 \uC870\uD68C\uD569\uB2C8\uB2E4. Get minute candles (OHLCV).",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          unit: {
+            type: "number",
+            enum: [1, 3, 5, 10, 15, 30, 60, 240],
+            description: "Candle unit in minutes"
+          },
+          market: {
+            type: "string",
+            description: "Market code, e.g. KRW-BTC"
+          },
+          to: {
+            type: "string",
+            description: "Return candles before this timestamp"
+          },
+          count: {
+            type: "number",
+            description: "Number of candles to return (max 200)"
+          }
+        },
+        required: ["unit", "market"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const unit = readNumber(args, "unit");
+        if (!unit) throw new Error('Missing required parameter "unit".');
+        const response = await context.client.publicGet(
+          `/v1/candles/minutes/${unit}`,
+          compactObject({
+            market: requireString(args, "market"),
+            to: readString(args, "to"),
+            count: readNumber(args, "count")
+          }),
+          publicRateLimit("market_get_candles_minutes")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 6. market_get_candles_days ─────────────────────────────────
+    {
+      name: "market_get_candles_days",
+      module: "market",
+      description: "\uC77C(day) \uCE94\uB4E4\uC744 \uC870\uD68C\uD569\uB2C8\uB2E4. Get daily candles.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          market: {
+            type: "string",
+            description: "Market code, e.g. KRW-BTC"
+          },
+          to: {
+            type: "string",
+            description: "Return candles before this timestamp"
+          },
+          count: {
+            type: "number",
+            description: "Number of candles to return (max 200)"
+          },
+          convertingPriceUnit: {
+            type: "string",
+            description: "Price unit for conversion"
+          }
+        },
+        required: ["market"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/v1/candles/days",
+          compactObject({
+            market: requireString(args, "market"),
+            to: readString(args, "to"),
+            count: readNumber(args, "count"),
+            convertingPriceUnit: readString(args, "convertingPriceUnit")
+          }),
+          publicRateLimit("market_get_candles_days")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 7. market_get_candles_weeks ────────────────────────────────
+    {
+      name: "market_get_candles_weeks",
+      module: "market",
+      description: "\uC8FC(week) \uCE94\uB4E4\uC744 \uC870\uD68C\uD569\uB2C8\uB2E4. Get weekly candles.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          market: {
+            type: "string",
+            description: "Market code, e.g. KRW-BTC"
+          },
+          to: {
+            type: "string",
+            description: "Return candles before this timestamp"
+          },
+          count: {
+            type: "number",
+            description: "Number of candles to return (max 200)"
+          }
+        },
+        required: ["market"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/v1/candles/weeks",
+          compactObject({
+            market: requireString(args, "market"),
+            to: readString(args, "to"),
+            count: readNumber(args, "count")
+          }),
+          publicRateLimit("market_get_candles_weeks")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 8. market_get_candles_months ───────────────────────────────
+    {
+      name: "market_get_candles_months",
+      module: "market",
+      description: "\uC6D4(month) \uCE94\uB4E4\uC744 \uC870\uD68C\uD569\uB2C8\uB2E4. Get monthly candles.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          market: {
+            type: "string",
+            description: "Market code, e.g. KRW-BTC"
+          },
+          to: {
+            type: "string",
+            description: "Return candles before this timestamp"
+          },
+          count: {
+            type: "number",
+            description: "Number of candles to return (max 200)"
+          }
+        },
+        required: ["market"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.publicGet(
+          "/v1/candles/months",
+          compactObject({
+            market: requireString(args, "market"),
+            to: readString(args, "to"),
+            count: readNumber(args, "count")
+          }),
+          publicRateLimit("market_get_candles_months")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 9. market_get_warnings ─────────────────────────────────────
+    {
+      name: "market_get_warnings",
+      module: "market",
+      description: "\uD22C\uC790\uACBD\uBCF4 \uB9C8\uCF13 \uBAA9\uB85D\uC744 \uC870\uD68C\uD569\uB2C8\uB2E4. Get virtual asset warning market list.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {},
+        required: []
+      },
+      handler: async (_rawArgs, context) => {
+        const response = await context.client.publicGet(
+          "/v1/market/virtual_asset_warning",
+          {},
+          publicRateLimit("market_get_warnings")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 10. market_get_notices ─────────────────────────────────────
+    {
+      name: "market_get_notices",
+      module: "market",
+      description: "\uACF5\uC9C0\uC0AC\uD56D \uBAA9\uB85D\uC744 \uC870\uD68C\uD569\uB2C8\uB2E4. Get notice list.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          count: {
+            type: "number",
+            description: "Number of notices to return (min 1, max 20, default 5)"
+          }
+        },
+        required: []
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const count = readNumber(args, "count");
+        const response = await context.client.publicGet(
+          "/v1/notices",
+          compactObject({ count }),
+          publicRateLimit("market_get_notices")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 11. market_get_fee_inout ───────────────────────────────────
+    {
+      name: "market_get_fee_inout",
+      module: "market",
+      description: "\uC785\uCD9C\uAE08 \uC218\uC218\uB8CC\uB97C \uC870\uD68C\uD569\uB2C8\uB2E4. Get deposit/withdrawal fee info for a currency.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          currency: {
+            type: "string",
+            description: 'Currency symbol (use "ALL" to retrieve all currencies), e.g. BTC, ETH'
+          }
+        },
+        required: ["currency"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const currency = requireString(args, "currency");
+        const response = await context.client.publicGet(
+          `/v2/fee/inout/${currency}`,
+          {},
+          publicRateLimit("market_get_fee_inout")
+        );
+        return normalizeResponse(response);
+      }
+    }
+  ];
+}
+function registerAccountTools() {
+  return [
+    // ── 1. account_get_balance ─────────────────────────────────────
+    {
+      name: "account_get_balance",
+      module: "account",
+      description: "\uC804\uCCB4 \uACC4\uC88C \uC794\uACE0\uB97C \uC870\uD68C\uD569\uB2C8\uB2E4. Get all account balances.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {},
+        required: []
+      },
+      handler: async (_rawArgs, context) => {
+        const response = await context.client.privateGet(
+          "/v1/accounts",
+          void 0,
+          privateRateLimit("account_get_balance")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 2. account_get_order_chance ────────────────────────────────
+    {
+      name: "account_get_order_chance",
+      module: "account",
+      description: "\uC8FC\uBB38 \uAC00\uB2A5 \uC815\uBCF4\uB97C \uC870\uD68C\uD569\uB2C8\uB2E4. Get order chance info (available balance, fees, limits) for a market.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          market: {
+            type: "string",
+            description: "Market code, e.g. KRW-BTC"
+          }
+        },
+        required: ["market"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/v1/orders/chance",
+          compactObject({ market: requireString(args, "market") }),
+          privateRateLimit("account_get_order_chance")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 3. account_get_wallet_status ───────────────────────────────
+    {
+      name: "account_get_wallet_status",
+      module: "account",
+      description: "\uC785\uCD9C\uAE08 \uD604\uD669\uC744 \uC870\uD68C\uD569\uB2C8\uB2E4. Get wallet status (block status, deposit/withdrawal availability).",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {},
+        required: []
+      },
+      handler: async (_rawArgs, context) => {
+        const response = await context.client.privateGet(
+          "/v1/status/wallet",
+          {},
+          privateRateLimit("account_get_wallet_status")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 4. account_get_api_keys ────────────────────────────────────
+    {
+      name: "account_get_api_keys",
+      module: "account",
+      description: "API \uD0A4 \uBAA9\uB85D\uC744 \uC870\uD68C\uD569\uB2C8\uB2E4. Get list of API keys and expiration dates.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {},
+        required: []
+      },
+      handler: async (_rawArgs, context) => {
+        const response = await context.client.privateGet(
+          "/v1/api_keys",
+          {},
+          privateRateLimit("account_get_api_keys")
+        );
+        return normalizeResponse(response);
+      }
+    }
+  ];
+}
+function registerTradeTools() {
+  return [
+    // ── 1. trade_get_order ─────────────────────────────────────────
+    {
+      name: "trade_get_order",
+      module: "trade",
+      description: "\uAC1C\uBCC4 \uC8FC\uBB38\uC744 \uC870\uD68C\uD569\uB2C8\uB2E4. Get a specific order by uuid or client_order_id.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          uuid: {
+            type: "string",
+            description: "Order UUID"
+          },
+          client_order_id: {
+            type: "string",
+            description: "Client-assigned order ID"
+          }
+        },
+        required: []
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/v1/order",
+          compactObject({
+            uuid: readString(args, "uuid"),
+            client_order_id: readString(args, "client_order_id")
+          }),
+          privateRateLimit("trade_get_order")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 2. trade_get_orders ────────────────────────────────────────
+    {
+      name: "trade_get_orders",
+      module: "trade",
+      description: "\uC8FC\uBB38 \uB9AC\uC2A4\uD2B8\uB97C \uC870\uD68C\uD569\uB2C8\uB2E4. Get list of orders with filters.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          market: {
+            type: "string",
+            description: "Market code, e.g. KRW-BTC"
+          },
+          state: {
+            type: "string",
+            enum: ["wait", "watch", "done", "cancel"],
+            description: "Order state filter"
+          },
+          states: {
+            type: "array",
+            items: { type: "string" },
+            description: "Multiple order state filters"
+          },
+          uuids: {
+            type: "array",
+            items: { type: "string" },
+            description: "Filter by order UUIDs"
+          },
+          client_order_ids: {
+            type: "array",
+            items: { type: "string" },
+            description: "Filter by client order IDs"
+          },
+          page: {
+            type: "number",
+            description: "Page number"
+          },
+          limit: {
+            type: "number",
+            description: "Number of results per page"
+          },
+          order_by: {
+            type: "string",
+            description: "Sort order"
+          }
+        },
+        required: []
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/v1/orders",
+          compactObject({
+            market: readString(args, "market"),
+            state: readString(args, "state"),
+            states: readStringArray(args, "states"),
+            uuids: readStringArray(args, "uuids"),
+            client_order_ids: readStringArray(args, "client_order_ids"),
+            page: readNumber(args, "page"),
+            limit: readNumber(args, "limit"),
+            order_by: readString(args, "order_by")
+          }),
+          privateRateLimit("trade_get_orders")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 3. trade_place_order ───────────────────────────────────────
+    {
+      name: "trade_place_order",
+      module: "trade",
+      description: '\uC8FC\uBB38\uC744 \uC0DD\uC131\uD569\uB2C8\uB2E4. Place a new spot order on Bithumb. Use when: user asks to buy/sell a single market at a specific price or quantity. Do NOT use: for multiple orders at once (use trade_batch_place); for time-weighted execution (use twap_place). Field: order_type \u2208 {limit, price, market}. limit: price+volume required. price(\uC2DC\uC7A5\uAC00 \uB9E4\uC218): only price (total KRW). market(\uC2DC\uC7A5\uAC00 \uB9E4\uB3C4): only volume (coin qty). CLI flag: --order-type (alias: --ord-type, deprecated). Response field `ord_type` is preserved as Bithumb upstream. Example call: {"market":"KRW-BTC","side":"bid","order_type":"limit","price":"50000000","volume":"0.0001"}',
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          market: {
+            type: "string",
+            description: "Market code, e.g. KRW-BTC"
+          },
+          side: {
+            type: "string",
+            enum: ["bid", "ask"],
+            description: "Order side: bid (buy) or ask (sell)"
+          },
+          order_type: {
+            type: "string",
+            enum: ["limit", "price", "market"],
+            description: "Order type: limit, price (market buy), market (market sell). CLI flag: --order-type (alias: --ord-type, deprecated). Response field is `ord_type` (upstream Bithumb), preserved as-is."
+          },
+          price: {
+            type: "string",
+            description: "Order price (required for limit and price orders)"
+          },
+          volume: {
+            type: "string",
+            description: "Order volume (required for limit and market orders)"
+          },
+          client_order_id: {
+            type: "string",
+            description: "Client-assigned order ID for idempotency"
+          }
+        },
+        required: ["market", "side", "order_type"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privatePost(
+          "/v2/orders",
+          compactObject({
+            market: requireString(args, "market"),
+            side: requireString(args, "side"),
+            order_type: requireString(args, "order_type"),
+            price: readString(args, "price"),
+            volume: readString(args, "volume"),
+            client_order_id: readString(args, "client_order_id")
+          }),
+          orderRateLimit("trade_place_order")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 4. trade_cancel_order ──────────────────────────────────────
+    {
+      name: "trade_cancel_order",
+      module: "trade",
+      description: "\uC8FC\uBB38\uC744 \uCDE8\uC18C\uD569\uB2C8\uB2E4. Cancel an order by order_id or client_order_id.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          order_id: {
+            type: "string",
+            description: "Order UUID to cancel"
+          },
+          client_order_id: {
+            type: "string",
+            description: "Client-assigned order ID to cancel"
+          }
+        },
+        required: []
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateDelete(
+          "/v2/order",
+          compactObject({
+            order_id: readString(args, "order_id"),
+            client_order_id: readString(args, "client_order_id")
+          }),
+          orderRateLimit("trade_cancel_order")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 5. trade_batch_place ───────────────────────────────────────
+    {
+      name: "trade_batch_place",
+      module: "trade",
+      description: '\uB2E4\uAC74 \uC8FC\uBB38\uC744 \uC694\uCCAD\uD569\uB2C8\uB2E4. Place multiple orders in a single batch (max 20). Use when: user asks for multiple orders at once (e.g., grid orders, simultaneous BTC+ETH limit buys). Do NOT use: for a single order (use trade_place_order); for time-sliced execution (use twap_place). Each order item field: `order_type` (canonical). Legacy `ord_type` is auto-normalized to `order_type` by the CLI; MCP callers should always send `order_type`. Partial-failure semantics: each item may succeed or fail independently. Do NOT auto-retry failed items; surface them to the user. Example call: {"batch_orders":[{"market":"KRW-BTC","side":"bid","order_type":"limit","price":"50000000","volume":"0.0001"},{"market":"KRW-ETH","side":"bid","order_type":"limit","price":"4500000","volume":"0.001"}]}',
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          batch_orders: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                market: { type: "string", description: "Market code, e.g. KRW-BTC" },
+                side: { type: "string", enum: ["bid", "ask"], description: "Order side" },
+                order_type: { type: "string", enum: ["limit", "price", "market"], description: "Order type" },
+                price: { type: "string", description: "Order price" },
+                volume: { type: "string", description: "Order volume" },
+                client_order_id: { type: "string", description: "Client-assigned order ID" }
+              },
+              required: ["market", "side", "order_type"]
+            },
+            description: "Array of order objects (max 20)"
+          }
+        },
+        required: ["batch_orders"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const batchOrders = args.batch_orders;
+        if (!Array.isArray(batchOrders) || batchOrders.length === 0) {
+          throw new ValidationError(
+            'Missing required parameter "batch_orders".',
+            "Provide an array of order objects."
+          );
+        }
+        const response = await context.client.privatePost(
+          "/v2/orders/batch",
+          { batch_orders: batchOrders },
+          orderRateLimit("trade_batch_place")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 6. trade_batch_cancel ──────────────────────────────────────
+    {
+      name: "trade_batch_cancel",
+      module: "trade",
+      description: "\uB2E4\uAC74 \uC8FC\uBB38\uC744 \uCDE8\uC18C\uD569\uB2C8\uB2E4. Cancel multiple orders (max 30). Provide order_ids or client_order_ids.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          order_ids: {
+            type: "array",
+            items: { type: "string" },
+            description: "List of order UUIDs to cancel (max 30)"
+          },
+          client_order_ids: {
+            type: "array",
+            items: { type: "string" },
+            description: "List of client-assigned order IDs to cancel (max 30)"
+          }
+        },
+        required: []
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privatePost(
+          "/v2/orders/cancel",
+          compactObject({
+            order_ids: readStringArray(args, "order_ids"),
+            client_order_ids: readStringArray(args, "client_order_ids")
+          }),
+          orderRateLimit("trade_batch_cancel")
+        );
+        return normalizeResponse(response);
+      }
+    }
+  ];
+}
+var DEFAULT_LOG_DIR = path.join(os.homedir(), ".bithumb", "logs");
+function getLogPaths(logDir, days = 7) {
+  const paths = [];
+  const now = /* @__PURE__ */ new Date();
+  for (let i = 0; i < days; i++) {
+    const d = new Date(now);
+    d.setDate(d.getDate() - i);
+    const yyyy = d.getFullYear();
+    const mm = String(d.getMonth() + 1).padStart(2, "0");
+    const dd = String(d.getDate()).padStart(2, "0");
+    paths.push(path.join(logDir, `trade-${yyyy}-${mm}-${dd}.log`));
+  }
+  return paths;
+}
+function readEntries(logDir) {
+  const filePaths = getLogPaths(logDir);
+  const entries = [];
+  for (const filePath of filePaths) {
+    if (!fs.existsSync(filePath)) continue;
+    let content;
+    try {
+      content = fs.readFileSync(filePath, "utf8");
+    } catch {
+      continue;
+    }
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const entry = JSON.parse(trimmed);
+        entries.push(entry);
+      } catch {
+      }
+    }
+  }
+  return entries;
+}
+function extractTool(entry) {
+  if (entry.tool) return entry.tool;
+  if (typeof entry.message === "string" && entry.message.startsWith("tool:")) {
+    return entry.message.slice("tool:".length);
+  }
+  return void 0;
+}
+function registerAuditTools(logDir) {
+  const resolvedLogDir = logDir ?? DEFAULT_LOG_DIR;
+  return [
+    // ── trade_get_history ──────────────────────────────────────────
+    {
+      name: "trade_get_history",
+      module: "account",
+      description: "\uB85C\uCEEC \uB85C\uADF8\uC5D0\uC11C \uAC70\uB798 \uC774\uB825\uC744 \uC870\uD68C\uD569\uB2C8\uB2E4. Read local audit logs filtered by tool, level, and time.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          limit: {
+            type: "number",
+            description: "Maximum number of entries to return (default 20)."
+          },
+          tool: {
+            type: "string",
+            description: "Filter by tool name."
+          },
+          level: {
+            type: "string",
+            enum: ["INFO", "WARN", "ERROR", "DEBUG"],
+            description: "Filter by log level (case-insensitive)."
+          },
+          since: {
+            type: "string",
+            description: "ISO 8601 timestamp; return entries at or after this time."
+          }
+        },
+        required: []
+      },
+      handler: async (rawArgs, _context) => {
+        const args = asRecord(rawArgs);
+        const limit = readNumber(args, "limit") ?? 20;
+        const toolFilter = readString(args, "tool");
+        const levelFilter = readString(args, "level")?.toLowerCase();
+        const sinceStr = readString(args, "since");
+        const sinceMs = sinceStr ? new Date(sinceStr).getTime() : void 0;
+        const entries = readEntries(resolvedLogDir);
+        const filtered = entries.filter((entry) => {
+          if (toolFilter) {
+            const t = extractTool(entry);
+            if (!t || !t.includes(toolFilter)) return false;
+          }
+          if (levelFilter && entry.level !== levelFilter) return false;
+          if (sinceMs !== void 0) {
+            const entryMs = new Date(entry.ts).getTime();
+            if (Number.isNaN(entryMs) || entryMs < sinceMs) return false;
+          }
+          return true;
+        });
+        filtered.sort((a, b) => {
+          const ta = new Date(a.ts).getTime();
+          const tb = new Date(b.ts).getTime();
+          return tb - ta;
+        });
+        return {
+          endpoint: "local:audit-log",
+          requestTime: (/* @__PURE__ */ new Date()).toISOString(),
+          data: filtered.slice(0, limit)
+        };
+      }
+    }
+  ];
+}
+var BITHUMB_API_BASE_URL = "https://api.bithumb.com";
+var MODULES = ["market", "account", "trade", "twap", "withdraw", "deposit"];
+var DEFAULT_MODULES = ["market", "account", "trade", "twap", "withdraw", "deposit"];
+async function checkApiReachability(baseUrl) {
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 5e3);
+    const res = await fetch(`${baseUrl}/v1/market/all`, {
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    return {
+      name: "API Reachability",
+      status: res.ok ? "pass" : "fail",
+      message: res.ok ? `${baseUrl} reachable (HTTP ${res.status})` : `${baseUrl} returned HTTP ${res.status}`
+    };
+  } catch (err) {
+    return {
+      name: "API Reachability",
+      status: "fail",
+      message: `Cannot reach ${baseUrl}: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+}
+function checkAuthentication() {
+  const accessKey = process.env.BITHUMB_ACCESS_KEY?.trim();
+  const secretKey = process.env.BITHUMB_SECRET_KEY?.trim();
+  if (accessKey && secretKey) {
+    return { name: "Authentication", status: "pass", message: "API keys configured via environment variables" };
+  }
+  const tomlPath = join(homedir(), ".bithumb", "config.toml");
+  if (existsSync(tomlPath)) {
+    return { name: "Authentication", status: "pass", message: "config.toml found (credentials may be in profile)" };
+  }
+  if (accessKey || secretKey) {
+    return { name: "Authentication", status: "fail", message: "Partial credentials: set both BITHUMB_ACCESS_KEY and BITHUMB_SECRET_KEY" };
+  }
+  return { name: "Authentication", status: "fail", message: "No credentials found (set env vars or create ~/.bithumb/config.toml)" };
+}
+function checkTomlConfig() {
+  const tomlPath = join(homedir(), ".bithumb", "config.toml");
+  if (existsSync(tomlPath)) {
+    return { name: "TOML Config", status: "pass", message: `Found ${tomlPath}` };
+  }
+  return { name: "TOML Config", status: "fail", message: `Not found: ${tomlPath} (optional \u2014 use 'setup' command to create)` };
+}
+function checkModules(enabledModules) {
+  return {
+    name: "Enabled Modules",
+    status: "pass",
+    message: `Active: ${enabledModules.join(", ")}`
+  };
+}
+var ALL_MODULES = ["market", "account", "trade", "twap", "withdraw", "deposit"];
+function registerDiagnoseTools() {
+  return [
+    {
+      name: "system_get_capabilities",
+      module: "account",
+      description: "Return server capabilities and module availability for agent planning.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {},
+        additionalProperties: false
+      },
+      handler: async (_args, context) => {
+        const enabledModules = new Set(context.config.modules);
+        const moduleAvailability = {};
+        for (const mod of ALL_MODULES) {
+          if (!enabledModules.has(mod)) {
+            moduleAvailability[mod] = { status: "disabled", reasonCode: "MODULE_FILTERED" };
+          } else if (mod !== "market" && !context.config.hasAuth) {
+            moduleAvailability[mod] = { status: "requires_auth", reasonCode: "AUTH_MISSING" };
+          } else {
+            moduleAvailability[mod] = { status: "enabled" };
+          }
+        }
+        return {
+          endpoint: "local:capabilities",
+          requestTime: (/* @__PURE__ */ new Date()).toISOString(),
+          data: {
+            readOnly: context.config.readOnly,
+            hasAuth: context.config.hasAuth,
+            moduleAvailability
+          }
+        };
+      }
+    },
+    {
+      name: "system_diagnose",
+      module: "account",
+      description: "Run diagnostic checks on the Bithumb Trade Kit configuration. Checks API reachability, authentication, TOML config, and module status.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {}
+      },
+      handler: async (_args, context) => {
+        const baseUrl = context?.config?.baseUrl ?? BITHUMB_API_BASE_URL;
+        const modules = context?.config?.modules ?? [];
+        const checks = [];
+        checks.push(await checkApiReachability(baseUrl));
+        checks.push(checkAuthentication());
+        checks.push(checkTomlConfig());
+        checks.push(checkModules(modules));
+        const passed = checks.filter((c) => c.status === "pass").length;
+        const total = checks.length;
+        return {
+          endpoint: "local:diagnose",
+          requestTime: (/* @__PURE__ */ new Date()).toISOString(),
+          data: {
+            summary: `${passed}/${total} checks passed`,
+            checks
+          }
+        };
+      }
+    }
+  ];
+}
+function registerTwapTools() {
+  return [
+    // ── 6. twap_place_order ────────────────────────────────────────
+    {
+      name: "twap_place_order",
+      module: "twap",
+      description: "TWAP \uC8FC\uBB38\uC744 \uC694\uCCAD\uD569\uB2C8\uB2E4. Place a TWAP (Time-Weighted Average Price) order.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          market: {
+            type: "string",
+            description: "\uAC70\uB798 \uB300\uC0C1 \uD398\uC5B4\uC758 \uACE0\uC720 \uC2EC\uBCFC (\uC608\uC2DC: KRW-BTC)"
+          },
+          side: {
+            type: "string",
+            enum: ["bid", "ask"],
+            description: "\uC8FC\uBB38 \uC885\uB958: bid (\uB9E4\uC218), ask (\uB9E4\uB3C4)"
+          },
+          duration: {
+            type: "string",
+            description: "\uC8FC\uBB38 \uC2DC\uAC04 - TWAP \uC8FC\uBB38\uC774 \uC9C4\uD589\uB418\uB294 \uC2DC\uAC04(\uCD08). min 300, max 43200"
+          },
+          frequency: {
+            type: "string",
+            enum: ["5", "15", "20", "30", "60", "120"],
+            description: "\uC8FC\uBB38 \uAC04\uACA9(\uCD08)"
+          },
+          volume: {
+            type: "string",
+            description: "\uC8FC\uBB38 \uC218\uB7C9 (\uB9E4\uB3C4 \uC2DC \uD544\uC218)"
+          },
+          price: {
+            type: "string",
+            description: "\uC8FC\uBB38 \uAC00\uACA9 (\uB9E4\uC218 \uC2DC \uD544\uC218)"
+          }
+        },
+        required: ["market", "side", "duration", "frequency"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privatePost(
+          "/v1/twap",
+          compactObject({
+            market: requireString(args, "market"),
+            side: requireString(args, "side"),
+            duration: requireString(args, "duration"),
+            frequency: requireString(args, "frequency"),
+            volume: readString(args, "volume"),
+            price: readString(args, "price")
+          }),
+          orderRateLimit("twap_place_order")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 7. twap_get_orders ─────────────────────────────────────────
+    {
+      name: "twap_get_orders",
+      module: "twap",
+      description: "TWAP \uC8FC\uBB38 \uB0B4\uC5ED\uC744 \uC870\uD68C\uD569\uB2C8\uB2E4. Get TWAP order history.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          market: {
+            type: "string",
+            description: "\uAC70\uB798 \uB300\uC0C1 \uD398\uC5B4\uC758 \uACE0\uC720 \uC2EC\uBCFC (\uC608\uC2DC: KRW-BTC)"
+          },
+          uuids: {
+            type: "array",
+            items: { type: "string" },
+            description: "TWAP \uC8FC\uBB38 ID \uBAA9\uB85D"
+          },
+          state: {
+            type: "string",
+            enum: ["progress", "done", "cancel"],
+            description: "\uC8FC\uBB38 \uC0C1\uD0DC: progress (\uC9C4\uD589\uC911, default), done (\uC644\uB8CC), cancel (\uCDE8\uC18C)"
+          },
+          next_key: {
+            type: "string",
+            description: "\uB2E4\uC74C \uD398\uC774\uC9C0 \uC870\uD68C\uB97C \uC704\uD55C \uCEE4\uC11C \uAC12"
+          },
+          limit: {
+            type: "number",
+            description: "\uAC1C\uC218 \uC81C\uD55C (max 100)"
+          },
+          order_by: {
+            type: "string",
+            enum: ["asc", "desc"],
+            description: "\uC870\uD68C \uACB0\uACFC \uC815\uB82C \uBC29\uC2DD: asc (\uC624\uB984\uCC28\uC21C), desc (\uB0B4\uB9BC\uCC28\uC21C, default)"
+          }
+        },
+        required: []
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/v1/twap",
+          compactObject({
+            market: readString(args, "market"),
+            uuids: readStringArray(args, "uuids"),
+            state: readString(args, "state"),
+            next_key: readString(args, "next_key"),
+            limit: readNumber(args, "limit"),
+            order_by: readString(args, "order_by")
+          }),
+          privateRateLimit("twap_get_orders")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 8. twap_cancel_order ───────────────────────────────────────
+    {
+      name: "twap_cancel_order",
+      module: "twap",
+      description: "TWAP \uC8FC\uBB38\uC744 \uCDE8\uC18C\uD569\uB2C8\uB2E4. Cancel a TWAP order.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          algo_order_id: {
+            type: "string",
+            description: "\uCDE8\uC18C\uD560 TWAP \uC8FC\uBB38 ID"
+          }
+        },
+        required: ["algo_order_id"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const algo_order_id = requireString(args, "algo_order_id");
+        const response = await context.client.privateDelete(
+          "/v1/twap",
+          { algo_order_id },
+          orderRateLimit("twap_cancel_order")
+        );
+        return normalizeResponse(response);
+      }
+    }
+  ];
+}
+function registerWithdrawTools() {
+  return [
+    // ── 9. withdraw_get_chance ───────────────────────────────────────
+    {
+      name: "withdraw_get_chance",
+      module: "withdraw",
+      description: "\uCD9C\uAE08 \uAC00\uB2A5 \uC815\uBCF4\uB97C \uC870\uD68C\uD569\uB2C8\uB2E4. Get withdrawal chance info (available balance, fees).",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          currency: {
+            type: "string",
+            description: "Currency symbol, e.g. BTC"
+          },
+          net_type: {
+            type: "string",
+            description: "Withdrawal network, e.g. BTC, DASH"
+          }
+        },
+        required: ["currency", "net_type"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/v1/withdraws/chance",
+          {
+            currency: requireString(args, "currency"),
+            net_type: requireString(args, "net_type")
+          },
+          privateRateLimit("withdraw_get_chance")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 10. withdraw_get ─────────────────────────────────────────────
+    {
+      name: "withdraw_get",
+      module: "withdraw",
+      description: "\uAC1C\uBCC4 \uCD9C\uAE08\uC744 \uC870\uD68C\uD569\uB2C8\uB2E4. Get a specific withdrawal by currency.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          currency: {
+            type: "string",
+            description: "Currency symbol, e.g. BTC"
+          },
+          uuid: {
+            type: "string",
+            description: "Withdrawal unique ID"
+          },
+          txid: {
+            type: "string",
+            description: "Withdrawal transaction ID"
+          }
+        },
+        required: ["currency"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/v1/withdraw",
+          compactObject({
+            currency: requireString(args, "currency"),
+            uuid: readString(args, "uuid"),
+            txid: readString(args, "txid")
+          }),
+          privateRateLimit("withdraw_get")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 11. withdraw_get_list ────────────────────────────────────────
+    {
+      name: "withdraw_get_list",
+      module: "withdraw",
+      description: "\uCD9C\uAE08 \uB9AC\uC2A4\uD2B8\uB97C \uC870\uD68C\uD569\uB2C8\uB2E4. Get list of coin withdrawals.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          currency: {
+            type: "string",
+            description: "Currency symbol, e.g. BTC"
+          },
+          state: {
+            type: "string",
+            enum: ["PROCESSING", "DONE", "CANCELED"],
+            description: "Withdrawal state filter"
+          },
+          uuids: {
+            type: "array",
+            items: { type: "string" },
+            description: "Filter by withdrawal UUIDs"
+          },
+          txids: {
+            type: "array",
+            items: { type: "string" },
+            description: "Filter by transaction IDs"
+          },
+          limit: {
+            type: "number",
+            description: "Number of results per page (max 100)"
+          },
+          page: {
+            type: "number",
+            description: "Page number"
+          },
+          order_by: {
+            type: "string",
+            enum: ["asc", "desc"],
+            description: "Sort order (default: desc)"
+          }
+        },
+        required: []
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/v1/withdraws",
+          compactObject({
+            currency: readString(args, "currency"),
+            state: readString(args, "state"),
+            uuids: readStringArray(args, "uuids"),
+            txids: readStringArray(args, "txids"),
+            limit: readNumber(args, "limit"),
+            page: readNumber(args, "page"),
+            order_by: readString(args, "order_by")
+          }),
+          privateRateLimit("withdraw_get_list")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 12. withdraw_get_list_krw ────────────────────────────────────
+    {
+      name: "withdraw_get_list_krw",
+      module: "withdraw",
+      description: "\uC6D0\uD654 \uCD9C\uAE08 \uB9AC\uC2A4\uD2B8\uB97C \uC870\uD68C\uD569\uB2C8\uB2E4. Get list of KRW withdrawals.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          state: {
+            type: "string",
+            enum: ["PROCESSING", "DONE", "CANCELED"],
+            description: "Withdrawal state filter"
+          },
+          uuids: {
+            type: "array",
+            items: { type: "string" },
+            description: "Filter by withdrawal UUIDs"
+          },
+          txids: {
+            type: "array",
+            items: { type: "string" },
+            description: "Filter by transaction IDs"
+          },
+          limit: {
+            type: "number",
+            description: "Number of results per page (max 100)"
+          },
+          page: {
+            type: "number",
+            description: "Page number"
+          },
+          order_by: {
+            type: "string",
+            enum: ["asc", "desc"],
+            description: "Sort order (default: desc)"
+          }
+        },
+        required: []
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/v1/withdraws/krw",
+          compactObject({
+            state: readString(args, "state"),
+            uuids: readStringArray(args, "uuids"),
+            txids: readStringArray(args, "txids"),
+            limit: readNumber(args, "limit"),
+            page: readNumber(args, "page"),
+            order_by: readString(args, "order_by")
+          }),
+          privateRateLimit("withdraw_get_list_krw")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 13. withdraw_coin ────────────────────────────────────────────
+    {
+      name: "withdraw_coin",
+      module: "withdraw",
+      description: "\uC2E4\uC81C \uAC00\uC0C1 \uC790\uC0B0\uC744 \uCD9C\uAE08\uD569\uB2C8\uB2E4. \uC774 \uC791\uC5C5\uC740 \uB418\uB3CC\uB9B4 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4. Withdraw cryptocurrency. This action is IRREVERSIBLE. Use when: user has explicitly approved a withdrawal AND the full pre-flight checklist has run (account_get_balance, account_get_wallet_status, withdraw_get_chance, withdraw_get_addresses, market_get_fee_inout). Do NOT use: without prior `withdraw_get_chance` to confirm net_type/min/fee; without `withdraw_get_addresses` to confirm destination is in the allow-list; without explicit user confirmation of the full destination string. Multi-network coins (USDT/USDC/XRP): always run `withdraw_get_chance` first to discover supported `net_type`. Wrong net_type = permanent loss. secondary_address (memo/tag): mandatory for XRP/EOS/ATOM-class coins. Missing it = lost funds.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          currency: {
+            type: "string",
+            description: "Currency symbol, e.g. BTC"
+          },
+          net_type: {
+            type: "string",
+            description: "Withdrawal network, e.g. BTC, DASH"
+          },
+          amount: {
+            type: "string",
+            description: "Withdrawal amount"
+          },
+          address: {
+            type: "string",
+            description: "Registered withdrawal address"
+          },
+          secondary_address: {
+            type: "string",
+            description: "Secondary address (for certain assets)"
+          },
+          exchange_name: {
+            type: "string",
+            description: "Exchange name (English)"
+          },
+          receiver_type: {
+            type: "string",
+            enum: ["personal", "corporation"],
+            description: "Receiver type: personal or corporation"
+          },
+          receiver_ko_name: {
+            type: "string",
+            description: "Receiver Korean name"
+          },
+          receiver_en_name: {
+            type: "string",
+            description: "Receiver English name"
+          },
+          receiver_corp_ko_name: {
+            type: "string",
+            description: "Corporation Korean name (required if corporation)"
+          },
+          receiver_corp_en_name: {
+            type: "string",
+            description: "Corporation English name (required if corporation)"
+          }
+        },
+        required: ["currency", "net_type", "amount", "address"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privatePost(
+          "/v1/withdraws/coin",
+          compactObject({
+            currency: requireString(args, "currency"),
+            net_type: requireString(args, "net_type"),
+            amount: requireString(args, "amount"),
+            address: requireString(args, "address"),
+            secondary_address: readString(args, "secondary_address"),
+            exchange_name: readString(args, "exchange_name"),
+            receiver_type: readString(args, "receiver_type"),
+            receiver_ko_name: readString(args, "receiver_ko_name"),
+            receiver_en_name: readString(args, "receiver_en_name"),
+            receiver_corp_ko_name: readString(args, "receiver_corp_ko_name"),
+            receiver_corp_en_name: readString(args, "receiver_corp_en_name")
+          }),
+          orderRateLimit("withdraw_coin")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 14. withdraw_krw ─────────────────────────────────────────────
+    {
+      name: "withdraw_krw",
+      module: "withdraw",
+      description: "\uB4F1\uB85D\uB41C \uACC4\uC88C\uB85C \uC6D0\uD654\uB97C \uCD9C\uAE08\uD569\uB2C8\uB2E4. 2\uCC28 \uC778\uC99D(\uCE74\uCE74\uC624)\uC774 \uD544\uC694\uD569\uB2C8\uB2E4. Withdraw KRW to registered bank account. Requires 2FA (Kakao).",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          amount: {
+            type: "string",
+            description: "Withdrawal amount in KRW"
+          },
+          two_factor_type: {
+            type: "string",
+            description: "2FA method (e.g. kakao)"
+          }
+        },
+        required: ["amount", "two_factor_type"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privatePost(
+          "/v1/withdraws/krw",
+          {
+            amount: requireString(args, "amount"),
+            two_factor_type: requireString(args, "two_factor_type")
+          },
+          orderRateLimit("withdraw_krw")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 15. withdraw_cancel_coin ─────────────────────────────────────
+    {
+      name: "withdraw_cancel_coin",
+      module: "withdraw",
+      description: "\uAC00\uC0C1 \uC790\uC0B0 \uCD9C\uAE08\uC744 \uCDE8\uC18C\uD569\uB2C8\uB2E4. Cancel a cryptocurrency withdrawal.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          withdrawal_id: {
+            type: "string",
+            description: "Withdrawal unique ID to cancel"
+          }
+        },
+        required: ["withdrawal_id"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateDelete(
+          "/v1/withdraws/coin",
+          {
+            withdrawal_id: requireString(args, "withdrawal_id")
+          },
+          orderRateLimit("withdraw_cancel_coin")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 16. withdraw_get_addresses ───────────────────────────────────
+    {
+      name: "withdraw_get_addresses",
+      module: "withdraw",
+      description: "\uCD9C\uAE08 \uD5C8\uC6A9 \uC8FC\uC18C \uB9AC\uC2A4\uD2B8\uB97C \uC870\uD68C\uD569\uB2C8\uB2E4. Get list of allowed withdrawal addresses.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {},
+        required: []
+      },
+      handler: async (_rawArgs, context) => {
+        const response = await context.client.privateGet(
+          "/v1/withdraws/coin_addresses",
+          {},
+          privateRateLimit("withdraw_get_addresses")
+        );
+        return normalizeResponse(response);
+      }
+    }
+  ];
+}
+function registerDepositTools() {
+  return [
+    // ── 17. deposit_get ───────────────────────────────────────────
+    {
+      name: "deposit_get",
+      module: "deposit",
+      description: '\uAC1C\uBCC4 \uC785\uAE08\uC744 \uC870\uD68C\uD569\uB2C8\uB2E4. Get a single deposit by currency + uuid (or single txid). Use when: user has a specific deposit UUID and wants the full record. Do NOT use: to search by transaction id list \u2014 use `deposit_get_list` with `txids` (array). The CLI blocks `deposit get --txids` and redirects to `deposit list --txids`. Example call: {"currency":"BTC","uuid":"12345678-...."}',
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          currency: {
+            type: "string",
+            description: "Currency symbol, e.g. BTC"
+          },
+          uuid: {
+            type: "string",
+            description: "Deposit UUID"
+          },
+          txid: {
+            type: "string",
+            description: "Deposit TXID"
+          }
+        },
+        required: ["currency"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/v1/deposit",
+          compactObject({
+            currency: requireString(args, "currency"),
+            uuid: readString(args, "uuid"),
+            txid: readString(args, "txid")
+          }),
+          privateRateLimit("deposit_get")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 18. deposit_get_list ──────────────────────────────────────
+    {
+      name: "deposit_get_list",
+      module: "deposit",
+      description: `\uC785\uAE08 \uB9AC\uC2A4\uD2B8\uB97C \uC870\uD68C\uD569\uB2C8\uB2E4. Get list of coin deposits with optional filters. Use when: user asks 'find this txid' / 'recent deposits' / 'list deposits in PROCESSING state'. Do NOT use: when you already have a deposit UUID and want a single record (use \`deposit_get\`). Example call (txid lookup): {"txids":["0xabc123..."]}`,
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          currency: {
+            type: "string",
+            description: "Currency symbol, e.g. BTC"
+          },
+          state: {
+            type: "string",
+            description: "Deposit state filter"
+          },
+          uuids: {
+            type: "array",
+            items: { type: "string" },
+            description: "Filter by deposit UUIDs"
+          },
+          txids: {
+            type: "array",
+            items: { type: "string" },
+            description: "Filter by deposit TXIDs"
+          },
+          limit: {
+            type: "number",
+            description: "Number of results (max 100)"
+          },
+          page: {
+            type: "number",
+            description: "Page number (default 1)"
+          },
+          order_by: {
+            type: "string",
+            description: "Sort order: asc or desc (default desc)"
+          }
+        },
+        required: []
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/v1/deposits",
+          compactObject({
+            currency: readString(args, "currency"),
+            state: readString(args, "state"),
+            uuids: readStringArray(args, "uuids"),
+            txids: readStringArray(args, "txids"),
+            limit: readNumber(args, "limit"),
+            page: readNumber(args, "page"),
+            order_by: readString(args, "order_by")
+          }),
+          privateRateLimit("deposit_get_list")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 19. deposit_get_list_krw ──────────────────────────────────
+    {
+      name: "deposit_get_list_krw",
+      module: "deposit",
+      description: "\uC6D0\uD654 \uC785\uAE08 \uB9AC\uC2A4\uD2B8\uB97C \uC870\uD68C\uD569\uB2C8\uB2E4. Get list of KRW deposits.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          state: {
+            type: "string",
+            description: "Deposit state: PROCESSING, ACCEPTED, CANCELED"
+          },
+          uuids: {
+            type: "array",
+            items: { type: "string" },
+            description: "Filter by deposit UUIDs"
+          },
+          txids: {
+            type: "array",
+            items: { type: "string" },
+            description: "Filter by deposit TXIDs"
+          },
+          limit: {
+            type: "number",
+            description: "Number of results (max 100)"
+          },
+          page: {
+            type: "number",
+            description: "Page number (default 1)"
+          },
+          order_by: {
+            type: "string",
+            description: "Sort order: asc or desc (default desc)"
+          }
+        },
+        required: []
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/v1/deposits/krw",
+          compactObject({
+            state: readString(args, "state"),
+            uuids: readStringArray(args, "uuids"),
+            txids: readStringArray(args, "txids"),
+            limit: readNumber(args, "limit"),
+            page: readNumber(args, "page"),
+            order_by: readString(args, "order_by")
+          }),
+          privateRateLimit("deposit_get_list_krw")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 20. deposit_krw ──────────────────────────────────────────
+    {
+      name: "deposit_krw",
+      module: "deposit",
+      description: "\uC6D0\uD654 \uC785\uAE08\uC744 \uC694\uCCAD\uD569\uB2C8\uB2E4. 2\uCC28 \uC778\uC99D(\uCE74\uCE74\uC624)\uC774 \uD544\uC694\uD569\uB2C8\uB2E4. Request KRW deposit. Requires 2FA (Kakao).",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          amount: {
+            type: "string",
+            description: "Deposit amount in KRW"
+          },
+          two_factor_type: {
+            type: "string",
+            description: "2FA method, e.g. kakao"
+          }
+        },
+        required: ["amount", "two_factor_type"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privatePost(
+          "/v1/deposits/krw",
+          {
+            amount: requireString(args, "amount"),
+            two_factor_type: requireString(args, "two_factor_type")
+          },
+          privateRateLimit("deposit_krw")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 21. deposit_generate_address ─────────────────────────────
+    {
+      name: "deposit_generate_address",
+      module: "deposit",
+      description: "\uC785\uAE08 \uC8FC\uC18C\uB97C \uC0DD\uC131\uD569\uB2C8\uB2E4. Generate a new deposit address.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          currency: {
+            type: "string",
+            description: "Currency symbol, e.g. BTC"
+          },
+          net_type: {
+            type: "string",
+            description: "Network type, e.g. BTC, ETH"
+          }
+        },
+        required: ["currency", "net_type"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privatePost(
+          "/v1/deposits/generate_coin_address",
+          {
+            currency: requireString(args, "currency"),
+            net_type: requireString(args, "net_type")
+          },
+          privateRateLimit("deposit_generate_address")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 22. deposit_get_addresses ────────────────────────────────
+    {
+      name: "deposit_get_addresses",
+      module: "deposit",
+      description: "\uC804\uCCB4 \uC785\uAE08 \uC8FC\uC18C\uB97C \uC870\uD68C\uD569\uB2C8\uB2E4. Get all deposit addresses.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {},
+        required: []
+      },
+      handler: async (_rawArgs, context) => {
+        const response = await context.client.privateGet(
+          "/v1/deposits/coin_addresses",
+          {},
+          privateRateLimit("deposit_get_addresses")
+        );
+        return normalizeResponse(response);
+      }
+    },
+    // ── 23. deposit_get_address ──────────────────────────────────
+    {
+      name: "deposit_get_address",
+      module: "deposit",
+      description: "\uAC1C\uBCC4 \uC785\uAE08 \uC8FC\uC18C\uB97C \uC870\uD68C\uD569\uB2C8\uB2E4. Get deposit address for a specific currency and network.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          currency: {
+            type: "string",
+            description: "Currency symbol, e.g. BTC"
+          },
+          net_type: {
+            type: "string",
+            description: "Network type, e.g. BTC, ETH"
+          }
+        },
+        required: ["currency", "net_type"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/v1/deposits/coin_address",
+          {
+            currency: requireString(args, "currency"),
+            net_type: requireString(args, "net_type")
+          },
+          privateRateLimit("deposit_get_address")
+        );
+        return normalizeResponse(response);
+      }
+    }
+  ];
+}
+function allToolSpecs() {
+  return [
+    ...registerMarketTools(),
+    ...registerAccountTools(),
+    ...registerTradeTools(),
+    ...registerAuditTools(),
+    ...registerDiagnoseTools(),
+    ...registerTwapTools(),
+    ...registerWithdrawTools(),
+    ...registerDepositTools()
+  ];
+}
+function buildTools(config) {
+  const enabledModules = new Set(config.modules);
+  const tools = allToolSpecs().filter((t) => enabledModules.has(t.module));
+  return config.readOnly ? tools.filter((t) => !t.isWrite) : tools;
+}
+function toMcpTool(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+    annotations: {
+      readOnlyHint: !tool.isWrite,
+      destructiveHint: tool.isWrite,
+      idempotentHint: !tool.isWrite,
+      openWorldHint: true
+    }
+  };
+}
+function configFilePath() {
+  return join2(homedir2(), ".bithumb", "config.toml");
+}
+function readFullConfig() {
+  const path3 = configFilePath();
+  if (!existsSync2(path3)) return { profiles: {} };
+  const raw = readFileSync(path3, "utf-8");
+  try {
+    return parse(raw);
+  } catch (err) {
+    throw new ConfigError(
+      `Failed to parse ${path3}: ${err instanceof Error ? err.message : String(err)}`,
+      "Check TOML syntax in your config file, or delete and re-create it."
+    );
+  }
+}
+function readTomlProfile(profileName) {
+  const config = readFullConfig();
+  const name = profileName ?? config.default_profile ?? "default";
+  return config.profiles?.[name] ?? {};
+}
+function loadConfig(options) {
+  const toml = readTomlProfile(options?.profile);
+  const accessKey = process.env.BITHUMB_ACCESS_KEY?.trim() ?? toml.access_key;
+  const secretKey = process.env.BITHUMB_SECRET_KEY?.trim() ?? toml.secret_key;
+  const hasAuth = Boolean(accessKey && secretKey);
+  const partialAuth = Boolean(accessKey) || Boolean(secretKey);
+  if (partialAuth && !hasAuth) {
+    throw new ConfigError(
+      "Partial API credentials.",
+      "Set both BITHUMB_ACCESS_KEY and BITHUMB_SECRET_KEY (env vars or config.toml profile)."
+    );
+  }
+  const baseUrl = (process.env.BITHUMB_API_BASE_URL?.trim() ?? toml.base_url ?? BITHUMB_API_BASE_URL).replace(/\/+$/, "");
+  const rawTimeout = process.env.BITHUMB_TIMEOUT_MS ? Number(process.env.BITHUMB_TIMEOUT_MS) : toml.timeout_ms ?? 15e3;
+  if (!Number.isFinite(rawTimeout) || rawTimeout <= 0) {
+    throw new ConfigError(
+      "Invalid timeout.",
+      "BITHUMB_TIMEOUT_MS must be a positive integer."
+    );
+  }
+  let modules = [...DEFAULT_MODULES];
+  if (options?.modules) {
+    const requested = options.modules.split(",").map((s) => s.trim()).filter(Boolean);
+    if (requested.length > 0) {
+      let isAll = false;
+      for (const m of requested) {
+        if (m === "all") {
+          modules = [...MODULES];
+          isAll = true;
+          break;
+        }
+        if (!MODULES.includes(m)) {
+          throw new ConfigError(
+            `Unknown module "${m}".`,
+            `Use: ${MODULES.join(", ")} or "all".`
+          );
+        }
+      }
+      if (!isAll) modules = requested;
+    }
+  }
+  return {
+    accessKey,
+    secretKey,
+    hasAuth,
+    baseUrl,
+    timeoutMs: Math.floor(rawTimeout),
+    modules,
+    readOnly: options?.readOnly ?? false,
+    verbose: options?.verbose ?? false
+  };
+}
+var LEVEL_ORDER = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var SENSITIVE_KEY_PATTERN = /accessKey|secretKey|password|secret|token|jwt/i;
+function redactSensitive(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (SENSITIVE_KEY_PATTERN.test(key)) {
+      result[key] = "***REDACTED***";
+    } else if (value && typeof value === "object" && !Array.isArray(value)) {
+      result[key] = redactSensitive(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function todayDateString() {
+  const d = /* @__PURE__ */ new Date();
+  const yyyy = d.getFullYear();
+  const mm = String(d.getMonth() + 1).padStart(2, "0");
+  const dd = String(d.getDate()).padStart(2, "0");
+  return `${yyyy}-${mm}-${dd}`;
+}
+var TradeLogger = class {
+  logDir;
+  minLevel;
+  verbose;
+  constructor(minLevelOrOptions) {
+    if (typeof minLevelOrOptions === "string") {
+      this.logDir = join3(homedir3(), ".bithumb", "logs");
+      this.minLevel = minLevelOrOptions;
+      this.verbose = false;
+    } else {
+      this.logDir = minLevelOrOptions?.logDir ?? join3(homedir3(), ".bithumb", "logs");
+      this.minLevel = minLevelOrOptions?.minLevel ?? "info";
+      this.verbose = minLevelOrOptions?.verbose ?? false;
+    }
+    try {
+      mkdirSync2(this.logDir, { recursive: true });
+    } catch {
+    }
+  }
+  debug(message, meta) {
+    this.log("debug", message, meta);
+  }
+  info(message, meta) {
+    this.log("info", message, meta);
+  }
+  warn(message, meta) {
+    this.log("warn", message, meta);
+  }
+  error(message, meta) {
+    this.log("error", message, meta);
+  }
+  /** Log a tool invocation result (used by MCP server). */
+  logTool(level, toolName, args, result, elapsedMs) {
+    this.log(level, `tool:${toolName}`, {
+      args,
+      result,
+      elapsedMs
+    });
+  }
+  log(level, message, meta) {
+    if (LEVEL_ORDER[level] < LEVEL_ORDER[this.minLevel]) return;
+    const entry = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      message,
+      ...meta ? redactSensitive(meta) : {}
+    };
+    const line = JSON.stringify(entry);
+    if (this.verbose || level === "error") {
+      process.stderr.write(`[${level}] ${message}
+`);
+    }
+    try {
+      const filePath = join3(this.logDir, `trade-${todayDateString()}.log`);
+      appendFileSync(filePath, line + "\n", "utf8");
+    } catch {
+    }
+  }
+};
+var CACHE_DIR = join4(homedir4(), ".bithumb");
+var CACHE_FILE = join4(CACHE_DIR, "update-check.json");
+var CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+function isNewerVersion(current, latest) {
+  const parse2 = (v) => v.replace(/^v/, "").split(".").map((n) => parseInt(n, 10) || 0);
+  const cur = parse2(current);
+  const lat = parse2(latest);
+  for (let i = 0; i < Math.max(cur.length, lat.length); i++) {
+    const c = cur[i] ?? 0;
+    const l = lat[i] ?? 0;
+    if (l > c) return true;
+    if (l < c) return false;
+  }
+  return false;
+}
+async function fetchDistTags(packageName) {
+  try {
+    const url = `https://registry.npmjs.org/-/package/${encodeURIComponent(packageName)}/dist-tags`;
+    const res = await fetch(url, { signal: AbortSignal.timeout(5e3) });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function fetchLatestVersion(packageName) {
+  const tags = await fetchDistTags(packageName);
+  return tags?.latest ?? null;
+}
+function readCache() {
+  try {
+    if (!existsSync3(CACHE_FILE)) return null;
+    const raw = readFileSync2(CACHE_FILE, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeCache(data) {
+  try {
+    if (!existsSync3(CACHE_DIR)) {
+      mkdirSync3(CACHE_DIR, { recursive: true });
+    }
+    writeFileSync2(CACHE_FILE, JSON.stringify(data), "utf8");
+  } catch {
+  }
+}
+function isCacheStale(cache) {
+  return Date.now() - cache.checkedAt > CACHE_TTL_MS;
+}
+function checkForUpdates(packageName, currentVersion) {
+  try {
+    const cache = readCache();
+    if (cache && !isCacheStale(cache)) {
+      if (isNewerVersion(currentVersion, cache.latestVersion)) {
+        process.stderr.write(
+          `
+Update available: ${currentVersion} \u2192 ${cache.latestVersion}
+Run: npm install -g ${packageName}
+
+`
+        );
+      }
+      return;
+    }
+    setImmediate(() => {
+      fetchLatestVersion(packageName).then((latest) => {
+        if (latest) {
+          writeCache({ latestVersion: latest, checkedAt: Date.now() });
+          if (isNewerVersion(currentVersion, latest)) {
+            process.stderr.write(
+              `
+Update available: ${currentVersion} \u2192 ${latest}
+Run: npm install -g ${packageName}
+
+`
+            );
+          }
+        }
+      }).catch(() => {
+      });
+    });
+  } catch {
+  }
+}
+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);
+function appData() {
+  return process.env.APPDATA ?? path2.join(os2.homedir(), "AppData", "Roaming");
+}
+var CLAUDE_CONFIG_FILE = "claude_desktop_config.json";
+function findMsStoreClaudePath() {
+  const localAppData = process.env.LOCALAPPDATA ?? path2.join(os2.homedir(), "AppData", "Local");
+  const packagesDir = path2.join(localAppData, "Packages");
+  try {
+    const entries = fs2.readdirSync(packagesDir);
+    const claudePkg = entries.find((e) => e.startsWith("Claude_"));
+    if (claudePkg) {
+      const configPath = path2.join(
+        packagesDir,
+        claudePkg,
+        "LocalCache",
+        "Roaming",
+        "Claude",
+        CLAUDE_CONFIG_FILE
+      );
+      if (fs2.existsSync(configPath) || fs2.existsSync(path2.dirname(configPath))) {
+        return configPath;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function getConfigPath(client) {
+  const home = os2.homedir();
+  const platform = process.platform;
+  switch (client) {
+    case "claude-desktop":
+      if (platform === "win32") {
+        return findMsStoreClaudePath() ?? path2.join(appData(), "Claude", CLAUDE_CONFIG_FILE);
+      }
+      if (platform === "darwin") {
+        return path2.join(home, "Library", "Application Support", "Claude", CLAUDE_CONFIG_FILE);
+      }
+      return path2.join(process.env.XDG_CONFIG_HOME ?? path2.join(home, ".config"), "Claude", CLAUDE_CONFIG_FILE);
+    case "cursor":
+      return path2.join(home, ".cursor", "mcp.json");
+    case "windsurf":
+      return path2.join(home, ".codeium", "windsurf", "mcp_config.json");
+    case "vscode":
+      return path2.join(process.cwd(), ".mcp.json");
+    case "claude-code":
+      return null;
+  }
+}
+var NPX_PACKAGE = "@bithumb-tradekit/mcp";
+function buildEntry(client, args) {
+  if (client === "vscode") {
+    return { type: "stdio", command: "bithumb-trade-mcp", args };
+  }
+  return { command: "npx", args: ["-y", NPX_PACKAGE, ...args] };
+}
+function buildArgs(options) {
+  const args = [];
+  if (options.profile) args.push("--profile", options.profile);
+  args.push("--modules", options.modules ?? "all");
+  return args;
+}
+function mergeJsonConfig(configPath, serverName, entry) {
+  const dir = path2.dirname(configPath);
+  if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
+  let data = {};
+  if (fs2.existsSync(configPath)) {
+    const raw = fs2.readFileSync(configPath, "utf-8");
+    try {
+      data = JSON.parse(raw);
+    } catch {
+      throw new Error(`Failed to parse existing config at ${configPath}`);
+    }
+    const backupPath = configPath + ".bak";
+    fs2.copyFileSync(configPath, backupPath);
+    process.stdout.write(`  Backup \u2192 ${backupPath}
+`);
+  }
+  if (typeof data.mcpServers !== "object" || data.mcpServers === null) {
+    data.mcpServers = {};
+  }
+  data.mcpServers[serverName] = entry;
+  fs2.writeFileSync(configPath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+function printSetupUsage() {
+  process.stdout.write(
+    `Usage: bithumb-trade-mcp setup --client <client> [--profile <name>] [--modules <list>]
+
+Clients:
+` + SUPPORTED_CLIENTS.map((id) => `  ${id.padEnd(16)} ${CLIENT_NAMES[id]}`).join("\n") + `
+
+Options:
+  --profile <name>   Profile from ${configFilePath()} (default: uses default_profile)
+  --modules <list>   Comma-separated modules or "all" (default: all)
+`
+  );
+}
+function runSetup(options) {
+  const { client } = options;
+  const name = CLIENT_NAMES[client];
+  const args = buildArgs(options);
+  const serverName = options.profile ? `bithumb-trade-mcp-${options.profile}` : "bithumb-trade-mcp";
+  if (client === "claude-code") {
+    const claudeArgs = [
+      "mcp",
+      "add",
+      "--transport",
+      "stdio",
+      serverName,
+      "--",
+      "bithumb-trade-mcp",
+      ...args
+    ];
+    process.stdout.write(`Running: claude ${claudeArgs.join(" ")}
+`);
+    execFileSync("claude", claudeArgs, { stdio: "inherit" });
+    process.stdout.write(`\u2713 Configured ${name}
+`);
+    return;
+  }
+  const configPath = getConfigPath(client);
+  if (!configPath) {
+    throw new Error(`${name} is not supported on this platform`);
+  }
+  const entry = buildEntry(client, args);
+  mergeJsonConfig(configPath, serverName, entry);
+  process.stdout.write(
+    `\u2713 Configured ${name}
+  ${configPath}
+  Server args: ${args.join(" ")}
+`
+  );
+  if (client !== "vscode") {
+    process.stdout.write(`  Restart ${name} to apply changes.
+`);
+  }
+}
+
+// src/constants.ts
+import { createRequire } from "module";
+var _require = createRequire(import.meta.url);
+var pkg = _require("../package.json");
+var SERVER_NAME = "bithumb-trade-mcp";
+var SERVER_VERSION = pkg.version;
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+var SYSTEM_CAPABILITIES_TOOL_NAME = "system_get_capabilities";
+var SYSTEM_CAPABILITIES_TOOL = {
+  name: SYSTEM_CAPABILITIES_TOOL_NAME,
+  description: "Return server capabilities and module availability for agent planning. Use when: user asks '\uC0AC\uC6A9 \uAC00\uB2A5\uD55C \uBE57\uC378 \uAE30\uB2A5 \uC54C\uB824\uC918' / 'what can you do?' / 'what features are available?'; or when an agent needs to plan a multi-step workflow and must know which modules are enabled. Do NOT use: as a substitute for `system_diagnose` (which checks live connectivity and auth). CLI: `bithumb-trade system capabilities` (alias: `bithumb-trade account capabilities`). Returns: server name/version, readOnly flag, hasAuth flag, and per-module status (enabled / disabled / requires_auth).",
+  inputSchema: { type: "object", additionalProperties: false },
+  annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }
+};
+function buildCapabilitySnapshot(config) {
+  const enabledModules = new Set(config.modules);
+  const moduleAvailability = {};
+  for (const moduleId of MODULES) {
+    if (!enabledModules.has(moduleId)) {
+      moduleAvailability[moduleId] = { status: "disabled", reasonCode: "MODULE_FILTERED" };
+      continue;
+    }
+    if (moduleId === "market") {
+      moduleAvailability[moduleId] = { status: "enabled" };
+      continue;
+    }
+    if (!config.hasAuth) {
+      moduleAvailability[moduleId] = { status: "requires_auth", reasonCode: "AUTH_MISSING" };
+      continue;
+    }
+    moduleAvailability[moduleId] = { status: "enabled" };
+  }
+  return { readOnly: config.readOnly, hasAuth: config.hasAuth, moduleAvailability };
+}
+function successResult(toolName, data, snapshot) {
+  const payload = {
+    tool: toolName,
+    ok: true,
+    data,
+    capabilities: snapshot,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+    structuredContent: payload
+  };
+}
+function errorResult(toolName, error, snapshot) {
+  const payload = toToolErrorPayload(error);
+  const structured = {
+    tool: toolName,
+    ...payload,
+    serverVersion: SERVER_VERSION,
+    capabilities: snapshot
+  };
+  return {
+    isError: true,
+    content: [{ type: "text", text: JSON.stringify(structured, null, 2) }],
+    structuredContent: structured
+  };
+}
+function unknownToolResult(toolName, snapshot) {
+  return errorResult(
+    toolName,
+    new BithumbApiError(`Tool "${toolName}" is not available.`, { code: "TOOL_NOT_AVAILABLE" }),
+    snapshot
+  );
+}
+function createServer(config, logger) {
+  const client = new BithumbRestClient(config);
+  const tools = buildTools(config);
+  const toolMap = new Map(tools.map((t) => [t.name, t]));
+  const server = new Server(
+    { name: SERVER_NAME, version: SERVER_VERSION },
+    { capabilities: { tools: {} } }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [...tools.map(toMcpTool), SYSTEM_CAPABILITIES_TOOL]
+  }));
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const toolName = request.params.name;
+    if (toolName === SYSTEM_CAPABILITIES_TOOL_NAME) {
+      const snapshot = buildCapabilitySnapshot(config);
+      return successResult(toolName, { server: { name: SERVER_NAME, version: SERVER_VERSION }, capabilities: snapshot }, snapshot);
+    }
+    const tool = toolMap.get(toolName);
+    if (!tool) return unknownToolResult(toolName, buildCapabilitySnapshot(config));
+    const startTime = Date.now();
+    try {
+      const response = await tool.handler(request.params.arguments ?? {}, { config, client });
+      logger?.logTool("info", toolName, request.params.arguments ?? {}, response, Date.now() - startTime);
+      return successResult(toolName, response, buildCapabilitySnapshot(config));
+    } catch (error) {
+      const level = error instanceof BithumbApiError ? "warn" : "error";
+      logger?.logTool(level, toolName, request.params.arguments ?? {}, error, Date.now() - startTime);
+      return errorResult(toolName, error, buildCapabilitySnapshot(config));
+    }
+  });
+  return server;
+}
+
+// src/index.ts
+function printHelp() {
+  const help = `
+Usage: bithumb-trade-mcp [options]
+
+Options:
+  --modules <list>     Comma-separated modules: market, account, trade, twap, withdraw, deposit, or "all"
+                       Default: market,account,trade,twap,withdraw,deposit (all modules)
+  --read-only          Expose only read/query tools (disable order placement/cancellation)
+  --no-log             Disable audit logging
+  --log-level <level>  Log level: error, warn, info, debug (default: info)
+  --verbose            Enable verbose request logging to stderr
+  --profile <name>     Config profile from ~/.bithumb/config.toml (default: uses default_profile)
+  --help               Show this help message
+  --version            Show version
+
+Credentials (environment variables):
+  BITHUMB_ACCESS_KEY   Bithumb API access key
+  BITHUMB_SECRET_KEY   Bithumb API secret key
+
+Other Environment Variables:
+  BITHUMB_API_BASE_URL Optional API base URL override (default: https://api.bithumb.com)
+  BITHUMB_TIMEOUT_MS   Request timeout in milliseconds (default: 15000)
+`;
+  process.stdout.write(help);
+}
+function parseCli() {
+  const parsed = parseArgs({
+    options: {
+      modules: { type: "string" },
+      "read-only": { type: "boolean", default: false },
+      "no-log": { type: "boolean", default: false },
+      "log-level": { type: "string", default: "info" },
+      verbose: { type: "boolean", default: false },
+      profile: { type: "string" },
+      help: { type: "boolean", default: false },
+      version: { type: "boolean", default: false }
+    },
+    allowPositionals: false
+  });
+  return {
+    modules: parsed.values.modules,
+    readOnly: parsed.values["read-only"] ?? false,
+    noLog: parsed.values["no-log"] ?? false,
+    logLevel: parsed.values["log-level"] ?? "info",
+    verbose: parsed.values.verbose ?? false,
+    profile: parsed.values.profile,
+    help: parsed.values.help ?? false,
+    version: parsed.values.version ?? false
+  };
+}
+async function main() {
+  if (process.argv[2] === "setup") {
+    const setupArgs = parseArgs({
+      args: process.argv.slice(3),
+      options: {
+        client: { type: "string" },
+        profile: { type: "string" },
+        modules: { type: "string" },
+        help: { type: "boolean", default: false }
+      },
+      allowPositionals: false
+    });
+    if (setupArgs.values.help || !setupArgs.values.client) {
+      printSetupUsage();
+      return;
+    }
+    if (!SUPPORTED_CLIENTS.includes(setupArgs.values.client)) {
+      process.stderr.write(`Unknown client "${setupArgs.values.client}". Use: ${SUPPORTED_CLIENTS.join(", ")}
+`);
+      process.exitCode = 1;
+      return;
+    }
+    runSetup({
+      client: setupArgs.values.client,
+      profile: setupArgs.values.profile,
+      modules: setupArgs.values.modules
+    });
+    return;
+  }
+  const cli = parseCli();
+  if (cli.help) {
+    printHelp();
+    return;
+  }
+  if (cli.version) {
+    process.stdout.write(`${SERVER_VERSION}
+`);
+    return;
+  }
+  checkForUpdates("@bithumb-tradekit/mcp", SERVER_VERSION);
+  const config = loadConfig({
+    modules: cli.modules,
+    readOnly: cli.readOnly,
+    verbose: cli.verbose,
+    profile: cli.profile
+  });
+  const logger = cli.noLog ? void 0 : new TradeLogger(cli.logLevel);
+  const server = createServer(config, logger);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((error) => {
+  const payload = toToolErrorPayload(error);
+  process.stderr.write(`${JSON.stringify(payload, null, 2)}
+`);
+  process.exitCode = 1;
+});
+export {
+  main
+};
+/*! Bundled license information:
+
+smol-toml/dist/error.js:
+smol-toml/dist/util.js:
+smol-toml/dist/date.js:
+smol-toml/dist/primitive.js:
+smol-toml/dist/extract.js:
+smol-toml/dist/struct.js:
+smol-toml/dist/parse.js:
+smol-toml/dist/stringify.js:
+smol-toml/dist/index.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+*/
+//# sourceMappingURL=index.js.map