@kadoa/mcp 0.3.9-rc.1 → 0.3.9-rc.2

package/dist/index.js

@@ -28820,6 +28820,17 @@ function isArrayBufferView(val) {
   }
   return result;
 }
+function getGlobal() {
+  if (typeof globalThis !== "undefined")
+    return globalThis;
+  if (typeof self !== "undefined")
+    return self;
+  if (typeof window !== "undefined")
+    return window;
+  if (typeof global !== "undefined")
+    return global;
+  return {};
+}
 function forEach(obj, fn, { allOwnKeys = false } = {}) {
   if (obj === null || typeof obj === "undefined") {
     return;
@@ -28906,10 +28917,14 @@ var toString, getPrototypeOf, iterator, toStringTag, kindOf, kindOfTest = (type)
   } catch (e) {
     return false;
   }
-}, isDate, isFile, isBlob, isFileList, isStream = (val) => isObject2(val) && isFunction(val.pipe), isFormData = (thing) => {
+}, isDate, isFile, isReactNativeBlob = (value) => {
+  return !!(value && typeof value.uri !== "undefined");
+}, isReactNative = (formData) => formData && typeof formData.getParts !== "undefined", isBlob, isFileList, isStream = (val) => isObject2(val) && isFunction(val.pipe), G, FormDataCtor, isFormData = (thing) => {
   let kind;
-  return thing && (typeof FormData === "function" && thing instanceof FormData || isFunction(thing.append) && ((kind = kindOf(thing)) === "formdata" || kind === "object" && isFunction(thing.toString) && thing.toString() === "[object FormData]"));
-}, isURLSearchParams, isReadableStream, isRequest, isResponse, isHeaders, trim = (str) => str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, ""), _global, isContextDefined = (context) => !isUndefined(context) && context !== _global, extend2 = (a, b, thisArg, { allOwnKeys } = {}) => {
+  return thing && (FormDataCtor && thing instanceof FormDataCtor || isFunction(thing.append) && ((kind = kindOf(thing)) === "formdata" || kind === "object" && isFunction(thing.toString) && thing.toString() === "[object FormData]"));
+}, isURLSearchParams, isReadableStream, isRequest, isResponse, isHeaders, trim = (str) => {
+  return str.trim ? str.trim() : str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
+}, _global, isContextDefined = (context) => !isUndefined(context) && context !== _global, extend2 = (a, b, thisArg, { allOwnKeys } = {}) => {
   forEach(b, (val, key) => {
     if (thisArg && isFunction(val)) {
       Object.defineProperty(a, key, {
@@ -29089,6 +29104,8 @@ var init_utils = __esm(() => {
   isFile = kindOfTest("File");
   isBlob = kindOfTest("Blob");
   isFileList = kindOfTest("FileList");
+  G = getGlobal();
+  FormDataCtor = typeof G.FormData !== "undefined" ? G.FormData : undefined;
   isURLSearchParams = kindOfTest("URLSearchParams");
   [isReadableStream, isRequest, isResponse, isHeaders] = [
     "ReadableStream",
@@ -29146,6 +29163,8 @@ var init_utils = __esm(() => {
     isUndefined,
     isDate,
     isFile,
+    isReactNativeBlob,
+    isReactNative,
     isBlob,
     isRegExp,
     isFunction,
@@ -29197,11 +29216,20 @@ var init_AxiosError = __esm(() => {
       const axiosError = new AxiosError(error48.message, code || error48.code, config2, request, response);
       axiosError.cause = error48;
       axiosError.name = error48.name;
+      if (error48.status != null && axiosError.status == null) {
+        axiosError.status = error48.status;
+      }
       customProps && Object.assign(axiosError, customProps);
       return axiosError;
     }
     constructor(message, code, config2, request, response) {
       super(message);
+      Object.defineProperty(this, "message", {
+        value: message,
+        enumerable: true,
+        writable: true,
+        configurable: true
+      });
       this.name = "AxiosError";
       this.isAxiosError = true;
       code && (this.code = code);
@@ -39414,6 +39442,10 @@ function toFormData(obj, formData, options) {
   }
   function defaultVisitor(value, key, path) {
     let arr = value;
+    if (utils_default.isReactNative(formData) && utils_default.isReactNativeBlob(value)) {
+      formData.append(renderKey(path, key, dots), convertValue(value));
+      return false;
+    }
     if (value && !path && typeof value === "object") {
       if (utils_default.endsWith(key, "{}")) {
         key = metaTokens ? key : key.slice(0, -2);
@@ -39763,66 +39795,70 @@ var init_defaults = __esm(() => {
   defaults = {
     transitional: transitional_default,
     adapter: ["xhr", "http", "fetch"],
-    transformRequest: [function transformRequest(data, headers) {
-      const contentType = headers.getContentType() || "";
-      const hasJSONContentType = contentType.indexOf("application/json") > -1;
-      const isObjectPayload = utils_default.isObject(data);
-      if (isObjectPayload && utils_default.isHTMLForm(data)) {
-        data = new FormData(data);
-      }
-      const isFormData2 = utils_default.isFormData(data);
-      if (isFormData2) {
-        return hasJSONContentType ? JSON.stringify(formDataToJSON_default(data)) : data;
-      }
-      if (utils_default.isArrayBuffer(data) || utils_default.isBuffer(data) || utils_default.isStream(data) || utils_default.isFile(data) || utils_default.isBlob(data) || utils_default.isReadableStream(data)) {
-        return data;
-      }
-      if (utils_default.isArrayBufferView(data)) {
-        return data.buffer;
-      }
-      if (utils_default.isURLSearchParams(data)) {
-        headers.setContentType("application/x-www-form-urlencoded;charset=utf-8", false);
-        return data.toString();
-      }
-      let isFileList2;
-      if (isObjectPayload) {
-        if (contentType.indexOf("application/x-www-form-urlencoded") > -1) {
-          return toURLEncodedForm(data, this.formSerializer).toString();
+    transformRequest: [
+      function transformRequest(data, headers) {
+        const contentType = headers.getContentType() || "";
+        const hasJSONContentType = contentType.indexOf("application/json") > -1;
+        const isObjectPayload = utils_default.isObject(data);
+        if (isObjectPayload && utils_default.isHTMLForm(data)) {
+          data = new FormData(data);
+        }
+        const isFormData2 = utils_default.isFormData(data);
+        if (isFormData2) {
+          return hasJSONContentType ? JSON.stringify(formDataToJSON_default(data)) : data;
+        }
+        if (utils_default.isArrayBuffer(data) || utils_default.isBuffer(data) || utils_default.isStream(data) || utils_default.isFile(data) || utils_default.isBlob(data) || utils_default.isReadableStream(data)) {
+          return data;
+        }
+        if (utils_default.isArrayBufferView(data)) {
+          return data.buffer;
+        }
+        if (utils_default.isURLSearchParams(data)) {
+          headers.setContentType("application/x-www-form-urlencoded;charset=utf-8", false);
+          return data.toString();
+        }
+        let isFileList2;
+        if (isObjectPayload) {
+          if (contentType.indexOf("application/x-www-form-urlencoded") > -1) {
+            return toURLEncodedForm(data, this.formSerializer).toString();
+          }
+          if ((isFileList2 = utils_default.isFileList(data)) || contentType.indexOf("multipart/form-data") > -1) {
+            const _FormData = this.env && this.env.FormData;
+            return toFormData_default(isFileList2 ? { "files[]": data } : data, _FormData && new _FormData, this.formSerializer);
+          }
         }
-        if ((isFileList2 = utils_default.isFileList(data)) || contentType.indexOf("multipart/form-data") > -1) {
-          const _FormData = this.env && this.env.FormData;
-          return toFormData_default(isFileList2 ? { "files[]": data } : data, _FormData && new _FormData, this.formSerializer);
+        if (isObjectPayload || hasJSONContentType) {
+          headers.setContentType("application/json", false);
+          return stringifySafely(data);
         }
-      }
-      if (isObjectPayload || hasJSONContentType) {
-        headers.setContentType("application/json", false);
-        return stringifySafely(data);
-      }
-      return data;
-    }],
-    transformResponse: [function transformResponse(data) {
-      const transitional = this.transitional || defaults.transitional;
-      const forcedJSONParsing = transitional && transitional.forcedJSONParsing;
-      const JSONRequested = this.responseType === "json";
-      if (utils_default.isResponse(data) || utils_default.isReadableStream(data)) {
         return data;
       }
-      if (data && utils_default.isString(data) && (forcedJSONParsing && !this.responseType || JSONRequested)) {
-        const silentJSONParsing = transitional && transitional.silentJSONParsing;
-        const strictJSONParsing = !silentJSONParsing && JSONRequested;
-        try {
-          return JSON.parse(data, this.parseReviver);
-        } catch (e) {
-          if (strictJSONParsing) {
-            if (e.name === "SyntaxError") {
-              throw AxiosError_default.from(e, AxiosError_default.ERR_BAD_RESPONSE, this, null, this.response);
+    ],
+    transformResponse: [
+      function transformResponse(data) {
+        const transitional = this.transitional || defaults.transitional;
+        const forcedJSONParsing = transitional && transitional.forcedJSONParsing;
+        const JSONRequested = this.responseType === "json";
+        if (utils_default.isResponse(data) || utils_default.isReadableStream(data)) {
+          return data;
+        }
+        if (data && utils_default.isString(data) && (forcedJSONParsing && !this.responseType || JSONRequested)) {
+          const silentJSONParsing = transitional && transitional.silentJSONParsing;
+          const strictJSONParsing = !silentJSONParsing && JSONRequested;
+          try {
+            return JSON.parse(data, this.parseReviver);
+          } catch (e) {
+            if (strictJSONParsing) {
+              if (e.name === "SyntaxError") {
+                throw AxiosError_default.from(e, AxiosError_default.ERR_BAD_RESPONSE, this, null, this.response);
+              }
+              throw e;
             }
-            throw e;
           }
         }
+        return data;
       }
-      return data;
-    }],
+    ],
     timeout: 0,
     xsrfCookieName: "XSRF-TOKEN",
     xsrfHeaderName: "X-XSRF-TOKEN",
@@ -40118,7 +40154,14 @@ var init_AxiosHeaders = __esm(() => {
       return this;
     }
   };
-  AxiosHeaders.accessor(["Content-Type", "Content-Length", "Accept", "Accept-Encoding", "User-Agent", "Authorization"]);
+  AxiosHeaders.accessor([
+    "Content-Type",
+    "Content-Length",
+    "Accept",
+    "Accept-Encoding",
+    "User-Agent",
+    "Authorization"
+  ]);
   utils_default.reduceDescriptors(AxiosHeaders.prototype, ({ value }, key) => {
     let mapped = key[0].toUpperCase() + key.slice(1);
     return {
@@ -41381,7 +41424,7 @@ var require_follow_redirects = __commonJS((exports, module) => {
 });
 
 // node_modules/axios/lib/env/data.js
-var VERSION = "1.13.5";
+var VERSION = "1.13.6";
 
 // node_modules/axios/lib/helpers/parseProtocol.js
 function parseProtocol(url3) {
@@ -41791,11 +41834,14 @@ var progressEventReducer = (listener, isDownloadStream, freq = 3) => {
   }, freq);
 }, progressEventDecorator = (total, throttled) => {
   const lengthComputable = total != null;
-  return [(loaded) => throttled[0]({
-    lengthComputable,
-    total,
-    loaded
-  }), throttled[1]];
+  return [
+    (loaded) => throttled[0]({
+      lengthComputable,
+      total,
+      loaded
+    }),
+    throttled[1]
+  ];
 }, asyncDecorator = (fn) => (...args) => utils_default.asap(() => fn(...args));
 var init_progressEventReducer = __esm(() => {
   init_speedometer();
@@ -41925,10 +41971,7 @@ class Http2Sessions {
       };
     }
     session.once("close", removeSession);
-    let entry = [
-      session,
-      options
-    ];
+    let entry = [session, options];
     authoritySessions ? authoritySessions.push(entry) : authoritySessions = this.sessions[authority] = [entry];
     return session;
   }
@@ -42049,12 +42092,7 @@ var init_http = __esm(() => {
       const authority = options.protocol + "//" + options.hostname + ":" + (options.port || (options.protocol === "https:" ? 443 : 80));
       const { http2Options, headers } = options;
       const session = http2Sessions.getSession(authority, http2Options);
-      const {
-        HTTP2_HEADER_SCHEME,
-        HTTP2_HEADER_METHOD,
-        HTTP2_HEADER_PATH,
-        HTTP2_HEADER_STATUS
-      } = http2.constants;
+      const { HTTP2_HEADER_SCHEME, HTTP2_HEADER_METHOD, HTTP2_HEADER_PATH, HTTP2_HEADER_STATUS } = http2.constants;
       const http2Headers = {
         [HTTP2_HEADER_SCHEME]: options.protocol.replace(":", ""),
         [HTTP2_HEADER_METHOD]: options.method,
@@ -42241,9 +42279,12 @@ var init_http = __esm(() => {
         if (!utils_default.isStream(data)) {
           data = stream3.Readable.from(data, { objectMode: false });
         }
-        data = stream3.pipeline([data, new AxiosTransformStream_default({
-          maxRate: utils_default.toFiniteNumber(maxUploadRate)
-        })], utils_default.noop);
+        data = stream3.pipeline([
+          data,
+          new AxiosTransformStream_default({
+            maxRate: utils_default.toFiniteNumber(maxUploadRate)
+          })
+        ], utils_default.noop);
         onUploadProgress && data.on("progress", flushOnFinish(data, progressEventDecorator(contentLength, progressEventReducer(asyncDecorator(onUploadProgress), false, 3))));
       }
       let auth = undefined;
@@ -43073,11 +43114,7 @@ var DEFAULT_CHUNK_SIZE, isFunction2, globalFetchAPI, ReadableStream2, TextEncode
 }, seedCache, getFetch = (config2) => {
   let env = config2 && config2.env || {};
   const { fetch: fetch2, Request, Response: Response2 } = env;
-  const seeds = [
-    Request,
-    Response2,
-    fetch2
-  ];
+  const seeds = [Request, Response2, fetch2];
   let len = seeds.length, i = len, seed, target, map3 = seedCache;
   while (i--) {
     seed = seeds[i];
@@ -43102,10 +43139,7 @@ var init_fetch = __esm(() => {
     Request,
     Response: Response2
   }))(utils_default.global);
-  ({
-    ReadableStream: ReadableStream2,
-    TextEncoder: TextEncoder2
-  } = utils_default.global);
+  ({ ReadableStream: ReadableStream2, TextEncoder: TextEncoder2 } = utils_default.global);
   seedCache = new Map;
   adapter = getFetch();
 });
@@ -47552,7 +47586,7 @@ var import_debug, __require2, BASE_PATH, BaseAPI = class {
     const newSettings = await Promise.all(eventTypes.map(async (eventType) => {
       const existing = existingSettings.find((s) => s.eventType === eventType);
       if (existing?.id) {
-        const existingChannelIds = (existing.channels || []).map((c) => c.id).filter(Boolean);
+        const existingChannelIds = (existing.channels || []).map((channel) => channel.id).filter(Boolean);
         const mergedChannelIds = [
           .../* @__PURE__ */ new Set([...existingChannelIds, ...channelIds])
         ];
@@ -47678,87 +47712,246 @@ var import_debug, __require2, BASE_PATH, BaseAPI = class {
     }));
     return channels;
   }
-}, PUBLIC_API_URI, WSS_API_URI, REALTIME_API_URI, SDK_VERSION = "0.23.0", SDK_NAME = "kadoa-node-sdk", SDK_LANGUAGE = "node", debug5, Realtime = class {
+}, PUBLIC_API_URI, WSS_API_URI, REALTIME_API_URI, SDK_VERSION = "0.24.2", SDK_NAME = "kadoa-node-sdk", SDK_LANGUAGE = "node", debug5, isDrainControlMessage = (message) => message.type === "control.draining", isRealtimeEvent = (message) => message.type !== "heartbeat" && message.type !== "control.draining", _Realtime = class _Realtime2 {
   constructor(config2) {
+    this.drainingSockets = /* @__PURE__ */ new Set;
     this.lastHeartbeat = Date.now();
     this.isConnecting = false;
     this.eventListeners = /* @__PURE__ */ new Set;
     this.connectionListeners = /* @__PURE__ */ new Set;
     this.errorListeners = /* @__PURE__ */ new Set;
+    this.isClosed = false;
+    this.hasConnectedOnce = false;
+    this.recentEventIds = /* @__PURE__ */ new Set;
+    this.recentEventIdQueue = [];
+    this.maxRecentEventIds = 1000;
     this.apiKey = config2.apiKey;
     this.heartbeatInterval = config2.heartbeatInterval || 1e4;
-    this.reconnectDelay = config2.reconnectDelay || 5000;
+    this.reconnectDelay = this.normalizeReconnectDelay(config2.reconnectDelay);
     this.missedHeartbeatsLimit = config2.missedHeartbeatsLimit || 30000;
   }
   async connect() {
-    if (this.isConnecting)
+    if (this.isClosed || this.isConnecting || this.activeSocket) {
       return;
+    }
     this.isConnecting = true;
     try {
-      const response = await fetch(`${PUBLIC_API_URI}/v4/oauth2/token`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "x-api-key": `${this.apiKey}`,
-          "x-sdk-version": SDK_VERSION
-        }
-      });
-      const { access_token, team_id } = await response.json();
-      await new Promise((resolve, reject) => {
-        this.socket = new WebSocket(`${WSS_API_URI}?access_token=${access_token}`);
-        this.socket.onopen = () => {
-          this.isConnecting = false;
-          this.lastHeartbeat = Date.now();
-          if (this.socket?.readyState === WebSocket.OPEN) {
-            this.socket.send(JSON.stringify({
-              action: "subscribe",
-              channel: team_id
-            }));
-            debug5("Connected to WebSocket");
-            this.notifyConnectionListeners(true);
-          }
-          this.startHeartbeatCheck();
-          resolve();
-        };
-        this.socket.onmessage = (event) => {
-          try {
-            const data = JSON.parse(event.data);
-            if (data.type === "heartbeat") {
-              this.handleHeartbeat();
-            } else {
-              if (data?.id) {
-                fetch(`${REALTIME_API_URI}/api/v1/events/ack`, {
-                  method: "POST",
-                  headers: { "Content-Type": "application/json" },
-                  body: JSON.stringify({ id: data.id })
-                });
-              }
-              this.notifyEventListeners(data);
-            }
-          } catch (err) {
-            debug5("Failed to parse incoming message: %O", err);
-          }
-        };
-        this.socket.onclose = () => {
-          debug5("WebSocket disconnected. Attempting to reconnect...");
-          this.isConnecting = false;
-          this.stopHeartbeatCheck();
-          this.notifyConnectionListeners(false, "Connection closed");
-          setTimeout(() => this.connect(), this.reconnectDelay);
-        };
-        this.socket.onerror = (error48) => {
-          debug5("WebSocket error: %O", error48);
-          this.isConnecting = false;
-          this.notifyErrorListeners(error48);
-          reject(error48);
-        };
-      });
+      const { access_token, team_id } = await this.getOAuthToken();
+      await this.openSocket(access_token, team_id, "active");
+      this.hasConnectedOnce = true;
     } catch (err) {
       debug5("Failed to connect: %O", err);
       this.isConnecting = false;
-      setTimeout(() => this.connect(), this.reconnectDelay);
+      this.notifyErrorListeners(err);
+      if (!this.hasConnectedOnce) {
+        throw err;
+      }
+      this.scheduleReconnect();
     }
   }
+  async getOAuthToken() {
+    const response = await fetch(`${PUBLIC_API_URI}/v4/oauth2/token`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": `${this.apiKey}`,
+        "x-sdk-version": SDK_VERSION
+      }
+    });
+    return await response.json();
+  }
+  async openSocket(accessToken, teamId, role) {
+    await new Promise((resolve, reject) => {
+      const socket = new WebSocket(`${WSS_API_URI}?access_token=${accessToken}`);
+      let settled = false;
+      socket.onopen = () => {
+        const subscribeMessage = {
+          action: "subscribe",
+          channel: teamId
+        };
+        if (this.lastCursor) {
+          subscribeMessage.lastCursor = this.lastCursor;
+        }
+        socket.send(JSON.stringify(subscribeMessage));
+        this.promoteSocket(socket, role);
+        this.isConnecting = false;
+        this.lastHeartbeat = Date.now();
+        this.startHeartbeatCheck();
+        debug5("Connected to WebSocket");
+        if (!settled) {
+          settled = true;
+          resolve();
+        }
+      };
+      socket.onmessage = (event) => {
+        this.handleSocketMessage(socket, event.data);
+      };
+      socket.onclose = () => {
+        this.handleSocketClose(socket);
+        if (!settled) {
+          settled = true;
+          reject(new Error("WebSocket closed before opening"));
+        }
+      };
+      socket.onerror = (error48) => {
+        this.notifyErrorListeners(error48);
+        if (!settled) {
+          settled = true;
+          reject(error48);
+          return;
+        }
+        if (socket === this.activeSocket) {
+          this.handleUnexpectedDisconnect("Socket error");
+        }
+      };
+    });
+  }
+  promoteSocket(socket, role) {
+    if (role === "replacement" && this.activeSocket && this.activeSocket !== socket) {
+      this.drainingSockets.add(this.activeSocket);
+    }
+    this.activeSocket = socket;
+    this.drainingSockets.delete(socket);
+    if (role === "active" || !this.hasConnectedOnce) {
+      this.notifyConnectionListeners(true);
+    }
+  }
+  handleSocketMessage(socket, rawData) {
+    try {
+      const payload = typeof rawData === "string" ? rawData : rawData.toString?.() ?? "";
+      const data = JSON.parse(payload);
+      if (data.type === "heartbeat") {
+        if (socket === this.activeSocket) {
+          this.handleHeartbeat();
+        }
+        return;
+      }
+      if (isDrainControlMessage(data)) {
+        this.handleDrainSignal(socket, data);
+        return;
+      }
+      if (!isRealtimeEvent(data)) {
+        return;
+      }
+      if (typeof data._cursor === "string") {
+        this.lastCursor = data._cursor;
+      }
+      if (typeof data.id === "string") {
+        fetch(`${REALTIME_API_URI}/api/v1/events/ack`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ id: data.id })
+        }).catch((error48) => {
+          debug5("Failed to acknowledge event %s: %O", data.id, error48);
+        });
+      }
+      if (this.isDuplicateEvent(data.id)) {
+        return;
+      }
+      this.notifyEventListeners(data);
+    } catch (err) {
+      debug5("Failed to parse incoming message: %O", err);
+    }
+  }
+  handleDrainSignal(socket, message) {
+    if (socket !== this.activeSocket || this.isClosed) {
+      return;
+    }
+    debug5("Received drain signal, preparing replacement socket");
+    this.drainingSockets.add(socket);
+    this.scheduleDrainReconnect(message.retryAfterMs);
+  }
+  handleSocketClose(socket) {
+    const wasActiveSocket = socket === this.activeSocket;
+    this.drainingSockets.delete(socket);
+    if (!wasActiveSocket) {
+      return;
+    }
+    this.activeSocket = undefined;
+    this.stopHeartbeatCheck();
+    if (this.isClosed) {
+      return;
+    }
+    if (this.drainingSockets.size > 0) {
+      debug5("Draining socket closed after replacement was scheduled");
+      return;
+    }
+    this.handleUnexpectedDisconnect("Connection closed");
+  }
+  handleUnexpectedDisconnect(reason) {
+    this.isConnecting = false;
+    this.notifyConnectionListeners(false, reason);
+    this.scheduleReconnect();
+  }
+  scheduleReconnect(replacement = false) {
+    if (this.isClosed || this.reconnectTimer) {
+      return;
+    }
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = undefined;
+      if (this.isClosed || this.isConnecting || !replacement && this.activeSocket) {
+        return;
+      }
+      this.isConnecting = true;
+      try {
+        const { access_token, team_id } = await this.getOAuthToken();
+        await this.openSocket(access_token, team_id, replacement ? "replacement" : "active");
+      } catch (err) {
+        debug5("Reconnect failed: %O", err);
+        this.isConnecting = false;
+        this.notifyErrorListeners(err);
+        this.scheduleReconnect(replacement);
+      }
+    }, this.reconnectDelay);
+  }
+  scheduleDrainReconnect(retryAfterMs) {
+    if (this.isClosed || this.reconnectTimer) {
+      return;
+    }
+    let safeDelayMs = this.reconnectDelay;
+    if (typeof retryAfterMs === "number" && Number.isFinite(retryAfterMs) && retryAfterMs >= 0 && retryAfterMs <= _Realtime2.MAX_RECONNECT_DELAY_MS) {
+      safeDelayMs = Math.trunc(retryAfterMs);
+    }
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = undefined;
+      if (this.isClosed || this.isConnecting) {
+        return;
+      }
+      this.isConnecting = true;
+      try {
+        const { access_token, team_id } = await this.getOAuthToken();
+        await this.openSocket(access_token, team_id, "replacement");
+      } catch (err) {
+        debug5("Reconnect failed: %O", err);
+        this.isConnecting = false;
+        this.notifyErrorListeners(err);
+        this.scheduleReconnect(true);
+      }
+    }, safeDelayMs);
+  }
+  normalizeReconnectDelay(delay) {
+    if (typeof delay !== "number" || !Number.isFinite(delay)) {
+      return _Realtime2.DEFAULT_RECONNECT_DELAY_MS;
+    }
+    return Math.min(Math.max(0, Math.trunc(delay)), _Realtime2.MAX_RECONNECT_DELAY_MS);
+  }
+  isDuplicateEvent(eventId) {
+    if (!eventId) {
+      return false;
+    }
+    if (this.recentEventIds.has(eventId)) {
+      return true;
+    }
+    this.recentEventIds.add(eventId);
+    this.recentEventIdQueue.push(eventId);
+    if (this.recentEventIdQueue.length > this.maxRecentEventIds) {
+      const expiredId = this.recentEventIdQueue.shift();
+      if (expiredId) {
+        this.recentEventIds.delete(expiredId);
+      }
+    }
+    return false;
+  }
   handleHeartbeat() {
     debug5("Heartbeat received");
     this.lastHeartbeat = Date.now();
@@ -47785,22 +47978,24 @@ var import_debug, __require2, BASE_PATH, BaseAPI = class {
     this.errorListeners.forEach((listener) => {
       try {
         listener(error48);
-      } catch (error210) {
-        debug5("Error in error listener: %O", error210);
+      } catch (listenerError) {
+        debug5("Error in error listener: %O", listenerError);
       }
     });
   }
   startHeartbeatCheck() {
+    this.stopHeartbeatCheck();
     this.missedHeartbeatCheckTimer = setInterval(() => {
-      if (Date.now() - this.lastHeartbeat > this.missedHeartbeatsLimit) {
+      if (this.activeSocket && Date.now() - this.lastHeartbeat > this.missedHeartbeatsLimit) {
         debug5("No heartbeat received in 30 seconds! Closing connection.");
-        this.socket?.close();
+        this.activeSocket.close();
       }
     }, this.heartbeatInterval);
   }
   stopHeartbeatCheck() {
     if (this.missedHeartbeatCheckTimer) {
       clearInterval(this.missedHeartbeatCheckTimer);
+      this.missedHeartbeatCheckTimer = undefined;
     }
   }
   onEvent(listener) {
@@ -47811,6 +48006,9 @@ var import_debug, __require2, BASE_PATH, BaseAPI = class {
   }
   onConnection(listener) {
     this.connectionListeners.add(listener);
+    if (this.isConnected()) {
+      listener(true);
+    }
     return () => {
       this.connectionListeners.delete(listener);
     };
@@ -47822,19 +48020,27 @@ var import_debug, __require2, BASE_PATH, BaseAPI = class {
     };
   }
   close() {
-    if (this.socket) {
-      this.stopHeartbeatCheck();
-      this.socket.close();
-      this.socket = undefined;
-    }
+    this.isClosed = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = undefined;
+    }
+    this.stopHeartbeatCheck();
+    this.activeSocket?.close();
+    this.activeSocket = undefined;
+    this.drainingSockets.forEach((socket) => {
+      socket.close();
+    });
+    this.drainingSockets.clear();
+    this.isConnecting = false;
     this.eventListeners.clear();
     this.connectionListeners.clear();
     this.errorListeners.clear();
   }
   isConnected() {
-    return this.socket?.readyState === WebSocket.OPEN;
+    return this.activeSocket?.readyState === WebSocket.OPEN;
   }
-}, UserService = class {
+}, Realtime, UserService = class {
   constructor(client) {
     this.client = client;
   }
@@ -48915,6 +49121,9 @@ var init_dist2 = __esm(() => {
   if (typeof WebSocket === "undefined") {
     global.WebSocket = __require2("ws");
   }
+  _Realtime.DEFAULT_RECONNECT_DELAY_MS = 5000;
+  _Realtime.MAX_RECONNECT_DELAY_MS = 60000;
+  Realtime = _Realtime;
   DEFAULT_POLLING_OPTIONS = {
     pollIntervalMs: 1e4,
     timeoutMs: 5 * 60 * 1000

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kadoa/mcp",
-  "version": "0.3.9-rc.1",
+  "version": "0.3.9-rc.2",
   "description": "Kadoa MCP Server — manage workflows from Claude Desktop, Cursor, and other MCP clients",
   "type": "module",
   "main": "dist/index.js",
@@ -24,7 +24,7 @@
     "prepublishOnly": "bun run check-types && bun run test:unit && bun run build"
   },
   "dependencies": {
-    "@kadoa/node-sdk": "^0.23.0",
+    "@kadoa/node-sdk": "^0.24.2",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "express": "^5.2.1",
     "ioredis": "^5.6.1",