hvip-mcp-server 0.2.45 → 0.2.47

package/dist/index.js

@@ -4238,8 +4238,8 @@ var require_core = __commonJS({
             return this;
           }
           case "object": {
-            const cacheKey = schemaKeyRef;
-            this._cache.delete(cacheKey);
+            const cacheKey2 = schemaKeyRef;
+            this._cache.delete(cacheKey2);
             let id = schemaKeyRef[this.opts.schemaId];
             if (id) {
               id = (0, resolve_1.normalizeId)(id);
@@ -9138,7 +9138,7 @@ var require_websocket = __commonJS({
     var net = require("net");
     var tls = require("tls");
     var { randomBytes, createHash } = require("crypto");
-    var { Duplex, Readable } = require("stream");
+    var { Duplex, Readable: Readable2 } = require("stream");
     var { URL: URL2 } = require("url");
     var PerMessageDeflate2 = require_permessage_deflate();
     var Receiver2 = require_receiver();
@@ -10576,15 +10576,15 @@ __export(wrapper_exports, {
   Sender: () => import_sender.default,
   WebSocket: () => import_websocket.default,
   WebSocketServer: () => import_websocket_server.default,
-  createWebSocketStream: () => import_stream.default,
+  createWebSocketStream: () => import_stream2.default,
   default: () => wrapper_default,
   extension: () => import_extension.default,
   subprotocol: () => import_subprotocol.default
 });
-var import_stream, import_extension, import_permessage_deflate, import_receiver, import_sender, import_subprotocol, import_websocket, import_websocket_server, wrapper_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_stream = __toESM(require_stream(), 1);
+    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);
@@ -10596,6 +10596,9 @@ var init_wrapper = __esm({
   }
 });
 
+// src/index.ts
+var import_node_http = require("node:http");
+
 // node_modules/zod/v3/external.js
 var external_exports = {};
 __export(external_exports, {
@@ -19327,6 +19330,7 @@ config(en_default2());
 
 // node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
 var LATEST_PROTOCOL_VERSION = "2025-11-25";
+var DEFAULT_NEGOTIATED_PROTOCOL_VERSION = "2025-03-26";
 var SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05", "2024-10-07"];
 var RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task";
 var JSONRPC_VERSION = "2.0";
@@ -19655,6 +19659,7 @@ var InitializeRequestSchema = RequestSchema.extend({
   method: literal("initialize"),
   params: InitializeRequestParamsSchema
 });
+var isInitializeRequest = (value) => InitializeRequestSchema.safeParse(value).success;
 var ServerCapabilitiesSchema = object2({
   /**
    * Experimental, non-standard capabilities that the server supports.
@@ -24808,6 +24813,1331 @@ var StdioServerTransport = class {
   }
 };
 
+// node_modules/@hono/node-server/dist/index.mjs
+var import_http2 = require("http2");
+var import_http22 = require("http2");
+var import_stream = require("stream");
+var import_crypto = __toESM(require("crypto"), 1);
+var RequestError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RequestError";
+  }
+};
+var toRequestError = (e) => {
+  if (e instanceof RequestError) {
+    return e;
+  }
+  return new RequestError(e.message, { cause: e });
+};
+var GlobalRequest = global.Request;
+var Request = class extends GlobalRequest {
+  constructor(input, options) {
+    if (typeof input === "object" && getRequestCache in input) {
+      input = input[getRequestCache]();
+    }
+    if (typeof options?.body?.getReader !== "undefined") {
+      ;
+      options.duplex ??= "half";
+    }
+    super(input, options);
+  }
+};
+var newHeadersFromIncoming = (incoming) => {
+  const headerRecord = [];
+  const rawHeaders = incoming.rawHeaders;
+  for (let i = 0; i < rawHeaders.length; i += 2) {
+    const { [i]: key, [i + 1]: value } = rawHeaders;
+    if (key.charCodeAt(0) !== /*:*/
+    58) {
+      headerRecord.push([key, value]);
+    }
+  }
+  return new Headers(headerRecord);
+};
+var wrapBodyStream = /* @__PURE__ */ Symbol("wrapBodyStream");
+var newRequestFromIncoming = (method, url, headers, incoming, abortController) => {
+  const init = {
+    method,
+    headers,
+    signal: abortController.signal
+  };
+  if (method === "TRACE") {
+    init.method = "GET";
+    const req = new Request(url, init);
+    Object.defineProperty(req, "method", {
+      get() {
+        return "TRACE";
+      }
+    });
+    return req;
+  }
+  if (!(method === "GET" || method === "HEAD")) {
+    if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) {
+      init.body = new ReadableStream({
+        start(controller) {
+          controller.enqueue(incoming.rawBody);
+          controller.close();
+        }
+      });
+    } else if (incoming[wrapBodyStream]) {
+      let reader;
+      init.body = new ReadableStream({
+        async pull(controller) {
+          try {
+            reader ||= import_stream.Readable.toWeb(incoming).getReader();
+            const { done, value } = await reader.read();
+            if (done) {
+              controller.close();
+            } else {
+              controller.enqueue(value);
+            }
+          } catch (error2) {
+            controller.error(error2);
+          }
+        }
+      });
+    } else {
+      init.body = import_stream.Readable.toWeb(incoming);
+    }
+  }
+  return new Request(url, init);
+};
+var getRequestCache = /* @__PURE__ */ Symbol("getRequestCache");
+var requestCache = /* @__PURE__ */ Symbol("requestCache");
+var incomingKey = /* @__PURE__ */ Symbol("incomingKey");
+var urlKey = /* @__PURE__ */ Symbol("urlKey");
+var headersKey = /* @__PURE__ */ Symbol("headersKey");
+var abortControllerKey = /* @__PURE__ */ Symbol("abortControllerKey");
+var getAbortController = /* @__PURE__ */ Symbol("getAbortController");
+var requestPrototype = {
+  get method() {
+    return this[incomingKey].method || "GET";
+  },
+  get url() {
+    return this[urlKey];
+  },
+  get headers() {
+    return this[headersKey] ||= newHeadersFromIncoming(this[incomingKey]);
+  },
+  [getAbortController]() {
+    this[getRequestCache]();
+    return this[abortControllerKey];
+  },
+  [getRequestCache]() {
+    this[abortControllerKey] ||= new AbortController();
+    return this[requestCache] ||= newRequestFromIncoming(
+      this.method,
+      this[urlKey],
+      this.headers,
+      this[incomingKey],
+      this[abortControllerKey]
+    );
+  }
+};
+[
+  "body",
+  "bodyUsed",
+  "cache",
+  "credentials",
+  "destination",
+  "integrity",
+  "mode",
+  "redirect",
+  "referrer",
+  "referrerPolicy",
+  "signal",
+  "keepalive"
+].forEach((k) => {
+  Object.defineProperty(requestPrototype, k, {
+    get() {
+      return this[getRequestCache]()[k];
+    }
+  });
+});
+["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+  Object.defineProperty(requestPrototype, k, {
+    value: function() {
+      return this[getRequestCache]()[k]();
+    }
+  });
+});
+Object.defineProperty(requestPrototype, /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom"), {
+  value: function(depth, options, inspectFn) {
+    const props = {
+      method: this.method,
+      url: this.url,
+      headers: this.headers,
+      nativeRequest: this[requestCache]
+    };
+    return `Request (lightweight) ${inspectFn(props, { ...options, depth: depth == null ? null : depth - 1 })}`;
+  }
+});
+Object.setPrototypeOf(requestPrototype, Request.prototype);
+var newRequest = (incoming, defaultHostname) => {
+  const req = Object.create(requestPrototype);
+  req[incomingKey] = incoming;
+  const incomingUrl = incoming.url || "";
+  if (incomingUrl[0] !== "/" && // short-circuit for performance. most requests are relative URL.
+  (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
+    if (incoming instanceof import_http22.Http2ServerRequest) {
+      throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
+    }
+    try {
+      const url2 = new URL(incomingUrl);
+      req[urlKey] = url2.href;
+    } catch (e) {
+      throw new RequestError("Invalid absolute URL", { cause: e });
+    }
+    return req;
+  }
+  const host = (incoming instanceof import_http22.Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
+  if (!host) {
+    throw new RequestError("Missing host header");
+  }
+  let scheme;
+  if (incoming instanceof import_http22.Http2ServerRequest) {
+    scheme = incoming.scheme;
+    if (!(scheme === "http" || scheme === "https")) {
+      throw new RequestError("Unsupported scheme");
+    }
+  } else {
+    scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
+  }
+  const url = new URL(`${scheme}://${host}${incomingUrl}`);
+  if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
+    throw new RequestError("Invalid host header");
+  }
+  req[urlKey] = url.href;
+  return req;
+};
+var responseCache = /* @__PURE__ */ Symbol("responseCache");
+var getResponseCache = /* @__PURE__ */ Symbol("getResponseCache");
+var cacheKey = /* @__PURE__ */ Symbol("cache");
+var GlobalResponse = global.Response;
+var Response2 = class _Response {
+  #body;
+  #init;
+  [getResponseCache]() {
+    delete this[cacheKey];
+    return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
+  }
+  constructor(body, init) {
+    let headers;
+    this.#body = body;
+    if (init instanceof _Response) {
+      const cachedGlobalResponse = init[responseCache];
+      if (cachedGlobalResponse) {
+        this.#init = cachedGlobalResponse;
+        this[getResponseCache]();
+        return;
+      } else {
+        this.#init = init.#init;
+        headers = new Headers(init.#init.headers);
+      }
+    } else {
+      this.#init = init;
+    }
+    if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) {
+      ;
+      this[cacheKey] = [init?.status || 200, body, headers || init?.headers];
+    }
+  }
+  get headers() {
+    const cache = this[cacheKey];
+    if (cache) {
+      if (!(cache[2] instanceof Headers)) {
+        cache[2] = new Headers(
+          cache[2] || { "content-type": "text/plain; charset=UTF-8" }
+        );
+      }
+      return cache[2];
+    }
+    return this[getResponseCache]().headers;
+  }
+  get status() {
+    return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
+  }
+  get ok() {
+    const status = this.status;
+    return status >= 200 && status < 300;
+  }
+};
+["body", "bodyUsed", "redirected", "statusText", "trailers", "type", "url"].forEach((k) => {
+  Object.defineProperty(Response2.prototype, k, {
+    get() {
+      return this[getResponseCache]()[k];
+    }
+  });
+});
+["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+  Object.defineProperty(Response2.prototype, k, {
+    value: function() {
+      return this[getResponseCache]()[k]();
+    }
+  });
+});
+Object.defineProperty(Response2.prototype, /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom"), {
+  value: function(depth, options, inspectFn) {
+    const props = {
+      status: this.status,
+      headers: this.headers,
+      ok: this.ok,
+      nativeResponse: this[responseCache]
+    };
+    return `Response (lightweight) ${inspectFn(props, { ...options, depth: depth == null ? null : depth - 1 })}`;
+  }
+});
+Object.setPrototypeOf(Response2, GlobalResponse);
+Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
+async function readWithoutBlocking(readPromise) {
+  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(void 0))]);
+}
+function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
+  const cancel = (error2) => {
+    reader.cancel(error2).catch(() => {
+    });
+  };
+  writable.on("close", cancel);
+  writable.on("error", cancel);
+  (currentReadPromise ?? reader.read()).then(flow, handleStreamError);
+  return reader.closed.finally(() => {
+    writable.off("close", cancel);
+    writable.off("error", cancel);
+  });
+  function handleStreamError(error2) {
+    if (error2) {
+      writable.destroy(error2);
+    }
+  }
+  function onDrain() {
+    reader.read().then(flow, handleStreamError);
+  }
+  function flow({ done, value }) {
+    try {
+      if (done) {
+        writable.end();
+      } else if (!writable.write(value)) {
+        writable.once("drain", onDrain);
+      } else {
+        return reader.read().then(flow, handleStreamError);
+      }
+    } catch (e) {
+      handleStreamError(e);
+    }
+  }
+}
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  } else if (writable.destroyed) {
+    return;
+  }
+  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
+}
+var buildOutgoingHttpHeaders = (headers) => {
+  const res = {};
+  if (!(headers instanceof Headers)) {
+    headers = new Headers(headers ?? void 0);
+  }
+  const cookies = [];
+  for (const [k, v] of headers) {
+    if (k === "set-cookie") {
+      cookies.push(v);
+    } else {
+      res[k] = v;
+    }
+  }
+  if (cookies.length > 0) {
+    res["set-cookie"] = cookies;
+  }
+  res["content-type"] ??= "text/plain; charset=UTF-8";
+  return res;
+};
+var X_ALREADY_SENT = "x-hono-already-sent";
+if (typeof global.crypto === "undefined") {
+  global.crypto = import_crypto.default;
+}
+var outgoingEnded = /* @__PURE__ */ Symbol("outgoingEnded");
+var incomingDraining = /* @__PURE__ */ Symbol("incomingDraining");
+var DRAIN_TIMEOUT_MS = 500;
+var MAX_DRAIN_BYTES = 64 * 1024 * 1024;
+var drainIncoming = (incoming) => {
+  const incomingWithDrainState = incoming;
+  if (incoming.destroyed || incomingWithDrainState[incomingDraining]) {
+    return;
+  }
+  incomingWithDrainState[incomingDraining] = true;
+  if (incoming instanceof import_http2.Http2ServerRequest) {
+    try {
+      ;
+      incoming.stream?.close?.(import_http2.constants.NGHTTP2_NO_ERROR);
+    } catch {
+    }
+    return;
+  }
+  let bytesRead = 0;
+  const cleanup = () => {
+    clearTimeout(timer);
+    incoming.off("data", onData);
+    incoming.off("end", cleanup);
+    incoming.off("error", cleanup);
+  };
+  const forceClose = () => {
+    cleanup();
+    const socket = incoming.socket;
+    if (socket && !socket.destroyed) {
+      socket.destroySoon();
+    }
+  };
+  const timer = setTimeout(forceClose, DRAIN_TIMEOUT_MS);
+  timer.unref?.();
+  const onData = (chunk) => {
+    bytesRead += chunk.length;
+    if (bytesRead > MAX_DRAIN_BYTES) {
+      forceClose();
+    }
+  };
+  incoming.on("data", onData);
+  incoming.on("end", cleanup);
+  incoming.on("error", cleanup);
+  incoming.resume();
+};
+var handleRequestError = () => new Response(null, {
+  status: 400
+});
+var handleFetchError = (e) => new Response(null, {
+  status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500
+});
+var handleResponseError = (e, outgoing) => {
+  const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
+  if (err.code === "ERR_STREAM_PREMATURE_CLOSE") {
+    console.info("The user aborted a request.");
+  } else {
+    console.error(e);
+    if (!outgoing.headersSent) {
+      outgoing.writeHead(500, { "Content-Type": "text/plain" });
+    }
+    outgoing.end(`Error: ${err.message}`);
+    outgoing.destroy(err);
+  }
+};
+var flushHeaders = (outgoing) => {
+  if ("flushHeaders" in outgoing && outgoing.writable) {
+    outgoing.flushHeaders();
+  }
+};
+var responseViaCache = async (res, outgoing) => {
+  let [status, body, header] = res[cacheKey];
+  let hasContentLength = false;
+  if (!header) {
+    header = { "content-type": "text/plain; charset=UTF-8" };
+  } else if (header instanceof Headers) {
+    hasContentLength = header.has("content-length");
+    header = buildOutgoingHttpHeaders(header);
+  } else if (Array.isArray(header)) {
+    const headerObj = new Headers(header);
+    hasContentLength = headerObj.has("content-length");
+    header = buildOutgoingHttpHeaders(headerObj);
+  } else {
+    for (const key in header) {
+      if (key.length === 14 && key.toLowerCase() === "content-length") {
+        hasContentLength = true;
+        break;
+      }
+    }
+  }
+  if (!hasContentLength) {
+    if (typeof body === "string") {
+      header["Content-Length"] = Buffer.byteLength(body);
+    } else if (body instanceof Uint8Array) {
+      header["Content-Length"] = body.byteLength;
+    } else if (body instanceof Blob) {
+      header["Content-Length"] = body.size;
+    }
+  }
+  outgoing.writeHead(status, header);
+  if (typeof body === "string" || body instanceof Uint8Array) {
+    outgoing.end(body);
+  } else if (body instanceof Blob) {
+    outgoing.end(new Uint8Array(await body.arrayBuffer()));
+  } else {
+    flushHeaders(outgoing);
+    await writeFromReadableStream(body, outgoing)?.catch(
+      (e) => handleResponseError(e, outgoing)
+    );
+  }
+  ;
+  outgoing[outgoingEnded]?.();
+};
+var isPromise = (res) => typeof res.then === "function";
+var responseViaResponseObject = async (res, outgoing, options = {}) => {
+  if (isPromise(res)) {
+    if (options.errorHandler) {
+      try {
+        res = await res;
+      } catch (err) {
+        const errRes = await options.errorHandler(err);
+        if (!errRes) {
+          return;
+        }
+        res = errRes;
+      }
+    } else {
+      res = await res.catch(handleFetchError);
+    }
+  }
+  if (cacheKey in res) {
+    return responseViaCache(res, outgoing);
+  }
+  const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
+  if (res.body) {
+    const reader = res.body.getReader();
+    const values = [];
+    let done = false;
+    let currentReadPromise = void 0;
+    if (resHeaderRecord["transfer-encoding"] !== "chunked") {
+      let maxReadCount = 2;
+      for (let i = 0; i < maxReadCount; i++) {
+        currentReadPromise ||= reader.read();
+        const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {
+          console.error(e);
+          done = true;
+        });
+        if (!chunk) {
+          if (i === 1) {
+            await new Promise((resolve) => setTimeout(resolve));
+            maxReadCount = 3;
+            continue;
+          }
+          break;
+        }
+        currentReadPromise = void 0;
+        if (chunk.value) {
+          values.push(chunk.value);
+        }
+        if (chunk.done) {
+          done = true;
+          break;
+        }
+      }
+      if (done && !("content-length" in resHeaderRecord)) {
+        resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
+      }
+    }
+    outgoing.writeHead(res.status, resHeaderRecord);
+    values.forEach((value) => {
+      ;
+      outgoing.write(value);
+    });
+    if (done) {
+      outgoing.end();
+    } else {
+      if (values.length === 0) {
+        flushHeaders(outgoing);
+      }
+      await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
+    }
+  } else if (resHeaderRecord[X_ALREADY_SENT]) {
+  } else {
+    outgoing.writeHead(res.status, resHeaderRecord);
+    outgoing.end();
+  }
+  ;
+  outgoing[outgoingEnded]?.();
+};
+var getRequestListener = (fetchCallback, options = {}) => {
+  const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
+  if (options.overrideGlobalObjects !== false && global.Request !== Request) {
+    Object.defineProperty(global, "Request", {
+      value: Request
+    });
+    Object.defineProperty(global, "Response", {
+      value: Response2
+    });
+  }
+  return async (incoming, outgoing) => {
+    let res, req;
+    try {
+      req = newRequest(incoming, options.hostname);
+      let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
+      if (!incomingEnded) {
+        ;
+        incoming[wrapBodyStream] = true;
+        incoming.on("end", () => {
+          incomingEnded = true;
+        });
+        if (incoming instanceof import_http2.Http2ServerRequest) {
+          ;
+          outgoing[outgoingEnded] = () => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                if (!incomingEnded) {
+                  setTimeout(() => {
+                    drainIncoming(incoming);
+                  });
+                }
+              });
+            }
+          };
+        }
+        outgoing.on("finish", () => {
+          if (!incomingEnded) {
+            drainIncoming(incoming);
+          }
+        });
+      }
+      outgoing.on("close", () => {
+        const abortController = req[abortControllerKey];
+        if (abortController) {
+          if (incoming.errored) {
+            req[abortControllerKey].abort(incoming.errored.toString());
+          } else if (!outgoing.writableFinished) {
+            req[abortControllerKey].abort("Client connection prematurely closed.");
+          }
+        }
+        if (!incomingEnded) {
+          setTimeout(() => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                drainIncoming(incoming);
+              });
+            }
+          });
+        }
+      });
+      res = fetchCallback(req, { incoming, outgoing });
+      if (cacheKey in res) {
+        return responseViaCache(res, outgoing);
+      }
+    } catch (e) {
+      if (!res) {
+        if (options.errorHandler) {
+          res = await options.errorHandler(req ? e : toRequestError(e));
+          if (!res) {
+            return;
+          }
+        } else if (!req) {
+          res = handleRequestError();
+        } else {
+          res = handleFetchError(e);
+        }
+      } else {
+        return handleResponseError(e, outgoing);
+      }
+    }
+    try {
+      return await responseViaResponseObject(res, outgoing, options);
+    } catch (e) {
+      return handleResponseError(e, outgoing);
+    }
+  };
+};
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/webStandardStreamableHttp.js
+var WebStandardStreamableHTTPServerTransport = class {
+  constructor(options = {}) {
+    this._started = false;
+    this._hasHandledRequest = false;
+    this._streamMapping = /* @__PURE__ */ new Map();
+    this._requestToStreamMapping = /* @__PURE__ */ new Map();
+    this._requestResponseMap = /* @__PURE__ */ new Map();
+    this._initialized = false;
+    this._enableJsonResponse = false;
+    this._standaloneSseStreamId = "_GET_stream";
+    this.sessionIdGenerator = options.sessionIdGenerator;
+    this._enableJsonResponse = options.enableJsonResponse ?? false;
+    this._eventStore = options.eventStore;
+    this._onsessioninitialized = options.onsessioninitialized;
+    this._onsessionclosed = options.onsessionclosed;
+    this._allowedHosts = options.allowedHosts;
+    this._allowedOrigins = options.allowedOrigins;
+    this._enableDnsRebindingProtection = options.enableDnsRebindingProtection ?? false;
+    this._retryInterval = options.retryInterval;
+  }
+  /**
+   * Starts the transport. This is required by the Transport interface but is a no-op
+   * for the Streamable HTTP transport as connections are managed per-request.
+   */
+  async start() {
+    if (this._started) {
+      throw new Error("Transport already started");
+    }
+    this._started = true;
+  }
+  /**
+   * Helper to create a JSON error response
+   */
+  createJsonErrorResponse(status, code, message, options) {
+    const error2 = { code, message };
+    if (options?.data !== void 0) {
+      error2.data = options.data;
+    }
+    return new Response(JSON.stringify({
+      jsonrpc: "2.0",
+      error: error2,
+      id: null
+    }), {
+      status,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers
+      }
+    });
+  }
+  /**
+   * Validates request headers for DNS rebinding protection.
+   * @returns Error response if validation fails, undefined if validation passes.
+   */
+  validateRequestHeaders(req) {
+    if (!this._enableDnsRebindingProtection) {
+      return void 0;
+    }
+    if (this._allowedHosts && this._allowedHosts.length > 0) {
+      const hostHeader = req.headers.get("host");
+      if (!hostHeader || !this._allowedHosts.includes(hostHeader)) {
+        const error2 = `Invalid Host header: ${hostHeader}`;
+        this.onerror?.(new Error(error2));
+        return this.createJsonErrorResponse(403, -32e3, error2);
+      }
+    }
+    if (this._allowedOrigins && this._allowedOrigins.length > 0) {
+      const originHeader = req.headers.get("origin");
+      if (originHeader && !this._allowedOrigins.includes(originHeader)) {
+        const error2 = `Invalid Origin header: ${originHeader}`;
+        this.onerror?.(new Error(error2));
+        return this.createJsonErrorResponse(403, -32e3, error2);
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Handles an incoming HTTP request, whether GET, POST, or DELETE
+   * Returns a Response object (Web Standard)
+   */
+  async handleRequest(req, options) {
+    if (!this.sessionIdGenerator && this._hasHandledRequest) {
+      throw new Error("Stateless transport cannot be reused across requests. Create a new transport per request.");
+    }
+    this._hasHandledRequest = true;
+    const validationError = this.validateRequestHeaders(req);
+    if (validationError) {
+      return validationError;
+    }
+    switch (req.method) {
+      case "POST":
+        return this.handlePostRequest(req, options);
+      case "GET":
+        return this.handleGetRequest(req);
+      case "DELETE":
+        return this.handleDeleteRequest(req);
+      default:
+        return this.handleUnsupportedRequest();
+    }
+  }
+  /**
+   * Writes a priming event to establish resumption capability.
+   * Only sends if eventStore is configured (opt-in for resumability) and
+   * the client's protocol version supports empty SSE data (>= 2025-11-25).
+   */
+  async writePrimingEvent(controller, encoder, streamId, protocolVersion) {
+    if (!this._eventStore) {
+      return;
+    }
+    if (protocolVersion < "2025-11-25") {
+      return;
+    }
+    const primingEventId = await this._eventStore.storeEvent(streamId, {});
+    let primingEvent = `id: ${primingEventId}
+data: 
+
+`;
+    if (this._retryInterval !== void 0) {
+      primingEvent = `id: ${primingEventId}
+retry: ${this._retryInterval}
+data: 
+
+`;
+    }
+    controller.enqueue(encoder.encode(primingEvent));
+  }
+  /**
+   * Handles GET requests for SSE stream
+   */
+  async handleGetRequest(req) {
+    const acceptHeader = req.headers.get("accept");
+    if (!acceptHeader?.includes("text/event-stream")) {
+      this.onerror?.(new Error("Not Acceptable: Client must accept text/event-stream"));
+      return this.createJsonErrorResponse(406, -32e3, "Not Acceptable: Client must accept text/event-stream");
+    }
+    const sessionError = this.validateSession(req);
+    if (sessionError) {
+      return sessionError;
+    }
+    const protocolError = this.validateProtocolVersion(req);
+    if (protocolError) {
+      return protocolError;
+    }
+    if (this._eventStore) {
+      const lastEventId = req.headers.get("last-event-id");
+      if (lastEventId) {
+        return this.replayEvents(lastEventId);
+      }
+    }
+    if (this._streamMapping.get(this._standaloneSseStreamId) !== void 0) {
+      this.onerror?.(new Error("Conflict: Only one SSE stream is allowed per session"));
+      return this.createJsonErrorResponse(409, -32e3, "Conflict: Only one SSE stream is allowed per session");
+    }
+    const encoder = new TextEncoder();
+    let streamController;
+    const readable = new ReadableStream({
+      start: (controller) => {
+        streamController = controller;
+      },
+      cancel: () => {
+        this._streamMapping.delete(this._standaloneSseStreamId);
+      }
+    });
+    const headers = {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive"
+    };
+    if (this.sessionId !== void 0) {
+      headers["mcp-session-id"] = this.sessionId;
+    }
+    this._streamMapping.set(this._standaloneSseStreamId, {
+      controller: streamController,
+      encoder,
+      cleanup: () => {
+        this._streamMapping.delete(this._standaloneSseStreamId);
+        try {
+          streamController.close();
+        } catch {
+        }
+      }
+    });
+    return new Response(readable, { headers });
+  }
+  /**
+   * Replays events that would have been sent after the specified event ID
+   * Only used when resumability is enabled
+   */
+  async replayEvents(lastEventId) {
+    if (!this._eventStore) {
+      this.onerror?.(new Error("Event store not configured"));
+      return this.createJsonErrorResponse(400, -32e3, "Event store not configured");
+    }
+    try {
+      let streamId;
+      if (this._eventStore.getStreamIdForEventId) {
+        streamId = await this._eventStore.getStreamIdForEventId(lastEventId);
+        if (!streamId) {
+          this.onerror?.(new Error("Invalid event ID format"));
+          return this.createJsonErrorResponse(400, -32e3, "Invalid event ID format");
+        }
+        if (this._streamMapping.get(streamId) !== void 0) {
+          this.onerror?.(new Error("Conflict: Stream already has an active connection"));
+          return this.createJsonErrorResponse(409, -32e3, "Conflict: Stream already has an active connection");
+        }
+      }
+      const headers = {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive"
+      };
+      if (this.sessionId !== void 0) {
+        headers["mcp-session-id"] = this.sessionId;
+      }
+      const encoder = new TextEncoder();
+      let streamController;
+      const readable = new ReadableStream({
+        start: (controller) => {
+          streamController = controller;
+        },
+        cancel: () => {
+        }
+      });
+      const replayedStreamId = await this._eventStore.replayEventsAfter(lastEventId, {
+        send: async (eventId, message) => {
+          const success = this.writeSSEEvent(streamController, encoder, message, eventId);
+          if (!success) {
+            this.onerror?.(new Error("Failed replay events"));
+            try {
+              streamController.close();
+            } catch {
+            }
+          }
+        }
+      });
+      this._streamMapping.set(replayedStreamId, {
+        controller: streamController,
+        encoder,
+        cleanup: () => {
+          this._streamMapping.delete(replayedStreamId);
+          try {
+            streamController.close();
+          } catch {
+          }
+        }
+      });
+      return new Response(readable, { headers });
+    } catch (error2) {
+      this.onerror?.(error2);
+      return this.createJsonErrorResponse(500, -32e3, "Error replaying events");
+    }
+  }
+  /**
+   * Writes an event to an SSE stream via controller with proper formatting
+   */
+  writeSSEEvent(controller, encoder, message, eventId) {
+    try {
+      let eventData = `event: message
+`;
+      if (eventId) {
+        eventData += `id: ${eventId}
+`;
+      }
+      eventData += `data: ${JSON.stringify(message)}
+
+`;
+      controller.enqueue(encoder.encode(eventData));
+      return true;
+    } catch (error2) {
+      this.onerror?.(error2);
+      return false;
+    }
+  }
+  /**
+   * Handles unsupported requests (PUT, PATCH, etc.)
+   */
+  handleUnsupportedRequest() {
+    this.onerror?.(new Error("Method not allowed."));
+    return new Response(JSON.stringify({
+      jsonrpc: "2.0",
+      error: {
+        code: -32e3,
+        message: "Method not allowed."
+      },
+      id: null
+    }), {
+      status: 405,
+      headers: {
+        Allow: "GET, POST, DELETE",
+        "Content-Type": "application/json"
+      }
+    });
+  }
+  /**
+   * Handles POST requests containing JSON-RPC messages
+   */
+  async handlePostRequest(req, options) {
+    try {
+      const acceptHeader = req.headers.get("accept");
+      if (!acceptHeader?.includes("application/json") || !acceptHeader.includes("text/event-stream")) {
+        this.onerror?.(new Error("Not Acceptable: Client must accept both application/json and text/event-stream"));
+        return this.createJsonErrorResponse(406, -32e3, "Not Acceptable: Client must accept both application/json and text/event-stream");
+      }
+      const ct = req.headers.get("content-type");
+      if (!ct || !ct.includes("application/json")) {
+        this.onerror?.(new Error("Unsupported Media Type: Content-Type must be application/json"));
+        return this.createJsonErrorResponse(415, -32e3, "Unsupported Media Type: Content-Type must be application/json");
+      }
+      const requestInfo = {
+        headers: Object.fromEntries(req.headers.entries()),
+        url: new URL(req.url)
+      };
+      let rawMessage;
+      if (options?.parsedBody !== void 0) {
+        rawMessage = options.parsedBody;
+      } else {
+        try {
+          rawMessage = await req.json();
+        } catch {
+          this.onerror?.(new Error("Parse error: Invalid JSON"));
+          return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON");
+        }
+      }
+      let messages;
+      try {
+        if (Array.isArray(rawMessage)) {
+          messages = rawMessage.map((msg) => JSONRPCMessageSchema.parse(msg));
+        } else {
+          messages = [JSONRPCMessageSchema.parse(rawMessage)];
+        }
+      } catch {
+        this.onerror?.(new Error("Parse error: Invalid JSON-RPC message"));
+        return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON-RPC message");
+      }
+      const isInitializationRequest = messages.some(isInitializeRequest);
+      if (isInitializationRequest) {
+        if (this._initialized && this.sessionId !== void 0) {
+          this.onerror?.(new Error("Invalid Request: Server already initialized"));
+          return this.createJsonErrorResponse(400, -32600, "Invalid Request: Server already initialized");
+        }
+        if (messages.length > 1) {
+          this.onerror?.(new Error("Invalid Request: Only one initialization request is allowed"));
+          return this.createJsonErrorResponse(400, -32600, "Invalid Request: Only one initialization request is allowed");
+        }
+        this.sessionId = this.sessionIdGenerator?.();
+        this._initialized = true;
+        if (this.sessionId && this._onsessioninitialized) {
+          await Promise.resolve(this._onsessioninitialized(this.sessionId));
+        }
+      }
+      if (!isInitializationRequest) {
+        const sessionError = this.validateSession(req);
+        if (sessionError) {
+          return sessionError;
+        }
+        const protocolError = this.validateProtocolVersion(req);
+        if (protocolError) {
+          return protocolError;
+        }
+      }
+      const hasRequests = messages.some(isJSONRPCRequest);
+      if (!hasRequests) {
+        for (const message of messages) {
+          this.onmessage?.(message, { authInfo: options?.authInfo, requestInfo });
+        }
+        return new Response(null, { status: 202 });
+      }
+      const streamId = crypto.randomUUID();
+      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((resolve) => {
+          this._streamMapping.set(streamId, {
+            resolveJson: resolve,
+            cleanup: () => {
+              this._streamMapping.delete(streamId);
+            }
+          });
+          for (const message of messages) {
+            if (isJSONRPCRequest(message)) {
+              this._requestToStreamMapping.set(message.id, streamId);
+            }
+          }
+          for (const message of messages) {
+            this.onmessage?.(message, { authInfo: options?.authInfo, requestInfo });
+          }
+        });
+      }
+      const encoder = new TextEncoder();
+      let streamController;
+      const readable = new ReadableStream({
+        start: (controller) => {
+          streamController = controller;
+        },
+        cancel: () => {
+          this._streamMapping.delete(streamId);
+        }
+      });
+      const headers = {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      };
+      if (this.sessionId !== void 0) {
+        headers["mcp-session-id"] = this.sessionId;
+      }
+      for (const message of messages) {
+        if (isJSONRPCRequest(message)) {
+          this._streamMapping.set(streamId, {
+            controller: streamController,
+            encoder,
+            cleanup: () => {
+              this._streamMapping.delete(streamId);
+              try {
+                streamController.close();
+              } catch {
+              }
+            }
+          });
+          this._requestToStreamMapping.set(message.id, streamId);
+        }
+      }
+      await this.writePrimingEvent(streamController, encoder, streamId, clientProtocolVersion);
+      for (const message of messages) {
+        let closeSSEStream;
+        let closeStandaloneSSEStream;
+        if (isJSONRPCRequest(message) && this._eventStore && clientProtocolVersion >= "2025-11-25") {
+          closeSSEStream = () => {
+            this.closeSSEStream(message.id);
+          };
+          closeStandaloneSSEStream = () => {
+            this.closeStandaloneSSEStream();
+          };
+        }
+        this.onmessage?.(message, { authInfo: options?.authInfo, requestInfo, closeSSEStream, closeStandaloneSSEStream });
+      }
+      return new Response(readable, { status: 200, headers });
+    } catch (error2) {
+      this.onerror?.(error2);
+      return this.createJsonErrorResponse(400, -32700, "Parse error", { data: String(error2) });
+    }
+  }
+  /**
+   * Handles DELETE requests to terminate sessions
+   */
+  async handleDeleteRequest(req) {
+    const sessionError = this.validateSession(req);
+    if (sessionError) {
+      return sessionError;
+    }
+    const protocolError = this.validateProtocolVersion(req);
+    if (protocolError) {
+      return protocolError;
+    }
+    await Promise.resolve(this._onsessionclosed?.(this.sessionId));
+    await this.close();
+    return new Response(null, { status: 200 });
+  }
+  /**
+   * Validates session ID for non-initialization requests.
+   * Returns Response error if invalid, undefined otherwise
+   */
+  validateSession(req) {
+    if (this.sessionIdGenerator === void 0) {
+      return void 0;
+    }
+    if (!this._initialized) {
+      this.onerror?.(new Error("Bad Request: Server not initialized"));
+      return this.createJsonErrorResponse(400, -32e3, "Bad Request: Server not initialized");
+    }
+    const sessionId = req.headers.get("mcp-session-id");
+    if (!sessionId) {
+      this.onerror?.(new Error("Bad Request: Mcp-Session-Id header is required"));
+      return this.createJsonErrorResponse(400, -32e3, "Bad Request: Mcp-Session-Id header is required");
+    }
+    if (sessionId !== this.sessionId) {
+      this.onerror?.(new Error("Session not found"));
+      return this.createJsonErrorResponse(404, -32001, "Session not found");
+    }
+    return void 0;
+  }
+  /**
+   * Validates the MCP-Protocol-Version header on incoming requests.
+   *
+   * For initialization: Version negotiation handles unknown versions gracefully
+   * (server responds with its supported version).
+   *
+   * For subsequent requests with MCP-Protocol-Version header:
+   * - Accept if in supported list
+   * - 400 if unsupported
+   *
+   * For HTTP requests without the MCP-Protocol-Version header:
+   * - Accept and default to the version negotiated at initialization
+   */
+  validateProtocolVersion(req) {
+    const protocolVersion = req.headers.get("mcp-protocol-version");
+    if (protocolVersion !== null && !SUPPORTED_PROTOCOL_VERSIONS.includes(protocolVersion)) {
+      this.onerror?.(new Error(`Bad Request: Unsupported protocol version: ${protocolVersion} (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`));
+      return this.createJsonErrorResponse(400, -32e3, `Bad Request: Unsupported protocol version: ${protocolVersion} (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`);
+    }
+    return void 0;
+  }
+  async close() {
+    this._streamMapping.forEach(({ cleanup }) => {
+      cleanup();
+    });
+    this._streamMapping.clear();
+    this._requestResponseMap.clear();
+    this.onclose?.();
+  }
+  /**
+   * Close an SSE stream for a specific request, triggering client reconnection.
+   * Use this to implement polling behavior during long-running operations -
+   * client will reconnect after the retry interval specified in the priming event.
+   */
+  closeSSEStream(requestId) {
+    const streamId = this._requestToStreamMapping.get(requestId);
+    if (!streamId)
+      return;
+    const stream = this._streamMapping.get(streamId);
+    if (stream) {
+      stream.cleanup();
+    }
+  }
+  /**
+   * Close the standalone GET SSE stream, triggering client reconnection.
+   * Use this to implement polling behavior for server-initiated notifications.
+   */
+  closeStandaloneSSEStream() {
+    const stream = this._streamMapping.get(this._standaloneSseStreamId);
+    if (stream) {
+      stream.cleanup();
+    }
+  }
+  async send(message, options) {
+    let requestId = options?.relatedRequestId;
+    if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
+      requestId = message.id;
+    }
+    if (requestId === void 0) {
+      if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
+        throw new Error("Cannot send a response on a standalone SSE stream unless resuming a previous client request");
+      }
+      let eventId;
+      if (this._eventStore) {
+        eventId = await this._eventStore.storeEvent(this._standaloneSseStreamId, message);
+      }
+      const standaloneSse = this._streamMapping.get(this._standaloneSseStreamId);
+      if (standaloneSse === void 0) {
+        return;
+      }
+      if (standaloneSse.controller && standaloneSse.encoder) {
+        this.writeSSEEvent(standaloneSse.controller, standaloneSse.encoder, message, eventId);
+      }
+      return;
+    }
+    const streamId = this._requestToStreamMapping.get(requestId);
+    if (!streamId) {
+      throw new Error(`No connection established for request ID: ${String(requestId)}`);
+    }
+    const stream = this._streamMapping.get(streamId);
+    if (!this._enableJsonResponse && stream?.controller && stream?.encoder) {
+      let eventId;
+      if (this._eventStore) {
+        eventId = await this._eventStore.storeEvent(streamId, message);
+      }
+      this.writeSSEEvent(stream.controller, stream.encoder, message, eventId);
+    }
+    if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
+      this._requestResponseMap.set(requestId, message);
+      const relatedIds = Array.from(this._requestToStreamMapping.entries()).filter(([_, sid]) => sid === streamId).map(([id]) => id);
+      const allResponsesReady = relatedIds.every((id) => this._requestResponseMap.has(id));
+      if (allResponsesReady) {
+        if (!stream) {
+          throw new Error(`No connection established for request ID: ${String(requestId)}`);
+        }
+        if (this._enableJsonResponse && stream.resolveJson) {
+          const headers = {
+            "Content-Type": "application/json"
+          };
+          if (this.sessionId !== void 0) {
+            headers["mcp-session-id"] = this.sessionId;
+          }
+          const responses = relatedIds.map((id) => this._requestResponseMap.get(id));
+          if (responses.length === 1) {
+            stream.resolveJson(new Response(JSON.stringify(responses[0]), { status: 200, headers }));
+          } else {
+            stream.resolveJson(new Response(JSON.stringify(responses), { status: 200, headers }));
+          }
+        } else {
+          stream.cleanup();
+        }
+        for (const id of relatedIds) {
+          this._requestResponseMap.delete(id);
+          this._requestToStreamMapping.delete(id);
+        }
+      }
+    }
+  }
+};
+
+// node_modules/@modelcontextprotocol/sdk/dist/esm/server/streamableHttp.js
+var StreamableHTTPServerTransport = class {
+  constructor(options = {}) {
+    this._requestContext = /* @__PURE__ */ new WeakMap();
+    this._webStandardTransport = new WebStandardStreamableHTTPServerTransport(options);
+    this._requestListener = getRequestListener(async (webRequest) => {
+      const context = this._requestContext.get(webRequest);
+      return this._webStandardTransport.handleRequest(webRequest, {
+        authInfo: context?.authInfo,
+        parsedBody: context?.parsedBody
+      });
+    }, { overrideGlobalObjects: false });
+  }
+  /**
+   * Gets the session ID for this transport instance.
+   */
+  get sessionId() {
+    return this._webStandardTransport.sessionId;
+  }
+  /**
+   * Sets callback for when the transport is closed.
+   */
+  set onclose(handler) {
+    this._webStandardTransport.onclose = handler;
+  }
+  get onclose() {
+    return this._webStandardTransport.onclose;
+  }
+  /**
+   * Sets callback for transport errors.
+   */
+  set onerror(handler) {
+    this._webStandardTransport.onerror = handler;
+  }
+  get onerror() {
+    return this._webStandardTransport.onerror;
+  }
+  /**
+   * Sets callback for incoming messages.
+   */
+  set onmessage(handler) {
+    this._webStandardTransport.onmessage = handler;
+  }
+  get onmessage() {
+    return this._webStandardTransport.onmessage;
+  }
+  /**
+   * Starts the transport. This is required by the Transport interface but is a no-op
+   * for the Streamable HTTP transport as connections are managed per-request.
+   */
+  async start() {
+    return this._webStandardTransport.start();
+  }
+  /**
+   * Closes the transport and all active connections.
+   */
+  async close() {
+    return this._webStandardTransport.close();
+  }
+  /**
+   * Sends a JSON-RPC message through the transport.
+   */
+  async send(message, options) {
+    return this._webStandardTransport.send(message, options);
+  }
+  /**
+   * Handles an incoming HTTP request, whether GET or POST.
+   *
+   * This method converts Node.js HTTP objects to Web Standard Request/Response
+   * and delegates to the underlying WebStandardStreamableHTTPServerTransport.
+   *
+   * @param req - Node.js IncomingMessage, optionally with auth property from middleware
+   * @param res - Node.js ServerResponse
+   * @param parsedBody - Optional pre-parsed body from body-parser middleware
+   */
+  async handleRequest(req, res, parsedBody) {
+    const authInfo = req.auth;
+    const handler = getRequestListener(async (webRequest) => {
+      return this._webStandardTransport.handleRequest(webRequest, {
+        authInfo,
+        parsedBody
+      });
+    }, { overrideGlobalObjects: false });
+    await handler(req, res);
+  }
+  /**
+   * Close an SSE stream for a specific request, triggering client reconnection.
+   * Use this to implement polling behavior during long-running operations -
+   * client will reconnect after the retry interval specified in the priming event.
+   */
+  closeSSEStream(requestId) {
+    this._webStandardTransport.closeSSEStream(requestId);
+  }
+  /**
+   * Close the standalone GET SSE stream, triggering client reconnection.
+   * Use this to implement polling behavior for server-initiated notifications.
+   */
+  closeStandaloneSSEStream() {
+    this._webStandardTransport.closeStandaloneSSEStream();
+  }
+};
+
 // src/adapters/okx.ts
 var import_node_crypto = __toESM(require("node:crypto"));
 var BASE = "https://www.okx.com";
@@ -25298,7 +26628,41 @@ var INST_TYPE_CONTRACTS = ["SWAP", "FUTURES", "OPTION"];
 var INST_TYPE_SWAP_FUT = ["SWAP", "FUTURES"];
 var INST_TYPE_MARGIN_PUB = ["MARGIN", "SWAP", "FUTURES", "OPTION"];
 var INST_TYPE_RUBIK = ["SPOT", "CONTRACTS"];
+function autoSummary(data) {
+  if (Array.isArray(data)) {
+    const n = data.length;
+    if (n === 0) return "\u8FD4\u56DE\u7A7A\u5217\u8868";
+    const first = data[0];
+    if (first?.instId && first?.last) return `\u8FD4\u56DE ${n} \u4E2A\u4EA7\u54C1\u884C\u60C5`;
+    if (first?.instId && first?.pos) return `\u8FD4\u56DE ${n} \u4E2A\u6301\u4ED3`;
+    if (first?.ccy) return `\u8FD4\u56DE ${n} \u4E2A\u5E01\u79CD\u4FE1\u606F`;
+    if (first?.ordId) return `\u8FD4\u56DE ${n} \u7B14\u8BA2\u5355`;
+    if (first?.ts) return `\u8FD4\u56DE ${n} \u6761\u65F6\u95F4\u5E8F\u5217\u6570\u636E`;
+    if (first?.name) return `\u8FD4\u56DE ${n} \u6761\u8BB0\u5F55`;
+    return `\u8FD4\u56DE ${n} \u6761\u8BB0\u5F55`;
+  }
+  if (typeof data === "object" && data !== null) {
+    const d = data;
+    if (d.ok === true && d.message) return d.message;
+    if (d._summary) return void 0;
+    if (d.data && Array.isArray(d.data)) return `\u8FD4\u56DE ${d.data.length} \u6761\u8BB0\u5F55`;
+  }
+  return void 0;
+}
 function toResult(data) {
+  if (Array.isArray(data)) {
+    const summary = autoSummary(data);
+    const wrapper = { list: data };
+    if (summary) wrapper._summary = summary;
+    return { content: [{ type: "text", text: JSON.stringify(wrapper, null, 2) }] };
+  }
+  if (typeof data === "object" && data !== null && !data._summary) {
+    const summary = autoSummary(data);
+    if (summary) {
+      const enriched = { _summary: summary, ...data };
+      return { content: [{ type: "text", text: JSON.stringify(enriched, null, 2) }] };
+    }
+  }
   return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
 }
 function classifyError(msg) {
@@ -32214,10 +33578,10 @@ function registerAgentUtils(server, auth) {
   );
   const CATALOG = {
     _instruction: [
-      "\u4F60\u662F hvip MCP Server \u7684 Agent\u3002\u672C\u76EE\u5F55\u5E2E\u4F60\u6309\u7528\u6237\u610F\u56FE\u5FEB\u901F\u5B9A\u4F4D\u5DE5\u5177\uFF0C\u65E0\u9700\u626B\u63CF\u5168\u90E8 350+ \u4E2A\u5DE5\u5177\u63CF\u8FF0\u3002",
-      "\u7528\u6CD5: 1) \u6839\u636E\u7528\u6237\u8BF4\u7684\u8BDD\u5339\u914D\u4E0B\u65B9\u67D0\u4E2A\u57DF\u7684 when \u89E6\u53D1\u8BCD \u2192 2) \u8C03\u7528\u8BE5\u57DF\u7684 go_to \u5DE5\u5177 \u2192 3) \u5982\u9700\u6DF1\u5165\u518D\u8C03\u7528 also \u5217\u8868\u4E2D\u7684\u5DE5\u5177\u3002",
+      "\u4F60\u662F hvip MCP Server \u7684 AI Agent\u3002\u6536\u5230\u672C\u76EE\u5F55\u540E\uFF0C\u4F60\u5DF2\u7ECF\u638C\u63E1\u5168\u90E8\u5FC5\u8981\u4FE1\u606F\uFF0C\u65E0\u9700\u518D\u626B\u63CF tools/list\u3002",
+      "\u5DE5\u4F5C\u6D41: 1) \u770B _setup \u4E86\u89E3\u8FDE\u63A5\u72B6\u6001 -> 2) _onboarding \u51B3\u5B9A\u7B2C\u4E00\u6B65 -> 3) \u5339\u914D\u7528\u6237\u610F\u56FE\u5230\u57DF -> 4) \u7528 go_to_params \u76F4\u63A5\u8C03\u76EE\u6807\u5DE5\u5177\u3002",
       "\u4E0D\u786E\u5B9A\u57DF\u65F6\u8C03\u7528 agent_catalog_detail { domain } \u67E5\u770B\u8BE5\u57DF\u7684\u8BE6\u7EC6\u5DE5\u5177\u6E05\u5355\u3002",
-      "\u6CE8\u610F: \u6240\u6709 WRITE/ADMIN \u7EA7\u522B\u7684\u5DE5\u5177\u9700\u7528\u6237\u786E\u8BA4\u540E\u624D\u80FD\u8C03\u7528\u3002"
+      "\u6240\u6709 WRITE/FUND_TRANSFER/ADMIN \u5DE5\u5177\u9700\u7528\u6237\u786E\u8BA4\u540E\u8C03\u7528\uFF0C\u4E0D\u53EF\u81EA\u52A8\u53D1\u8D77\u3002"
     ].join(" "),
     domains: [
       {
@@ -32433,10 +33797,10 @@ function registerAgentUtils(server, auth) {
       }
     ],
     _tips: [
-      "Agent \u6700\u4F73\u5B9E\u8DF5\uFF1A\u6BCF\u4E2A\u65B0\u4F1A\u8BDD\u5148\u8C03 agent_get_preference \u6062\u590D\u7528\u6237\u504F\u597D",
-      "\u9700\u8981 API Key \u7684\u5DE5\u5177\uFF08\u8D26\u6237/\u4EA4\u6613\u7C7B\uFF09\u9700\u7528\u6237\u5148\u914D\u7F6E OKX_API_KEY / OKX_SECRET_KEY / OKX_PASSPHRASE \u73AF\u5883\u53D8\u91CF",
-      "WRITE \u7EA7\u522B\u5DE5\u5177\u4F1A\u4FEE\u6539\u7528\u6237\u8D26\u6237\uFF0C\u8C03\u7528\u524D Agent \u5FC5\u987B\u5411\u7528\u6237\u786E\u8BA4",
-      "\u6DF1\u5EA6\u8C03\u7814\u67D0\u4E2A\u57DF\u65F6\u8C03 agent_catalog_detail { domain } \u83B7\u53D6\u8BE5\u57DF\u5168\u90E8\u5DE5\u5177\u8BE6\u60C5",
+      "\u6BCF\u4E2A\u65B0\u4F1A\u8BDD\u5148\u8C03 agent_get_preference \u6062\u590D\u7528\u6237\u504F\u597D(\u9ED8\u8BA4\u4EA4\u6613\u5BF9/\u98CE\u9669\u504F\u597D/\u4ED3\u4F4D\u5360\u6BD4)",
+      "\u9700\u8981 API Key \u65F6\u544A\u8BC9\u7528\u6237\u53BB OKX \u5B98\u7F51\u521B\u5EFA\uFF0C\u5F00\u901A\u8BFB\u53D6+\u4EA4\u6613\u6743\u9650",
+      "\u5148\u6A21\u62DF\u540E\u4EA4\u6613: agent_simulate_order \u9884\u4F30 -> \u786E\u8BA4 -> agent_quick_trade \u4E0B\u5355",
+      "WRITE \u5DE5\u5177\u4F1A\u4FEE\u6539\u8D26\u6237\uFF0C\u8C03\u7528\u524D\u5FC5\u987B\u5411\u7528\u6237\u786E\u8BA4\uFF0C\u4E0D\u53EF\u81EA\u52A8\u53D1\u8D77",
       "\u6280\u672F\u6307\u6807\u7528 okx_indicator \u5355\u4E2A\u8BA1\u7B97\u6216 okx_indicator_batch \u6279\u91CF\uFF0C\u652F\u6301 RSI/MACD/\u5E03\u6797\u5E26\u7B49 17 \u79CD",
       "\u806A\u660E\u94B1\u5206\u6790\u7528 okx_smart_leaderboard \u627E\u9876\u5C16\u4EA4\u6613\u5458 \u2192 okx_smart_sentiment \u770B\u5E02\u573A\u60C5\u7EEA"
     ]
@@ -32447,9 +33811,53 @@ function registerAgentUtils(server, auth) {
     {},
     async () => {
       try {
+        const hasAuth = auth !== null;
+        const setup = {
+          hasApiKey: hasAuth,
+          readOnly: process.env.OKX_READ_ONLY === "true",
+          mode: hasAuth ? process.env.OKX_READ_ONLY === "true" ? "\u53EA\u8BFB\uFF08WRITE \u5DE5\u5177\u5DF2\u9690\u85CF\uFF09" : "\u5B8C\u6574\u4EA4\u6613\uFF08\u6240\u6709\u5DE5\u5177\u53EF\u7528\uFF09" : "\u672A\u914D\u7F6E API Key\uFF08\u4EC5\u516C\u5F00\u5DE5\u5177\u53EF\u7528\uFF09"
+        };
+        if (!hasAuth) {
+          setup.howToConfigure = {
+            required: ["OKX_API_KEY", "OKX_SECRET_KEY", "OKX_PASSPHRASE"],
+            where: "OKX \u5B98\u7F51 -> \u4E2A\u4EBA\u4E2D\u5FC3 -> API -> \u521B\u5EFA API Key\uFF08\u5F00\u901A \u8BFB\u53D6+\u4EA4\u6613 \u6743\u9650\uFF09",
+            quickStart: "npx hvip-mcp setup --client claude-code"
+          };
+          setup.whatYouCanDoNow = "\u5F53\u524D\u65E0 API Key\uFF0C\u4F46\u4EE5\u4E0B\u57DF\u7684\u5DE5\u5177\u53EF\u7ACB\u5373\u4F7F\u7528: \u884C\u60C5\u770B\u76D8 / \u6280\u672F\u6307\u6807 / \u5E02\u573A\u626B\u63CF / \u806A\u660E\u94B1 / \u9884\u6D4B\u5E02\u573A\uFF08\u516C\u5F00\u67E5\u8BE2\uFF09/ WebSocket \u5B9E\u65F6 / \u7CFB\u7EDF\u5DE5\u5177";
+        }
+        const onboarding = hasAuth ? "API Key \u5DF2\u914D\u7F6E\u3002\u5EFA\u8BAE\u7B2C\u4E00\u6B65: agent_get_preference \u6062\u590D\u504F\u597D -> okx_account_overview \u4E86\u89E3\u8D26\u6237\u5168\u666F -> \u6839\u636E\u7528\u6237\u610F\u56FE\u5339\u914D\u57DF go_to \u5DE5\u5177" : "\u6B22\u8FCE\uFF01hvip MCP \u5DF2\u8FDE\u63A5\u4F46\u5C1A\u672A\u914D\u7F6E API Key\u3002\u544A\u8BC9\u7528\u6237\uFF1A\u60F3\u770B\u884C\u60C5\u548C\u6307\u6807\u73B0\u5728\u5C31\u80FD\u770B\uFF0C\u60F3\u770B\u8D26\u6237\u548C\u4EA4\u6613\u8BF7\u5148\u914D Key\u3002\u914D\u597D\u540E\u91CD\u8FDE MCP \u5373\u53EF\u3002";
+        const paramsHints = {
+          "okx_account_overview": "\u65E0\u9700\u53C2\u6570",
+          "okx_quick_market": "instId (\u5982 BTC-USDT\u3001ETH-USDT-SWAP)",
+          "okx_preflight_check": "instId, tdMode (cash|cross|isolated), sz, px?, side?, ordType?",
+          "agent_quick_trade": "instId, side (buy|sell), sz, tdMode (cash|cross|isolated), px?, ordType?",
+          "agent_risk_overview": "\u65E0\u9700\u53C2\u6570",
+          "agent_market_scan": "instType? (\u9ED8\u8BA4SWAP), topN?, sortBy? (change|vol|fundingRate)",
+          "agent_pnl_report": "days? (\u9ED8\u8BA47)",
+          "okx_get_balance": "ccy? (\u5982 BTC\uFF0C\u4E0D\u586B\u5168\u90E8)",
+          "agent_simulate_order": "instId, side, sz, tdMode, px?",
+          "okx_indicator": "instId, indicator (rsi|macd|bb|atr|stoch \u7B4917\u79CD), period?, bar? (\u9ED8\u8BA41H)",
+          "okx_indicator_batch": "instId, indicators (\u9017\u53F7\u5206\u9694\u5982 rsi,macd,bb), bar?",
+          "okx_smart_leaderboard": "instType?, sortBy?, topN?",
+          "okx_smart_trader_detail": "uniqueCode (\u4EA4\u6613\u5458\u7801), instType?",
+          "okx_smart_sentiment": "instFamily? (\u9ED8\u8BA4BTC-USD)",
+          "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_get_grid_ai_param": "instType, algoOrdType"
+        };
+        const enrichedDomains = CATALOG.domains.map((d) => ({
+          ...d,
+          go_to_params: paramsHints[d.go_to] || "\u89C1 agent_catalog_detail"
+        }));
         return toResult({
           tsIso: (/* @__PURE__ */ new Date()).toISOString(),
-          ...CATALOG
+          _setup: setup,
+          _onboarding: onboarding,
+          _instruction: CATALOG._instruction,
+          domains: enrichedDomains,
+          _tips: CATALOG._tips
         });
       } catch (e) {
         return toError(e);
@@ -34661,20 +36069,28 @@ function registerAgentHubTools(server) {
 }
 
 // src/index.ts
-async function main() {
-  const VERSION = "0.2.45";
-  const server = new McpServer({
-    name: "hvip-mcp",
-    version: VERSION,
-    description: "hvip MCP Server \u2014 362 \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"
-  });
-  const auth = getAuth();
-  const READ_ONLY = process.env.OKX_READ_ONLY === "true";
+function resolveExecutionMode() {
+  if (process.env.MCP_EXECUTION_ENABLED === "false") {
+    return { readOnly: true, reason: "MCP_EXECUTION_ENABLED=false" };
+  }
+  if (process.env.OKX_READ_ONLY === "true" || process.env.MCP_READONLY_MODE === "true") {
+    return { readOnly: true, reason: "\u53EA\u8BFB\u6A21\u5F0F\u5DF2\u542F\u7528 (OKX_READ_ONLY / MCP_READONLY_MODE)" };
+  }
+  return { readOnly: false, reason: "" };
+}
+function resolveTransportMode() {
+  const argv = process.argv.slice(2);
+  const arg = argv[0] || "";
+  if (arg === "start:http") return "http";
+  if (arg === "start:stdio" || arg === "" || arg.startsWith("-")) return "stdio";
+  return "stdio";
+}
+function registerAllTools(server, auth, readOnly) {
   let skipped = 0;
   const skipLog = [];
-  function createReadOnlyProxy(s) {
-    const orig = s.tool?.bind?.(s) ?? s.tool.bind(s);
-    s.tool = function(name, ...args) {
+  if (readOnly) {
+    const orig = server.tool.bind(server);
+    server.tool = function(name, ...args) {
       const risk = classifyRisk(name);
       if (risk !== "READ") {
         skipped++;
@@ -34683,64 +36099,135 @@ async function main() {
       }
       return orig(name, ...args);
     };
-    return s;
-  }
-  const effectiveServer = READ_ONLY ? createReadOnlyProxy(server) : server;
-  registerMarketTools(effectiveServer);
-  registerPublicTools(effectiveServer, auth);
-  registerStatsTools(effectiveServer);
-  registerSpreadTools(effectiveServer, auth);
-  registerOutcomesTools(effectiveServer);
-  registerAccountTools(effectiveServer, auth);
-  registerTradingTools(effectiveServer, auth);
-  registerAlgoTools(effectiveServer, auth);
-  registerBotTools(effectiveServer, auth);
-  registerCopyTools(effectiveServer, auth);
-  registerSignalTools(effectiveServer, auth);
-  registerFundingTools(effectiveServer, auth);
-  registerSubAccountTools(effectiveServer, auth);
-  registerFinanceTools(effectiveServer, auth);
-  registerAffiliateTools(effectiveServer, auth);
-  registerFiatTools(effectiveServer, auth);
-  registerRfqTools(effectiveServer, auth);
-  registerAgentUtils(effectiveServer, auth);
-  registerIndicatorTools(effectiveServer);
-  registerSmartMoneyTools(effectiveServer, auth);
-  registerXLayerWSTools(effectiveServer);
-  registerWsTools(effectiveServer);
-  registerAgentHubTools(effectiveServer);
-  if (READ_ONLY) {
-    let authStatus = "\u672A\u914D\u7F6E";
-    if (auth) {
-      try {
-        authStatus = "\u5DF2\u914D\u7F6E\uFF08\u53EA\u8BFB\u6A21\u5F0F\uFF0C\u4EC5\u66B4\u9732 READ \u7EA7\u522B\u5DE5\u5177\uFF09";
-      } catch {
-        authStatus = "\u5DF2\u914D\u7F6E";
-      }
+  }
+  registerMarketTools(server);
+  registerPublicTools(server, auth);
+  registerStatsTools(server);
+  registerSpreadTools(server, auth);
+  registerOutcomesTools(server);
+  registerAccountTools(server, auth);
+  registerTradingTools(server, auth);
+  registerAlgoTools(server, auth);
+  registerBotTools(server, auth);
+  registerCopyTools(server, auth);
+  registerSignalTools(server, auth);
+  registerFundingTools(server, auth);
+  registerSubAccountTools(server, auth);
+  registerFinanceTools(server, auth);
+  registerAffiliateTools(server, auth);
+  registerFiatTools(server, auth);
+  registerRfqTools(server, auth);
+  registerAgentUtils(server, auth);
+  registerIndicatorTools(server);
+  registerSmartMoneyTools(server, auth);
+  registerXLayerWSTools(server);
+  registerWsTools(server);
+  registerAgentHubTools(server);
+  return { skipped, skipLog };
+}
+async function startHttp(server, version2, auth, readOnly, skipped) {
+  const port = parseInt(process.env.PORT || "3000", 10);
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: void 0
+    // stateless
+  });
+  await server.connect(transport);
+  const httpServer = (0, import_node_http.createServer)(async (req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Mcp-Session-Id");
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
     }
-    process.stderr.write(`[hvip] \u53EA\u8BFB\u6A21\u5F0F\u5DF2\u542F\u7528 | API Key: ${authStatus} | \u5199\u5165\u5DE5\u5177\u5DF2\u8DF3\u8FC7: ${skipped}
+    if (req.method === "GET" && req.url === "/health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        status: "ok",
+        name: "hvip-mcp",
+        version: version2,
+        mode: readOnly ? "read-only" : "full",
+        auth: !!auth,
+        skippedTools: skipped,
+        uptime: process.uptime(),
+        tsIso: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+      return;
+    }
+    if (req.method === "POST" && req.url === "/mcp") {
+      const chunks = [];
+      req.on("data", (chunk) => chunks.push(chunk));
+      req.on("end", async () => {
+        try {
+          const body = Buffer.concat(chunks).toString("utf-8");
+          const parsed = body ? JSON.parse(body) : void 0;
+          await transport.handleRequest(req, res, parsed);
+        } catch {
+          res.writeHead(400, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ jsonrpc: "2.0", error: { code: -32700, message: "Parse error" }, id: null }));
+        }
+      });
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not Found" }));
+  });
+  httpServer.listen(port, "0.2.47.0", () => {
+    process.stderr.write([
+      `\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557`,
+      `\u2551  hvip-mcp v${version2}  HTTP \u6A21\u5F0F             \u2551`,
+      `\u2551  POST http://0.2.47.0:${port}/mcp              \u2551`,
+      `\u2551  GET  http://0.2.47.0:${port}/health            \u2551`,
+      `\u2551  \u6A21\u5F0F: ${readOnly ? "\u53EA\u8BFB" : "\u5B8C\u6574"}  | \u5DE5\u5177: ${readOnly ? "READ only" : "\u5168\u90E8"}  \u2551`,
+      `\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D`
+    ].join("\n") + "\n");
+  });
+}
+async function startStdio(server, version2, auth, readOnly, skipped, skipLog) {
+  if (readOnly) {
+    const authStatus = auth ? "\u5DF2\u914D\u7F6E\uFF08\u4EC5 READ \u5DE5\u5177\uFF09" : "\u672A\u914D\u7F6E";
+    process.stderr.write(`[hvip] \u53EA\u8BFB\u6A21\u5F0F | API Key: ${authStatus} | \u8DF3\u8FC7 ${skipped} \u4E2A\u975E READ \u5DE5\u5177
 `);
     if (skipLog.length > 0 && process.env.NODE_ENV !== "production") {
       const sample = skipLog.slice(0, 8).join(", ");
-      process.stderr.write(`[hvip] \u8DF3\u8FC7\u793A\u4F8B: ${sample}${skipLog.length > 8 ? ` +${skipLog.length - 8} \u4E2A` : ""}
+      process.stderr.write(`[hvip] \u8DF3\u8FC7: ${sample}${skipLog.length > 8 ? ` +${skipLog.length - 8}` : ""}
 `);
     }
   } else if (auth) {
     try {
       const cfg = await privateApi.getAccountConfig(auth);
       const uid = cfg?.[0]?.uid ?? "?";
-      process.stderr.write(`[hvip] API Key \u5DF2\u9A8C\u8BC1 | UID: ${uid} | \u5B8C\u6574\u6A21\u5F0F\uFF08\u5168\u90E8 357 \u5DE5\u5177\uFF09
+      process.stderr.write(`[hvip] API Key \u5DF2\u9A8C\u8BC1 | UID: ${uid} | \u5B8C\u6574\u6A21\u5F0F (v${version2})
 `);
     } catch {
-      process.stderr.write(`[hvip] API Key \u9A8C\u8BC1\u5931\u8D25 | \u5C06\u4EE5\u672A\u8BA4\u8BC1\u6A21\u5F0F\u542F\u52A8\uFF08\u516C\u5F00\u5DE5\u5177\u53EF\u7528\uFF09
+      process.stderr.write(`[hvip] API Key \u9A8C\u8BC1\u5931\u8D25 | \u964D\u7EA7\u4E3A\u672A\u8BA4\u8BC1\u6A21\u5F0F
 `);
     }
   } else {
-    process.stderr.write(`[hvip] \u672A\u914D\u7F6E API Key | \u4EC5\u516C\u5F00\u5DE5\u5177\u53EF\u7528
+    process.stderr.write(`[hvip] \u672A\u914D\u7F6E API Key | \u4EC5\u516C\u5F00\u5DE5\u5177\u53EF\u7528 (v${version2})
 `);
   }
-  startAgentHub(parseInt(process.env.WS_AGENT_PORT || "9321"), "0.2.45.0", VERSION);
+  startAgentHub(parseInt(process.env.WS_AGENT_PORT || "9321"), "0.2.47.0", version2);
   const transport = new StdioServerTransport();
-  await effectiveServer.connect(transport);
+  await server.connect(transport);
+}
+async function main() {
+  const VERSION = "0.2.47";
+  const auth = getAuth();
+  const mode = resolveTransportMode();
+  const exec = resolveExecutionMode();
+  const readOnly = exec.readOnly || !auth;
+  const server = new McpServer({
+    name: "hvip-mcp",
+    version: VERSION,
+    description: "hvip MCP Server \u2014 362 \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"
+  });
+  const { skipped, skipLog } = registerAllTools(server, auth, readOnly);
+  if (mode === "http") {
+    await startHttp(server, VERSION, auth, readOnly, skipped);
+  } else {
+    await startStdio(server, VERSION, auth, readOnly, skipped, skipLog);
+  }
 }
 main();