@csntgao/ai-employee-client 0.15.7 → 0.16.0

package/dist/index.js

@@ -221,9 +221,9 @@ function extractText(raw) {
   try {
     const parsed = JSON.parse(value);
     if (typeof parsed === "string") return parsed.trim();
-    const record3 = asRecord(parsed);
+    const record4 = asRecord(parsed);
     for (const key of ["text", "result", "message", "content"]) {
-      const candidate = stringValue(record3[key]).trim();
+      const candidate = stringValue(record4[key]).trim();
       if (candidate) return candidate;
     }
   } catch {
@@ -941,9 +941,9 @@ var AiEmployeeClient = class {
     for (const streamEvent of event.result.streamEvents) {
       this.applyAssistantStreamEvent(event.sessionId, streamEvent);
     }
-    for (const text2 of event.result.activities) {
+    for (const text3 of event.result.activities) {
       if (!this.assistantReceivedInCurrentTurn) {
-        this.emit("work-activity", { sessionId: event.sessionId, text: text2 });
+        this.emit("work-activity", { sessionId: event.sessionId, text: text3 });
       }
     }
     for (const message of event.result.messages) {
@@ -1085,20 +1085,20 @@ var AiEmployeeClient = class {
     if (!this.isCurrentSocket(socket, generation)) return;
     this.socket = null;
     this.clearHeartbeatTimer();
-    const authenticationFailure3 = this.socketAuthenticationFailure?.generation === generation ? this.socketAuthenticationFailure : null;
+    const authenticationFailure4 = this.socketAuthenticationFailure?.generation === generation ? this.socketAuthenticationFailure : null;
     this.socketAuthenticationFailure = null;
     if (!this.shouldReconnect || this.destroyed) {
       if (!this.destroyed) this.setState("disconnected");
       return;
     }
-    if (authenticationFailure3?.retryMode === "never") {
+    if (authenticationFailure4?.retryMode === "never") {
       this.shouldReconnect = false;
       this.setState("disconnected");
       return;
     }
     if (code === 4400 || code === 4403) {
       this.shouldReconnect = false;
-      if (!authenticationFailure3) {
+      if (!authenticationFailure4) {
         const errorCode = code === 4403 ? "AUTHENTICATION_FAILED" : "PROTOCOL_ERROR";
         const message = code === 4403 ? "\u5F53\u524D\u8EAB\u4EFD\u65E0\u6743\u5EFA\u7ACB\u5B9E\u65F6\u8FDE\u63A5\u3002" : "\u5B9E\u65F6\u8FDE\u63A5\u534F\u8BAE\u4E0D\u53D7\u652F\u6301\u3002";
         this.emitError(errorCode, message, false);
@@ -1106,15 +1106,15 @@ var AiEmployeeClient = class {
       this.setState("disconnected");
       return;
     }
-    if (authenticationFailure3?.retryMode === "availability" || code === 1013) {
-      if (!authenticationFailure3) {
+    if (authenticationFailure4?.retryMode === "availability" || code === 1013) {
+      if (!authenticationFailure4) {
         this.emitError("REALTIME_UNAVAILABLE", "\u5B9E\u65F6\u9274\u6743\u670D\u52A1\u6682\u4E0D\u53EF\u7528\uFF0C\u6B63\u5728\u91CD\u8BD5\u3002", true);
       }
       this.scheduleAvailabilityReconnect();
       return;
     }
     if (code === 4401) {
-      if (!authenticationFailure3) {
+      if (!authenticationFailure4) {
         this.emitError("AUTHENTICATION_FAILED", "\u8FDE\u63A5\u51ED\u8BC1\u5DF2\u5931\u6548\uFF0C\u6B63\u5728\u91CD\u65B0\u8FDE\u63A5\u3002", true);
       }
     }
@@ -2070,13 +2070,13 @@ var CustomerSupportClient = class {
     this.socket = null;
     if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
     this.heartbeatTimer = null;
-    const authenticationFailure3 = this.socketAuthenticationFailure?.generation === generation ? this.socketAuthenticationFailure : null;
+    const authenticationFailure4 = this.socketAuthenticationFailure?.generation === generation ? this.socketAuthenticationFailure : null;
     this.socketAuthenticationFailure = null;
     if (!this.shouldReconnect || this.destroyed) {
       if (!this.destroyed) this.setState("disconnected");
       return;
     }
-    if (authenticationFailure3?.retryMode === "never") {
+    if (authenticationFailure4?.retryMode === "never") {
       this.shouldReconnect = false;
       this.stopFallbackHistoryRefresh();
       this.setState("disconnected");
@@ -2085,7 +2085,7 @@ var CustomerSupportClient = class {
     if (code === 4400 || code === 4403) {
       this.shouldReconnect = false;
       this.stopFallbackHistoryRefresh();
-      if (!authenticationFailure3) {
+      if (!authenticationFailure4) {
         this.emitError(
           code === 4400 ? "PROTOCOL_ERROR" : "AUTHENTICATION_FAILED",
           code === 4400 ? "\u5BA2\u670D\u5B9E\u65F6\u8FDE\u63A5\u534F\u8BAE\u4E0D\u53D7\u652F\u6301\u3002" : "\u5F53\u524D\u8EAB\u4EFD\u65E0\u6743\u4F7F\u7528\u4EBA\u5DE5\u5BA2\u670D\u3002",
@@ -2095,15 +2095,15 @@ var CustomerSupportClient = class {
       this.setState("disconnected");
       return;
     }
-    if (authenticationFailure3?.retryMode === "availability" || code === 1013) {
-      if (!authenticationFailure3) {
+    if (authenticationFailure4?.retryMode === "availability" || code === 1013) {
+      if (!authenticationFailure4) {
         this.emitError("REALTIME_UNAVAILABLE", "\u5BA2\u670D\u5B9E\u65F6\u9274\u6743\u670D\u52A1\u6682\u4E0D\u53EF\u7528\uFF0C\u6B63\u5728\u91CD\u8BD5\u3002", true);
       }
       this.scheduleAvailabilityReconnect();
       return;
     }
-    if (authenticationFailure3?.retryMode === "token" || code === 4401) {
-      if (!authenticationFailure3) {
+    if (authenticationFailure4?.retryMode === "token" || code === 4401) {
+      if (!authenticationFailure4) {
         this.emitError("AUTHENTICATION_FAILED", "\u5BA2\u670D\u8FDE\u63A5\u51ED\u8BC1\u5DF2\u5931\u6548\uFF0C\u6B63\u5728\u91CD\u65B0\u8FDE\u63A5\u3002", true);
       }
       if (this.tokenReconnectAttempt >= MAX_TOKEN_RECONNECTS) {
@@ -2465,6 +2465,7 @@ var NotificationCenterClient = class {
       this.applyRead([id], result.readAt);
       this.setUnreadCount(result.unreadCount);
       this.emit("notification-read", { notificationId: id });
+      if (this.readStatus === "unread") this.resyncUnreadInbox();
     } catch {
       this.emitError("MARK_READ_FAILED", "\u901A\u77E5\u6807\u8BB0\u5DF2\u8BFB\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002", true);
     }
@@ -2610,6 +2611,7 @@ var NotificationCenterClient = class {
     if (change.kind === "read") {
       this.applyRead(change.notificationIds, change.readAt ?? null);
       this.syncRealtimeUnreadCount(change.unreadCount);
+      if (this.readStatus === "unread") this.resyncUnreadInbox();
       return;
     }
     const removed = new Set(change.notificationIds);
@@ -2621,6 +2623,15 @@ var NotificationCenterClient = class {
       }
     }
     this.syncRealtimeUnreadCount(change.unreadCount);
+    if (this.readStatus === "unread") this.resyncUnreadInbox();
+  }
+  resyncUnreadInbox() {
+    if (this.destroyed) return;
+    if (this.loadingInbox) {
+      this.pendingResync = true;
+      return;
+    }
+    void this.reloadInbox();
   }
   syncRealtimeUnreadCount(value) {
     if (this.applicationName && typeof value === "number") this.setUnreadCount(value);
@@ -2684,6 +2695,640 @@ function normalizedText2(value) {
   return typeof value === "string" ? value.trim() : "";
 }
 
-export { AiEmployeeClient, AiEmployeeClientError, AiEmployeeTransportError, CustomerSupportClient, CustomerSupportClientError, NotificationCenterClient, NotificationCenterClientError, createAuthenticateFrame, createPingFrame, createSubscriptionFrame, hashText, isUuidV4, parseAiEmployeeAssistantContent, parseAiEmployeeEvent, parseJsonRecord };
+// src/user-realtime-client.ts
+var DEFAULT_RECONNECT3 = {
+  initialDelayMs: 1e3,
+  maximumDelayMs: 3e4,
+  factor: 2,
+  jitter: 0.2
+};
+var DEFAULT_MAXIMUM_SEEN_EVENT_IDS = 2e3;
+var DEFAULT_HEARTBEAT_INTERVAL_MS = 25e3;
+var CHANNEL_PATTERN = /^[a-z][a-z0-9_]{0,63}$/;
+var CURSOR_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/;
+var UserRealtimeClientError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "UserRealtimeClientError";
+    this.code = code;
+  }
+};
+var UserRealtimeClient = class {
+  requestedChannels;
+  realtimeUrl;
+  getAccessToken;
+  cursorStore;
+  reconnectOptions;
+  webSocketFactory;
+  minimumHeartbeatMs;
+  maximumSeenEventIds;
+  listeners = /* @__PURE__ */ new Map();
+  cursors = /* @__PURE__ */ new Map();
+  cursorWriteChains = /* @__PURE__ */ new Map();
+  seenEventIds = /* @__PURE__ */ new Map();
+  channelSequences = /* @__PURE__ */ new Map();
+  pendingResyncs = /* @__PURE__ */ new Map();
+  resyncGenerations = /* @__PURE__ */ new Map();
+  socket = null;
+  messageChain = Promise.resolve();
+  reconnectTimer = null;
+  heartbeatTimer = null;
+  startPromise = null;
+  currentState = "idle";
+  socketGeneration = 0;
+  lifecycleGeneration = 0;
+  reconnectAttempt = 0;
+  deliverySequence = 0;
+  shouldReconnect = false;
+  destroyed = false;
+  socketAuthenticationFailure = null;
+  constructor(options) {
+    if (!options || typeof options !== "object") {
+      throw new UserRealtimeClientError("INVALID_CONFIGURATION", "\u7F3A\u5C11\u7EDF\u4E00\u5B9E\u65F6\u5BA2\u6237\u7AEF\u914D\u7F6E\u3002");
+    }
+    this.realtimeUrl = validateRealtimeUrl3(options.realtimeUrl);
+    if (typeof options.getAccessToken !== "function") {
+      throw new UserRealtimeClientError("INVALID_CONFIGURATION", "\u7F3A\u5C11\u5B9E\u65F6\u8FDE\u63A5\u51ED\u8BC1\u63D0\u4F9B\u5668\u3002");
+    }
+    this.getAccessToken = options.getAccessToken;
+    this.requestedChannels = normalizeChannels(options.requestedChannels);
+    if (options.cursorStore !== void 0 && options.cursorStore !== null && (typeof options.cursorStore.load !== "function" || typeof options.cursorStore.save !== "function" || typeof options.cursorStore.clear !== "function")) {
+      throw new UserRealtimeClientError("INVALID_CONFIGURATION", "cursorStore \u914D\u7F6E\u65E0\u6548\u3002");
+    }
+    this.cursorStore = options.cursorStore ?? null;
+    this.reconnectOptions = normalizeReconnect2(options.reconnect);
+    this.minimumHeartbeatMs = positiveNumber2(options.minimumHeartbeatMs, 5e3);
+    this.maximumSeenEventIds = positiveInteger(
+      options.maximumSeenEventIds,
+      DEFAULT_MAXIMUM_SEEN_EVENT_IDS
+    );
+    this.webSocketFactory = options.webSocketFactory ?? ((url) => {
+      if (typeof WebSocket === "undefined") {
+        throw new UserRealtimeClientError(
+          "WEBSOCKET_UNAVAILABLE",
+          "\u5F53\u524D\u8FD0\u884C\u73AF\u5883\u4E0D\u652F\u6301\u7EDF\u4E00\u5B9E\u65F6\u8FDE\u63A5\u3002"
+        );
+      }
+      return new WebSocket(url);
+    });
+  }
+  get connectionState() {
+    return this.currentState;
+  }
+  get eventSequence() {
+    return this.deliverySequence;
+  }
+  get isDestroyed() {
+    return this.destroyed;
+  }
+  on(type, listener) {
+    this.assertUsable();
+    const listeners = this.listeners.get(type) ?? /* @__PURE__ */ new Set();
+    const untyped = listener;
+    listeners.add(untyped);
+    this.listeners.set(type, listeners);
+    return () => listeners.delete(untyped);
+  }
+  start() {
+    this.assertUsable();
+    if (this.shouldReconnect) return this.startPromise ?? Promise.resolve();
+    this.shouldReconnect = true;
+    this.reconnectAttempt = 0;
+    const lifecycle = ++this.lifecycleGeneration;
+    this.setState("connecting");
+    const pending = this.loadCursors(lifecycle).then(() => {
+      if (!this.isCurrentLifecycle(lifecycle) || !this.shouldReconnect) return;
+      this.openSocket(false);
+    });
+    this.startPromise = pending;
+    const clear = () => {
+      if (this.startPromise === pending) this.startPromise = null;
+    };
+    void pending.then(clear, clear);
+    return pending;
+  }
+  stop() {
+    if (this.destroyed) return;
+    this.stopConnection();
+    this.setState("stopped");
+  }
+  async restart(options = {}) {
+    this.assertUsable();
+    this.stopConnection();
+    this.clearDeliveryState();
+    if (options.clearCursors) await this.clearCursors();
+    await this.start();
+  }
+  async clearCursors() {
+    this.assertUsable();
+    this.cursors.clear();
+    this.pendingResyncs.clear();
+    await Promise.all(this.requestedChannels.map((channel) => this.clearStoredCursor(channel)));
+  }
+  /**
+   * Confirm that Host HTTP state was restored for a previously emitted resync signal.
+   * Stale confirmations never overwrite a cursor advanced by a newer realtime event.
+   */
+  async confirmResync(detail) {
+    this.assertUsable();
+    const pending = this.pendingResyncs.get(detail.channel)?.detail;
+    if (!pending || pending.generation !== detail.generation || pending.latestEventId !== detail.latestEventId || pending.sequence !== detail.sequence || (this.channelSequences.get(detail.channel) ?? 0) !== detail.sequence || !validCursor(detail.latestEventId)) {
+      return false;
+    }
+    this.pendingResyncs.delete(detail.channel);
+    this.rememberCursor(detail.channel, detail.latestEventId);
+    await this.flushCursorWrite(detail.channel);
+    return true;
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.stopConnection();
+    this.destroyed = true;
+    this.setState("destroyed");
+    this.listeners.clear();
+    this.clearDeliveryState();
+    this.cursors.clear();
+    this.cursorWriteChains.clear();
+  }
+  async loadCursors(lifecycle) {
+    if (!this.cursorStore) return;
+    await Promise.all(
+      this.requestedChannels.map(async (channel) => {
+        try {
+          const value = await this.cursorStore?.load(channel);
+          if (!this.isCurrentLifecycle(lifecycle)) return;
+          const cursor = normalizedCursor(value);
+          if (cursor) this.cursors.set(channel, cursor);
+          else this.cursors.delete(channel);
+        } catch {
+          if (this.isCurrentLifecycle(lifecycle)) {
+            this.emitError(
+              "CURSOR_STORE_FAILED",
+              "\u5B9E\u65F6\u6E38\u6807\u8BFB\u53D6\u5931\u8D25\uFF0C\u5C06\u4ECE\u5F53\u524D\u670D\u52A1\u7AEF\u4F4D\u7F6E\u7EE7\u7EED\u3002",
+              true,
+              channel
+            );
+          }
+        }
+      })
+    );
+  }
+  openSocket(reconnecting) {
+    if (this.destroyed || !this.shouldReconnect) return;
+    this.clearReconnectTimer();
+    this.closeCurrentSocket();
+    this.setState(reconnecting ? "reconnecting" : "connecting");
+    let socket;
+    try {
+      socket = this.webSocketFactory(this.realtimeUrl);
+    } catch {
+      this.shouldReconnect = false;
+      this.emitError("WEBSOCKET_UNAVAILABLE", "\u65E0\u6CD5\u5EFA\u7ACB\u7EDF\u4E00\u5B9E\u65F6\u8FDE\u63A5\u3002", false);
+      this.setState("stopped");
+      return;
+    }
+    const generation = ++this.socketGeneration;
+    this.socket = socket;
+    this.socketAuthenticationFailure = null;
+    socket.onopen = () => void this.authenticate(socket, generation);
+    socket.onmessage = (event) => {
+      const next = this.messageChain.catch(() => void 0).then(() => this.handleSocketData(event.data, socket, generation));
+      this.messageChain = next;
+      void next.catch(() => {
+        if (this.isCurrentSocket(socket, generation)) {
+          this.emitError("PROTOCOL_ERROR", "\u7EDF\u4E00\u5B9E\u65F6\u6D88\u606F\u5904\u7406\u5931\u8D25\u3002", true);
+        }
+      });
+    };
+    socket.onerror = () => {
+      if (!this.isCurrentSocket(socket, generation)) return;
+      this.emitError("WEBSOCKET_ERROR", "\u7EDF\u4E00\u5B9E\u65F6\u8FDE\u63A5\u53D1\u751F\u5F02\u5E38\u3002", true);
+    };
+    socket.onclose = (event) => this.handleSocketClose(socket, generation, event.code);
+  }
+  async authenticate(socket, generation) {
+    if (!this.isCurrentSocket(socket, generation)) return;
+    this.setState("authenticating");
+    let accessToken = "";
+    try {
+      const supplied = await this.getAccessToken();
+      accessToken = typeof supplied === "string" ? supplied.trim() : "";
+    } catch {
+    }
+    if (!this.isCurrentSocket(socket, generation)) return;
+    if (!accessToken) {
+      this.shouldReconnect = false;
+      this.emitError("TOKEN_UNAVAILABLE", "\u65E0\u6CD5\u83B7\u53D6\u7EDF\u4E00\u5B9E\u65F6\u8FDE\u63A5\u51ED\u8BC1\u3002", false);
+      this.closeCurrentSocket();
+      this.setState("stopped");
+      return;
+    }
+    const cursors = {};
+    for (const channel of this.requestedChannels)
+      cursors[channel] = this.cursors.get(channel) ?? null;
+    socket.send(
+      JSON.stringify({
+        type: "authenticate",
+        protocol_version: 1,
+        access_token: accessToken,
+        requested_channels: [...this.requestedChannels],
+        cursors
+      })
+    );
+    accessToken = "";
+  }
+  async handleSocketData(data, socket, generation) {
+    if (!this.isCurrentSocket(socket, generation)) return;
+    let raw = "";
+    if (typeof data === "string") raw = data;
+    else if (typeof Blob !== "undefined" && data instanceof Blob) raw = await data.text();
+    else if (typeof ArrayBuffer !== "undefined" && data instanceof ArrayBuffer) {
+      raw = new TextDecoder().decode(data);
+    } else {
+      this.emitError("PROTOCOL_ERROR", "\u6536\u5230\u65E0\u6CD5\u8BC6\u522B\u7684\u7EDF\u4E00\u5B9E\u65F6\u6D88\u606F\u3002", true);
+      return;
+    }
+    if (!this.isCurrentSocket(socket, generation)) return;
+    const message = parseJsonRecord(raw);
+    if (!message) {
+      this.emitError("PROTOCOL_ERROR", "\u6536\u5230\u65E0\u6CD5\u89E3\u6790\u7684\u7EDF\u4E00\u5B9E\u65F6\u6D88\u606F\u3002", true);
+      return;
+    }
+    this.handleServerMessage(message, socket, generation);
+  }
+  handleServerMessage(message, socket, generation) {
+    const type = text2(message.type);
+    if (type === "realtime_ready") {
+      this.handleReady(message, socket, generation);
+      return;
+    }
+    if (type === "realtime_event") {
+      this.handleRealtimeEvent(message);
+      return;
+    }
+    if (type === "channel_resync_required") {
+      this.handleResyncRequired(message);
+      return;
+    }
+    if (type === "channel_error") {
+      this.handleChannelError(message, socket);
+      return;
+    }
+    if (type === "authentication_error") {
+      this.handleAuthenticationError(message, socket, generation);
+      return;
+    }
+    if (type === "protocol_error") {
+      this.shouldReconnect = false;
+      this.emitError("PROTOCOL_ERROR", "\u7EDF\u4E00\u5B9E\u65F6\u8FDE\u63A5\u534F\u8BAE\u5F02\u5E38\u3002", false);
+      this.closeCurrentSocket();
+      this.setState("stopped");
+    }
+  }
+  handleReady(message, socket, generation) {
+    const channels = record3(message.channels);
+    const unavailable = this.requestedChannels.find(
+      (channel) => record3(channels[channel]).available !== true
+    );
+    if (unavailable) {
+      this.shouldReconnect = false;
+      this.emitError("CHANNEL_UNAVAILABLE", "\u8BF7\u6C42\u7684\u5B9E\u65F6\u901A\u9053\u4E0D\u53EF\u7528\u3002", false, unavailable);
+      this.closeCurrentSocket();
+      this.setState("stopped");
+      return;
+    }
+    this.reconnectAttempt = 0;
+    this.startHeartbeat(numberValue3(message.heartbeat_interval_seconds), socket, generation);
+    this.setState("connected");
+    this.emit("ready", { channels: [...this.requestedChannels] });
+  }
+  handleRealtimeEvent(message) {
+    const channel = text2(message.channel);
+    if (!this.requestedChannels.includes(channel)) return;
+    const event = record3(message.event);
+    const eventId = normalizedEventId(event.event_id) ?? normalizedEventId(message.event_id) ?? "";
+    if (!eventId) {
+      this.emitError("PROTOCOL_ERROR", "\u5B9E\u65F6\u4E8B\u4EF6\u7F3A\u5C11\u7A33\u5B9A\u4E8B\u4EF6\u6807\u8BC6\u3002", true, channel);
+      return;
+    }
+    const cursor = normalizedCursor(event.cursor) ?? normalizedCursor(message.cursor) ?? "";
+    if (this.hasSeenEvent(channel, eventId)) return;
+    const previousChannelSequence = this.channelSequences.get(channel) ?? 0;
+    const sequence = previousChannelSequence + 1;
+    this.channelSequences.set(channel, sequence);
+    this.deliverySequence += 1;
+    const detail = {
+      channel,
+      event: message.event,
+      eventId,
+      cursor,
+      sequence
+    };
+    if (!this.emitSafely("channel-event", detail)) {
+      this.channelSequences.set(channel, previousChannelSequence);
+      this.deliverySequence -= 1;
+      this.emitError("EVENT_HANDLER_FAILED", "\u5B9E\u65F6\u4E8B\u4EF6\u5904\u7406\u5931\u8D25\uFF0C\u5C06\u7B49\u5F85\u670D\u52A1\u7AEF\u91CD\u653E\u3002", true, channel);
+      return;
+    }
+    this.rememberEventId(channel, eventId);
+    if (cursor) this.rememberCursor(channel, cursor);
+    else this.emitError("PROTOCOL_ERROR", "\u5B9E\u65F6\u4E8B\u4EF6\u7F3A\u5C11\u53EF\u7EED\u4F20\u6E38\u6807\u3002", true, channel);
+  }
+  handleResyncRequired(message) {
+    const channel = text2(message.channel);
+    if (!this.requestedChannels.includes(channel)) return;
+    const generation = (this.resyncGenerations.get(channel) ?? 0) + 1;
+    this.resyncGenerations.set(channel, generation);
+    const detail = {
+      channel,
+      reason: text2(message.reason) || "cursor_expired",
+      latestEventId: normalizedCursor(message.latest_event_id) ?? "",
+      sequence: this.channelSequences.get(channel) ?? 0,
+      generation
+    };
+    this.pendingResyncs.set(channel, { detail });
+    this.emit("resync-required", detail);
+  }
+  handleChannelError(message, socket) {
+    const channel = text2(message.channel);
+    if (!this.requestedChannels.includes(channel)) return;
+    this.emitError("CHANNEL_UNAVAILABLE", "\u5B9E\u65F6\u901A\u9053\u6682\u4E0D\u53EF\u7528\uFF0C\u6B63\u5728\u91CD\u65B0\u8FDE\u63A5\u3002", true, channel);
+    socket.close();
+  }
+  handleAuthenticationError(message, socket, generation) {
+    const failure = authenticationFailure3(text2(message.code));
+    this.socketAuthenticationFailure = { generation, retryMode: failure.retryMode };
+    this.emitError(failure.code, failure.message, failure.retryMode !== "never");
+    socket.close();
+  }
+  startHeartbeat(intervalSeconds, socket, generation) {
+    this.clearHeartbeatTimer();
+    const requestedMs = Number.isFinite(intervalSeconds) && intervalSeconds > 0 ? intervalSeconds * 1e3 : DEFAULT_HEARTBEAT_INTERVAL_MS;
+    const intervalMs = Math.max(this.minimumHeartbeatMs, requestedMs);
+    this.heartbeatTimer = setInterval(() => {
+      if (!this.isCurrentSocket(socket, generation) || socket.readyState !== 1) return;
+      socket.send(JSON.stringify(createPingFrame()));
+    }, intervalMs);
+  }
+  handleSocketClose(socket, generation, code) {
+    if (!this.isCurrentSocket(socket, generation)) return;
+    this.socket = null;
+    this.clearHeartbeatTimer();
+    const failure = this.socketAuthenticationFailure?.generation === generation ? this.socketAuthenticationFailure : null;
+    this.socketAuthenticationFailure = null;
+    if (!this.shouldReconnect || this.destroyed) return;
+    if (failure?.retryMode === "never" || code === 4400 || code === 4401 || code === 4403) {
+      this.shouldReconnect = false;
+      if (!failure) {
+        if (code === 4401) {
+          this.emitError("AUTHENTICATION_FAILED", "\u7EDF\u4E00\u5B9E\u65F6\u8FDE\u63A5\u51ED\u8BC1\u5DF2\u5931\u6548\u3002", false);
+        } else if (code === 4403) {
+          this.emitError("AUTHENTICATION_FAILED", "\u5F53\u524D\u8EAB\u4EFD\u65E0\u6743\u5EFA\u7ACB\u7EDF\u4E00\u5B9E\u65F6\u8FDE\u63A5\u3002", false);
+        } else {
+          this.emitError("PROTOCOL_ERROR", "\u7EDF\u4E00\u5B9E\u65F6\u8FDE\u63A5\u534F\u8BAE\u4E0D\u53D7\u652F\u6301\u3002", false);
+        }
+      }
+      this.setState("stopped");
+      return;
+    }
+    if (code === 1013 && !failure) {
+      this.emitError("REALTIME_UNAVAILABLE", "\u7EDF\u4E00\u5B9E\u65F6\u670D\u52A1\u6682\u4E0D\u53EF\u7528\uFF0C\u6B63\u5728\u91CD\u8BD5\u3002", true);
+    }
+    this.scheduleReconnect();
+  }
+  scheduleReconnect() {
+    if (this.destroyed || !this.shouldReconnect || this.reconnectTimer) return;
+    this.setState("reconnecting");
+    const base = Math.min(
+      this.reconnectOptions.initialDelayMs * this.reconnectOptions.factor ** this.reconnectAttempt,
+      this.reconnectOptions.maximumDelayMs
+    );
+    const jitter = base * this.reconnectOptions.jitter * (Math.random() * 2 - 1);
+    this.reconnectAttempt += 1;
+    const lifecycle = this.lifecycleGeneration;
+    this.reconnectTimer = setTimeout(
+      () => {
+        this.reconnectTimer = null;
+        if (!this.isCurrentLifecycle(lifecycle) || !this.shouldReconnect) return;
+        this.openSocket(true);
+      },
+      Math.max(0, base + jitter)
+    );
+  }
+  rememberEventId(channel, eventId) {
+    const seen = this.seenEventIds.get(channel) ?? /* @__PURE__ */ new Set();
+    seen.add(eventId);
+    while (seen.size > this.maximumSeenEventIds) {
+      const oldest = seen.values().next().value;
+      if (typeof oldest !== "string") break;
+      seen.delete(oldest);
+    }
+    this.seenEventIds.set(channel, seen);
+  }
+  hasSeenEvent(channel, eventId) {
+    return this.seenEventIds.get(channel)?.has(eventId) === true;
+  }
+  rememberCursor(channel, cursor) {
+    this.cursors.set(channel, cursor);
+    if (!this.cursorStore) return;
+    const previous = this.cursorWriteChains.get(channel) ?? Promise.resolve();
+    const next = previous.catch(() => void 0).then(() => this.cursorStore?.save(channel, cursor)).then(() => void 0).catch(() => {
+      this.emitError("CURSOR_STORE_FAILED", "\u5B9E\u65F6\u6E38\u6807\u4FDD\u5B58\u5931\u8D25\u3002", true, channel);
+    });
+    this.cursorWriteChains.set(channel, next);
+    void next.finally(() => {
+      if (this.cursorWriteChains.get(channel) === next) this.cursorWriteChains.delete(channel);
+    });
+  }
+  async flushCursorWrite(channel) {
+    await this.cursorWriteChains.get(channel);
+  }
+  async clearStoredCursor(channel) {
+    try {
+      await this.cursorWriteChains.get(channel);
+      await this.cursorStore?.clear(channel);
+    } catch {
+      this.emitError("CURSOR_STORE_FAILED", "\u5B9E\u65F6\u6E38\u6807\u6E05\u7406\u5931\u8D25\u3002", true, channel);
+    }
+  }
+  stopConnection() {
+    this.shouldReconnect = false;
+    this.startPromise = null;
+    this.lifecycleGeneration += 1;
+    this.clearReconnectTimer();
+    this.clearHeartbeatTimer();
+    this.closeCurrentSocket();
+    this.socketAuthenticationFailure = null;
+  }
+  closeCurrentSocket() {
+    const socket = this.socket;
+    this.socket = null;
+    this.socketGeneration += 1;
+    if (socket && socket.readyState < 2) socket.close();
+  }
+  clearReconnectTimer() {
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = null;
+  }
+  clearHeartbeatTimer() {
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = null;
+  }
+  clearDeliveryState() {
+    this.seenEventIds.clear();
+    this.channelSequences.clear();
+    this.pendingResyncs.clear();
+    this.resyncGenerations.clear();
+    this.deliverySequence = 0;
+  }
+  isCurrentSocket(socket, generation) {
+    return !this.destroyed && this.shouldReconnect && this.socket === socket && this.socketGeneration === generation;
+  }
+  isCurrentLifecycle(generation) {
+    return !this.destroyed && this.lifecycleGeneration === generation;
+  }
+  setState(current) {
+    if (this.currentState === current) return;
+    const previous = this.currentState;
+    this.currentState = current;
+    this.emit("state-change", { previous, current });
+  }
+  emitError(code, message, recoverable, channel) {
+    const detail = {
+      code,
+      message,
+      recoverable,
+      ...channel ? { channel } : {}
+    };
+    this.emit("error", detail);
+    return detail;
+  }
+  emit(type, detail) {
+    for (const listener of this.listeners.get(type) ?? []) {
+      try {
+        listener(detail);
+      } catch {
+      }
+    }
+  }
+  emitSafely(type, detail) {
+    let success = true;
+    for (const listener of this.listeners.get(type) ?? []) {
+      try {
+        listener(detail);
+      } catch {
+        success = false;
+      }
+    }
+    return success;
+  }
+  assertUsable() {
+    if (this.destroyed) {
+      throw new UserRealtimeClientError("CLIENT_DESTROYED", "\u7EDF\u4E00\u5B9E\u65F6\u5BA2\u6237\u7AEF\u5DF2\u7ECF\u9500\u6BC1\u3002");
+    }
+  }
+};
+function validateRealtimeUrl3(rawUrl) {
+  let url;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    throw new UserRealtimeClientError("INVALID_CONFIGURATION", "realtimeUrl \u4E0D\u662F\u6709\u6548\u5730\u5740\u3002");
+  }
+  if (!["ws:", "wss:"].includes(url.protocol)) {
+    throw new UserRealtimeClientError("INVALID_CONFIGURATION", "realtimeUrl \u53EA\u5141\u8BB8 ws: \u6216 wss:\u3002");
+  }
+  if (url.search || url.hash || url.username || url.password) {
+    throw new UserRealtimeClientError(
+      "INVALID_CONFIGURATION",
+      "realtimeUrl \u4E0D\u5141\u8BB8\u5305\u542B\u67E5\u8BE2\u53C2\u6570\u3001\u7247\u6BB5\u6216\u7528\u6237\u51ED\u636E\u3002"
+    );
+  }
+  return url.toString();
+}
+function normalizeChannels(channels) {
+  if (!Array.isArray(channels)) {
+    throw new UserRealtimeClientError("INVALID_CONFIGURATION", "requestedChannels \u4E0D\u80FD\u4E3A\u7A7A\u3002");
+  }
+  const normalized = [...new Set(channels.map((channel) => text2(channel).trim()))];
+  if (!normalized.length || normalized.some((channel) => !CHANNEL_PATTERN.test(channel))) {
+    throw new UserRealtimeClientError("INVALID_CONFIGURATION", "requestedChannels \u5305\u542B\u65E0\u6548\u901A\u9053\u3002");
+  }
+  return Object.freeze(normalized);
+}
+function normalizeReconnect2(value) {
+  const jitter = value?.jitter;
+  return {
+    initialDelayMs: positiveNumber2(value?.initialDelayMs, DEFAULT_RECONNECT3.initialDelayMs),
+    maximumDelayMs: positiveNumber2(value?.maximumDelayMs, DEFAULT_RECONNECT3.maximumDelayMs),
+    factor: Math.max(1, positiveNumber2(value?.factor, DEFAULT_RECONNECT3.factor)),
+    jitter: typeof jitter === "number" && Number.isFinite(jitter) ? Math.min(1, Math.max(0, jitter)) : DEFAULT_RECONNECT3.jitter
+  };
+}
+function authenticationFailure3(code) {
+  if (isRealtimeAvailabilityFailure2(code)) {
+    return {
+      code: "REALTIME_UNAVAILABLE",
+      message: "\u7EDF\u4E00\u5B9E\u65F6\u670D\u52A1\u6682\u4E0D\u53EF\u7528\uFF0C\u6B63\u5728\u91CD\u8BD5\u3002",
+      retryMode: "availability"
+    };
+  }
+  if (code === "INVALID_ARGUMENT") {
+    return {
+      code: "PROTOCOL_ERROR",
+      message: "\u7EDF\u4E00\u5B9E\u65F6\u8FDE\u63A5\u534F\u8BAE\u4E0D\u53D7\u652F\u6301\u3002",
+      retryMode: "never"
+    };
+  }
+  if (code === "ACCESS_DENIED") {
+    return {
+      code: "AUTHENTICATION_FAILED",
+      message: "\u5F53\u524D\u8EAB\u4EFD\u65E0\u6743\u5EFA\u7ACB\u7EDF\u4E00\u5B9E\u65F6\u8FDE\u63A5\u3002",
+      retryMode: "never"
+    };
+  }
+  return {
+    code: "AUTHENTICATION_FAILED",
+    message: "\u7EDF\u4E00\u5B9E\u65F6\u8FDE\u63A5\u51ED\u8BC1\u5DF2\u5931\u6548\u3002",
+    retryMode: "never"
+  };
+}
+function isRealtimeAvailabilityFailure2(code) {
+  return code === "REALTIME_UNAVAILABLE" || code === "KANBAN_AUTH_FAILED" || code.startsWith("SERVICE_");
+}
+function normalizedCursor(value) {
+  const cursor = text2(value).trim();
+  return validCursor(cursor) ? cursor : null;
+}
+function normalizedEventId(value) {
+  const eventId = text2(value).trim();
+  if (!eventId || eventId.length > 256) return null;
+  for (const character of eventId) {
+    const code = character.charCodeAt(0);
+    if (code < 32 || code === 127) return null;
+  }
+  return eventId;
+}
+function validCursor(value) {
+  return CURSOR_PATTERN.test(value);
+}
+function positiveNumber2(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function positiveInteger(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.max(1, Math.floor(value)) : fallback;
+}
+function text2(value) {
+  return typeof value === "string" ? value : "";
+}
+function record3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function numberValue3(value) {
+  return typeof value === "number" ? value : Number.NaN;
+}
+
+export { AiEmployeeClient, AiEmployeeClientError, AiEmployeeTransportError, CustomerSupportClient, CustomerSupportClientError, NotificationCenterClient, NotificationCenterClientError, UserRealtimeClient, UserRealtimeClientError, createAuthenticateFrame, createPingFrame, createSubscriptionFrame, hashText, isUuidV4, parseAiEmployeeAssistantContent, parseAiEmployeeEvent, parseJsonRecord };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map