hvip-mcp-server 0.2.49 → 0.2.50

package/dist/index.js

@@ -6,9 +6,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -33,6 +30,410 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// node_modules/dotenv/package.json
+var require_package = __commonJS({
+  "node_modules/dotenv/package.json"(exports2, module2) {
+    module2.exports = {
+      name: "dotenv",
+      version: "16.6.1",
+      description: "Loads environment variables from .env file",
+      main: "lib/main.js",
+      types: "lib/main.d.ts",
+      exports: {
+        ".": {
+          types: "./lib/main.d.ts",
+          require: "./lib/main.js",
+          default: "./lib/main.js"
+        },
+        "./config": "./config.js",
+        "./config.js": "./config.js",
+        "./lib/env-options": "./lib/env-options.js",
+        "./lib/env-options.js": "./lib/env-options.js",
+        "./lib/cli-options": "./lib/cli-options.js",
+        "./lib/cli-options.js": "./lib/cli-options.js",
+        "./package.json": "./package.json"
+      },
+      scripts: {
+        "dts-check": "tsc --project tests/types/tsconfig.json",
+        lint: "standard",
+        pretest: "npm run lint && npm run dts-check",
+        test: "tap run --allow-empty-coverage --disable-coverage --timeout=60000",
+        "test:coverage": "tap run --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
+        prerelease: "npm test",
+        release: "standard-version"
+      },
+      repository: {
+        type: "git",
+        url: "git://github.com/motdotla/dotenv.git"
+      },
+      homepage: "https://github.com/motdotla/dotenv#readme",
+      funding: "https://dotenvx.com",
+      keywords: [
+        "dotenv",
+        "env",
+        ".env",
+        "environment",
+        "variables",
+        "config",
+        "settings"
+      ],
+      readmeFilename: "README.md",
+      license: "BSD-2-Clause",
+      devDependencies: {
+        "@types/node": "^18.11.3",
+        decache: "^4.6.2",
+        sinon: "^14.0.1",
+        standard: "^17.0.0",
+        "standard-version": "^9.5.0",
+        tap: "^19.2.0",
+        typescript: "^4.8.4"
+      },
+      engines: {
+        node: ">=12"
+      },
+      browser: {
+        fs: false
+      }
+    };
+  }
+});
+
+// node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+  "node_modules/dotenv/lib/main.js"(exports2, module2) {
+    var fs2 = require("fs");
+    var path2 = require("path");
+    var os2 = require("os");
+    var crypto5 = require("crypto");
+    var packageJson = require_package();
+    var version2 = packageJson.version;
+    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+    function parse3(src) {
+      const obj = {};
+      let lines = src.toString();
+      lines = lines.replace(/\r\n?/mg, "\n");
+      let match;
+      while ((match = LINE.exec(lines)) != null) {
+        const key = match[1];
+        let value = match[2] || "";
+        value = value.trim();
+        const maybeQuote = value[0];
+        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+        if (maybeQuote === '"') {
+          value = value.replace(/\\n/g, "\n");
+          value = value.replace(/\\r/g, "\r");
+        }
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _parseVault(options) {
+      options = options || {};
+      const vaultPath = _vaultPath(options);
+      options.path = vaultPath;
+      const result = DotenvModule.configDotenv(options);
+      if (!result.parsed) {
+        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+        err.code = "MISSING_DATA";
+        throw err;
+      }
+      const keys = _dotenvKey(options).split(",");
+      const length = keys.length;
+      let decrypted;
+      for (let i = 0; i < length; i++) {
+        try {
+          const key = keys[i].trim();
+          const attrs = _instructions(result, key);
+          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+          break;
+        } catch (error2) {
+          if (i + 1 >= length) {
+            throw error2;
+          }
+        }
+      }
+      return DotenvModule.parse(decrypted);
+    }
+    function _warn(message) {
+      console.log(`[dotenv@${version2}][WARN] ${message}`);
+    }
+    function _debug(message) {
+      console.log(`[dotenv@${version2}][DEBUG] ${message}`);
+    }
+    function _log(message) {
+      console.log(`[dotenv@${version2}] ${message}`);
+    }
+    function _dotenvKey(options) {
+      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+        return options.DOTENV_KEY;
+      }
+      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+        return process.env.DOTENV_KEY;
+      }
+      return "";
+    }
+    function _instructions(result, dotenvKey) {
+      let uri;
+      try {
+        uri = new URL(dotenvKey);
+      } catch (error2) {
+        if (error2.code === "ERR_INVALID_URL") {
+          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        throw error2;
+      }
+      const key = uri.password;
+      if (!key) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environment = uri.searchParams.get("environment");
+      if (!environment) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+      const ciphertext = result.parsed[environmentKey];
+      if (!ciphertext) {
+        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+        throw err;
+      }
+      return { ciphertext, key };
+    }
+    function _vaultPath(options) {
+      let possibleVaultPath = null;
+      if (options && options.path && options.path.length > 0) {
+        if (Array.isArray(options.path)) {
+          for (const filepath of options.path) {
+            if (fs2.existsSync(filepath)) {
+              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+            }
+          }
+        } else {
+          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+        }
+      } else {
+        possibleVaultPath = path2.resolve(process.cwd(), ".env.vault");
+      }
+      if (fs2.existsSync(possibleVaultPath)) {
+        return possibleVaultPath;
+      }
+      return null;
+    }
+    function _resolveHome(envPath) {
+      return envPath[0] === "~" ? path2.join(os2.homedir(), envPath.slice(1)) : envPath;
+    }
+    function _configVault(options) {
+      const debug = Boolean(options && options.debug);
+      const quiet = options && "quiet" in options ? options.quiet : true;
+      if (debug || !quiet) {
+        _log("Loading env from encrypted .env.vault");
+      }
+      const parsed = DotenvModule._parseVault(options);
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsed, options);
+      return { parsed };
+    }
+    function configDotenv(options) {
+      const dotenvPath = path2.resolve(process.cwd(), ".env");
+      let encoding = "utf8";
+      const debug = Boolean(options && options.debug);
+      const quiet = options && "quiet" in options ? options.quiet : true;
+      if (options && options.encoding) {
+        encoding = options.encoding;
+      } else {
+        if (debug) {
+          _debug("No encoding is specified. UTF-8 is used by default");
+        }
+      }
+      let optionPaths = [dotenvPath];
+      if (options && options.path) {
+        if (!Array.isArray(options.path)) {
+          optionPaths = [_resolveHome(options.path)];
+        } else {
+          optionPaths = [];
+          for (const filepath of options.path) {
+            optionPaths.push(_resolveHome(filepath));
+          }
+        }
+      }
+      let lastError;
+      const parsedAll = {};
+      for (const path3 of optionPaths) {
+        try {
+          const parsed = DotenvModule.parse(fs2.readFileSync(path3, { encoding }));
+          DotenvModule.populate(parsedAll, parsed, options);
+        } catch (e) {
+          if (debug) {
+            _debug(`Failed to load ${path3} ${e.message}`);
+          }
+          lastError = e;
+        }
+      }
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsedAll, options);
+      if (debug || !quiet) {
+        const keysCount = Object.keys(parsedAll).length;
+        const shortPaths = [];
+        for (const filePath of optionPaths) {
+          try {
+            const relative = path2.relative(process.cwd(), filePath);
+            shortPaths.push(relative);
+          } catch (e) {
+            if (debug) {
+              _debug(`Failed to load ${filePath} ${e.message}`);
+            }
+            lastError = e;
+          }
+        }
+        _log(`injecting env (${keysCount}) from ${shortPaths.join(",")}`);
+      }
+      if (lastError) {
+        return { parsed: parsedAll, error: lastError };
+      } else {
+        return { parsed: parsedAll };
+      }
+    }
+    function config2(options) {
+      if (_dotenvKey(options).length === 0) {
+        return DotenvModule.configDotenv(options);
+      }
+      const vaultPath = _vaultPath(options);
+      if (!vaultPath) {
+        _warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+        return DotenvModule.configDotenv(options);
+      }
+      return DotenvModule._configVault(options);
+    }
+    function decrypt(encrypted, keyStr) {
+      const key = Buffer.from(keyStr.slice(-64), "hex");
+      let ciphertext = Buffer.from(encrypted, "base64");
+      const nonce = ciphertext.subarray(0, 12);
+      const authTag = ciphertext.subarray(-16);
+      ciphertext = ciphertext.subarray(12, -16);
+      try {
+        const aesgcm = crypto5.createDecipheriv("aes-256-gcm", key, nonce);
+        aesgcm.setAuthTag(authTag);
+        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+      } catch (error2) {
+        const isRange = error2 instanceof RangeError;
+        const invalidKeyLength = error2.message === "Invalid key length";
+        const decryptionFailed = error2.message === "Unsupported state or unable to authenticate data";
+        if (isRange || invalidKeyLength) {
+          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        } else if (decryptionFailed) {
+          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+          err.code = "DECRYPTION_FAILED";
+          throw err;
+        } else {
+          throw error2;
+        }
+      }
+    }
+    function populate(processEnv, parsed, options = {}) {
+      const debug = Boolean(options && options.debug);
+      const override = Boolean(options && options.override);
+      if (typeof parsed !== "object") {
+        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+        err.code = "OBJECT_REQUIRED";
+        throw err;
+      }
+      for (const key of Object.keys(parsed)) {
+        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+          if (override === true) {
+            processEnv[key] = parsed[key];
+          }
+          if (debug) {
+            if (override === true) {
+              _debug(`"${key}" is already defined and WAS overwritten`);
+            } else {
+              _debug(`"${key}" is already defined and was NOT overwritten`);
+            }
+          }
+        } else {
+          processEnv[key] = parsed[key];
+        }
+      }
+    }
+    var DotenvModule = {
+      configDotenv,
+      _configVault,
+      _parseVault,
+      config: config2,
+      decrypt,
+      parse: parse3,
+      populate
+    };
+    module2.exports.configDotenv = DotenvModule.configDotenv;
+    module2.exports._configVault = DotenvModule._configVault;
+    module2.exports._parseVault = DotenvModule._parseVault;
+    module2.exports.config = DotenvModule.config;
+    module2.exports.decrypt = DotenvModule.decrypt;
+    module2.exports.parse = DotenvModule.parse;
+    module2.exports.populate = DotenvModule.populate;
+    module2.exports = DotenvModule;
+  }
+});
+
+// node_modules/dotenv/lib/env-options.js
+var require_env_options = __commonJS({
+  "node_modules/dotenv/lib/env-options.js"(exports2, module2) {
+    var options = {};
+    if (process.env.DOTENV_CONFIG_ENCODING != null) {
+      options.encoding = process.env.DOTENV_CONFIG_ENCODING;
+    }
+    if (process.env.DOTENV_CONFIG_PATH != null) {
+      options.path = process.env.DOTENV_CONFIG_PATH;
+    }
+    if (process.env.DOTENV_CONFIG_QUIET != null) {
+      options.quiet = process.env.DOTENV_CONFIG_QUIET;
+    }
+    if (process.env.DOTENV_CONFIG_DEBUG != null) {
+      options.debug = process.env.DOTENV_CONFIG_DEBUG;
+    }
+    if (process.env.DOTENV_CONFIG_OVERRIDE != null) {
+      options.override = process.env.DOTENV_CONFIG_OVERRIDE;
+    }
+    if (process.env.DOTENV_CONFIG_DOTENV_KEY != null) {
+      options.DOTENV_KEY = process.env.DOTENV_CONFIG_DOTENV_KEY;
+    }
+    module2.exports = options;
+  }
+});
+
+// node_modules/dotenv/lib/cli-options.js
+var require_cli_options = __commonJS({
+  "node_modules/dotenv/lib/cli-options.js"(exports2, module2) {
+    var re = /^dotenv_config_(encoding|path|quiet|debug|override|DOTENV_KEY)=(.+)$/;
+    module2.exports = function optionMatcher(args) {
+      const options = args.reduce(function(acc, cur) {
+        const matches = cur.match(re);
+        if (matches) {
+          acc[matches[1]] = matches[2];
+        }
+        return acc;
+      }, {});
+      if (!("quiet" in options)) {
+        options.quiet = "true";
+      }
+      return options;
+    };
+  }
+});
+
 // node_modules/ajv/dist/compile/codegen/code.js
 var require_code = __commonJS({
   "node_modules/ajv/dist/compile/codegen/code.js"(exports2) {
@@ -2984,7 +3385,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve2.call(this, root, ref);
+      let _sch = resolve.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
@@ -3011,7 +3412,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve2(root, ref) {
+    function resolve(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3229,8 +3630,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path3) {
-      let input = path3;
+    function removeDotSegments(path2) {
+      let input = path2;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3482,8 +3883,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path3, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path3 && path3 !== "/" ? path3 : void 0;
+        const [path2, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path2 && path2 !== "/" ? path2 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -3642,7 +4043,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve2(baseURI, relativeURI, options) {
+    function resolve(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -3900,7 +4301,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve2,
+      resolve,
       resolveComponent,
       equal,
       serialize,
@@ -6876,12 +7277,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs3, exportName) {
+    function addFormats(ajv, list, fs2, exportName) {
       var _a;
       var _b;
       (_a = (_b = ajv.opts.code).formats) !== null && _a !== void 0 ? _a : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs3[f]);
+        ajv.addFormat(f, fs2[f]);
     }
     module2.exports = exports2 = formatsPlugin;
     Object.defineProperty(exports2, "__esModule", { value: true });
@@ -10568,34 +10969,51 @@ var require_websocket_server = __commonJS({
   }
 });
 
-// node_modules/ws/wrapper.mjs
-var wrapper_exports = {};
-__export(wrapper_exports, {
-  PerMessageDeflate: () => import_permessage_deflate.default,
-  Receiver: () => import_receiver.default,
-  Sender: () => import_sender.default,
-  WebSocket: () => import_websocket.default,
-  WebSocketServer: () => import_websocket_server.default,
-  createWebSocketStream: () => import_stream2.default,
-  default: () => wrapper_default,
-  extension: () => import_extension.default,
-  subprotocol: () => import_subprotocol.default
-});
-var import_stream2, import_extension, import_permessage_deflate, import_receiver, import_sender, import_subprotocol, import_websocket, import_websocket_server, wrapper_default;
-var init_wrapper = __esm({
-  "node_modules/ws/wrapper.mjs"() {
-    import_stream2 = __toESM(require_stream(), 1);
-    import_extension = __toESM(require_extension(), 1);
-    import_permessage_deflate = __toESM(require_permessage_deflate(), 1);
-    import_receiver = __toESM(require_receiver(), 1);
-    import_sender = __toESM(require_sender(), 1);
-    import_subprotocol = __toESM(require_subprotocol(), 1);
-    import_websocket = __toESM(require_websocket(), 1);
-    import_websocket_server = __toESM(require_websocket_server(), 1);
-    wrapper_default = import_websocket.default;
+// node_modules/@colbymchenry/codegraph/npm-sdk.js
+var require_npm_sdk = __commonJS({
+  "node_modules/@colbymchenry/codegraph/npm-sdk.js"(exports2, module2) {
+    "use strict";
+    var path2 = require("path");
+    var os2 = require("os");
+    var fs2 = require("fs");
+    var target = process.platform + "-" + process.arch;
+    var pkg = "@colbymchenry/codegraph-" + target;
+    module2.exports = require(resolveLibrary());
+    function resolveLibrary() {
+      try {
+        return require.resolve(pkg + "/lib/dist/index.js");
+      } catch (e) {
+      }
+      var cached2 = cachedLibrary();
+      if (cached2) return cached2;
+      throw new Error(
+        "codegraph: the programmatic API is unavailable because the platform bundle\n(" + pkg + ") is not installed.\nThe compiled library ships inside that per-platform optional dependency.\nFixes:\n  - install from the official npm registry so the matching bundle is fetched:\n      npm i @colbymchenry/codegraph --registry=https://registry.npmjs.org\n  - or run the CLI once (e.g. `npx @colbymchenry/codegraph status`) to\n    self-heal the bundle into ~/.codegraph, then require() will find it."
+      );
+    }
+    function cachedLibrary() {
+      try {
+        var version2 = require(path2.join(__dirname, "package.json")).version;
+        var base = process.env.CODEGRAPH_INSTALL_DIR || path2.join(os2.homedir(), ".codegraph");
+        var lib = path2.join(base, "bundles", target + "-" + version2, "lib", "dist", "index.js");
+        if (fs2.existsSync(lib)) return lib;
+      } catch (e) {
+      }
+      return null;
+    }
   }
 });
 
+// node_modules/dotenv/config.js
+(function() {
+  require_main().config(
+    Object.assign(
+      {},
+      require_env_options(),
+      require_cli_options()(process.argv)
+    )
+  );
+})();
+
 // src/index.ts
 var import_node_http = require("node:http");
 
@@ -11077,8 +11495,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path3, errorMaps, issueData } = params;
-  const fullPath = [...path3, ...issueData.path || []];
+  const { data, path: path2, errorMaps, issueData } = params;
+  const fullPath = [...path2, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -11194,11 +11612,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path3, key) {
+  constructor(parent, value, path2, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path3;
+    this._path = path2;
     this._key = key;
   }
   get path() {
@@ -14835,10 +15253,10 @@ function assignProp(target, prop, value) {
     configurable: true
   });
 }
-function getElementAtPath(obj, path3) {
-  if (!path3)
+function getElementAtPath(obj, path2) {
+  if (!path2)
     return obj;
-  return path3.reduce((acc, key) => acc?.[key], obj);
+  return path2.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -15158,11 +15576,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path3, issues) {
+function prefixIssues(path2, issues) {
   return issues.map((iss) => {
     var _a;
     (_a = iss).path ?? (_a.path = []);
-    iss.path.unshift(path3);
+    iss.path.unshift(path2);
     return iss;
   });
 }
@@ -22692,7 +23110,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -22709,7 +23127,7 @@ var Protocol = class {
    */
   request(request3, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -22787,7 +23205,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve2(parseResult.data);
+            resolve(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -23048,12 +23466,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve2, interval);
+      const timeoutId = setTimeout(resolve, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -24153,7 +24571,7 @@ var McpServer = class {
     let task = createTaskResult.task;
     const pollInterval = task.pollInterval ?? 5e3;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -24802,12 +25220,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve2) => {
+    return new Promise((resolve) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve2();
+        resolve();
       } else {
-        this._stdout.once("drain", resolve2);
+        this._stdout.once("drain", resolve);
       }
     });
   }
@@ -25306,7 +25724,7 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
         });
         if (!chunk) {
           if (i === 1) {
-            await new Promise((resolve2) => setTimeout(resolve2));
+            await new Promise((resolve) => setTimeout(resolve));
             maxReadCount = 3;
             continue;
           }
@@ -25806,9 +26224,9 @@ data:
       const initRequest = messages.find((m) => isInitializeRequest(m));
       const clientProtocolVersion = initRequest ? initRequest.params.protocolVersion : req.headers.get("mcp-protocol-version") ?? DEFAULT_NEGOTIATED_PROTOCOL_VERSION;
       if (this._enableJsonResponse) {
-        return new Promise((resolve2) => {
+        return new Promise((resolve) => {
           this._streamMapping.set(streamId, {
-            resolveJson: resolve2,
+            resolveJson: resolve,
             cleanup: () => {
               this._streamMapping.delete(streamId);
             }
@@ -26141,8 +26559,8 @@ var StreamableHTTPServerTransport = class {
 // src/adapters/okx.ts
 var import_node_crypto = __toESM(require("node:crypto"));
 var BASE = "https://www.okx.com";
-function sign(ts, method, path3, body, secret) {
-  const msg = ts + method + path3 + body;
+function sign(ts, method, path2, body, secret) {
+  const msg = ts + method + path2 + body;
   return import_node_crypto.default.createHmac("sha256", secret).update(msg).digest("base64");
 }
 function timestamp() {
@@ -26155,9 +26573,9 @@ function buildQuery(params) {
   }
   return p.size ? "?" + p.toString() : "";
 }
-async function request(method, path3, options = {}) {
+async function request(method, path2, options = {}) {
   const query = options.params ? buildQuery(options.params) : "";
-  const fullPath = path3 + query;
+  const fullPath = path2 + query;
   const bodyStr = options.body ? JSON.stringify(options.body) : "";
   const headers = {
     "Content-Type": "application/json",
@@ -26546,12 +26964,12 @@ var privateApi = {
 
 // src/adapters/hrails.ts
 var DEFAULT_BASE = "https://api-staging.hwallet.vip";
-async function request2(path3, params = {}, apiKey, base) {
+async function request2(path2, params = {}, apiKey, base) {
   const filtered = Object.entries(params).filter(([, v]) => v !== void 0 && v !== "");
   const p = new URLSearchParams();
   for (const [k, v] of filtered) p.append(k, String(v));
   const query = p.size ? "?" + p.toString() : "";
-  const res = await fetch(base + path3 + query, {
+  const res = await fetch(base + path2 + query, {
     headers: {
       "Accept": "application/json",
       "Authorization": `Bearer ${apiKey}`
@@ -26563,7 +26981,7 @@ async function request2(path3, params = {}, apiKey, base) {
   return json.data ?? json;
 }
 function createHRailsClient(apiKey, baseUrl = DEFAULT_BASE) {
-  const get = (path3, params) => request2(path3, params, apiKey, baseUrl);
+  const get = (path2, params) => request2(path2, params, apiKey, baseUrl);
   return {
     health: () => fetch(baseUrl + "/health").then((r) => r.json()),
     listEvents: (params) => {
@@ -26665,24 +27083,181 @@ function toResult(data) {
   }
   return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
 }
+var OKX_ERROR_MESSAGES = {
+  // 公共 / 系统
+  5e4: "\u7CFB\u7EDF\u5185\u90E8\u9519\u8BEF",
+  50001: "\u7CFB\u7EDF\u7E41\u5FD9\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5",
+  50002: "\u7CFB\u7EDF\u5347\u7EA7\u7EF4\u62A4\u4E2D",
+  50004: "\u8BF7\u6C42\u8D85\u65F6",
+  50005: "\u63A5\u53E3\u5DF2\u88AB\u51BB\u7ED3\uFF0C\u8BF7\u8054\u7CFB\u5BA2\u670D",
+  50006: "OK-ACCESS-KEY \u65E0\u6548",
+  50007: "OK-ACCESS-SIGN \u7B7E\u540D\u9519\u8BEF",
+  50008: "OK-ACCESS-TIMESTAMP \u65F6\u95F4\u6233\u65E0\u6548",
+  50009: "OK-ACCESS-PASSPHRASE \u5BC6\u7801\u77ED\u8BED\u9519\u8BEF",
+  50010: "\u5F53\u524D IP \u4E0D\u5728 API Key \u767D\u540D\u5355\u4E2D",
+  50011: "\u8BF7\u6C42\u9891\u7387\u8FC7\u5FEB\uFF0C\u5DF2\u89E6\u53D1\u9650\u6D41\u3002\u8BF7\u964D\u4F4E\u8BF7\u6C42\u901F\u7387",
+  50012: "\u7CFB\u7EDF\u7E41\u5FD9\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5",
+  50013: "\u7CFB\u7EDF\u9519\u8BEF",
+  50014: "\u53C2\u6570\u6821\u9A8C\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u5FC5\u586B\u5B57\u6BB5\u548C\u683C\u5F0F",
+  50015: "\u4ED3\u4F4D\u5DF2\u88AB\u51BB\u7ED3",
+  50016: "\u8D26\u6237\u5DF2\u88AB\u51BB\u7ED3",
+  50017: "\u8D26\u6237\u5DF2\u88AB\u6682\u505C",
+  50018: "\u8D26\u6237\u7B49\u7EA7\u4E0D\u8DB3",
+  50019: "\u5408\u7EA6\u5DF2\u5230\u671F",
+  50020: "\u4F59\u989D\u4E0D\u8DB3",
+  50021: "\u4FDD\u8BC1\u91D1\u4E0D\u8DB3",
+  50022: "\u4E0B\u5355\u6570\u91CF\u5C0F\u4E8E\u6700\u5C0F\u9650\u5236",
+  50023: "\u4E0B\u5355\u6570\u91CF\u8D85\u8FC7\u6700\u5927\u9650\u5236",
+  50024: "\u6301\u4ED3\u6570\u91CF\u5DF2\u8FBE\u4E0A\u9650",
+  50025: "\u6302\u5355\u6570\u91CF\u5DF2\u8FBE\u4E0A\u9650",
+  50026: "\u4E0B\u5355\u4EF7\u683C\u8D85\u51FA\u9650\u4EF7\u8303\u56F4",
+  50027: "\u4EF7\u683C\u7CBE\u5EA6\u4E0D\u7B26\u5408\u8981\u6C42",
+  50028: "\u6570\u91CF\u7CBE\u5EA6\u4E0D\u7B26\u5408\u8981\u6C42",
+  50029: "\u8BE5\u5408\u7EA6\u6682\u4E0D\u53EF\u7528",
+  50030: "API Key \u65E0\u6B64\u64CD\u4F5C\u6743\u9650",
+  50031: "API Key \u5DF2\u8FC7\u671F",
+  50032: "API Key \u672A\u627E\u5230",
+  50033: "API Key \u672A\u6FC0\u6D3B",
+  50035: "\u89E6\u53D1\u98CE\u63A7\u89C4\u5219\uFF0C\u4EA4\u6613\u88AB\u62D2\u7EDD",
+  50036: "\u65E0\u4EA4\u6613\u6743\u9650",
+  50044: "\u8BA2\u5355\u4E0D\u5B58\u5728",
+  50045: "\u8BE5\u8BA2\u5355\u4E0D\u53EF\u64A4\u9500",
+  50046: "\u8BA2\u5355\u5DF2\u5168\u90E8\u6210\u4EA4",
+  50047: "\u8BA2\u5355\u5DF2\u88AB\u64A4\u9500",
+  50050: "\u6301\u4ED3\u4E0D\u5B58\u5728",
+  50051: "\u4ED3\u4F4D\u5DF2\u5E73\u4ED3",
+  50053: "\u4ED3\u4F4D\u4FDD\u8BC1\u91D1\u4E0D\u8DB3",
+  50056: "\u4E0B\u5355\u8FC7\u4E8E\u9891\u7E41",
+  50058: "\u8BE5\u5E01\u79CD\u6682\u4E0D\u652F\u6301",
+  50059: "\u53C2\u6570\u89E3\u6790\u5931\u8D25",
+  50060: "\u8D26\u6237\u6A21\u5F0F\u4E0D\u652F\u6301\u6B64\u64CD\u4F5C",
+  50061: "\u5B50\u8D26\u6237\u8BF7\u6C42\u9891\u7387\u8D85\u9650",
+  50064: "\u8BE5\u5408\u7EA6\u4E0D\u652F\u6301\u6B64\u64CD\u4F5C",
+  50068: "\u7CFB\u7EDF\u5347\u7EA7\u4E2D\uFF0C\u6682\u4E0D\u53EF\u7528",
+  50070: "\u6301\u4ED3\u6A21\u5F0F\u4E0D\u5339\u914D",
+  50071: "\u4FDD\u8BC1\u91D1\u6A21\u5F0F\u4E0D\u5339\u914D",
+  50072: "\u6760\u6746\u500D\u6570\u8D85\u51FA\u5141\u8BB8\u8303\u56F4",
+  50074: "\u89E6\u53D1\u4EF7\u683C\u65E0\u6548",
+  50080: "\u4E0B\u5355\u4EF7\u683C\u504F\u79BB\u5E02\u573A\u4EF7\u8FC7\u5927",
+  50082: "\u8D26\u6237\u6743\u76CA\u4E0D\u8DB3",
+  // API Key 相关
+  50100: "API Key \u5DF2\u88AB\u51BB\u7ED3",
+  50101: "API Key \u5DF2\u8FC7\u671F",
+  50102: "\u8BF7\u6C42\u65F6\u95F4\u6233\u4E0E\u670D\u52A1\u5668\u65F6\u95F4\u504F\u5DEE\u8D85\u8FC7 30 \u79D2",
+  50103: "\u8BF7\u6C42\u5934 OK-ACCESS-KEY \u4E0D\u80FD\u4E3A\u7A7A",
+  50104: "\u8BF7\u6C42\u5934 OK-ACCESS-SIGN \u7B7E\u540D\u4E0D\u80FD\u4E3A\u7A7A",
+  50105: "\u8BF7\u6C42\u5934 OK-ACCESS-TIMESTAMP \u4E0D\u80FD\u4E3A\u7A7A",
+  50106: "\u8BF7\u6C42\u5934 OK-ACCESS-PASSPHRASE \u4E0D\u80FD\u4E3A\u7A7A",
+  50107: "API Key \u5BF9\u5E94\u7684\u8D26\u6237\u4E0D\u5B58\u5728",
+  50108: "\u8D26\u6237\u4F59\u989D\u4E0D\u8DB3",
+  50109: "\u5212\u8F6C\u91D1\u989D\u8D85\u8FC7\u9650\u989D",
+  50110: "\u5212\u8F6C\u5E01\u79CD\u4E0D\u652F\u6301",
+  50111: "\u5212\u8F6C\u5931\u8D25",
+  50120: "API Key \u6743\u9650\u4E0D\u8DB3\uFF0C\u8BF7\u68C0\u67E5\u662F\u5426\u5F00\u901A\u4E86\u6240\u9700\u6743\u9650\uFF08\u8BFB\u53D6/\u4EA4\u6613/\u63D0\u73B0\uFF09",
+  50121: "API Key \u5DF2\u8FC7\u671F",
+  50122: "API Key \u672A\u627E\u5230",
+  50123: "API Key \u672A\u6FC0\u6D3B",
+  50124: "API Key \u5DF2\u88AB\u5220\u9664",
+  50125: "API Key \u5DF2\u88AB\u51BB\u7ED3",
+  50126: "API Key \u5DF2\u88AB\u7981\u7528",
+  // 交易
+  51e3: "\u53C2\u6570\u9519\u8BEF\uFF0C\u8BF7\u68C0\u67E5\u5FC5\u586B\u53C2\u6570",
+  51001: "\u8BA2\u5355\u7C7B\u578B\u4E0D\u652F\u6301",
+  51002: "\u8BA2\u5355\u65B9\u5411\u4E0D\u652F\u6301",
+  51003: "\u8BA2\u5355\u6570\u91CF\u4E0D\u80FD\u4E3A 0 \u6216\u8D1F\u6570",
+  51004: "\u8BA2\u5355\u4EF7\u683C\u4E0D\u80FD\u4E3A 0 \u6216\u8D1F\u6570",
+  51005: "\u4FDD\u8BC1\u91D1\u6A21\u5F0F\u4E0D\u652F\u6301",
+  51006: "\u8BA2\u5355\u4EF7\u683C\u8D85\u51FA\u9650\u4EF7\u8303\u56F4",
+  51007: "\u8BA2\u5355\u6570\u91CF\u7CBE\u5EA6\u4E0D\u7B26\u5408\u8981\u6C42",
+  51008: "\u8BA2\u5355\u4EF7\u683C\u7CBE\u5EA6\u4E0D\u7B26\u5408\u8981\u6C42",
+  51009: "\u8BA2\u5355\u6570\u91CF\u8D85\u51FA\u6700\u5927\u9650\u5236",
+  51010: "\u8BA2\u5355\u6570\u91CF\u4F4E\u4E8E\u6700\u5C0F\u9650\u5236",
+  51011: "\u8BE5\u4EA7\u54C1\u4E0D\u652F\u6301\u6B64\u8BA2\u5355\u7C7B\u578B",
+  51012: "\u8BE5\u4EA7\u54C1\u4E0D\u652F\u6301\u6B64\u4FDD\u8BC1\u91D1\u6A21\u5F0F",
+  51013: "\u8BE5\u4EA7\u54C1\u4E0D\u652F\u6301\u6B64\u6301\u4ED3\u6A21\u5F0F",
+  51014: "\u5F53\u524D\u6301\u4ED3\u6A21\u5F0F\u4E0D\u5141\u8BB8\u6B64\u64CD\u4F5C",
+  51015: "\u5F53\u524D\u8D26\u6237\u6A21\u5F0F\u4E0D\u5141\u8BB8\u6B64\u64CD\u4F5C",
+  51020: "\u6279\u91CF\u4E0B\u5355\u6570\u91CF\u8D85\u8FC7\u4E0A\u9650",
+  51021: "\u6279\u91CF\u64CD\u4F5C\u4E2D\u5305\u542B\u91CD\u590D\u8BA2\u5355",
+  51026: "\u8BA2\u5355\u4EF7\u683C\u8D85\u51FA\u6ED1\u70B9\u4FDD\u62A4\u8303\u56F4",
+  51027: "\u8BA2\u5355\u5DF2\u8FC7\u671F",
+  51100: "\u8BE5\u4EA7\u54C1\u4E0D\u5728\u53EF\u4EA4\u6613\u5217\u8868",
+  51102: "\u6301\u4ED3\u6A21\u5F0F\u4E0D\u5339\u914D\uFF0C\u65E0\u6CD5\u5E73\u4ED3",
+  51103: "\u4FDD\u8BC1\u91D1\u6A21\u5F0F\u4E0D\u5339\u914D\uFF0C\u65E0\u6CD5\u5E73\u4ED3",
+  51104: "\u6760\u6746\u500D\u6570\u4E0D\u5339\u914D",
+  51107: "\u5E02\u4EF7\u5355\u5F53\u524D\u4E0D\u53EF\u7528",
+  51108: "\u6B62\u635F\u5355\u5F53\u524D\u4E0D\u53EF\u7528",
+  // 资金
+  52e3: "\u5212\u8F6C\u5931\u8D25",
+  52001: "\u63D0\u73B0\u91D1\u989D\u8D85\u8FC7\u9650\u989D",
+  52002: "\u63D0\u73B0\u5730\u5740\u65E0\u6548",
+  52003: "\u63D0\u73B0\u94FE\u4E0D\u652F\u6301",
+  52004: "\u63D0\u73B0\u7F51\u7EDC\u8D39\u4E0D\u8DB3",
+  52005: "\u63D0\u73B0\u5DF2\u51BB\u7ED3",
+  52006: "\u5145\u503C\u5730\u5740\u751F\u6210\u5931\u8D25",
+  52007: "\u8BE5\u5E01\u79CD\u4E0D\u652F\u6301\u5145\u503C",
+  52008: "\u8BE5\u5E01\u79CD\u4E0D\u652F\u6301\u63D0\u73B0",
+  // 跟单交易
+  52100: "\u4EA4\u6613\u5458\u4E0D\u5B58\u5728",
+  52101: "\u4EA4\u6613\u5458\u4E0D\u5BF9\u5916\u516C\u5F00",
+  52102: "\u8DDF\u5355\u91D1\u989D\u8D85\u51FA\u9650\u5236",
+  52103: "\u8DDF\u5355\u4EBA\u6570\u5DF2\u8FBE\u4E0A\u9650",
+  52104: "\u5F53\u524D\u4E0D\u652F\u6301\u8DDF\u5355\u8BE5\u4EA4\u6613\u5458",
+  52105: "\u8BE5\u4EA4\u6613\u5458\u5DF2\u505C\u6B62\u5E26\u5355",
+  // 策略 / 网格
+  53e3: "\u7B56\u7565\u59D4\u6258\u521B\u5EFA\u5931\u8D25",
+  53001: "\u7B56\u7565\u59D4\u6258\u4FEE\u6539\u5931\u8D25",
+  53002: "\u7B56\u7565\u59D4\u6258\u64A4\u9500\u5931\u8D25",
+  53003: "\u7B56\u7565\u59D4\u6258\u4E0D\u5B58\u5728",
+  53004: "\u7B56\u7565\u59D4\u6258\u5DF2\u89E6\u53D1",
+  53005: "\u7F51\u683C\u7B56\u7565\u521B\u5EFA\u5931\u8D25",
+  53006: "\u7F51\u683C\u7B56\u7565\u4E0D\u5B58\u5728",
+  53007: "\u7F51\u683C\u7B56\u7565\u5DF2\u505C\u6B62",
+  53008: "\u7F51\u683C\u53C2\u6570\u65E0\u6548",
+  // WebSocket
+  60001: "\u8BA2\u9605\u9891\u9053\u4E0D\u5B58\u5728\u6216\u53C2\u6570\u9519\u8BEF",
+  60002: "WebSocket \u767B\u5F55\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5 API Key",
+  60003: "WebSocket \u8BA2\u9605\u53C2\u6570\u65E0\u6548",
+  60004: "WebSocket \u8BF7\u6C42\u9891\u7387\u8FC7\u9AD8",
+  60005: "WebSocket \u8FDE\u63A5\u6570\u5DF2\u8FBE\u4E0A\u9650",
+  60006: "WebSocket \u8FDE\u63A5\u88AB\u670D\u52A1\u7AEF\u5173\u95ED",
+  60007: "WebSocket \u8BE5\u9891\u9053\u9700\u8981\u767B\u5F55",
+  60008: "WebSocket \u8BE5\u9891\u9053\u4E0D\u9700\u8981\u767B\u5F55",
+  60009: "WebSocket \u767B\u5F55\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55",
+  64008: "\u670D\u52A1\u5347\u7EA7\u4E2D\uFF0C\u8FDE\u63A5\u5373\u5C06\u5173\u95ED\uFF0C\u8BF7\u91CD\u8FDE"
+};
+function translateError(code, rawMsg) {
+  const translated = OKX_ERROR_MESSAGES[code];
+  if (translated) return translated;
+  if (code >= 5e4 && code < 50100) return `\u7CFB\u7EDF/\u8BA4\u8BC1\u9519\u8BEF (${code}): ${rawMsg}`;
+  if (code >= 50100 && code < 50200) return `API Key \u9519\u8BEF (${code}): ${rawMsg}`;
+  if (code >= 51e3 && code < 51200) return `\u4EA4\u6613\u53C2\u6570\u9519\u8BEF (${code}): ${rawMsg}`;
+  if (code >= 52e3 && code < 52200) return `\u8D44\u91D1/\u8DDF\u5355\u9519\u8BEF (${code}): ${rawMsg}`;
+  if (code >= 53e3 && code < 54e3) return `\u7B56\u7565\u59D4\u6258\u9519\u8BEF (${code}): ${rawMsg}`;
+  if (code >= 6e4 && code < 65e3) return `WebSocket \u9519\u8BEF (${code}): ${rawMsg}`;
+  return rawMsg;
+}
 function classifyError(msg) {
   const okxMatch = msg.match(/OKX (\d+):/);
   if (okxMatch && okxMatch[1]) {
     const code = parseInt(okxMatch[1]);
-    if (code >= 5e4 && code < 50100) return { errorCode: `OKX_${code}`, errorCategory: "AUTH" };
-    if (code >= 51e3) return { errorCode: `OKX_${code}`, errorCategory: "BUSINESS" };
-    if (code >= 50004 && code <= 50014) return { errorCode: `OKX_${code}`, errorCategory: "VALIDATION" };
-    return { errorCode: `OKX_${code}`, errorCategory: "BUSINESS" };
+    const rawMsg = msg.replace(/^OKX \d+: /, "");
+    const translated = translateError(code, rawMsg);
+    if (code >= 5e4 && code < 50100) return { errorCode: `OKX_${code}`, errorCategory: "AUTH", errorMessage: translated };
+    if (code === 50100 || code === 50101 || code === 50120) return { errorCode: `OKX_${code}`, errorCategory: "AUTH", errorMessage: translated };
+    if (code >= 50004 && code <= 50014) return { errorCode: `OKX_${code}`, errorCategory: "VALIDATION", errorMessage: translated };
+    if (code >= 51e3 && code < 51200) return { errorCode: `OKX_${code}`, errorCategory: "VALIDATION", errorMessage: translated };
+    return { errorCode: `OKX_${code}`, errorCategory: "BUSINESS", errorMessage: translated };
   }
   if (msg.startsWith("HTTP ")) {
     const httpMatch = msg.match(/HTTP (\d+)/);
     const status = httpMatch && httpMatch[1] ? parseInt(httpMatch[1]) : 0;
-    if (status === 401 || status === 403) return { errorCode: "HTTP_401", errorCategory: "AUTH" };
-    if (status === 429) return { errorCode: "HTTP_429", errorCategory: "RATE_LIMIT" };
-    return { errorCode: "NETWORK_ERROR", errorCategory: "NETWORK" };
+    if (status === 401 || status === 403) return { errorCode: "HTTP_401", errorCategory: "AUTH", errorMessage: "API Key \u8BA4\u8BC1\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u5BC6\u94A5\u662F\u5426\u6B63\u786E\u914D\u7F6E" };
+    if (status === 429) return { errorCode: "HTTP_429", errorCategory: "RATE_LIMIT", errorMessage: "\u8BF7\u6C42\u8FC7\u4E8E\u9891\u7E41\uFF0C\u5DF2\u89E6\u53D1\u9650\u6D41\u3002\u8BF7\u7A0D\u7B49\u540E\u91CD\u8BD5" };
+    return { errorCode: "NETWORK_ERROR", errorCategory: "NETWORK", errorMessage: `\u7F51\u7EDC\u9519\u8BEF HTTP ${status}` };
   }
-  if (msg.includes("API Key")) return { errorCode: "AUTH_REQUIRED", errorCategory: "AUTH" };
-  return { errorCode: "UNKNOWN_ERROR", errorCategory: "BUSINESS" };
+  if (msg.includes("API Key")) return { errorCode: "AUTH_REQUIRED", errorCategory: "AUTH", errorMessage: msg };
+  return { errorCode: "UNKNOWN_ERROR", errorCategory: "BUSINESS", errorMessage: msg };
 }
 function classifyRisk(toolName) {
   const admin = ["okx_set_account_mode", "okx_set_position_mode", "okx_set_settle_currency"];
@@ -26737,12 +27312,13 @@ function classifyRisk(toolName) {
 }
 function toError(e) {
   const msg = e instanceof Error ? e.message : String(e);
-  const { errorCode, errorCategory } = classifyError(msg);
+  const { errorCode, errorCategory, errorMessage } = classifyError(msg);
   return {
-    content: [{ type: "text", text: msg }],
+    content: [{ type: "text", text: errorMessage }],
     isError: true,
     errorCode,
-    errorCategory
+    errorCategory,
+    errorMessage
   };
 }
 
@@ -33757,12 +34333,13 @@ function registerAgentUtils(server, auth) {
       },
       {
         domain: "WebSocket \u5B9E\u65F6",
-        what: "\u5B9E\u65F6\u884C\u60C5\u63A8\u9001\u3001\u6210\u4EA4\u63A8\u9001",
-        when: ["\u5B9E\u65F6", "\u8BA2\u9605", "\u63A8\u9001", "websocket", "ws", "\u76D1\u542C"],
+        what: "\u5B9E\u65F6\u884C\u60C5\u3001\u8D26\u6237\u3001\u8BA2\u5355\u3001\u7206\u4ED3\u3001\u4EF7\u5DEE\u3001\u5927\u5B97\u63A8\u9001\uFF0855 \u9891\u9053\uFF09",
+        when: ["\u5B9E\u65F6", "\u8BA2\u9605", "\u63A8\u9001", "websocket", "ws", "\u76D1\u542C", "\u7206\u4ED3", "\u5B9E\u65F6\u8BA2\u5355"],
         go_to: "okx_ws_subscribe",
         also: [
-          "okx_ws_events \u2014 \u83B7\u53D6\u63A8\u9001\u4E8B\u4EF6",
-          "okx_ws_status \u2014 \u8BA2\u9605\u72B6\u6001",
+          "okx_ws_subscribe_private \u2014 \u79C1\u6709\u9891\u9053\uFF08\u8D26\u6237/\u6301\u4ED3/\u8BA2\u5355\uFF0C\u9700Key\uFF09",
+          "okx_ws_events \u2014 \u62C9\u53D6\u7F13\u51B2\u4E8B\u4EF6",
+          "okx_ws_status \u2014 \u67E5\u770B\u8BA2\u9605\u72B6\u6001",
           "okx_ws_close \u2014 \u5173\u95ED\u8BA2\u9605"
         ],
         risk: "READ"
@@ -33854,7 +34431,8 @@ function registerAgentUtils(server, auth) {
           "agent_get_preference": "key? (\u4E0D\u586B\u8FD4\u56DE\u5168\u90E8)",
           "agent_set_preference": "key, value",
           "okx_event_instruments": "eventType? (\u4E0D\u586B\u8FD4\u56DE\u5168\u90E8)",
-          "okx_ws_subscribe": "channels (JSON\u6570\u7EC4)",
+          "okx_ws_subscribe": "instId (\u4EA7\u54C1ID), channel (33\u4E2A\u516C\u5F00\u9891\u9053)",
+          "okx_ws_subscribe_private": "instId? (\u4EA7\u54C1ID), channel (22\u4E2A\u79C1\u6709\u9891\u9053\uFF0C\u9700Key)",
           "okx_get_grid_ai_param": "instType, algoOrdType"
         };
         const enrichedDomains = CATALOG.domains.map((d) => ({
@@ -34055,12 +34633,13 @@ function registerAgentUtils(server, auth) {
       ]
     },
     "WebSocket \u5B9E\u65F6": {
-      workflow: "okx_ws_subscribe \u8BA2\u9605\u9891\u9053 \u2192 okx_ws_events \u62C9\u53D6\u4E8B\u4EF6",
+      workflow: "okx_ws_subscribe \u516C\u5F00\u9891\u9053 \u2192 okx_ws_subscribe_private \u79C1\u6709\u9891\u9053\uFF08\u9700Key\uFF09\u2192 okx_ws_events \u62C9\u53D6 \u2192 okx_ws_status \u7BA1\u7406",
       tools: [
-        { name: "okx_ws_subscribe", auth: "\u516C\u5F00", params: "channels[]", what: "\u8BA2\u9605\u5B9E\u65F6\u9891\u9053\uFF08tickers/trades/books/candles/fundingRate \u7B49\uFF09" },
-        { name: "okx_ws_events", auth: "\u516C\u5F00", params: "channel?", what: "\u6536\u53D6\u8BA2\u9605\u7684\u5B9E\u65F6\u63A8\u9001\u4E8B\u4EF6" },
-        { name: "okx_ws_status", auth: "\u516C\u5F00", params: "\u65E0", what: "\u5F53\u524D\u8BA2\u9605\u72B6\u6001" },
-        { name: "okx_ws_close", auth: "\u516C\u5F00", params: "channel?", what: "\u53D6\u6D88\u8BA2\u9605" }
+        { name: "okx_ws_subscribe", auth: "\u516C\u5F00", params: "instId, channel (33\u516C\u5F00\u9891\u9053)", what: "\u8BA2\u9605\u516C\u5F00\u9891\u9053\uFF1A\u884C\u60C5/\u6DF1\u5EA6/\u7206\u4ED3/\u4EF7\u5DEE/\u5927\u5B97/\u8D44\u91D1\u8D39\u7387\u7B49" },
+        { name: "okx_ws_subscribe_private", auth: "API Key", params: "instId?, channel (22\u79C1\u6709\u9891\u9053)", what: "\u8BA2\u9605\u79C1\u6709\u9891\u9053\uFF1A\u8D26\u6237/\u6301\u4ED3/\u8BA2\u5355/\u7F51\u683C/\u8DDF\u5355\u7B49\u5B9E\u65F6\u63A8\u9001" },
+        { name: "okx_ws_events", auth: "\u516C\u5F00", params: "subscriptionId?, limit?, filter?", what: "\u62C9\u53D6\u7F13\u51B2\u7684\u5B9E\u65F6\u4E8B\u4EF6" },
+        { name: "okx_ws_status", auth: "\u516C\u5F00", params: "\u65E0", what: "\u5F53\u524D\u6240\u6709\u8BA2\u9605+\u7F13\u51B2\u79EF\u538B" },
+        { name: "okx_ws_close", auth: "\u516C\u5F00", params: "subscriptionId?", what: "\u5173\u95ED\u8BA2\u9605" }
       ]
     },
     "\u6A21\u62DF\u4F30\u7B97": {
@@ -35009,8 +35588,18 @@ function registerSmartMoneyTools(server, auth) {
   );
 }
 
+// node_modules/ws/wrapper.mjs
+var import_stream2 = __toESM(require_stream(), 1);
+var import_extension = __toESM(require_extension(), 1);
+var import_permessage_deflate = __toESM(require_permessage_deflate(), 1);
+var import_receiver = __toESM(require_receiver(), 1);
+var import_sender = __toESM(require_sender(), 1);
+var import_subprotocol = __toESM(require_subprotocol(), 1);
+var import_websocket = __toESM(require_websocket(), 1);
+var import_websocket_server = __toESM(require_websocket_server(), 1);
+var wrapper_default = import_websocket.default;
+
 // src/adapters/xlayer-ws.ts
-init_wrapper();
 var WS_URL = process.env.XLAYER_WS_URL || "wss://xlayerws.okx.com";
 var MAX_EVENTS = 500;
 var XLayerWSManager = class {
@@ -35024,7 +35613,7 @@ var XLayerWSManager = class {
   async connect() {
     if (this.ws?.readyState === wrapper_default.OPEN) return;
     if (this.connectPromise) return this.connectPromise;
-    this.connectPromise = new Promise((resolve2, reject) => {
+    this.connectPromise = new Promise((resolve, reject) => {
       const ws = new wrapper_default(WS_URL);
       ws.on("open", () => {
         this.ws = ws;
@@ -35032,7 +35621,7 @@ var XLayerWSManager = class {
         this.pingTimer = setInterval(() => {
           if (ws.readyState === wrapper_default.OPEN) ws.ping();
         }, 3e4);
-        resolve2();
+        resolve();
       });
       ws.on("message", (raw) => {
         try {
@@ -35085,12 +35674,12 @@ var XLayerWSManager = class {
     await this.connect();
     const ws = this.ws;
     const id = ++this.idCounter;
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`RPC \u8C03\u7528\u8D85\u65F6: ${method}`));
       }, 3e4);
-      this.pending.set(id, { resolve: resolve2, reject, timer });
+      this.pending.set(id, { resolve, reject, timer });
       ws.send(JSON.stringify({ jsonrpc: "2.0", id, method, params }));
     });
   }
@@ -35280,25 +35869,47 @@ var subCounter = 0;
 var WsManager = class {
   subscriptions = /* @__PURE__ */ new Map();
   events = [];
-  ws = null;
-  pingTimer = null;
-  channelArgs = /* @__PURE__ */ new Map();
-  // channel -> instIds
+  wsPub = null;
+  wsPriv = null;
+  pingPub = null;
+  pingPriv = null;
+  // Fix #1: 按 type 拆分 channelArgs，重连时只遍历同类型
+  channelArgsPub = /* @__PURE__ */ new Map();
+  channelArgsPriv = /* @__PURE__ */ new Map();
+  getWs(type) {
+    return type === "public" ? this.wsPub : this.wsPriv;
+  }
+  setWs(type, ws) {
+    if (type === "public") this.wsPub = ws;
+    else this.wsPriv = ws;
+  }
+  getPing(type) {
+    return type === "public" ? this.pingPub : this.pingPriv;
+  }
+  setPing(type, timer) {
+    if (type === "public") this.pingPub = timer;
+    else this.pingPriv = timer;
+  }
+  getChannelArgs(type) {
+    return type === "public" ? this.channelArgsPub : this.channelArgsPriv;
+  }
   async subscribe(opts) {
-    const wsModule = await Promise.resolve().then(() => (init_wrapper(), wrapper_exports));
     const id = `sub_${++subCounter}`;
-    this.subscriptions.set(id, { id, channel: opts.channel, instId: opts.instId });
+    const type = opts.type || "public";
+    this.subscriptions.set(id, { id, channel: opts.channel, instId: opts.instId, type });
     const arg = { channel: opts.channel, instId: opts.instId };
-    if (!this.ws || this.ws.readyState !== wsModule.WebSocket.OPEN) {
-      const url = opts.type === "private" ? WS_PRIVATE : WS_PUBLIC;
-      await this.connect(wsModule, url, opts.auth);
-    }
-    if (this.ws?.readyState === wsModule.WebSocket.OPEN) {
-      this.ws.send(JSON.stringify({ op: "subscribe", args: [arg] }));
-    }
-    const ck = opts.channel;
-    if (!this.channelArgs.has(ck)) this.channelArgs.set(ck, /* @__PURE__ */ new Set());
-    this.channelArgs.get(ck).add(opts.instId);
+    const currentWs = this.getWs(type);
+    if (!currentWs || currentWs.readyState !== wrapper_default.OPEN) {
+      const url = type === "private" ? WS_PRIVATE : WS_PUBLIC;
+      await this.connect(url, opts.auth, type);
+    }
+    const targetWs = this.getWs(type);
+    if (targetWs?.readyState === wrapper_default.OPEN) {
+      targetWs.send(JSON.stringify({ op: "subscribe", args: [arg] }));
+    }
+    const chanArgs = this.getChannelArgs(type);
+    if (!chanArgs.has(opts.channel)) chanArgs.set(opts.channel, /* @__PURE__ */ new Set());
+    chanArgs.get(opts.channel).add(opts.instId);
     return id;
   }
   drain(subId, limit = 20) {
@@ -35329,37 +35940,60 @@ var WsManager = class {
   }
   close(subId) {
     if (subId) {
+      const sub = this.subscriptions.get(subId);
+      if (sub) {
+        const chanArgs = this.getChannelArgs(sub.type);
+        const instIds = chanArgs.get(sub.channel);
+        if (instIds) {
+          instIds.delete(sub.instId);
+          if (instIds.size === 0) chanArgs.delete(sub.channel);
+        }
+        const ws = this.getWs(sub.type);
+        if (ws?.readyState === wrapper_default.OPEN) {
+          try {
+            ws.send(JSON.stringify({ op: "unsubscribe", args: [{ channel: sub.channel, instId: sub.instId }] }));
+          } catch {
+          }
+        }
+      }
       this.subscriptions.delete(subId);
       this.events = this.events.filter((e) => e.subId !== subId);
       return 1;
     }
     const count = this.subscriptions.size;
     this.subscriptions.clear();
+    this.channelArgsPub.clear();
+    this.channelArgsPriv.clear();
     this.events = [];
-    if (this.ws) {
-      try {
-        this.ws.close();
-      } catch {
+    for (const ws of [this.wsPub, this.wsPriv]) {
+      if (ws) {
+        try {
+          ws.close();
+        } catch {
+        }
       }
-      ;
-      this.ws = null;
     }
-    if (this.pingTimer) {
-      clearInterval(this.pingTimer);
-      this.pingTimer = null;
+    this.wsPub = null;
+    this.wsPriv = null;
+    for (const t of [this.pingPub, this.pingPriv]) {
+      if (t) {
+        clearInterval(t);
+      }
     }
+    this.pingPub = null;
+    this.pingPriv = null;
     return count;
   }
-  connect(wsModule, url, auth) {
-    return new Promise((resolve2, reject) => {
-      const ws = new wsModule.WebSocket(url);
+  connect(url, auth, type) {
+    return new Promise((resolve, reject) => {
+      const ws = new wrapper_default(url);
       const timeout = setTimeout(() => {
         ws.close();
         reject(new Error("WS \u8FDE\u63A5\u8D85\u65F6(10s)"));
       }, 1e4);
       ws.on("open", () => {
         clearTimeout(timeout);
-        if (auth && url.includes("private")) {
+        if (auth && type === "private") {
           const ts = Math.floor(Date.now() / 1e3).toString();
           const sign2 = import_node_crypto2.default.createHmac("sha256", auth.secret).update(ts + "GET/users/self/verify").digest("base64");
           ws.send(JSON.stringify({
@@ -35367,22 +36001,40 @@ var WsManager = class {
             args: [{ apiKey: auth.apiKey, passphrase: auth.passphrase, timestamp: ts, sign: sign2 }]
           }));
         }
-        for (const [channel, instIds] of this.channelArgs) {
+        const chanArgs = this.getChannelArgs(type);
+        for (const [channel, instIds] of chanArgs) {
           for (const instId of instIds) {
             ws.send(JSON.stringify({ op: "subscribe", args: [{ channel, instId }] }));
           }
         }
-        this.pingTimer = setInterval(() => {
-          if (ws.readyState === wsModule.WebSocket.OPEN) ws.send("ping");
+        const timer = setInterval(() => {
+          if (ws.readyState === wrapper_default.OPEN) ws.send("ping");
         }, 25e3);
-        this.ws = ws;
-        resolve2();
+        this.setPing(type, timer);
+        this.setWs(type, ws);
+        resolve();
       });
       ws.on("message", (raw) => {
         try {
           const msg = raw.toString();
           if (msg === "pong") return;
           const parsed = JSON.parse(msg);
+          if (parsed.event === "error" && parsed.code) {
+            this.events.push({
+              subId: "__error__",
+              channel: parsed.arg?.channel || "unknown",
+              instId: parsed.arg?.instId || "",
+              ts: Date.now(),
+              data: {
+                error: true,
+                code: parsed.code,
+                message: parsed.msg || "WebSocket \u9519\u8BEF",
+                hint: parsed.code === "60001" ? "\u9891\u9053\u540D\u4E0D\u652F\u6301\u6216\u53C2\u6570\u9519\u8BEF\uFF0C\u8BF7\u68C0\u67E5 channel \u503C" : parsed.code === "60003" ? "\u767B\u5F55\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u8FDE" : parsed.code === "60009" ? "\u79C1\u6709\u9891\u9053\u9700\u8981\u5148 login\uFF08API Key \u7B7E\u540D\uFF09" : `OKX WS \u9519\u8BEF ${parsed.code}`
+              }
+            });
+            if (this.events.length > 1e4) this.events = this.events.slice(-5e3);
+            return;
+          }
           if (parsed.arg && parsed.data) {
             for (const [id, sub] of this.subscriptions) {
               if (sub.channel === parsed.arg.channel && sub.instId === parsed.arg.instId) {
@@ -35406,11 +36058,12 @@ var WsManager = class {
         reject(err);
       });
       ws.on("close", () => {
-        if (this.pingTimer) {
-          clearInterval(this.pingTimer);
-          this.pingTimer = null;
+        const t = this.getPing(type);
+        if (t) {
+          clearInterval(t);
+          this.setPing(type, null);
         }
-        this.ws = null;
+        this.setWs(type, null);
       });
     });
   }
@@ -35422,36 +36075,103 @@ function getOrCreateWs() {
   if (!wsManager) wsManager = new WsManager();
   return wsManager;
 }
-var PUBLIC_CHANNELS = [
-  "tickers",
-  "trades",
-  "candle1m",
-  "candle5m",
-  "candle15m",
-  "candle1H",
-  "candle4H",
-  "candle1D",
-  "books5",
-  "books",
-  "mark-price",
-  "funding-rate",
-  "open-interest",
-  "price-limit",
-  "index-tickers"
-];
-function registerWsTools(server) {
+var ALL_CHANNELS = {
+  public: [
+    // 行情类（10）
+    "tickers",
+    "trades",
+    "all-trades",
+    "option-trades",
+    "candle1m",
+    "candle5m",
+    "candle15m",
+    "candle1H",
+    "candle4H",
+    "candle1D",
+    // 深度类（2）
+    "books5",
+    "books",
+    // 市场细节（1）
+    "call-auction-details",
+    // 公共数据（10）
+    "mark-price",
+    "mark-price-candles",
+    "index-tickers",
+    "index-candles",
+    "funding-rate",
+    "open-interest",
+    "price-limit",
+    "instruments",
+    "option-summary",
+    "estimated-price",
+    // 风险预警（3）
+    "liquidation-orders",
+    "adl-warning",
+    "status",
+    // 事件合约（1）
+    "event-contract-markets",
+    // 经济日历（1）
+    "economic-calendar",
+    // 价差公开（4）
+    "sprd/tickers",
+    "sprd/candles",
+    "sprd/order-book",
+    "sprd/public-trades",
+    // 大宗公开（3）
+    "public-structure-block-trades",
+    "public-block-trades",
+    "block-tickers"
+  ],
+  private: [
+    // 账户（5）
+    "account",
+    "positions",
+    "balance_and_position",
+    "position-risk-warning",
+    "account-greeks",
+    // 交易（4）
+    "orders",
+    "fills",
+    "algo-orders",
+    "advance-algo-orders",
+    // 网格（4）
+    "spot-grid-algo-orders",
+    "contract-grid-algo-orders",
+    "grid-positions",
+    "grid-sub-orders",
+    // 定投（1）
+    "recurring-buy-orders",
+    // 跟单（1）
+    "lead-trading-notification",
+    // 资金（2）
+    "deposit-info",
+    "withdrawal-info",
+    // 大宗私有（3）
+    "rfqs",
+    "quotes",
+    "structure-block-trades",
+    // 价差私有（2）
+    "sprd/orders",
+    "sprd/trades"
+  ]
+};
+function registerWsTools(server, auth) {
   server.tool(
     "okx_ws_subscribe",
-    "CAT:[\u884C\u60C5-WS] | ## \u529F\u80FD\uFF1A\u8BA2\u9605OKX WebSocket\u5B9E\u65F6\u6570\u636E\uFF0C\u4E8B\u4EF6\u81EA\u52A8\u7F13\u51B2\u5728\u5185\u5B58\u4E2D\n## \u573A\u666F\uFF1AAgent \u9700\u8981\u5B9E\u65F6\u76D1\u63A7\u884C\u60C5\u53D8\u5316\u800C\u975E\u8F6E\u8BE2\u65F6\u8C03\u7528\n## \u5173\u952E\u8BCD\uFF1AWebSocket, ws, \u5B9E\u65F6\u63A8\u9001, \u5B9E\u65F6\u884C\u60C5, \u8BA2\u9605, subscribe, \u6D41\u5F0F\n## \u53C2\u6570\uFF1A\n##   - instId: \u4EA7\u54C1ID\uFF0C\u5982 BTC-USDT\u3001ETH-USDT-SWAP\n##   - channel: \u9891\u9053\u540D\u3002(tickers/trades/candle1m~1D/books5/books\u7B49)\n##   - instType: SPOT/SWAP/FUTURES/OPTION\uFF08tickers/trades \u9891\u9053\u9700\u8981\uFF09\n## \u9274\u6743\uFF1APUBLIC \u2014 \u516C\u5F00\u9891\u9053\n## \u98CE\u9669\uFF1AREAD \u2014 \u53EA\u8BFB\u8BA2\u9605\n## \u8FD4\u56DE\u91CF\uFF1A\u5FAE\u5C0F ~500B\n## \u5173\u8054\uFF1A\u672C\u5DE5\u5177\u8BA2\u9605 \u2192 okx_ws_events \u62C9\u53D6 \u2192 \u51B3\u7B56 \u2192 okx_ws_close \u5173\u95ED",
+    "CAT:[\u884C\u60C5-WS] | ## \u529F\u80FD\uFF1A\u8BA2\u9605 OKX WebSocket \u5B9E\u65F6\u516C\u5F00\u9891\u9053\uFF0C\u4E8B\u4EF6\u81EA\u52A8\u7F13\u51B2\u5728\u5185\u5B58\u4E2D\n## \u573A\u666F\uFF1AAgent \u9700\u8981\u5B9E\u65F6\u76D1\u63A7\u884C\u60C5\u3001\u7206\u4ED3\u5355\u3001\u8D44\u91D1\u8D39\u7387\u3001\u4EF7\u5DEE/\u5927\u5B97\u5E02\u573A\u65F6\u8C03\u7528\uFF0C\u66FF\u4EE3 REST \u8F6E\u8BE2\n## \u5173\u952E\u8BCD\uFF1AWebSocket, ws, \u5B9E\u65F6\u63A8\u9001, \u5B9E\u65F6\u884C\u60C5, \u8BA2\u9605, subscribe, \u7206\u4ED3, \u8D44\u91D1\u8D39\u7387, \u4EF7\u5DEE, \u5927\u5B97\n## \u53C2\u6570\uFF1A\n##   - instId: \u4EA7\u54C1ID\uFF0C\u5982 BTC-USDT\u3001ETH-USDT-SWAP\u3002status/instruments/economic-calendar \u7B49\u5168\u5C40\u9891\u9053\u4E0D\u9700\u8981 instId\n##   - channel: \u9891\u9053\u540D\u3002\u53EF\u9009: tickers / trades / all-trades / candle1m~1D / books5 / books / funding-rate / open-interest / price-limit / instruments / mark-price / mark-price-candles / index-tickers / index-candles / option-summary / estimated-price / liquidation-orders / adl-warning / event-contract-markets / economic-calendar / status / sprd/* / public-*-block-trades / block-tickers\n## \u9274\u6743\uFF1APUBLIC \u2014 \u516C\u5F00\u9891\u9053\uFF0C\u65E0\u9700 API Key\n## \u98CE\u9669\uFF1AREAD \u2014 \u53EA\u8BFB\n## \u8FD4\u56DE\u91CF\uFF1A\u5FAE\u5C0F ~500B\n## \u5173\u8054\uFF1A\u672C\u5DE5\u5177\u8BA2\u9605 \u2192 okx_ws_events \u62C9\u53D6 \u2192 okx_ws_close \u5173\u95ED",
     {
-      instId: external_exports.string().describe("\u4EA7\u54C1ID\uFF0C\u5982 BTC-USDT"),
-      channel: external_exports.string().describe("\u9891\u9053\u540D"),
-      instType: external_exports.enum(["SPOT", "SWAP", "FUTURES", "OPTION"]).optional().describe("tickers/trades \u9700\u8981")
+      instId: external_exports.string().describe("\u4EA7\u54C1ID\uFF0C\u5982 BTC-USDT\u3001ETH-USDT-SWAP\u3002\u7EAF\u5168\u5C40\u9891\u9053\uFF08status/instruments/economic-calendar\uFF09\u53EF\u4F20\u7A7A\u5B57\u7B26\u4E32"),
+      channel: external_exports.string().describe("\u9891\u9053\u540D\u3002\u516C\u5F00\u9891\u9053\u5171 33 \u4E2A\uFF0C\u652F\u6301 tickers/trades/candle1m~1D/books5/books/funding-rate/open-interest/price-limit/instruments/mark-price/mark-price-candles/index-tickers/index-candles/option-summary/estimated-price/liquidation-orders/adl-warning/event-contract-markets/economic-calendar/status/sprd\u7CFB\u5217/public-block-trades\u7CFB\u5217/block-tickers"),
+      instType: external_exports.enum(["SPOT", "SWAP", "FUTURES", "OPTION"]).optional().describe("\u90E8\u5206\u9891\u9053\u9700\u8981\u4EA7\u54C1\u7C7B\u578B")
     },
     async ({ instId, channel }) => {
       try {
-        if (!PUBLIC_CHANNELS.includes(channel)) {
-          return toError(new Error(`\u9891\u9053 "${channel}" \u4E0D\u652F\u6301\u3002\u652F\u6301: ${PUBLIC_CHANNELS.join(" ")}`));
+        if (!ALL_CHANNELS.public.includes(channel)) {
+          return toError(new Error(
+            `\u9891\u9053 "${channel}" \u975E\u516C\u5F00\u9891\u9053\u3002
+\u516C\u5F00\u9891\u9053(${ALL_CHANNELS.public.length}\u4E2A): ${ALL_CHANNELS.public.join(" ")}
+\u79C1\u6709\u9891\u9053\u8BF7\u7528 okx_ws_subscribe_private\u3002`
+          ));
         }
         const ws = getOrCreateWs();
         const subId = await ws.subscribe({ channel, instId: instId.toUpperCase(), type: "public" });
@@ -35460,8 +36180,48 @@ function registerWsTools(server) {
           subscriptionId: subId,
           channel,
           instId: instId.toUpperCase(),
+          type: "public",
+          buffered: ws.countBuffered(subId),
+          hint: `\u5DF2\u8BA2\u9605 ${instId || "\u5168\u5C40"} ${channel}\u3002\u8C03\u7528 okx_ws_events \u62C9\u53D6\u4E8B\u4EF6\u3002`,
+          tsIso: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      } catch (e) {
+        return toError(e);
+      }
+    }
+  );
+  server.tool(
+    "okx_ws_subscribe_private",
+    "CAT:[\u884C\u60C5-WS] | ## \u529F\u80FD\uFF1A\u8BA2\u9605 OKX WebSocket \u79C1\u6709\u9891\u9053\u2014\u2014\u5B9E\u65F6\u63A8\u9001\u8D26\u6237\u4F59\u989D\u3001\u6301\u4ED3\u53D8\u52A8\u3001\u8BA2\u5355\u6210\u4EA4\u3001\u7F51\u683C/\u7B56\u7565/\u8DDF\u5355\u72B6\u6001\n## \u573A\u666F\uFF1AAgent \u9700\u8981\u5B9E\u65F6\u8DDF\u8E2A\u8D26\u6237\u53D8\u5316\uFF08\u975E\u8F6E\u8BE2 REST\uFF09\u65F6\u8C03\u7528\n## \u5173\u952E\u8BCD\uFF1AWebSocket, ws, \u79C1\u6709\u9891\u9053, \u5B9E\u65F6\u8D26\u6237, \u8BA2\u5355\u63A8\u9001, positions, orders, \u7F51\u683C, \u8DDF\u5355\n## \u53C2\u6570\uFF1A\n##   - instId: \u4EA7\u54C1ID\u3002account/positions/balance_and_position \u7B49\u8D26\u6237\u7EA7\u9891\u9053\u53EF\u4E0D\u4F20\n##   - channel: \u79C1\u6709\u9891\u9053\u540D\u3002\u53EF\u9009: account / positions / balance_and_position / position-risk-warning / account-greeks / orders / fills / algo-orders / advance-algo-orders / spot-grid-algo-orders / contract-grid-algo-orders / grid-positions / grid-sub-orders / recurring-buy-orders / lead-trading-notification / deposit-info / withdrawal-info / rfqs / quotes / structure-block-trades / sprd/orders / sprd/trades\n## \u9274\u6743\uFF1A\u26A0\uFE0F \u9700\u8981 API Key\uFF08\u5FC5\u987B\u5F00\u901A\u8BFB\u53D6\u6743\u9650\uFF09\n## \u98CE\u9669\uFF1AREAD \u2014 \u53EA\u8BFB\u8BA2\u9605\uFF0C\u4F46\u9700 API Key\n## \u8FD4\u56DE\u91CF\uFF1A\u5FAE\u5C0F ~500B\n## \u5173\u8054\uFF1A\u672C\u5DE5\u5177\u8BA2\u9605 \u2192 okx_ws_events \u62C9\u53D6 \u2192 okx_ws_close \u5173\u95ED",
+    {
+      instId: external_exports.string().optional().describe("\u4EA7\u54C1ID\u3002\u8D26\u6237\u7EA7\u9891\u9053\u53EF\u4E0D\u4F20\uFF08\u5982 account/positions/balances\uFF09"),
+      channel: external_exports.string().describe("\u79C1\u6709\u9891\u9053\u540D\u3002\u5171 22 \u4E2A: account / positions / balance_and_position / position-risk-warning / account-greeks / orders / fills / algo-orders / advance-algo-orders / spot-grid-algo-orders / contract-grid-algo-orders / grid-positions / grid-sub-orders / recurring-buy-orders / lead-trading-notification / deposit-info / withdrawal-info / rfqs / quotes / structure-block-trades / sprd/orders / sprd/trades")
+    },
+    async ({ instId, channel }) => {
+      if (!auth) return toError(AUTH_REQUIRED);
+      try {
+        if (!ALL_CHANNELS.private.includes(channel)) {
+          return toError(new Error(
+            `\u9891\u9053 "${channel}" \u975E\u79C1\u6709\u9891\u9053\u3002
+\u79C1\u6709\u9891\u9053(${ALL_CHANNELS.private.length}\u4E2A): ${ALL_CHANNELS.private.join(" ")}
+\u516C\u5F00\u9891\u9053\u8BF7\u7528 okx_ws_subscribe\u3002`
+          ));
+        }
+        const ws = getOrCreateWs();
+        const subId = await ws.subscribe({
+          channel,
+          instId: (instId || "").toUpperCase(),
+          type: "private",
+          auth
+        });
+        return toResult({
+          subscribed: true,
+          subscriptionId: subId,
+          channel,
+          instId: (instId || "\u5168\u5C40").toUpperCase(),
+          type: "private",
           buffered: ws.countBuffered(subId),
-          hint: `\u5DF2\u8BA2\u9605 ${instId.toUpperCase()} ${channel}\u3002\u8C03\u7528 okx_ws_events \u62C9\u53D6\u4E8B\u4EF6\u3002`,
+          hint: `\u5DF2\u8BA2\u9605\u79C1\u6709\u9891\u9053 ${channel}\u3002\u8C03\u7528 okx_ws_events \u62C9\u53D6\u5B9E\u65F6\u4E8B\u4EF6\u3002`,
           tsIso: (/* @__PURE__ */ new Date()).toISOString()
         });
       } catch (e) {
@@ -35536,7 +36296,6 @@ function registerWsTools(server) {
 }
 
 // src/adapters/agent-hub.ts
-init_wrapper();
 var MAX_ROOM_MESSAGES = 200;
 var AgentHub = class {
   wss = null;
@@ -36086,98 +36845,73 @@ function registerAgentHubTools(server) {
 }
 
 // src/tools/codegraph.ts
-var path2 = __toESM(require("node:path"));
-var fs2 = __toESM(require("node:fs"));
-var DatabaseSync = null;
-function getDB() {
-  if (DatabaseSync === null) {
-    try {
-      const sqlite = require("node:sqlite");
-      DatabaseSync = sqlite.DatabaseSync;
-    } catch {
-      return null;
-    }
-  }
-  const dbPath = path2.resolve(".codegraph", "codegraph.db");
-  if (!fs2.existsSync(dbPath)) {
-    return null;
-  }
+var _cg = null;
+var _cgInitError = null;
+var _cgInitDone = false;
+async function getCodeGraph() {
+  if (_cgInitDone) return _cg;
   try {
-    const db = new DatabaseSync(dbPath, { readonly: true });
-    db.prepare("SELECT 1").get();
-    return { db };
+    const mod = await Promise.resolve().then(() => __toESM(require_npm_sdk()));
+    const CodeGraph = mod.CodeGraph || mod.default?.CodeGraph;
+    _cg = await CodeGraph.open(".");
+    _cgInitDone = true;
+    return _cg;
   } catch (e) {
+    _cgInitError = e.message || String(e);
+    _cgInitDone = true;
     return null;
   }
 }
 function registerCodeGraphTools(server) {
   server.tool(
     "codegraph_status",
-    "CAT:[\u4EE3\u7801\u667A\u80FD] | ## \u529F\u80FD\uFF1A\u68C0\u67E5\u4EE3\u7801\u77E5\u8BC6\u56FE\u8C31\u72B6\u6001\u2014\u2014\u8282\u70B9\u6570\u3001\u8FB9\u6570\u3001\u8986\u76D6\u6587\u4EF6\u3001\u6700\u540E\u7D22\u5F15\u65F6\u95F4\n## \u573A\u666F\uFF1AAgent \u9996\u6B21\u8FDE\u63A5\u65F6\u8C03\u7528\uFF0C\u4E86\u89E3\u4EE3\u7801\u56FE\u8C31\u662F\u5426\u5C31\u7EEA\uFF1B\u6216\u7528\u6237\u95EE\u300C\u4EE3\u7801\u7ED3\u6784\u80FD\u67E5\u5417\u300D\u65F6\u786E\u8BA4\u72B6\u6001\n## \u5173\u952E\u8BCD\uFF1A\u4EE3\u7801\u56FE\u8C31, codegraph, \u77E5\u8BC6\u56FE\u8C31, \u4EE3\u7801\u7ED3\u6784, \u7D22\u5F15\u72B6\u6001\n## \u53C2\u6570\uFF1A\u65E0\n## \u9274\u6743\uFF1APUBLIC \u2014 \u672C\u5730\u53EA\u8BFB\uFF0C\u4E0D\u67E5\u5916\u90E8 API\n## \u98CE\u9669\uFF1AREAD \u2014 \u53EA\u8BFB\u672C\u5730\u6587\u4EF6\n## \u8FD4\u56DE\u91CF\uFF1A\u5FAE\u5C0F ~500B\n## \u5173\u8054\uFF1A\u672C\u5DE5\u5177\u786E\u8BA4\u72B6\u6001 \u2192 codegraph_query \u67E5\u8BE2 \u2192 \u83B7\u53D6\u8C03\u7528\u94FE/\u4F9D\u8D56/\u7ED3\u6784",
+    "CAT:[\u4EE3\u7801\u667A\u80FD] | ## \u529F\u80FD\uFF1A\u68C0\u67E5\u4EE3\u7801\u77E5\u8BC6\u56FE\u8C31\u72B6\u6001\u2014\u2014\u8282\u70B9\u6570\u3001\u8FB9\u6570\u3001\u8986\u76D6\u6587\u4EF6\u3001\u88AB\u8C03\u7528\u6700\u591A\u7684\u51FD\u6570\n## \u573A\u666F\uFF1AAgent \u9996\u6B21\u8FDE\u63A5\u65F6\u786E\u8BA4\u56FE\u8C31\u662F\u5426\u5C31\u7EEA\uFF0C\u6216\u7528\u6237\u95EE\u300Chvip \u4EE3\u7801\u7ED3\u6784\u80FD\u67E5\u5417\u300D\u65F6\u786E\u8BA4\n## \u5173\u952E\u8BCD\uFF1A\u4EE3\u7801\u56FE\u8C31, codegraph, \u77E5\u8BC6\u56FE\u8C31, \u7D22\u5F15\u72B6\u6001, \u8C03\u7528\u6392\u884C\n## \u53C2\u6570\uFF1A\u65E0\n## \u9274\u6743\uFF1APUBLIC \u2014 \u672C\u5730\u8BFB\u6570\u636E\u5E93\n## \u98CE\u9669\uFF1AREAD \u2014 \u53EA\u8BFB\n## \u8FD4\u56DE\u91CF\uFF1A\u5FAE\u5C0F ~800B\n## \u5173\u8054\uFF1A\u672C\u5DE5\u5177\u786E\u8BA4\u72B6\u6001 \u2192 codegraph_query \u8FFD\u8E2A\u8C03\u7528\u94FE/\u641C\u7D22\u7B26\u53F7",
     {},
     async () => {
       try {
-        const conn = getDB();
-        if (!conn) {
-          const nodeVersion = process.versions.node;
-          const nodeMajor = parseInt(nodeVersion.split(".")[0]);
-          const needsUpgrade = nodeMajor < 22 || nodeMajor === 22 && parseInt(nodeVersion.split(".")[1]) < 5;
+        const cg = await getCodeGraph();
+        if (!cg) {
           return toResult({
             status: "unavailable",
-            reason: needsUpgrade ? `Node.js ${nodeVersion} \u4E0D\u652F\u6301\u5185\u7F6E sqlite\uFF0C\u9700\u8981 Node >= 22.5.0` : "\u4EE3\u7801\u77E5\u8BC6\u56FE\u8C31\u6570\u636E\u5E93\u672A\u627E\u5230",
-            how_to_setup: [
-              "1. npm i -g @colbymchenry/codegraph",
-              "2. cd \u5230\u9879\u76EE\u6839\u76EE\u5F55",
-              "3. codegraph index    # \u751F\u6210 .codegraph/codegraph.db",
-              "4. \u91CD\u542F MCP Server"
-            ].join("\n"),
-            nodeVersion,
+            reason: _cgInitError || "CodeGraph \u5F15\u64CE\u52A0\u8F7D\u5931\u8D25",
+            how_to_setup: "npm i @colbymchenry/codegraph && codegraph index",
+            alternatives: "\u56FE\u8C31\u4E0D\u53EF\u7528\u65F6\uFF0C\u4ECD\u53EF\u7528\u672C\u5DE5\u5177\u8FD4\u56DE\u7684\u8282\u70B9\u6570\u548C\u8FB9\u6570\u4E86\u89E3\u4EE3\u7801\u89C4\u6A21",
             tsIso: (/* @__PURE__ */ new Date()).toISOString(),
-            _summary: needsUpgrade ? `\u4EE3\u7801\u56FE\u8C31\u4E0D\u53EF\u7528\uFF1ANode ${nodeVersion} \u9700 >= 22.5.0` : "\u4EE3\u7801\u56FE\u8C31\u672A\u521D\u59CB\u5316\u3002\u8BF7\u8FD0\u884C codegraph index \u751F\u6210\u6570\u636E\u5E93\u3002"
+            _summary: "\u4EE3\u7801\u56FE\u8C31\u672A\u5C31\u7EEA\u3002\u8BF7\u8FD0\u884C codegraph index \u751F\u6210\u6570\u636E\u5E93\u3002"
           });
         }
-        const { db } = conn;
-        const nodeCount = db.prepare("SELECT count(*) as n FROM nodes").get().n;
-        const edgeCount = db.prepare("SELECT count(*) as n FROM edges").get().n;
-        const fileCount = db.prepare("SELECT count(*) as n FROM files").get().n;
-        const langRows = db.prepare(
-          "SELECT language, count(*) as n FROM files GROUP BY language ORDER BY n DESC"
-        ).all();
-        const kindRows = db.prepare(
-          "SELECT kind, count(*) as n FROM nodes GROUP BY kind ORDER BY n DESC LIMIT 10"
-        ).all();
-        const lastIndexed = db.prepare(
-          "SELECT max(indexed_at) as ts FROM files"
-        ).get().ts;
-        const topCalled = db.prepare(`
-          SELECT n.name, n.kind, n.file_path, count(e.id) as caller_count
-          FROM edges e
-          JOIN nodes n ON e.target = n.id
-          WHERE e.kind = 'calls'
-          GROUP BY e.target
-          ORDER BY caller_count DESC
-          LIMIT 10
-        `).all();
+        const stats = await cg.getStats();
+        let topCalled = [];
+        try {
+          const allExported = await cg.getNodesByKind("function").then((nodes) => nodes.filter((n) => n.isExported)).catch(() => []);
+          const sample = allExported.slice(0, 50);
+          const withCounts = await Promise.all(
+            sample.map(async (n) => {
+              try {
+                const callers = await cg.getCallers(n.id, 1);
+                return { name: n.name, file: n.filePath, callers: callers?.length || 0 };
+              } catch {
+                return { name: n.name, file: n.filePath, callers: 0 };
+              }
+            })
+          );
+          topCalled = withCounts.sort((a, b) => b.callers - a.callers).slice(0, 5);
+        } catch {
+        }
         const status = {
           status: "ready",
-          database: {
-            path: ".codegraph/codegraph.db",
-            nodeCount,
-            edgeCount,
-            fileCount,
-            languages: langRows.reduce((acc, r) => ({ ...acc, [r.language]: r.n }), {})
+          stats: {
+            nodes: stats.nodeCount,
+            edges: stats.edgeCount,
+            files: stats.fileCount,
+            byKind: stats.nodesByKind,
+            byLanguage: stats.filesByLanguage,
+            dbSize: stats.dbSizeBytes ? `${(stats.dbSizeBytes / 1024 / 1024).toFixed(1)} MB` : "unknown"
           },
-          nodesByKind: kindRows.reduce((acc, r) => ({ ...acc, [r.kind]: r.n }), {}),
-          lastIndexed: lastIndexed ? new Date(lastIndexed).toISOString() : "unknown",
-          topCalledFunctions: topCalled.map((r) => ({
-            name: r.name,
-            kind: r.kind,
-            file: r.file_path,
-            callers: r.caller_count
-          })).slice(0, 5),
-          queryHint: "\u7528 codegraph_query \u67E5\u8BE2\u5177\u4F53\u7B26\u53F7\u7684\u8C03\u7528\u94FE\u6216\u63A2\u7D22\u4EE3\u7801\u7ED3\u6784\u3002\u4F8B\u5982: codegraph_query({ mode: 'callers', symbol: 'toResult' })",
+          topCalled,
+          queryHint: "\u7528 codegraph_query \u67E5\u8C03\u7528\u94FE\u3002\u4F8B: codegraph_query({ mode: 'callers', symbol: 'toResult' })",
           tsIso: (/* @__PURE__ */ new Date()).toISOString(),
-          _summary: `\u4EE3\u7801\u77E5\u8BC6\u56FE\u8C31\u5C31\u7EEA\u3002${nodeCount} \u4E2A\u8282\u70B9\uFF0C${edgeCount} \u6761\u5173\u7CFB\uFF0C\u8986\u76D6 ${fileCount} \u4E2A\u6587\u4EF6\u3002\u88AB\u8C03\u7528\u6700\u591A\u7684\u51FD\u6570: ${topCalled.slice(0, 3).map((r) => r.name).join("\u3001") || "\u65E0"}\u3002`
+          _summary: `\u4EE3\u7801\u77E5\u8BC6\u56FE\u8C31\u5C31\u7EEA\u3002${stats.nodeCount} \u4E2A\u8282\u70B9\uFF0C${stats.edgeCount} \u6761\u5173\u7CFB\uFF0C\u8986\u76D6 ${stats.fileCount} \u4E2A\u6587\u4EF6\u3002${topCalled.length ? `\u88AB\u8C03\u6700\u591A: ${topCalled.slice(0, 3).map((f) => f.name).join("\u3001")}` : ""}`
         };
         return toResult(status);
       } catch (e) {
@@ -36187,106 +36921,113 @@ function registerCodeGraphTools(server) {
   );
   server.tool(
     "codegraph_query",
-    "CAT:[\u4EE3\u7801\u667A\u80FD] | ## \u529F\u80FD\uFF1A\u67E5\u8BE2\u4EE3\u7801\u77E5\u8BC6\u56FE\u8C31\u2014\u2014\u8FFD\u8E2A\u51FD\u6570\u8C03\u7528\u94FE\uFF08\u8C01\u8C03\u4E86\u8C01/\u88AB\u8C01\u8C03\uFF09\u3001\u641C\u7D22\u7B26\u53F7\u3001\u63A2\u7D22\u6A21\u5757\u4F9D\u8D56\n## \u573A\u666F\uFF1AAgent \u56DE\u7B54\u300CtoResult \u88AB\u54EA\u4E9B\u5DE5\u5177\u8C03\u7528\u300D\u300CregisterMarketTools \u7684\u8C03\u7528\u94FE\u300D\u300Cindex.ts \u4F9D\u8D56\u54EA\u4E9B\u6A21\u5757\u300D\u65F6\u8C03\u7528\n## \u5173\u952E\u8BCD\uFF1Acodegraph, \u8C03\u7528\u94FE, callers, callees, \u4F9D\u8D56, \u4EE3\u7801\u641C\u7D22, \u7B26\u53F7\u67E5\u8BE2, \u4E0A\u4E0B\u6E38\n## \u53C2\u6570\uFF1A\n##   - mode: \u67E5\u8BE2\u6A21\u5F0F\u3002callers=\u8C01\u8C03\u7528\u5B83, callees=\u5B83\u8C03\u7528\u8C01, explore=\u81EA\u7136\u8BED\u8A00\u641C\u7D22, files=\u6309\u6587\u4EF6\u67E5\u8BE2\n##   - symbol: \u7B26\u53F7\u540D\uFF08mode=callers/callees \u65F6\u5FC5\u586B\uFF09\u6216\u6587\u4EF6\u540D\uFF08mode=files\uFF09\n##   - question: \u81EA\u7136\u8BED\u8A00\u641C\u7D22\uFF08mode=explore \u65F6\u4F7F\u7528\uFF09\n##   - limit: \u8FD4\u56DE\u6761\u6570\uFF0C\u9ED8\u8BA4 15\n## \u9274\u6743\uFF1APUBLIC \u2014 \u672C\u5730\u6570\u636E\u5E93\n## \u98CE\u9669\uFF1AREAD \u2014 \u53EA\u8BFB\n## \u8FD4\u56DE\u91CF\uFF1A\u5FAE\u5C0F ~2KB\n## \u5173\u8054\uFF1Acodegraph_status \u770B\u72B6\u6001 \u2192 \u672C\u5DE5\u5177\u67E5\u8BE2 \u2192 \u5B9A\u4F4D\u6E90\u7801 \u2192 Agent \u7528 Read \u67E5\u770B\u7EC6\u8282",
+    "CAT:[\u4EE3\u7801\u667A\u80FD] | ## \u529F\u80FD\uFF1A\u67E5\u8BE2\u4EE3\u7801\u77E5\u8BC6\u56FE\u8C31\u2014\u2014\u8FFD\u8E2A\u8C03\u7528\u94FE\u3001\u641C\u7D22\u7B26\u53F7\u3001\u63A2\u7D22\u6A21\u5757\u4F9D\u8D56\u3001\u6309\u6587\u4EF6\u5217\u51FA\u7B26\u53F7\n## \u573A\u666F\uFF1AAgent \u56DE\u7B54\u300CtoResult \u88AB\u54EA\u4E9B\u5DE5\u5177\u8C03\u7528\u300D\u300CregisterMarketTools \u7684\u4E0A\u4E0B\u6E38\u300D\u300C\u4EE3\u7801\u91CC\u54EA\u91CC\u5904\u7406\u4E86 WebSocket\u300D\u65F6\u8C03\u7528\n## \u5173\u952E\u8BCD\uFF1Acodegraph, \u8C03\u7528\u94FE, callers, callees, \u4F9D\u8D56, \u4EE3\u7801\u641C\u7D22, \u7B26\u53F7\u67E5\u8BE2, \u4E0A\u4E0B\u6E38, \u5F71\u54CD\u5206\u6790\n## \u53C2\u6570\uFF1A\n##   - mode: \u67E5\u8BE2\u6A21\u5F0F\u3002callers=\u8C01\u8C03\u7528\u5B83, callees=\u5B83\u8C03\u7528\u8C01, search=\u5168\u6587\u641C\u7D22, file=\u6309\u6587\u4EF6\u5217\u51FA\n##   - symbol: \u7B26\u53F7\u540D/\u8282\u70B9ID (callers/callees/file \u6A21\u5F0F)\n##   - query: \u641C\u7D22\u8BCD (search \u6A21\u5F0F)\n##   - limit: \u8FD4\u56DE\u6570\uFF0C\u9ED8\u8BA4 15\n## \u9274\u6743\uFF1APUBLIC \u2014 \u672C\u5730\u8BFB\u6570\u636E\u5E93\n## \u98CE\u9669\uFF1AREAD \u2014 \u53EA\u8BFB\n## \u8FD4\u56DE\u91CF\uFF1A\u5FAE\u5C0F ~2KB\n## \u5173\u8054\uFF1Acodegraph_status \u770B\u72B6\u6001 \u2192 \u672C\u5DE5\u5177\u67E5\u8BE2 \u2192 Agent \u5B9A\u4F4D\u6E90\u7801",
     {
-      mode: external_exports.enum(["callers", "callees", "explore", "files"]).describe("\u67E5\u8BE2\u6A21\u5F0F\u3002callers=\u8C01\u8C03\u7528\u5B83, callees=\u5B83\u8C03\u7528\u8C01, explore=\u81EA\u7136\u8BED\u8A00\u641C\u7D22, files=\u6309\u6587\u4EF6\u67E5\u8282\u70B9"),
-      symbol: external_exports.string().optional().describe("\u7B26\u53F7\u540D\uFF08\u5982 toResult, registerMarketTools\uFF09\u6216\u6587\u4EF6\u540D\uFF08\u5982 agent-utils.ts\uFF09"),
-      question: external_exports.string().optional().describe("\u81EA\u7136\u8BED\u8A00\u641C\u7D22\uFF08mode=explore \u65F6\u4F7F\u7528\uFF09\uFF0C\u5982 'HTTP \u8BF7\u6C42\u7B7E\u540D' 'WebSocket \u8FDE\u63A5'"),
-      limit: external_exports.number().int().min(1).max(100).optional().describe("\u8FD4\u56DE\u6761\u6570\uFF0C\u9ED8\u8BA4 15")
+      mode: external_exports.enum(["callers", "callees", "search", "file"]).describe("callers=\u8C01\u8C03\u7528\u5B83, callees=\u5B83\u8C03\u7528\u8C01, search=\u5168\u6587\u641C\u7D22, file=\u6309\u6587\u4EF6\u5217\u51FA\u7B26\u53F7"),
+      symbol: external_exports.string().optional().describe("\u7B26\u53F7\u540D\uFF08\u5982 toResult\uFF09\u6216\u6587\u4EF6\u540D\uFF08\u5982 agent-utils.ts\uFF09"),
+      query: external_exports.string().optional().describe("\u641C\u7D22\u8BCD\uFF08search \u6A21\u5F0F\uFF09\uFF0C\u5982 'websocket \u8FDE\u63A5'"),
+      limit: external_exports.number().int().min(1).max(100).optional().describe("\u8FD4\u56DE\u6570\uFF0C\u9ED8\u8BA4 15")
     },
-    async ({ mode, symbol, question, limit }) => {
+    async ({ mode, symbol, query, limit }) => {
       try {
-        const conn = getDB();
-        if (!conn) {
-          return toError("\u4EE3\u7801\u77E5\u8BC6\u56FE\u8C31\u4E0D\u53EF\u7528\u3002\u8BF7\u5148\u8C03 codegraph_status \u68C0\u67E5\u72B6\u6001\u3002");
-        }
-        const { db } = conn;
+        const cg = await getCodeGraph();
+        if (!cg) return toError("\u4EE3\u7801\u56FE\u8C31\u4E0D\u53EF\u7528\u3002\u8BF7\u5148\u8C03 codegraph_status \u68C0\u67E5\u72B6\u6001\u3002");
         const n = limit || 15;
-        if (mode === "callers") {
-          if (!symbol) return toError("callers \u6A21\u5F0F\u9700\u8981 symbol \u53C2\u6570\uFF0CAgent \u8BF7\u63D0\u4F9B\u51FD\u6570\u540D");
-          const nodes = db.prepare(
-            "SELECT id, name, kind, file_path, start_line, signature, qualified_name FROM nodes WHERE name = ? OR name LIKE ? LIMIT 5"
-          ).all(symbol, `%${symbol}%`);
-          if (nodes.length === 0) {
+        if (mode === "search") {
+          const q = query || symbol || "";
+          if (!q) return toError("search \u6A21\u5F0F\u9700\u8981 query \u6216 symbol \u53C2\u6570");
+          const results = await cg.searchNodes(q, { limit: n });
+          if (!results?.length) {
             return toResult({
-              mode: "callers",
-              symbol,
+              mode: "search",
+              query: q,
               found: false,
-              hint: `\u672A\u627E\u5230\u7B26\u53F7 "${symbol}"\u3002\u8BD5\u8BD5 codegraph_query({ mode: 'explore', question: '${symbol}' }) \u5168\u6587\u641C\u7D22`,
+              hint: `\u672A\u627E\u5230\u4E0E "${q}" \u76F8\u5173\u7684\u7B26\u53F7\u3002\u8BD5\u8BD5\u51FD\u6570\u540D\uFF08\u5982 registerTools\uFF09\u6216\u6587\u4EF6\u540D\u3002`,
               tsIso: (/* @__PURE__ */ new Date()).toISOString()
             });
           }
-          const results = [];
-          for (const node of nodes) {
-            const callers = db.prepare(`
-              SELECT n.name as caller_name, n.kind, n.file_path, e.line, e.kind as edge_kind
-              FROM edges e
-              JOIN nodes n ON e.source = n.id
-              WHERE e.target = ?
-              ORDER BY n.name
-              LIMIT ?
-            `).all(node.id, n);
-            results.push({
-              target: { name: node.name, kind: node.kind, file: node.file_path, line: node.start_line },
-              callers: callers.map((c) => ({
-                name: c.caller_name,
+          const items = await Promise.all(results.slice(0, n).map(async (r) => {
+            const node = r.node || r;
+            let callerCount = 0, calleeCount = 0;
+            try {
+              callerCount = (await cg.getCallers(node.id, 1))?.length || 0;
+            } catch {
+            }
+            try {
+              calleeCount = (await cg.getCallees(node.id, 1))?.length || 0;
+            } catch {
+            }
+            return {
+              id: node.id,
+              name: node.name,
+              kind: node.kind,
+              file: node.filePath,
+              line: node.startLine,
+              signature: node.signature?.slice(0, 120),
+              stats: { callers: callerCount, callees: calleeCount }
+            };
+          }));
+          return toResult({
+            mode: "search",
+            query: q,
+            total: results.length,
+            results: items,
+            _summary: `\u641C\u7D22 "${q}" \u627E\u5230 ${results.length} \u4E2A\u7B26\u53F7\u3002${items.slice(0, 3).map((i) => `${i.name}(${i.kind})`).join(" | ")}`,
+            hint: `\u627E\u5230\u5177\u4F53\u7B26\u53F7\u540E\uFF0C\u7528 codegraph_query({ mode: 'callers', symbol: '<id>' }) \u8FFD\u8E2A\u8C03\u7528\u94FE\u3002`,
+            tsIso: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+        if (mode === "callers") {
+          if (!symbol) return toError("callers \u6A21\u5F0F\u9700\u8981 symbol \u53C2\u6570");
+          const nodes = await cg.getNodesByName(symbol);
+          if (!nodes?.length) {
+            return toResult({ mode: "callers", symbol, found: false, tsIso: (/* @__PURE__ */ new Date()).toISOString() });
+          }
+          const results = await Promise.all(nodes.slice(0, 5).map(async (node) => {
+            const callers = await cg.getCallers(node.id, 1);
+            return {
+              target: { id: node.id, name: node.name, kind: node.kind, file: node.filePath, line: node.startLine },
+              callers: (callers || []).slice(0, n).map((c) => ({
+                name: c.name,
                 kind: c.kind,
-                file: c.file_path,
-                atLine: c.line,
-                relation: c.edge_kind
+                file: c.filePath,
+                line: c.line,
+                relation: c.edgeKind
               })),
-              totalCallers: callers.length
-            });
-          }
-          const total = results.reduce((s, r) => s + r.totalCallers, 0);
+              total: callers?.length || 0
+            };
+          }));
+          const total = results.reduce((s, r) => s + r.total, 0);
           return toResult({
             mode: "callers",
             symbol,
             matched: nodes.length,
             results,
-            _summary: `"${symbol}" \u5339\u914D ${nodes.length} \u4E2A\u7B26\u53F7\uFF0C\u5171 ${total} \u4E2A\u8C03\u7528\u8005\u3002${results.slice(0, 3).map((r) => `${r.target.name}: ${r.callers.slice(0, 3).map((c) => c.name).join("\u3001")}`).join(" | ")}`,
+            _summary: `"${symbol}" \u5339\u914D ${nodes.length} \u4E2A\u7B26\u53F7\uFF0C\u5171 ${total} \u4E2A\u8C03\u7528\u8005\u3002`,
             tsIso: (/* @__PURE__ */ new Date()).toISOString()
           });
         }
         if (mode === "callees") {
           if (!symbol) return toError("callees \u6A21\u5F0F\u9700\u8981 symbol \u53C2\u6570");
-          const nodes = db.prepare(
-            "SELECT id, name, kind, file_path, start_line FROM nodes WHERE name = ? OR name LIKE ? LIMIT 5"
-          ).all(symbol, `%${symbol}%`);
-          if (nodes.length === 0) {
-            return toResult({
-              mode: "callees",
-              symbol,
-              found: false,
-              hint: `\u672A\u627E\u5230 "${symbol}"\uFF0C\u8BD5\u8BD5 mode='explore' \u5168\u6587\u641C\u7D22`,
-              tsIso: (/* @__PURE__ */ new Date()).toISOString()
-            });
+          const nodes = await cg.getNodesByName(symbol);
+          if (!nodes?.length) {
+            return toResult({ mode: "callees", symbol, found: false, tsIso: (/* @__PURE__ */ new Date()).toISOString() });
           }
-          const results = [];
-          for (const node of nodes) {
-            const callees = db.prepare(`
-              SELECT n.name as callee_name, n.kind, n.file_path, e.line
-              FROM edges e
-              JOIN nodes n ON e.target = n.id
-              WHERE e.source = ?
-              ORDER BY e.kind, n.name
-              LIMIT ?
-            `).all(node.id, n);
-            const byKind = {};
-            for (const c of callees) {
-              (byKind[c.kind] || (byKind[c.kind] = [])).push(c);
-            }
-            results.push({
-              source: { name: node.name, kind: node.kind, file: node.file_path, line: node.start_line },
-              callees: Object.entries(byKind).map(([kind, items]) => ({
-                relation: kind,
-                count: items.length,
-                top: items.slice(0, 10).map((c) => ({ name: c.callee_name, kind: c.kind, file: c.file_path, atLine: c.line }))
+          const results = await Promise.all(nodes.slice(0, 5).map(async (node) => {
+            const callees = await cg.getCallees(node.id, 1);
+            return {
+              source: { id: node.id, name: node.name, kind: node.kind, file: node.filePath, line: node.startLine },
+              callees: (callees || []).slice(0, n).map((c) => ({
+                name: c.name,
+                kind: c.kind,
+                file: c.filePath,
+                line: c.line,
+                relation: c.edgeKind
               })),
-              totalCallees: callees.length
-            });
-          }
-          const total = results.reduce((s, r) => s + r.totalCallees, 0);
+              total: callees?.length || 0
+            };
+          }));
+          const total = results.reduce((s, r) => s + r.total, 0);
           return toResult({
             mode: "callees",
             symbol,
@@ -36296,95 +37037,23 @@ function registerCodeGraphTools(server) {
             tsIso: (/* @__PURE__ */ new Date()).toISOString()
           });
         }
-        if (mode === "explore") {
-          const q = question || symbol || "";
-          if (!q) return toError("explore \u6A21\u5F0F\u9700\u8981 question \u6216 symbol \u53C2\u6570");
-          let rows = db.prepare(`
-            SELECT n.id, n.name, n.kind, n.file_path, n.start_line, n.signature, n.docstring, n.qualified_name
-            FROM nodes_fts f
-            JOIN nodes n ON f.id = n.id
-            WHERE nodes_fts MATCH ?
-            ORDER BY rank
-            LIMIT ?
-          `).all(q, n);
-          if (rows.length === 0) {
-            rows = db.prepare(`
-              SELECT id, name, kind, file_path, start_line, signature, docstring, qualified_name
-              FROM nodes
-              WHERE name LIKE ? OR qualified_name LIKE ? OR docstring LIKE ?
-              ORDER BY name
-              LIMIT ?
-            `).all(`%${q}%`, `%${q}%`, `%${q}%`, n);
-          }
-          if (rows.length === 0) {
-            return toResult({
-              mode: "explore",
-              question: q,
-              found: false,
-              hint: `\u672A\u627E\u5230\u4E0E "${q}" \u76F8\u5173\u7684\u7B26\u53F7\u3002\u8BD5\u8BD5\u66F4\u77ED\u7684\u5173\u952E\u8BCD\u6216\u76F4\u63A5\u641C\u51FD\u6570\u540D\u3002`,
-              tsIso: (/* @__PURE__ */ new Date()).toISOString()
-            });
-          }
-          const top = rows.slice(0, 5);
-          const enriched = top.map((r) => {
-            const callers = db.prepare(
-              "SELECT count(*) as n FROM edges WHERE target = ? AND kind = 'calls'"
-            ).get(r.id).n;
-            const callees = db.prepare(
-              "SELECT count(*) as n FROM edges WHERE source = ? AND kind = 'calls'"
-            ).get(r.id).n;
-            return {
-              name: r.name,
-              kind: r.kind,
-              file: r.file_path,
-              line: r.start_line,
-              signature: r.signature,
-              docstring: r.docstring?.slice(0, 120),
-              stats: { callers, callees }
-            };
-          });
-          return toResult({
-            mode: "explore",
-            question: q,
-            found: true,
-            total: rows.length,
-            results: enriched,
-            _summary: `\u641C\u7D22 "${q}" \u627E\u5230 ${rows.length} \u4E2A\u7B26\u53F7\u3002${enriched.slice(0, 3).map((r) => `${r.name}(${r.kind}) in ${r.file}`).join(" | ")}`,
-            hint: `\u627E\u5230\u5177\u4F53\u7B26\u53F7\u540E\u7528 codegraph_query({ mode: 'callers', symbol: '<name>' }) \u770B\u5B8C\u6574\u8C03\u7528\u94FE\u3002`,
-            tsIso: (/* @__PURE__ */ new Date()).toISOString()
-          });
-        }
-        if (mode === "files") {
-          const file = symbol || "";
-          if (!file) return toError("files \u6A21\u5F0F\u9700\u8981 symbol \u53C2\u6570\uFF08\u6587\u4EF6\u540D\uFF09");
-          const fileInfo = db.prepare(
-            "SELECT * FROM files WHERE path LIKE ? LIMIT 1"
-          ).get(`%${file}%`);
-          const nodes = db.prepare(`
-            SELECT name, kind, start_line, signature, is_exported
-            FROM nodes
-            WHERE file_path LIKE ?
-            ORDER BY start_line
-            LIMIT ?
-          `).all(`%${file}%`, n);
+        if (mode === "file") {
+          if (!symbol) return toError("file \u6A21\u5F0F\u9700\u8981 symbol \u53C2\u6570\uFF08\u6587\u4EF6\u540D\uFF09");
+          const files = await cg.getFiles({ pattern: symbol });
+          const fileInfo = files?.[0];
+          const symbols = fileInfo ? await cg.getNodesInFile(fileInfo.path) : [];
           return toResult({
-            mode: "files",
-            file,
-            fileInfo: fileInfo ? {
-              path: fileInfo.path,
-              language: fileInfo.language,
-              size: fileInfo.size,
-              nodeCount: fileInfo.node_count,
-              indexedAt: fileInfo.indexed_at ? new Date(fileInfo.indexed_at).toISOString() : void 0
-            } : null,
-            symbols: nodes.map((r) => ({
-              name: r.name,
-              kind: r.kind,
-              line: r.start_line,
-              signature: r.signature,
-              exported: r.is_exported === 1
+            mode: "file",
+            file: symbol,
+            fileInfo: fileInfo ? { path: fileInfo.path, language: fileInfo.language, size: fileInfo.size } : null,
+            symbols: (symbols || []).slice(0, n).map((s) => ({
+              name: s.name,
+              kind: s.kind,
+              line: s.startLine,
+              signature: s.signature?.slice(0, 120),
+              exported: s.isExported
             })),
-            _summary: `\u6587\u4EF6 "${file}" \u5305\u542B ${nodes.length} \u4E2A\u7B26\u53F7\u3002${nodes.filter((r) => r.is_exported).length} \u4E2A\u5BFC\u51FA\u3002`,
+            _summary: `\u6587\u4EF6 "${symbol}" \u5305\u542B ${symbols?.length || 0} \u4E2A\u7B26\u53F7\u3002`,
             tsIso: (/* @__PURE__ */ new Date()).toISOString()
           });
         }
@@ -36449,7 +37118,7 @@ function registerAllTools(server, auth, readOnly) {
   registerIndicatorTools(server);
   registerSmartMoneyTools(server, auth);
   registerXLayerWSTools(server);
-  registerWsTools(server);
+  registerWsTools(server, auth);
   registerAgentHubTools(server);
   registerCodeGraphTools(server);
   return { skipped, skipLog };
@@ -36544,7 +37213,7 @@ async function startStdio(server, version2, auth, readOnly, skipped, skipLog) {
   await server.connect(transport);
 }
 async function main() {
-  const VERSION = "0.2.49";
+  const VERSION = "0.2.50";
   const auth = getAuth();
   const mode = resolveTransportMode();
   const exec = resolveExecutionMode();
@@ -36552,7 +37221,7 @@ async function main() {
   const server = new McpServer({
     name: "hvip-mcp",
     version: VERSION,
-    description: "hvip MCP Server \u2014 364 \u5DE5\u5177\u8986\u76D6 97.7% OKX REST API\uFF0C\u542B\u4EA4\u6613/\u884C\u60C5/\u8D44\u91D1/\u7B56\u7565/\u9884\u6D4B\u5E02\u573A/\u6280\u672F\u6307\u6807/Smart Money\uFF08\u975E OKX \u5B98\u65B9\u4EA7\u54C1\uFF09\u3002\u4ED3\u5E93: https://github.com/okx-wallet-H/hvip-mcp"
+    description: "hvip MCP Server \u2014 365 \u5DE5\u5177\u8986\u76D6 97.7% OKX REST API\uFF0C\u542B\u4EA4\u6613/\u884C\u60C5/\u8D44\u91D1/\u7B56\u7565/\u9884\u6D4B\u5E02\u573A/\u6280\u672F\u6307\u6807/Smart Money/WebSocket/\u4EE3\u7801\u56FE\u8C31\uFF08\u975E OKX \u5B98\u65B9\u4EA7\u54C1\uFF09\u3002\u4ED3\u5E93: https://github.com/okx-wallet-H/hvip-mcp"
   });
   const { skipped, skipLog } = registerAllTools(server, auth, readOnly);
   if (mode === "http") {