@kadoa/mcp 0.3.8 → 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,86 +47712,245 @@ 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");
@@ -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
@@ -48958,13 +49167,37 @@ function createKadoaClient(auth) {
   });
   return client;
 }
-var ctxRefreshMutex;
+var refreshRawMutex, ctxRefreshMutex;
 var init_client = __esm(() => {
   init_dist2();
+  refreshRawMutex = new Map;
   ctxRefreshMutex = new WeakMap;
 });
 
 // src/client.ts
+var exports_client = {};
+__export(exports_client, {
+  refreshSupabaseJwtRaw: () => refreshSupabaseJwtRaw,
+  refreshSupabaseJwt: () => refreshSupabaseJwt,
+  isJwtExpired: () => isJwtExpired,
+  getValidJwt: () => getValidJwt,
+  decodeJwtClaims: () => decodeJwtClaims,
+  createKadoaClient: () => createKadoaClient2,
+  SessionExpiredError: () => SessionExpiredError,
+  KadoaSdkException: () => KadoaSdkException,
+  KadoaClient: () => KadoaClient
+});
+function createKadoaClient2(auth) {
+  const client = new KadoaClient({ bearerToken: auth.jwt });
+  client.axiosInstance.interceptors.request.use((config2) => {
+    config2.headers["x-kadoa-source"] = "mcp";
+    if (auth.teamId) {
+      config2.headers["x-team-id"] = auth.teamId;
+    }
+    return config2;
+  });
+  return client;
+}
 function decodeJwtClaims(jwt2) {
   try {
     const payload = JSON.parse(Buffer.from(jwt2.split(".")[1], "base64url").toString());
@@ -48986,36 +49219,57 @@ function isJwtExpired(jwt2) {
     return true;
   }
 }
-async function refreshSupabaseJwt(ctx) {
-  if (!ctx.supabaseRefreshToken) {
-    console.error("[JWT_REFRESH] No refresh token available, cannot refresh");
-    return;
+async function refreshSupabaseJwtRaw(supabaseRefreshToken) {
+  const inflight = refreshRawMutex2.get(supabaseRefreshToken);
+  if (inflight) {
+    console.error(`[JWT_REFRESH] DEDUP: reusing in-flight raw refresh`);
+    return inflight;
   }
+  const promise3 = _doRefreshRaw(supabaseRefreshToken).finally(() => {
+    refreshRawMutex2.delete(supabaseRefreshToken);
+  });
+  refreshRawMutex2.set(supabaseRefreshToken, promise3);
+  return promise3;
+}
+async function _doRefreshRaw(supabaseRefreshToken) {
   const supabaseUrl = process.env.SUPABASE_URL;
   if (!supabaseUrl) {
     console.error("[JWT_REFRESH] SUPABASE_URL not set, cannot refresh");
+    return null;
+  }
+  const res = await fetch(`${supabaseUrl}/auth/v1/token?grant_type=refresh_token`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      apikey: process.env.SUPABASE_ANON_KEY
+    },
+    body: JSON.stringify({ refresh_token: supabaseRefreshToken })
+  });
+  if (res.ok) {
+    const data = await res.json();
+    return { jwt: data.access_token, refreshToken: data.refresh_token };
+  }
+  const body = await res.text().catch(() => "");
+  console.error(`[JWT_REFRESH] FAIL: Supabase returned ${res.status} (refreshToken=${supabaseRefreshToken.slice(0, 12)}...): ${body}`);
+  if (body.includes("session_expired") || body.includes("refresh_token_not_found") || body.includes("refresh_token_already_used")) {
+    throw new SessionExpiredError("Your Kadoa session has expired due to inactivity. Please reconnect to re-authenticate.");
+  }
+  return null;
+}
+async function refreshSupabaseJwt(ctx) {
+  if (!ctx.supabaseRefreshToken) {
+    console.error("[JWT_REFRESH] No refresh token available, cannot refresh");
     return;
   }
   try {
     const refreshToken = ctx.supabaseRefreshToken;
     console.error(`[JWT_REFRESH] Refreshing Supabase JWT (refreshToken=${refreshToken.slice(0, 12)}..., team=${ctx.teamId ?? "unknown"})`);
-    const res = await fetch(`${supabaseUrl}/auth/v1/token?grant_type=refresh_token`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        apikey: process.env.SUPABASE_ANON_KEY
-      },
-      body: JSON.stringify({ refresh_token: refreshToken })
-    });
-    if (!res.ok) {
-      const body = await res.text().catch(() => "");
-      console.error(`[JWT_REFRESH] FAIL: Supabase returned ${res.status} (refreshToken=${refreshToken.slice(0, 12)}...): ${body}`);
+    const result = await refreshSupabaseJwtRaw(refreshToken);
+    if (!result)
       return;
-    }
-    const data = await res.json();
-    ctx.supabaseJwt = data.access_token;
-    ctx.supabaseRefreshToken = data.refresh_token;
-    ctx.client.setBearerToken(data.access_token);
+    ctx.supabaseJwt = result.jwt;
+    ctx.supabaseRefreshToken = result.refreshToken;
+    ctx.client.setBearerToken(result.jwt);
     try {
       await ctx.persist?.({
         supabaseJwt: ctx.supabaseJwt,
@@ -49025,9 +49279,11 @@ async function refreshSupabaseJwt(ctx) {
     } catch (e) {
       console.error("[JWT_REFRESH] WARN: persist failed, tokens updated in-memory only:", e);
     }
-    console.error(`[JWT_REFRESH] OK: token refreshed (team=${ctx.teamId ?? "unknown"}, newRefreshToken=${data.refresh_token.slice(0, 12)}...)`);
-    return data.access_token;
+    console.error(`[JWT_REFRESH] OK: token refreshed (team=${ctx.teamId ?? "unknown"}, newRefreshToken=${result.refreshToken.slice(0, 12)}...)`);
+    return result.jwt;
   } catch (error48) {
+    if (error48 instanceof SessionExpiredError)
+      throw error48;
     console.error("[JWT_REFRESH] FAIL: threw", error48);
     return;
   }
@@ -49048,9 +49304,16 @@ async function getValidJwt(ctx) {
   ctxRefreshMutex2.set(ctx, promise3);
   return promise3;
 }
-var ctxRefreshMutex2;
+var SessionExpiredError, refreshRawMutex2, ctxRefreshMutex2;
 var init_client2 = __esm(() => {
   init_dist2();
+  SessionExpiredError = class SessionExpiredError extends Error {
+    constructor(message) {
+      super(message ?? "Supabase session expired. Please re-authenticate.");
+      this.name = "SessionExpiredError";
+    }
+  };
+  refreshRawMutex2 = new Map;
   ctxRefreshMutex2 = new WeakMap;
 });
 
@@ -49168,6 +49431,10 @@ function registerTools(server, ctx) {
         }
         return await handler(...args);
       } catch (error48) {
+        if (error48 instanceof SessionExpiredError) {
+          console.error(`[Tool Error] ${name}: session expired, user must re-authenticate`);
+          return errorResult("Your session has expired. Please reconnect the MCP server to re-authenticate.");
+        }
         let message = classifyError(error48);
         if (KadoaHttpException.isInstance(error48) && error48.httpStatus === 403) {
           try {
@@ -53892,45 +54159,6 @@ function generatePKCE() {
   const challenge = createHash2("sha256").update(verifier).digest("base64url");
   return { verifier, challenge };
 }
-async function refreshSupabaseToken(supabaseRefreshToken, context) {
-  const inflight = supabaseRefreshMutex.get(supabaseRefreshToken);
-  if (inflight) {
-    console.error(`[AUTH] REFRESH_DEDUP: reusing in-flight refresh (${context})`);
-    return inflight;
-  }
-  const promise3 = (async () => {
-    const supabaseUrl = process.env.SUPABASE_URL;
-    if (!supabaseUrl || !supabaseRefreshToken)
-      return null;
-    try {
-      const res = await fetch(`${supabaseUrl}/auth/v1/token?grant_type=refresh_token`, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          apikey: process.env.SUPABASE_ANON_KEY
-        },
-        body: JSON.stringify({ refresh_token: supabaseRefreshToken })
-      });
-      if (res.ok) {
-        const data = await res.json();
-        const newClaims = jwtClaims(data.access_token);
-        console.log(`[AUTH] REFRESH_OK: Supabase JWT refreshed (${context}, newEmail=${newClaims.email})`);
-        return { jwt: data.access_token, refreshToken: data.refresh_token };
-      }
-      const body = await res.text().catch(() => "");
-      console.error(`[AUTH] REFRESH_FAIL: Supabase returned ${res.status} (${context}): ${body.slice(0, 200)}`);
-      return null;
-    } catch (err) {
-      console.error(`[AUTH] REFRESH_FAIL: Supabase refresh threw (${context}):`, err);
-      return null;
-    }
-  })();
-  supabaseRefreshMutex.set(supabaseRefreshToken, promise3);
-  promise3.finally(() => {
-    supabaseRefreshMutex.delete(supabaseRefreshToken);
-  });
-  return promise3;
-}
 function jwtClaims(jwt2) {
   try {
     const payload = JSON.parse(Buffer.from(jwt2.split(".")[1], "base64url").toString());
@@ -54238,12 +54466,22 @@ class KadoaOAuthProvider {
     let { supabaseJwt, supabaseRefreshToken } = entry;
     const claims = jwtClaims(entry.supabaseJwt);
     const context = `email=${claims.email}, team=${entry.teamId}`;
-    const refreshed = await refreshSupabaseToken(supabaseRefreshToken, context);
-    if (refreshed) {
-      supabaseJwt = refreshed.jwt;
-      supabaseRefreshToken = refreshed.refreshToken;
-    } else {
-      console.error(`[AUTH] REFRESH_WARN: using stale Supabase JWT as fallback (${context})`);
+    try {
+      const { refreshSupabaseJwtRaw: refreshSupabaseJwtRaw2, SessionExpiredError: SessionExpiredError2 } = await Promise.resolve().then(() => (init_client2(), exports_client));
+      const refreshed = await refreshSupabaseJwtRaw2(supabaseRefreshToken);
+      if (refreshed) {
+        supabaseJwt = refreshed.jwt;
+        supabaseRefreshToken = refreshed.refreshToken;
+        console.error(`[AUTH] REFRESH_OK: Supabase JWT refreshed (${context})`);
+      } else {
+        console.error(`[AUTH] REFRESH_WARN: using stale Supabase JWT as fallback (${context})`);
+      }
+    } catch (error48) {
+      if (error48 instanceof Error && error48.name === "SessionExpiredError") {
+        console.error(`[AUTH] REFRESH_DEAD: session permanently expired (${context}): ${error48.message}`);
+        throw new InvalidTokenError("Supabase session expired. Please re-authenticate.");
+      }
+      console.error(`[AUTH] REFRESH_WARN: unexpected error, using stale JWT (${context}):`, error48);
     }
     const freshClaims = jwtClaims(supabaseJwt);
     const teamId = freshClaims.activeTeamId ?? entry.teamId;
@@ -54370,7 +54608,7 @@ class KadoaOAuthProvider {
       codeChallenge: pending.params.codeChallenge,
       clientId: pending.client.client_id,
       redirectUri: pending.params.redirectUri,
-      expiresAt: Date.now() + 10 * 60 * 1000
+      expiresAt: Date.now() + 600000
     }, 600);
     const redirectUrl = new URL(pending.params.redirectUri);
     redirectUrl.searchParams.set("code", mcpCode);
@@ -54799,12 +55037,11 @@ function renderLoginPage(state, error48) {
 function escapeHtml(str) {
   return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
-var TEAM_SELECTION_TTL, ACCESS_TOKEN_TTL, supabaseRefreshMutex;
+var TEAM_SELECTION_TTL, ACCESS_TOKEN_TTL;
 var init_auth2 = __esm(() => {
   init_errors4();
   TEAM_SELECTION_TTL = 10 * 60 * 1000;
   ACCESS_TOKEN_TTL = 7 * 24 * 3600;
-  supabaseRefreshMutex = new Map;
 });
 
 // src/redis-store.ts
@@ -54997,6 +55234,39 @@ async function startHttpServer(options) {
       return;
     }
     const identity = `jwt:${auth.userId.slice(0, 8)}...:team=${auth.teamId.slice(0, 8)}...`;
+    if (isJwtExpired(auth.jwt)) {
+      try {
+        const refreshed = await refreshSupabaseJwtRaw(auth.refreshToken);
+        if (refreshed) {
+          auth.jwt = refreshed.jwt;
+          auth.refreshToken = refreshed.refreshToken;
+          const entry = await store.get("access_tokens", auth.mcpToken);
+          if (entry) {
+            const remainingMs = entry.expiresAt - Date.now();
+            if (remainingMs > 0) {
+              await store.set("access_tokens", auth.mcpToken, {
+                ...entry,
+                supabaseJwt: refreshed.jwt,
+                supabaseRefreshToken: refreshed.refreshToken
+              }, Math.ceil(remainingMs / 1000));
+              console.error(`[PROACTIVE_REFRESH] OK: JWT refreshed on ${method} (${identity})`);
+            }
+          }
+        }
+      } catch (error48) {
+        if (error48 instanceof SessionExpiredError) {
+          console.error(`[PROACTIVE_REFRESH] Session dead on ${method} (${identity}): ${error48.message}`);
+          await store.del("access_tokens", auth.mcpToken);
+          res.status(401).json({
+            jsonrpc: "2.0",
+            error: { code: -32001, message: error48.message },
+            id: req.body?.id ?? null
+          });
+          return;
+        }
+        console.error(`[PROACTIVE_REFRESH] WARN: refresh failed on ${method}, continuing with stale JWT`, error48);
+      }
+    }
     try {
       console.error(`[MCP] POST method=${method} auth=${identity}`);
       const transport = new StreamableHTTPServerTransport({
@@ -55074,6 +55344,7 @@ var init_http2 = __esm(async () => {
   init_bearerAuth();
   init_auth2();
   init_redis_store();
+  init_client2();
   await init_src();
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kadoa/mcp",
-  "version": "0.3.8",
+  "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",