@csntgao/ai-employee-client 0.14.3

package/dist/index.js

@@ -0,0 +1,2207 @@
+// src/protocol.ts
+function createAuthenticateFrame(accessToken) {
+  return {
+    type: "authenticate",
+    protocol_version: 1,
+    access_token: accessToken,
+    requested_channels: ["ai_employee"],
+    cursors: {}
+  };
+}
+function createSubscriptionFrame(sessionId, action = "subscribe", replayHistory = false) {
+  const frame = {
+    action,
+    channel: "ai_employee",
+    resource_type: "session",
+    resource_id: sessionId
+  };
+  if (action === "subscribe") frame.replay_history = replayHistory;
+  return frame;
+}
+function createPingFrame(now = /* @__PURE__ */ new Date()) {
+  return { action: "ping", timestamp: now.toISOString() };
+}
+function parseJsonRecord(raw) {
+  try {
+    return asRecord(JSON.parse(raw));
+  } catch {
+    return null;
+  }
+}
+function parseAiEmployeeEvent(raw) {
+  const event = asRecord(raw);
+  const type = stringValue(event.type);
+  const sessionId = stringValue(event.session_id).trim();
+  if (type === "session_title_updated") {
+    const title = stringValue(asRecord(event.payload).title).trim();
+    return sessionId && title ? { kind: "session-title", sessionId, title } : { kind: "ignored" };
+  }
+  if (type !== "session_message" || !sessionId) return { kind: "ignored" };
+  return {
+    kind: "session-message",
+    sessionId,
+    result: parseSessionPayload(asRecord(event.payload), sessionId)
+  };
+}
+function parseSessionPayload(payload, sessionId) {
+  const messages = [];
+  const patches = Array.isArray(payload.JsonPatch) ? payload.JsonPatch : [];
+  for (const rawPatch of patches) {
+    const patch = asRecord(rawPatch);
+    const value = asRecord(patch.value);
+    const parsed = messageFromEntry(value, sessionId);
+    if (parsed) messages.push(parsed);
+  }
+  const result = stringValue(payload.result).trim();
+  const fallbackResult = result ? createMessage(
+    sessionId,
+    "assistant",
+    result,
+    `result:${sessionId}:${hashText(result)}`,
+    payload
+  ) : void 0;
+  if (payload.error) {
+    messages.push(
+      createMessage(
+        sessionId,
+        "error",
+        "AI \u56DE\u590D\u51FA\u73B0\u5F02\u5E38\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002",
+        `error:${sessionId}:${hashText(stableString(payload))}`,
+        payload
+      )
+    );
+  }
+  let processing;
+  if (payload.Ready === true) processing = true;
+  if (payload.finished === true || payload.stopped === true) processing = false;
+  return { messages, fallbackResult, processing };
+}
+function messageFromEntry(entry, sessionId) {
+  const entryTypeValue = entry.entry_type;
+  const entryType = typeof entryTypeValue === "string" ? entryTypeValue : stringValue(asRecord(entryTypeValue).type);
+  let role;
+  switch (entryType) {
+    case "assistant_message":
+    case "result":
+      role = "assistant";
+      break;
+    case "user_message":
+      role = "user";
+      break;
+    case "system_message":
+    case "system_push":
+      role = "system";
+      break;
+    case "error":
+    case "error_message":
+      role = "error";
+      break;
+    default:
+      return null;
+  }
+  const content = role === "error" ? "AI \u56DE\u590D\u51FA\u73B0\u5F02\u5E38\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002" : extractText(entry.content);
+  if (!content) return null;
+  const messageId = stringValue(entry.message_id);
+  const webSocketMessageId = stringValue(entry.ws_message_id);
+  const explicitId = role === "user" ? messageId || webSocketMessageId || stringValue(entry.id) : webSocketMessageId || messageId || stringValue(entry.id);
+  const fingerprint = stableString(entry);
+  const id = explicitId || `realtime:${sessionId}:${hashText(fingerprint)}`;
+  return createMessage(sessionId, role, content, id, entry);
+}
+function createMessage(sessionId, role, content, id, source) {
+  const createdAt = stringValue(source.timestamp) || stringValue(source.create_time) || stringValue(source.created_at) || (/* @__PURE__ */ new Date()).toISOString();
+  return { id, sessionId, role, content, createdAt };
+}
+function extractText(raw) {
+  if (typeof raw !== "string") return "";
+  const value = raw.trim();
+  if (!value) return "";
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed === "string") return parsed.trim();
+    const record3 = asRecord(parsed);
+    for (const key of ["text", "result", "message", "content"]) {
+      const candidate = stringValue(record3[key]).trim();
+      if (candidate) return candidate;
+    }
+  } catch {
+  }
+  const messageMatch = value.match(/<message>([\s\S]*?)<\/message>/i);
+  return (messageMatch?.[1] ?? value).trim();
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringValue(value) {
+  return typeof value === "string" ? value : "";
+}
+function stableString(value) {
+  try {
+    return JSON.stringify(value) ?? "";
+  } catch {
+    return "";
+  }
+}
+function hashText(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(36);
+}
+
+// src/client.ts
+var DEFAULT_RECONNECT = {
+  initialDelayMs: 1e3,
+  maximumDelayMs: 3e4,
+  factor: 2,
+  jitter: 0.2
+};
+var MAX_SEEN_MESSAGE_IDS = 2e3;
+var LOCAL_MESSAGE_MATCH_WINDOW_MS = 3e4;
+var MAX_AVAILABILITY_RECONNECTS = 3;
+var FIRST_MESSAGE_STORAGE_PREFIX = "uniplat.ai-employee.first-message";
+var AiEmployeeClientError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "AiEmployeeClientError";
+    this.code = code;
+  }
+};
+var AiEmployeeTransportError = class extends Error {
+  code;
+  constructor(code) {
+    super("AI Employee transport request failed.");
+    this.name = "AiEmployeeTransportError";
+    this.code = code;
+  }
+};
+var AiEmployeeClient = class {
+  aeCode;
+  agentCode;
+  realtimeUrl;
+  transport;
+  webSocketFactory;
+  reconnectOptions;
+  minimumHeartbeatMs;
+  requestIdFactory;
+  firstMessageRequestStore;
+  firstMessageRequestScope;
+  listeners = /* @__PURE__ */ new Map();
+  seenMessageIds = /* @__PURE__ */ new Set();
+  pendingLocalMessages = /* @__PURE__ */ new Map();
+  assistantReceivedInCurrentTurn = false;
+  socket = null;
+  reconnectTimer = null;
+  heartbeatTimer = null;
+  initializePromise = null;
+  currentMessages = [];
+  currentSessionId;
+  currentState = "idle";
+  reconnectAttempt = 0;
+  socketGeneration = 0;
+  lifecycleGeneration = 0;
+  shouldReconnect = false;
+  destroyed = false;
+  sending = false;
+  processing = false;
+  localMessageSequence = 0;
+  replayHistoryOnNextSubscription = false;
+  socketAuthenticationFailure = null;
+  availabilityReconnectAttempt = 0;
+  pendingFirstMessage = null;
+  constructor(options) {
+    this.realtimeUrl = validateRealtimeUrl(options.realtimeUrl);
+    this.aeCode = requiredText(options.aeCode, "aeCode");
+    this.agentCode = requiredText(options.agentCode, "agentCode");
+    if (!options.transport) {
+      throw new AiEmployeeClientError("INVALID_CONFIGURATION", "\u7F3A\u5C11 transport \u914D\u7F6E\u3002");
+    }
+    if (typeof options.transport.createSessionWithFirstMessage !== "function") {
+      throw new AiEmployeeClientError(
+        "INVALID_CONFIGURATION",
+        "transport \u7F3A\u5C11\u9996\u6761\u6D88\u606F\u539F\u5B50\u521B\u5EFA\u80FD\u529B\u3002"
+      );
+    }
+    this.transport = options.transport;
+    this.currentSessionId = normalizeSessionId(options.sessionId);
+    this.reconnectOptions = normalizeReconnectOptions(options.reconnect);
+    this.minimumHeartbeatMs = Math.max(1, options.minimumHeartbeatMs ?? 5e3);
+    this.requestIdFactory = options.requestIdFactory ?? createRequestId;
+    this.firstMessageRequestStore = options.firstMessageRequestStore === void 0 ? createSessionFirstMessageRequestStore() : options.firstMessageRequestStore;
+    this.firstMessageRequestScope = `${this.aeCode}:${this.agentCode}`;
+    this.webSocketFactory = options.webSocketFactory ?? ((url) => {
+      if (typeof WebSocket === "undefined") {
+        throw new AiEmployeeClientError("WEBSOCKET_UNAVAILABLE", "\u5F53\u524D\u8FD0\u884C\u73AF\u5883\u4E0D\u652F\u6301 WebSocket\u3002");
+      }
+      return new WebSocket(url);
+    });
+  }
+  get connectionState() {
+    return this.currentState;
+  }
+  get sessionId() {
+    return this.currentSessionId;
+  }
+  get messages() {
+    return [...this.currentMessages];
+  }
+  get isProcessing() {
+    return this.processing;
+  }
+  get isDestroyed() {
+    return this.destroyed;
+  }
+  on(type, listener) {
+    this.assertUsable();
+    const listeners = this.listeners.get(type) ?? /* @__PURE__ */ new Set();
+    const untypedListener = listener;
+    listeners.add(untypedListener);
+    this.listeners.set(type, listeners);
+    return () => listeners.delete(untypedListener);
+  }
+  connect() {
+    return this.start();
+  }
+  start() {
+    this.assertUsable();
+    if (this.initializePromise) return this.initializePromise;
+    const lifecycle = this.lifecycleGeneration;
+    const pending = this.initialize(lifecycle);
+    this.initializePromise = pending;
+    const clearPending = () => {
+      if (this.initializePromise === pending) this.initializePromise = null;
+    };
+    void pending.then(clearPending, clearPending);
+    return pending;
+  }
+  async bindSession(sessionId) {
+    this.assertUsable();
+    const target = requiredText(sessionId, "sessionId");
+    const lifecycle = ++this.lifecycleGeneration;
+    this.stopConnection(false);
+    this.currentSessionId = target;
+    this.currentMessages = [];
+    this.seenMessageIds.clear();
+    this.pendingLocalMessages.clear();
+    this.assistantReceivedInCurrentTurn = false;
+    this.pendingFirstMessage = null;
+    await this.clearStoredFirstMessageRequest();
+    this.replayHistoryOnNextSubscription = false;
+    this.shouldReconnect = true;
+    await this.refreshHistory(lifecycle);
+    this.assertUsable();
+    if (!this.isCurrentLifecycle(lifecycle)) {
+      throw new AiEmployeeClientError("SESSION_UNAVAILABLE", "\u4F1A\u8BDD\u5207\u6362\u5DF2\u88AB\u65B0\u7684\u64CD\u4F5C\u66FF\u4EE3\u3002");
+    }
+    if (this.isCurrentLifecycle(lifecycle)) this.openSocket(false);
+    return { sessionId: target, messages: this.messages };
+  }
+  async startNewConversation() {
+    this.assertUsable();
+    this.initializePromise = null;
+    this.lifecycleGeneration += 1;
+    this.stopConnection(false);
+    this.currentSessionId = null;
+    this.currentMessages = [];
+    this.seenMessageIds.clear();
+    this.pendingLocalMessages.clear();
+    this.assistantReceivedInCurrentTurn = false;
+    this.pendingFirstMessage = null;
+    await this.clearStoredFirstMessageRequest();
+    this.replayHistoryOnNextSubscription = false;
+    this.shouldReconnect = true;
+    this.openSocket(false);
+    return { sessionId: null, messages: [] };
+  }
+  async refreshMessages() {
+    this.assertUsable();
+    if (!this.currentSessionId) {
+      throw new AiEmployeeClientError("SESSION_UNAVAILABLE", "\u5C1A\u672A\u7ED1\u5B9A\u6570\u5B57\u5458\u5DE5\u4F1A\u8BDD\u3002");
+    }
+    await this.refreshHistory(this.lifecycleGeneration);
+    return this.messages;
+  }
+  async sendMessage(content, options = {}) {
+    this.assertUsable();
+    const normalizedContent = content.trim();
+    if (!normalizedContent) {
+      throw new AiEmployeeClientError("EMPTY_MESSAGE", "\u6D88\u606F\u5185\u5BB9\u4E0D\u80FD\u4E3A\u7A7A\u3002");
+    }
+    if (this.sending) {
+      throw new AiEmployeeClientError("SEND_IN_PROGRESS", "\u4E0A\u4E00\u6761\u6D88\u606F\u4ECD\u5728\u53D1\u9001\u4E2D\u3002");
+    }
+    this.sending = true;
+    try {
+      const sessionId = this.currentSessionId;
+      return sessionId ? await this.sendFollowUp(sessionId, normalizedContent) : await this.sendFirstMessage(normalizedContent, options);
+    } catch (error) {
+      if (error instanceof AiEmployeeClientError) throw error;
+      if (transportErrorCode(error) === "IDEMPOTENCY_CONFLICT") {
+        const detail2 = this.emitError(
+          "FIRST_MESSAGE_CONFLICT",
+          "\u9996\u6761\u6D88\u606F\u5185\u5BB9\u5DF2\u53D8\u5316\uFF0C\u8BF7\u5F00\u542F\u65B0\u5BF9\u8BDD\u540E\u91CD\u8BD5\u3002",
+          false
+        );
+        throw new AiEmployeeClientError(detail2.code, detail2.message);
+      }
+      if (transportErrorCode(error) === "TOO_MANY_REQUESTS") {
+        const detail2 = this.emitError("RATE_LIMITED", "\u8BF7\u6C42\u8FC7\u4E8E\u9891\u7E41\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5\u3002", false);
+        throw new AiEmployeeClientError(detail2.code, detail2.message);
+      }
+      const detail = this.emitError("SEND_FAILED", "\u6D88\u606F\u53D1\u9001\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002", true);
+      throw new AiEmployeeClientError(detail.code, detail.message);
+    } finally {
+      this.sending = false;
+    }
+  }
+  disconnect() {
+    if (this.destroyed) return;
+    this.lifecycleGeneration += 1;
+    this.stopConnection(true);
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.lifecycleGeneration += 1;
+    this.stopConnection(false);
+    this.destroyed = true;
+    this.initializePromise = null;
+    this.setState("destroyed");
+    this.listeners.clear();
+    this.currentMessages = [];
+    this.seenMessageIds.clear();
+    this.pendingLocalMessages.clear();
+    this.assistantReceivedInCurrentTurn = false;
+    this.pendingFirstMessage = null;
+  }
+  async sendFollowUp(sessionId, content) {
+    this.assistantReceivedInCurrentTurn = false;
+    await this.transport.sendMessage(sessionId, content);
+    this.assertUsable();
+    const now = /* @__PURE__ */ new Date();
+    const message = {
+      id: `local:${now.getTime()}:${++this.localMessageSequence}`,
+      sessionId,
+      role: "user",
+      content,
+      createdAt: now.toISOString()
+    };
+    this.rememberPendingLocalMessage(content);
+    this.appendMessage(message, "local");
+    this.setProcessing(true);
+    return message;
+  }
+  async sendFirstMessage(content, options) {
+    this.assistantReceivedInCurrentTurn = false;
+    const createSessionWithFirstMessage = this.transport.createSessionWithFirstMessage;
+    const lifecycle = this.lifecycleGeneration;
+    const normalizedOptions = normalizeFirstMessageOptions(options);
+    const fingerprint = firstMessageFingerprint(content, normalizedOptions);
+    if (!this.pendingFirstMessage || this.pendingFirstMessage.fingerprint !== fingerprint) {
+      const stored = await this.loadStoredFirstMessageRequest();
+      this.pendingFirstMessage = stored?.fingerprint === fingerprint ? stored : { fingerprint, requestId: requiredRequestId(this.requestIdFactory()) };
+      await this.saveStoredFirstMessageRequest(this.pendingFirstMessage);
+    }
+    this.assertUsable();
+    if (!this.isCurrentLifecycle(lifecycle) || this.currentSessionId) {
+      this.pendingFirstMessage = null;
+      await this.clearStoredFirstMessageRequest();
+      throw new AiEmployeeClientError("SESSION_UNAVAILABLE", "\u9996\u6761\u6D88\u606F\u53D7\u7406\u5DF2\u88AB\u65B0\u7684\u64CD\u4F5C\u66FF\u4EE3\u3002");
+    }
+    const request = {
+      requestId: this.pendingFirstMessage.requestId,
+      aeCode: this.aeCode,
+      agentCode: this.agentCode,
+      content,
+      attachments: normalizedOptions.attachments,
+      trustedContext: normalizedOptions.trustedContext
+    };
+    const rawResult = await createSessionWithFirstMessage.call(this.transport, request);
+    const result = normalizeFirstMessageResult(rawResult, this.aeCode, this.agentCode);
+    this.assertUsable();
+    if (!this.isCurrentLifecycle(lifecycle) || this.currentSessionId) {
+      this.pendingFirstMessage = null;
+      await this.clearStoredFirstMessageRequest();
+      throw new AiEmployeeClientError("SESSION_UNAVAILABLE", "\u9996\u6761\u6D88\u606F\u53D7\u7406\u5DF2\u88AB\u65B0\u7684\u64CD\u4F5C\u66FF\u4EE3\u3002");
+    }
+    this.currentSessionId = result.sessionId;
+    this.pendingFirstMessage = null;
+    await this.clearStoredFirstMessageRequest();
+    const message = {
+      id: result.messageId,
+      sessionId: result.sessionId,
+      role: "user",
+      content,
+      createdAt: result.createdAt ?? result.startedAt
+    };
+    this.rememberPendingLocalMessage(content);
+    this.appendMessage(message, "local");
+    this.setProcessing(true);
+    this.replayHistoryOnNextSubscription = true;
+    this.subscribeCurrentSession(true);
+    return message;
+  }
+  async initialize(lifecycle) {
+    if (!this.currentSessionId) {
+      this.shouldReconnect = true;
+      this.openSocket(false);
+      return { sessionId: null, messages: [] };
+    }
+    await this.refreshHistory(lifecycle);
+    this.assertUsable();
+    if (!this.isCurrentLifecycle(lifecycle)) {
+      throw new AiEmployeeClientError("SESSION_UNAVAILABLE", "\u4F1A\u8BDD\u521D\u59CB\u5316\u5DF2\u88AB\u65B0\u7684\u64CD\u4F5C\u66FF\u4EE3\u3002");
+    }
+    this.shouldReconnect = true;
+    this.openSocket(false);
+    return { sessionId: this.currentSessionId, messages: this.messages };
+  }
+  async loadStoredFirstMessageRequest() {
+    if (!this.firstMessageRequestStore) return null;
+    try {
+      const state = await this.firstMessageRequestStore.load(this.firstMessageRequestScope);
+      if (!state || typeof state.fingerprint !== "string") return null;
+      return {
+        fingerprint: state.fingerprint,
+        requestId: requiredRequestId(state.requestId)
+      };
+    } catch {
+      return null;
+    }
+  }
+  async saveStoredFirstMessageRequest(state) {
+    if (!this.firstMessageRequestStore) return;
+    try {
+      await this.firstMessageRequestStore.save(this.firstMessageRequestScope, state);
+    } catch {
+    }
+  }
+  async clearStoredFirstMessageRequest() {
+    if (!this.firstMessageRequestStore) return;
+    try {
+      await this.firstMessageRequestStore.clear(this.firstMessageRequestScope);
+    } catch {
+    }
+  }
+  async refreshHistory(lifecycle) {
+    const sessionId = this.currentSessionId;
+    if (!sessionId) return false;
+    try {
+      const history = await this.transport.listMessages(sessionId);
+      if (!this.isCurrentLifecycle(lifecycle) || this.currentSessionId !== sessionId) return false;
+      this.replaceHistory(history, sessionId);
+      return true;
+    } catch {
+      if (this.isCurrentLifecycle(lifecycle)) {
+        this.emitError("HISTORY_LOAD_FAILED", "\u5386\u53F2\u6D88\u606F\u52A0\u8F7D\u5931\u8D25\uFF0C\u5B9E\u65F6\u8FDE\u63A5\u4ECD\u4F1A\u7EE7\u7EED\u3002", true);
+      }
+      return false;
+    }
+  }
+  replaceHistory(history, sessionId) {
+    const unique = /* @__PURE__ */ new Map();
+    for (const candidate of history) {
+      const normalized = normalizeHistoryMessage(candidate, sessionId);
+      if (normalized) unique.set(normalized.id, normalized);
+    }
+    this.currentMessages = [...unique.values()];
+    this.seenMessageIds.clear();
+    for (const message of this.currentMessages) this.rememberMessageId(message.id);
+    this.emit("history", { sessionId, messages: this.messages });
+  }
+  openSocket(isReconnect) {
+    if (this.destroyed || !this.shouldReconnect) return;
+    this.clearReconnectTimer();
+    this.closeCurrentSocket();
+    this.setState(isReconnect ? "reconnecting" : "connecting");
+    let socket;
+    try {
+      socket = this.webSocketFactory(this.realtimeUrl);
+    } catch {
+      this.emitError("WEBSOCKET_UNAVAILABLE", "\u65E0\u6CD5\u5EFA\u7ACB\u5B9E\u65F6\u8FDE\u63A5\u3002", true);
+      this.scheduleReconnect();
+      return;
+    }
+    const generation = ++this.socketGeneration;
+    this.socket = socket;
+    this.socketAuthenticationFailure = null;
+    socket.onopen = () => void this.authenticateSocket(socket, generation);
+    socket.onmessage = (event) => void this.handleSocketData(event.data, socket, generation);
+    socket.onerror = () => {
+      if (!this.isCurrentSocket(socket, generation)) return;
+      this.emitError("WEBSOCKET_ERROR", "\u5B9E\u65F6\u8FDE\u63A5\u53D1\u751F\u5F02\u5E38\u3002", true);
+    };
+    socket.onclose = (event) => this.handleSocketClose(socket, generation, event.code);
+  }
+  async authenticateSocket(socket, generation) {
+    if (!this.isCurrentSocket(socket, generation)) return;
+    this.setState("authenticating");
+    let accessToken = "";
+    try {
+      accessToken = (await this.transport.getAccessToken()).trim();
+    } catch {
+    }
+    if (!this.isCurrentSocket(socket, generation)) return;
+    if (!accessToken) {
+      this.emitError("TOKEN_UNAVAILABLE", "\u65E0\u6CD5\u83B7\u53D6\u5B9E\u65F6\u8FDE\u63A5\u51ED\u8BC1\u3002", true);
+      socket.close();
+      return;
+    }
+    socket.send(JSON.stringify(createAuthenticateFrame(accessToken)));
+    accessToken = "";
+  }
+  async handleSocketData(data, socket, generation) {
+    if (!this.isCurrentSocket(socket, generation)) return;
+    let raw = "";
+    if (typeof data === "string") raw = data;
+    else if (data instanceof Blob) raw = await data.text();
+    else if (data instanceof ArrayBuffer) raw = new TextDecoder().decode(data);
+    else {
+      this.emitError("PROTOCOL_ERROR", "\u6536\u5230\u65E0\u6CD5\u8BC6\u522B\u7684\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\u5B9E\u65F6\u6D88\u606F\u3002", true);
+      return;
+    }
+    this.handleServerMessage(message, socket, generation);
+  }
+  handleServerMessage(message, socket, generation) {
+    const type = text(message.type);
+    if (type === "realtime_ready") {
+      const channels = record(message.channels);
+      const aiChannel = record(channels.ai_employee);
+      if (aiChannel.available !== true) {
+        this.emitError("CHANNEL_UNAVAILABLE", "\u6570\u5B57\u5458\u5DE5\u5B9E\u65F6\u901A\u9053\u4E0D\u53EF\u7528\u3002", false);
+        this.shouldReconnect = false;
+        socket.close();
+        return;
+      }
+      this.reconnectAttempt = 0;
+      this.availabilityReconnectAttempt = 0;
+      this.startHeartbeat(numberValue(message.heartbeat_interval_seconds), socket, generation);
+      if (this.currentSessionId) {
+        this.subscribeCurrentSession(this.replayHistoryOnNextSubscription, true);
+      } else {
+        this.setState("connected");
+      }
+      return;
+    }
+    if (type === "realtime_event" && message.channel === "ai_employee") {
+      this.handleAiEmployeeEvent(message.event);
+      return;
+    }
+    if (type === "channel_error" && message.channel === "ai_employee") {
+      this.handleChannelError(text(message.code));
+      return;
+    }
+    if (type === "authentication_error") {
+      const failure = authenticationFailure(text(message.code));
+      this.socketAuthenticationFailure = { generation, retryMode: failure.retryMode };
+      this.emitError(failure.code, failure.message, failure.retryMode !== "never");
+      return;
+    }
+    if (type === "protocol_error") {
+      this.emitError("PROTOCOL_ERROR", "\u5B9E\u65F6\u8FDE\u63A5\u534F\u8BAE\u5F02\u5E38\u3002", false);
+    }
+  }
+  handleAiEmployeeEvent(rawEvent) {
+    const event = parseAiEmployeeEvent(rawEvent);
+    if (event.kind === "ignored" || event.sessionId !== this.currentSessionId) return;
+    if (event.kind === "session-title") {
+      this.emit("title", { sessionId: event.sessionId, title: event.title });
+      return;
+    }
+    if (event.result.processing === true) this.assistantReceivedInCurrentTurn = false;
+    if (event.result.processing !== void 0) this.setProcessing(event.result.processing);
+    for (const message of event.result.messages) {
+      if (message.role === "user") this.assistantReceivedInCurrentTurn = false;
+      if (message.role === "user" && this.matchesPendingLocalMessage(message)) continue;
+      this.appendMessage(message, "realtime");
+      if (message.role === "assistant") this.assistantReceivedInCurrentTurn = true;
+    }
+    if (event.result.fallbackResult && !this.assistantReceivedInCurrentTurn) {
+      this.appendMessage(event.result.fallbackResult, "realtime");
+    }
+  }
+  subscribeCurrentSession(replayHistory, channelReady = false) {
+    const sessionId = this.currentSessionId;
+    const socket = this.socket;
+    if (!sessionId || !socket || socket.readyState !== 1 || !channelReady && this.currentState !== "connected")
+      return;
+    this.setState("subscribing");
+    socket.send(JSON.stringify(createSubscriptionFrame(sessionId, "subscribe", replayHistory)));
+    this.replayHistoryOnNextSubscription = false;
+    this.setState("connected");
+    this.emit("ready", { sessionId });
+  }
+  rememberPendingLocalMessage(content) {
+    const now = Date.now();
+    for (const [pendingContent, sentAt] of this.pendingLocalMessages) {
+      if (now - sentAt > LOCAL_MESSAGE_MATCH_WINDOW_MS) {
+        this.pendingLocalMessages.delete(pendingContent);
+      }
+    }
+    this.pendingLocalMessages.set(content, now);
+  }
+  /**
+   * 本地已渲染的用户消息会被服务端以 replay 和实时事件多次回送，且不保证复用
+   * 同一个消息 ID。窗口期内不消费该条目，多次回声都要挡住；本地发送本身每次都
+   * 会追加气泡，所以重复发送同样内容不会因此丢消息。
+   */
+  matchesPendingLocalMessage(message) {
+    const sentAt = this.pendingLocalMessages.get(message.content);
+    if (sentAt === void 0) return false;
+    if (Date.now() - sentAt <= LOCAL_MESSAGE_MATCH_WINDOW_MS) return true;
+    this.pendingLocalMessages.delete(message.content);
+    return false;
+  }
+  appendMessage(message, source) {
+    if (this.seenMessageIds.has(message.id)) return;
+    this.rememberMessageId(message.id);
+    this.currentMessages = [...this.currentMessages, message];
+    this.emit("message", { sessionId: message.sessionId, message, source });
+  }
+  rememberMessageId(id) {
+    this.seenMessageIds.add(id);
+    if (this.seenMessageIds.size <= MAX_SEEN_MESSAGE_IDS) return;
+    const oldest = this.seenMessageIds.values().next().value;
+    if (typeof oldest === "string") this.seenMessageIds.delete(oldest);
+  }
+  handleChannelError(code) {
+    if (code === "SESSION_NOT_FOUND") {
+      this.emitError("SESSION_NOT_FOUND", "\u4F1A\u8BDD\u4E0D\u5B58\u5728\u6216\u5F53\u524D\u7528\u6237\u65E0\u6743\u8BBF\u95EE\u3002", false);
+    } else {
+      this.emitError("CHANNEL_UNAVAILABLE", "\u6570\u5B57\u5458\u5DE5\u5B9E\u65F6\u901A\u9053\u6682\u4E0D\u53EF\u7528\u3002", true);
+    }
+    this.setProcessing(false);
+  }
+  startHeartbeat(intervalSeconds, socket, generation) {
+    this.clearHeartbeatTimer();
+    const requestedMs = Number.isFinite(intervalSeconds) && intervalSeconds > 0 ? intervalSeconds * 1e3 : 25e3;
+    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 authenticationFailure3 = 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") {
+      this.shouldReconnect = false;
+      this.setState("disconnected");
+      return;
+    }
+    if (code === 4400 || code === 4403) {
+      this.shouldReconnect = false;
+      if (!authenticationFailure3) {
+        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);
+      }
+      this.setState("disconnected");
+      return;
+    }
+    if (authenticationFailure3?.retryMode === "availability" || code === 1013) {
+      if (!authenticationFailure3) {
+        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) {
+        this.emitError("AUTHENTICATION_FAILED", "\u8FDE\u63A5\u51ED\u8BC1\u5DF2\u5931\u6548\uFF0C\u6B63\u5728\u91CD\u65B0\u8FDE\u63A5\u3002", true);
+      }
+    }
+    this.scheduleReconnect();
+  }
+  scheduleAvailabilityReconnect() {
+    if (this.availabilityReconnectAttempt >= MAX_AVAILABILITY_RECONNECTS) {
+      this.shouldReconnect = false;
+      this.emitError("REALTIME_UNAVAILABLE", "\u5B9E\u65F6\u9274\u6743\u670D\u52A1\u6301\u7EED\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002", false);
+      this.setState("disconnected");
+      return;
+    }
+    this.availabilityReconnectAttempt += 1;
+    this.scheduleReconnect();
+  }
+  scheduleReconnect() {
+    if (this.destroyed || !this.shouldReconnect || this.reconnectTimer) return;
+    this.setState("reconnecting");
+    const baseDelay = Math.min(
+      this.reconnectOptions.initialDelayMs * this.reconnectOptions.factor ** this.reconnectAttempt,
+      this.reconnectOptions.maximumDelayMs
+    );
+    const jitterRange = baseDelay * this.reconnectOptions.jitter;
+    const delay = Math.max(0, baseDelay - jitterRange + Math.random() * jitterRange * 2);
+    this.reconnectAttempt += 1;
+    const lifecycle = this.lifecycleGeneration;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      void this.recoverAndReconnect(lifecycle);
+    }, delay);
+  }
+  async recoverAndReconnect(lifecycle) {
+    if (!this.isCurrentLifecycle(lifecycle) || !this.shouldReconnect) return;
+    const historyRecovered = await this.refreshHistory(lifecycle);
+    if (!this.isCurrentLifecycle(lifecycle) || !this.shouldReconnect) return;
+    this.replayHistoryOnNextSubscription = !historyRecovered;
+    this.openSocket(true);
+  }
+  stopConnection(setDisconnectedState) {
+    this.shouldReconnect = false;
+    this.clearReconnectTimer();
+    this.clearHeartbeatTimer();
+    this.socketAuthenticationFailure = null;
+    this.closeCurrentSocket();
+    this.setProcessing(false);
+    if (setDisconnectedState) this.setState("disconnected");
+  }
+  closeCurrentSocket() {
+    const socket = this.socket;
+    this.socket = null;
+    this.socketGeneration += 1;
+    this.socketAuthenticationFailure = null;
+    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;
+  }
+  setState(next) {
+    if (this.currentState === next) return;
+    const previous = this.currentState;
+    this.currentState = next;
+    this.emit("connection-state-change", { previous, current: next });
+  }
+  setProcessing(processing) {
+    if (this.processing === processing) return;
+    this.processing = processing;
+    this.emit("processing-state-change", { processing });
+  }
+  emitError(code, message, recoverable) {
+    const detail = { code, message, recoverable };
+    this.emit("error", detail);
+    return detail;
+  }
+  emit(type, detail) {
+    for (const listener of this.listeners.get(type) ?? []) listener(detail);
+  }
+  isCurrentSocket(socket, generation) {
+    return !this.destroyed && this.socket === socket && this.socketGeneration === generation;
+  }
+  isCurrentLifecycle(generation) {
+    return !this.destroyed && this.lifecycleGeneration === generation;
+  }
+  assertUsable() {
+    if (this.destroyed) {
+      throw new AiEmployeeClientError("CLIENT_DESTROYED", "\u5BA2\u6237\u7AEF\u5DF2\u9500\u6BC1\u3002");
+    }
+  }
+};
+function validateRealtimeUrl(rawUrl) {
+  let url;
+  try {
+    url = new URL(rawUrl);
+  } catch {
+    throw new AiEmployeeClientError("INVALID_CONFIGURATION", "realtimeUrl \u4E0D\u662F\u6709\u6548\u5730\u5740\u3002");
+  }
+  if (!["ws:", "wss:"].includes(url.protocol)) {
+    throw new AiEmployeeClientError("INVALID_CONFIGURATION", "realtimeUrl \u53EA\u5141\u8BB8 ws: \u6216 wss:\u3002");
+  }
+  if (url.search || url.hash || url.username || url.password) {
+    throw new AiEmployeeClientError(
+      "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 requiredText(value, field) {
+  const normalized = typeof value === "string" ? value.trim() : "";
+  if (!normalized) {
+    throw new AiEmployeeClientError("INVALID_CONFIGURATION", `${field} \u4E0D\u80FD\u4E3A\u7A7A\u3002`);
+  }
+  return normalized;
+}
+function normalizeSessionId(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function normalizeFirstMessageOptions(options) {
+  const attachments = (options.attachments ?? []).map((attachment) => {
+    const transactionId = typeof attachment.transactionId === "string" ? attachment.transactionId.trim() : "";
+    const fspath = typeof attachment.fspath === "string" ? attachment.fspath.trim() : "";
+    if (!transactionId || !fspath.startsWith("fs/") || fspath.includes("\\") || fspath.split("/").some((segment) => segment === "..")) {
+      throw new AiEmployeeClientError("SEND_FAILED", "\u9996\u6761\u6D88\u606F\u9644\u4EF6\u5F15\u7528\u65E0\u6548\u3002");
+    }
+    return { transactionId, fspath };
+  });
+  const trustedContext = options.trustedContext ?? null;
+  if (trustedContext !== null && (typeof trustedContext !== "object" || Array.isArray(trustedContext))) {
+    throw new AiEmployeeClientError("SEND_FAILED", "\u9996\u6761\u6D88\u606F\u4E0A\u4E0B\u6587\u65E0\u6548\u3002");
+  }
+  return { attachments, trustedContext };
+}
+function firstMessageFingerprint(content, options) {
+  const serialized = stableFirstMessageString([
+    content,
+    options.attachments,
+    options.trustedContext
+  ]);
+  return `v1:${hashText(serialized)}:${hashText(`first-message:${serialized}`)}:${serialized.length}`;
+}
+function stableFirstMessageString(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const normalize = (candidate) => {
+    if (candidate === null || typeof candidate !== "object") return candidate;
+    if (seen.has(candidate)) {
+      throw new AiEmployeeClientError("SEND_FAILED", "\u9996\u6761\u6D88\u606F\u4E0A\u4E0B\u6587\u65E0\u6548\u3002");
+    }
+    seen.add(candidate);
+    if (Array.isArray(candidate)) {
+      const result2 = candidate.map((item) => normalize(item));
+      seen.delete(candidate);
+      return result2;
+    }
+    const source = candidate;
+    const result = {};
+    for (const key of Object.keys(source).sort()) result[key] = normalize(source[key]);
+    seen.delete(candidate);
+    return result;
+  };
+  return JSON.stringify(normalize(value));
+}
+function requiredRequestId(value) {
+  const requestId = typeof value === "string" ? value.trim() : "";
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(requestId)) {
+    throw new AiEmployeeClientError("INVALID_CONFIGURATION", "requestIdFactory \u5FC5\u987B\u8FD4\u56DE UUID\u3002");
+  }
+  return requestId;
+}
+function createRequestId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  if (typeof crypto === "undefined" || typeof crypto.getRandomValues !== "function") {
+    throw new AiEmployeeClientError("INVALID_CONFIGURATION", "\u5F53\u524D\u73AF\u5883\u65E0\u6CD5\u5B89\u5168\u751F\u6210 request_id\u3002");
+  }
+  const bytes = crypto.getRandomValues(new Uint8Array(16));
+  bytes[6] = (bytes[6] ?? 0) & 15 | 64;
+  bytes[8] = (bytes[8] ?? 0) & 63 | 128;
+  const value = [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  return `${value.slice(0, 8)}-${value.slice(8, 12)}-${value.slice(12, 16)}-${value.slice(16, 20)}-${value.slice(20)}`;
+}
+function normalizeFirstMessageResult(value, expectedAeCode, expectedAgentCode) {
+  if (!value || typeof value !== "object") {
+    throw new AiEmployeeClientError("SEND_FAILED", "\u9996\u6761\u6D88\u606F\u53D7\u7406\u54CD\u5E94\u65E0\u6548\u3002");
+  }
+  const sessionId = requiredFirstMessageResultText(value.sessionId);
+  const messageId = requiredFirstMessageResultText(value.messageId);
+  const executionId = requiredFirstMessageResultText(value.executionId);
+  const aeCode = requiredFirstMessageResultText(value.aeCode);
+  const agentCode = requiredFirstMessageResultText(value.agentCode);
+  const conversationType = requiredFirstMessageResultText(value.conversationType);
+  if (aeCode !== expectedAeCode || agentCode !== expectedAgentCode) {
+    throw new AiEmployeeClientError("SEND_FAILED", "\u9996\u6761\u6D88\u606F\u53D7\u7406\u54CD\u5E94\u4E0E\u5F53\u524D\u6570\u5B57\u5458\u5DE5\u4E0D\u5339\u914D\u3002");
+  }
+  if (value.status !== "running" && value.status !== "queued") {
+    throw new AiEmployeeClientError("SEND_FAILED", "\u9996\u6761\u6D88\u606F\u53D7\u7406\u72B6\u6001\u65E0\u6548\u3002");
+  }
+  const startedAt = requiredIsoDate(value.startedAt, "transport startedAt");
+  const result = {
+    sessionId,
+    messageId,
+    executionId,
+    status: value.status,
+    startedAt,
+    aeCode,
+    agentCode,
+    conversationType
+  };
+  if (typeof value.title === "string" && value.title.trim()) result.title = value.title.trim();
+  if (value.createdAt) result.createdAt = requiredIsoDate(value.createdAt, "transport createdAt");
+  return result;
+}
+function requiredIsoDate(value, field) {
+  const normalized = requiredFirstMessageResultText(value);
+  if (!Number.isFinite(Date.parse(normalized))) {
+    throw new AiEmployeeClientError("SEND_FAILED", `${field} \u4E0D\u662F\u6709\u6548\u65F6\u95F4\u3002`);
+  }
+  return normalized;
+}
+function requiredFirstMessageResultText(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new AiEmployeeClientError("SEND_FAILED", "\u9996\u6761\u6D88\u606F\u53D7\u7406\u54CD\u5E94\u65E0\u6548\u3002");
+  }
+  return value.trim();
+}
+function authenticationFailure(code) {
+  if (code === "UNAUTHORIZED") {
+    return {
+      code: "AUTHENTICATION_FAILED",
+      message: "\u8FDE\u63A5\u51ED\u8BC1\u5DF2\u5931\u6548\uFF0C\u6B63\u5728\u91CD\u65B0\u8FDE\u63A5\u3002",
+      retryMode: "token"
+    };
+  }
+  if (code === "ORGANIZATION_CONTEXT_REQUIRED") {
+    return {
+      code: "ORGANIZATION_CONTEXT_REQUIRED",
+      message: "\u8BF7\u9009\u62E9\u4F01\u4E1A/\u56E2\u961F\u540E\u518D\u5F00\u59CB\u54A8\u8BE2\u3002",
+      retryMode: "never"
+    };
+  }
+  if (code === "INVALID_ARGUMENT") {
+    return {
+      code: "PROTOCOL_ERROR",
+      message: "\u5B9E\u65F6\u8FDE\u63A5\u534F\u8BAE\u4E0D\u53D7\u652F\u6301\u3002",
+      retryMode: "never"
+    };
+  }
+  if (isRealtimeAvailabilityFailure(code)) {
+    return {
+      code: "REALTIME_UNAVAILABLE",
+      message: "\u5B9E\u65F6\u9274\u6743\u670D\u52A1\u6682\u4E0D\u53EF\u7528\uFF0C\u6B63\u5728\u91CD\u8BD5\u3002",
+      retryMode: "availability"
+    };
+  }
+  if (code === "AI_EMPLOYEE_NOT_AVAILABLE" || code === "APPLICATION_NOT_SUPPORTED") {
+    return {
+      code: "CHANNEL_UNAVAILABLE",
+      message: "\u5F53\u524D\u6570\u5B57\u5458\u5DE5\u6682\u4E0D\u53EF\u7528\u3002",
+      retryMode: "never"
+    };
+  }
+  if (code === "ACCESS_DENIED") {
+    return {
+      code: "AUTHENTICATION_FAILED",
+      message: "\u5F53\u524D\u8EAB\u4EFD\u65E0\u6743\u5EFA\u7ACB\u5B9E\u65F6\u8FDE\u63A5\u3002",
+      retryMode: "never"
+    };
+  }
+  return {
+    code: "AUTHENTICATION_FAILED",
+    message: "\u5B9E\u65F6\u8FDE\u63A5\u8BA4\u8BC1\u5931\u8D25\u3002",
+    retryMode: "never"
+  };
+}
+function transportErrorCode(error) {
+  if (error instanceof AiEmployeeTransportError) return error.code;
+  if (!error || typeof error !== "object" || !("code" in error)) return null;
+  switch (error.code) {
+    case "UNAUTHORIZED":
+    case "ACCESS_DENIED":
+    case "AI_EMPLOYEE_NOT_AVAILABLE":
+    case "APPLICATION_NOT_SUPPORTED":
+    case "ORGANIZATION_CONTEXT_REQUIRED":
+    case "INVALID_ARGUMENT":
+    case "IDEMPOTENCY_CONFLICT":
+    case "REALTIME_UNAVAILABLE":
+    case "TOO_MANY_REQUESTS":
+      return error.code;
+    default:
+      return null;
+  }
+}
+function createSessionFirstMessageRequestStore() {
+  try {
+    if (typeof sessionStorage === "undefined") return null;
+  } catch {
+    return null;
+  }
+  const key = (scope) => `${FIRST_MESSAGE_STORAGE_PREFIX}:${hashText(scope)}`;
+  return {
+    load(scope) {
+      const raw = sessionStorage.getItem(key(scope));
+      if (!raw) return null;
+      const parsed = JSON.parse(raw);
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+      const state = parsed;
+      return typeof state.fingerprint === "string" && typeof state.requestId === "string" ? { fingerprint: state.fingerprint, requestId: state.requestId } : null;
+    },
+    save(scope, state) {
+      sessionStorage.setItem(
+        key(scope),
+        JSON.stringify({ fingerprint: state.fingerprint, requestId: state.requestId })
+      );
+    },
+    clear(scope) {
+      sessionStorage.removeItem(key(scope));
+    }
+  };
+}
+function isRealtimeAvailabilityFailure(code) {
+  return code === "REALTIME_UNAVAILABLE" || code === "KANBAN_AUTH_FAILED" || code.startsWith("SERVICE_");
+}
+function normalizeReconnectOptions(options) {
+  return {
+    initialDelayMs: positiveNumber(options?.initialDelayMs, DEFAULT_RECONNECT.initialDelayMs),
+    maximumDelayMs: positiveNumber(options?.maximumDelayMs, DEFAULT_RECONNECT.maximumDelayMs),
+    factor: Math.max(1, positiveNumber(options?.factor, DEFAULT_RECONNECT.factor)),
+    jitter: Math.min(1, Math.max(0, options?.jitter ?? DEFAULT_RECONNECT.jitter))
+  };
+}
+function positiveNumber(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function normalizeHistoryMessage(candidate, expectedSessionId) {
+  if (!candidate || typeof candidate !== "object") return null;
+  const id = text(candidate.id).trim();
+  const content = text(candidate.content).trim();
+  const role = candidate.role;
+  if (!id || !content || !["user", "assistant", "system", "error"].includes(role)) return null;
+  return {
+    id,
+    sessionId: expectedSessionId,
+    role,
+    content: role === "error" ? "\u6D88\u606F\u5904\u7406\u51FA\u73B0\u5F02\u5E38\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002" : content,
+    createdAt: text(candidate.createdAt) || (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function text(value) {
+  return typeof value === "string" ? value : "";
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function numberValue(value) {
+  return typeof value === "number" ? value : Number.NaN;
+}
+
+// src/assistant-actions.ts
+var ACTION_KEYS = ["action", "entry", "transaction-id", "trigger", "type"];
+var OPEN_CUSTOMER_SUPPORT_MARKER = /"action"\s*:\s*"open_customer_support"/g;
+var UUID_V4_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function parseAiEmployeeAssistantContent(content) {
+  const source = typeof content === "string" ? content : "";
+  const candidate = trailingStructuredJson(source);
+  if (!candidate || markerCount(source) !== 1) return unchanged(source);
+  let value;
+  try {
+    value = JSON.parse(candidate.json);
+  } catch {
+    return unchanged(source);
+  }
+  const action = parseOpenCustomerSupportAction(value);
+  if (!action) return unchanged(source);
+  return Object.freeze({
+    content: candidate.content,
+    actions: Object.freeze([action])
+  });
+}
+function isUuidV4(value) {
+  return typeof value === "string" && UUID_V4_PATTERN.test(value);
+}
+function trailingStructuredJson(content) {
+  const withoutTrailingWhitespace = content.trimEnd();
+  const fenced = withoutTrailingWhitespace.match(
+    /(?:^|\r?\n)[\t ]*```json[\t ]*\r?\n([\s\S]*?)\r?\n[\t ]*```$/i
+  );
+  if (fenced?.index !== void 0) {
+    return {
+      content: withoutTrailingWhitespace.slice(0, fenced.index).trimEnd(),
+      json: fenced[1]?.trim() ?? ""
+    };
+  }
+  const starts = [...withoutTrailingWhitespace.matchAll(/(?:^|\r?\n)[\t ]*(\{)/g)];
+  for (let index = starts.length - 1; index >= 0; index -= 1) {
+    const match = starts[index];
+    const objectOffset = match?.index === void 0 ? -1 : match.index + (match[0]?.indexOf("{") ?? -1);
+    if (objectOffset < 0) continue;
+    const json = withoutTrailingWhitespace.slice(objectOffset).trim();
+    try {
+      JSON.parse(json);
+      return {
+        content: withoutTrailingWhitespace.slice(0, match?.index ?? 0).trimEnd(),
+        json
+      };
+    } catch {
+    }
+  }
+  return null;
+}
+function parseOpenCustomerSupportAction(value) {
+  if (!isRecord(value)) return null;
+  const keys = Object.keys(value).sort();
+  if (keys.length !== ACTION_KEYS.length || keys.some((key, index) => key !== ACTION_KEYS[index])) {
+    return null;
+  }
+  if (value.type !== "assistant_action" || value.action !== "open_customer_support" || !isUuidV4(value["transaction-id"]) || value.trigger !== "out_of_scope" || value.entry !== "help_and_support") {
+    return null;
+  }
+  return Object.freeze({
+    type: "assistant_action",
+    action: "open_customer_support",
+    transactionId: value["transaction-id"],
+    trigger: "out_of_scope",
+    entry: "help_and_support"
+  });
+}
+function markerCount(value) {
+  return [...value.matchAll(OPEN_CUSTOMER_SUPPORT_MARKER)].length;
+}
+function unchanged(content) {
+  return Object.freeze({ content, actions: Object.freeze([]) });
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/customer-support-client.ts
+var DEFAULT_RECONNECT2 = {
+  initialDelayMs: 1e3,
+  maximumDelayMs: 3e4,
+  factor: 2,
+  jitter: 0.2
+};
+var MAX_TOKEN_RECONNECTS = 1;
+var MAX_AVAILABILITY_RECONNECTS2 = 3;
+var CustomerSupportClientError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "CustomerSupportClientError";
+    this.code = code;
+  }
+};
+var CustomerSupportClient = class {
+  realtimeUrl;
+  transport;
+  webSocketFactory;
+  requestIdFactory;
+  reconnectOptions;
+  minimumHeartbeatMs;
+  listeners = /* @__PURE__ */ new Map();
+  currentSession = null;
+  currentSessions = [];
+  currentMessages = [];
+  currentState = "idle";
+  socket = null;
+  heartbeatTimer = null;
+  reconnectTimer = null;
+  reconnectAttempt = 0;
+  tokenReconnectAttempt = 0;
+  availabilityReconnectAttempt = 0;
+  socketGeneration = 0;
+  socketAuthenticationFailure = null;
+  destroyed = false;
+  shouldReconnect = false;
+  sending = false;
+  historyRefresh = null;
+  sessionsRefresh = null;
+  readCursorStates = /* @__PURE__ */ new Map();
+  readLifecycleGeneration = 0;
+  requestedSessionId;
+  constructor(options) {
+    this.realtimeUrl = validateRealtimeUrl2(options.realtimeUrl);
+    if (!options.transport) {
+      throw new CustomerSupportClientError("INVALID_CONFIGURATION", "\u7F3A\u5C11\u5BA2\u670D transport \u914D\u7F6E\u3002");
+    }
+    this.transport = options.transport;
+    this.requestedSessionId = normalizedText(options.sessionId) || null;
+    this.requestIdFactory = options.requestIdFactory ?? createRequestId2;
+    this.reconnectOptions = normalizeReconnect(options.reconnect);
+    this.minimumHeartbeatMs = Math.max(1, options.minimumHeartbeatMs ?? 5e3);
+    this.webSocketFactory = options.webSocketFactory ?? ((url) => {
+      if (typeof WebSocket === "undefined") {
+        throw new CustomerSupportClientError(
+          "WEBSOCKET_UNAVAILABLE",
+          "\u5F53\u524D\u8FD0\u884C\u73AF\u5883\u4E0D\u652F\u6301 WebSocket\u3002"
+        );
+      }
+      return new WebSocket(url);
+    });
+  }
+  get session() {
+    return this.currentSession;
+  }
+  get messages() {
+    return [...this.currentMessages];
+  }
+  get connectionState() {
+    return this.currentState;
+  }
+  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);
+  }
+  async start() {
+    this.assertUsable();
+    try {
+      const sessions = await this.transport.listSessions();
+      this.assertUsable();
+      this.replaceSessions(sessions);
+      const requested = this.requestedSessionId;
+      this.currentSession = requested ? sessions.find((session) => session.id === requested) ?? null : sessions.find(
+        (session) => session.status !== "closed" && hasCustomerSupportMessages(session)
+      ) ?? sessions.find(hasCustomerSupportMessages) ?? null;
+      if (this.currentSession) {
+        this.emit("session", { session: this.currentSession });
+        await this.refreshHistory();
+      }
+    } catch {
+      this.emitError("HISTORY_LOAD_FAILED", "\u5BA2\u670D\u4F1A\u8BDD\u52A0\u8F7D\u5931\u8D25\uFF0C\u5B9E\u65F6\u8FDE\u63A5\u4ECD\u4F1A\u7EE7\u7EED\u3002", true);
+    }
+    this.shouldReconnect = true;
+    this.openSocket(false);
+    this.emit("ready", { sessionId: this.currentSession?.id ?? null });
+  }
+  prepareNewConversation() {
+    this.assertUsable();
+    this.currentSession = null;
+    this.requestedSessionId = null;
+    this.currentMessages = [];
+  }
+  async bindSession(sessionId) {
+    this.assertUsable();
+    const normalized = requiredText2(sessionId, "sessionId");
+    const sessions = await this.transport.listSessions();
+    this.replaceSessions(sessions);
+    const session = sessions.find((candidate) => candidate.id === normalized);
+    if (!session) {
+      throw new CustomerSupportClientError("SESSION_UNAVAILABLE", "\u5BA2\u670D\u4F1A\u8BDD\u4E0D\u5B58\u5728\u3002");
+    }
+    this.currentSession = session;
+    this.requestedSessionId = session.id;
+    this.emit("session", { session });
+    await this.refreshHistory();
+  }
+  async sendMessage(content) {
+    this.assertUsable();
+    const normalized = content.trim();
+    if (!normalized) throw new CustomerSupportClientError("EMPTY_MESSAGE", "\u6D88\u606F\u5185\u5BB9\u4E0D\u80FD\u4E3A\u7A7A\u3002");
+    if (this.sending) {
+      throw new CustomerSupportClientError("SEND_IN_PROGRESS", "\u4E0A\u4E00\u6761\u6D88\u606F\u4ECD\u5728\u53D1\u9001\u4E2D\u3002");
+    }
+    this.sending = true;
+    try {
+      if (!this.currentSession) {
+        const result = await this.transport.createSession({
+          clientRequestId: requiredRequestId2(this.requestIdFactory()),
+          title: normalized.slice(0, 30),
+          initialMessage: normalized
+        });
+        this.assertUsable();
+        this.currentSession = result.session;
+        this.upsertSession(result.session);
+        this.requestedSessionId = result.session.id;
+        this.emit("session", { session: result.session });
+        let message2 = result.initialMessage;
+        if (!message2) {
+          const page = await this.transport.listMessages(result.session.id);
+          message2 = [...page.messages].reverse().find(
+            (candidate) => candidate.senderType === "customer" && candidate.content.trim() === normalized
+          );
+          this.currentMessages = page.messages.filter((candidate) => candidate.id !== message2?.id);
+        }
+        if (!message2) throw new Error("Missing initial message");
+        this.appendMessage(message2, "local");
+        return message2;
+      }
+      const message = await this.transport.sendMessage(
+        this.currentSession.id,
+        requiredRequestId2(this.requestIdFactory()),
+        normalized
+      );
+      this.assertUsable();
+      this.appendMessage(message, "local");
+      return message;
+    } catch (error) {
+      if (error instanceof CustomerSupportClientError) throw error;
+      const detail = this.emitError("SEND_FAILED", "\u6D88\u606F\u53D1\u9001\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002", true);
+      throw new CustomerSupportClientError(detail.code, detail.message);
+    } finally {
+      this.sending = false;
+    }
+  }
+  async listSessions() {
+    this.assertUsable();
+    return this.refreshSessions();
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.shouldReconnect = false;
+    this.clearTimers();
+    this.socketGeneration += 1;
+    this.socket?.close();
+    this.socket = null;
+    this.setState("destroyed");
+    this.listeners.clear();
+    this.currentMessages = [];
+    this.currentSessions = [];
+    this.historyRefresh = null;
+    this.sessionsRefresh = null;
+    this.readLifecycleGeneration += 1;
+    this.readCursorStates.clear();
+  }
+  async refreshHistory(realtime = false) {
+    const session = this.currentSession;
+    if (!session) return;
+    if (this.historyRefresh?.sessionId === session.id) return this.historyRefresh.promise;
+    const pending = (async () => {
+      try {
+        const page = await this.transport.listMessages(session.id);
+        if (this.destroyed || this.currentSession?.id !== session.id) return;
+        const unique = /* @__PURE__ */ new Map();
+        for (const message of page.messages) {
+          if (message.sessionId === session.id && message.id) unique.set(message.id, message);
+        }
+        const previousIds = new Set(this.currentMessages.map((message) => message.id));
+        this.currentMessages = [...unique.values()].sort(compareMessages);
+        this.emit("history", { sessionId: session.id, messages: this.messages });
+        if (realtime) {
+          for (const message of this.currentMessages) {
+            if (!previousIds.has(message.id)) {
+              this.emit("message", { sessionId: session.id, message, source: "realtime" });
+            }
+          }
+        }
+        this.markReadIfNeeded(session.id, page.latestSequence);
+      } catch {
+        this.emitError("HISTORY_LOAD_FAILED", "\u5386\u53F2\u6D88\u606F\u52A0\u8F7D\u5931\u8D25\uFF0C\u5B9E\u65F6\u8FDE\u63A5\u4ECD\u4F1A\u7EE7\u7EED\u3002", true);
+      }
+    })();
+    const refresh = { sessionId: session.id, promise: pending };
+    this.historyRefresh = refresh;
+    await pending.finally(() => {
+      if (this.historyRefresh === refresh) this.historyRefresh = null;
+    });
+  }
+  markReadIfNeeded(sessionId, latestSequence) {
+    const markRead = this.transport.markRead;
+    const cursor = normalizeReadCursor(latestSequence);
+    if (!markRead || !cursor || compareReadCursors(cursor, "0") <= 0 || this.destroyed) return;
+    const state = this.readCursorState(sessionId);
+    if (compareReadCursors(cursor, state.acknowledged) <= 0) return;
+    if (state.inFlight) {
+      if (compareReadCursors(cursor, state.inFlight) > 0) {
+        state.pending = maxReadCursor(state.pending, cursor);
+      }
+      return;
+    }
+    this.submitReadCursor(sessionId, cursor, state, markRead);
+  }
+  submitReadCursor(sessionId, cursor, state, markRead) {
+    const lifecycleGeneration = this.readLifecycleGeneration;
+    const requestGeneration = ++state.generation;
+    state.inFlight = cursor;
+    let request;
+    try {
+      request = markRead.call(this.transport, sessionId, cursor);
+    } catch {
+      state.inFlight = null;
+      state.pending = null;
+      return;
+    }
+    void request.then(() => {
+      if (!this.isCurrentReadRequest(state, lifecycleGeneration, requestGeneration, cursor))
+        return;
+      state.acknowledged = maxReadCursor(state.acknowledged, cursor);
+      const next = state.pending;
+      state.pending = null;
+      state.inFlight = null;
+      if (next && compareReadCursors(next, state.acknowledged) > 0) {
+        this.submitReadCursor(sessionId, next, state, markRead);
+      }
+    }).catch(() => {
+      if (!this.isCurrentReadRequest(state, lifecycleGeneration, requestGeneration, cursor))
+        return;
+      state.inFlight = null;
+      state.pending = null;
+    });
+  }
+  readCursorState(sessionId) {
+    const current = this.readCursorStates.get(sessionId);
+    if (current) return current;
+    const created = {
+      acknowledged: "0",
+      inFlight: null,
+      pending: null,
+      generation: 0
+    };
+    this.readCursorStates.set(sessionId, created);
+    return created;
+  }
+  isCurrentReadRequest(state, lifecycleGeneration, requestGeneration, cursor) {
+    return !this.destroyed && this.readLifecycleGeneration === lifecycleGeneration && state.generation === requestGeneration && state.inFlight === cursor;
+  }
+  openSocket(reconnecting) {
+    if (this.destroyed || !this.shouldReconnect) return;
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    this.socket?.close();
+    this.setState(reconnecting ? "reconnecting" : "connecting");
+    let socket;
+    try {
+      socket = this.webSocketFactory(this.realtimeUrl);
+    } catch {
+      this.emitError("WEBSOCKET_UNAVAILABLE", "\u65E0\u6CD5\u5EFA\u7ACB\u5BA2\u670D\u5B9E\u65F6\u8FDE\u63A5\u3002", true);
+      this.scheduleReconnect();
+      return;
+    }
+    const generation = ++this.socketGeneration;
+    this.socket = socket;
+    socket.onopen = () => void this.authenticate(socket, generation);
+    socket.onmessage = (event) => void this.handleSocketData(event.data, socket, generation);
+    socket.onerror = () => {
+      if (this.isCurrentSocket(socket, generation)) {
+        this.emitError("WEBSOCKET_ERROR", "\u5BA2\u670D\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 {
+      accessToken = (await this.transport.getAccessToken()).trim();
+    } catch {
+    }
+    if (!this.isCurrentSocket(socket, generation)) return;
+    if (!accessToken) {
+      this.emitError("TOKEN_UNAVAILABLE", "\u65E0\u6CD5\u83B7\u53D6\u5BA2\u670D\u5B9E\u65F6\u8FDE\u63A5\u51ED\u8BC1\u3002", true);
+      socket.close();
+      return;
+    }
+    socket.send(
+      JSON.stringify({
+        type: "authenticate",
+        protocol_version: 1,
+        access_token: accessToken,
+        requested_channels: ["customer_support"],
+        cursors: {}
+      })
+    );
+    accessToken = "";
+  }
+  async handleSocketData(data, socket, generation) {
+    if (!this.isCurrentSocket(socket, generation)) return;
+    let raw = "";
+    if (typeof data === "string") raw = data;
+    else if (data instanceof Blob) raw = await data.text();
+    else if (data instanceof ArrayBuffer) raw = new TextDecoder().decode(data);
+    const message = raw ? parseJsonRecord(raw) : null;
+    if (!message) {
+      this.emitError("PROTOCOL_ERROR", "\u6536\u5230\u65E0\u6CD5\u89E3\u6790\u7684\u5BA2\u670D\u5B9E\u65F6\u6D88\u606F\u3002", true);
+      return;
+    }
+    this.handleServerMessage(message, socket, generation);
+  }
+  handleServerMessage(message, socket, generation) {
+    const type = normalizedText(message.type);
+    if (type === "realtime_ready") {
+      const channels = record2(message.channels);
+      if (record2(channels.customer_support).available !== true) {
+        this.shouldReconnect = false;
+        this.emitError("CHANNEL_UNAVAILABLE", "\u4EBA\u5DE5\u5BA2\u670D\u5B9E\u65F6\u901A\u9053\u4E0D\u53EF\u7528\u3002", false);
+        socket.close();
+        return;
+      }
+      this.reconnectAttempt = 0;
+      this.tokenReconnectAttempt = 0;
+      this.availabilityReconnectAttempt = 0;
+      this.startHeartbeat(numberValue2(message.heartbeat_interval_seconds), socket, generation);
+      this.setState("connected");
+      return;
+    }
+    if (type === "realtime_event" && message.channel === "customer_support") {
+      const event = record2(message.event);
+      this.handleCustomerSupportEvent(event);
+      return;
+    }
+    if (type === "channel_resync_required" && message.channel === "customer_support") {
+      void this.refreshFromRealtime();
+      return;
+    }
+    if (type === "authentication_error") {
+      const failure = authenticationFailure2(normalizedText(message.code));
+      this.socketAuthenticationFailure = { generation, retryMode: failure.retryMode };
+      this.emitError(failure.code, failure.message, failure.retryMode !== "never");
+    }
+  }
+  handleCustomerSupportEvent(event) {
+    const eventType = normalizedText(event.event_type);
+    const sessionId = normalizedText(event.session_id);
+    if (!eventType || !sessionId) return;
+    this.refreshSessionsFromRealtime();
+    if (sessionId !== this.currentSession?.id) return;
+    if (eventType === "support_read_state_changed") return;
+    if (eventType === "support_message_created") {
+      void this.refreshHistory(true);
+      return;
+    }
+    void this.refreshSessionFromRealtime();
+  }
+  async refreshFromRealtime() {
+    await this.refreshSessions().catch(() => [...this.currentSessions]);
+    await this.refreshSessionFromRealtime();
+    await this.refreshHistory(true);
+  }
+  async refreshSessions() {
+    if (this.sessionsRefresh) return this.sessionsRefresh.promise;
+    const pending = (async () => {
+      const sessions = await this.transport.listSessions();
+      if (!this.destroyed) this.replaceSessions(sessions);
+      return [...this.currentSessions];
+    })();
+    const refresh = { promise: pending };
+    this.sessionsRefresh = refresh;
+    return pending.finally(() => {
+      if (this.sessionsRefresh === refresh) this.sessionsRefresh = null;
+    });
+  }
+  refreshSessionsFromRealtime() {
+    void this.refreshSessions().catch(() => {
+    });
+  }
+  replaceSessions(sessions) {
+    this.currentSessions = [...sessions];
+    this.emit("sessions", { sessions: [...this.currentSessions] });
+  }
+  upsertSession(session) {
+    const currentIndex = this.currentSessions.findIndex((candidate) => candidate.id === session.id);
+    if (currentIndex < 0) this.currentSessions = [session, ...this.currentSessions];
+    else {
+      this.currentSessions = this.currentSessions.map(
+        (candidate, index) => index === currentIndex ? session : candidate
+      );
+    }
+    this.emit("sessions", { sessions: [...this.currentSessions] });
+  }
+  async refreshSessionFromRealtime() {
+    const sessionId = this.currentSession?.id;
+    const getSession = this.transport.getSession;
+    if (!sessionId || !getSession) return;
+    try {
+      const session = await getSession.call(this.transport, sessionId);
+      if (!this.destroyed && this.currentSession?.id === sessionId) {
+        this.currentSession = session;
+        this.emit("session", { session });
+      }
+    } catch {
+    }
+  }
+  appendMessage(message, source) {
+    if (this.currentMessages.some((candidate) => candidate.id === message.id)) return;
+    this.currentMessages = [...this.currentMessages, message].sort(compareMessages);
+    this.emit("message", { sessionId: message.sessionId, message, source });
+  }
+  startHeartbeat(intervalSeconds, socket, generation) {
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    const requested = intervalSeconds > 0 ? intervalSeconds * 1e3 : 25e3;
+    this.heartbeatTimer = setInterval(
+      () => {
+        if (this.isCurrentSocket(socket, generation) && socket.readyState === 1) {
+          socket.send(JSON.stringify(createPingFrame()));
+        }
+      },
+      Math.max(this.minimumHeartbeatMs, requested)
+    );
+  }
+  handleSocketClose(socket, generation, code) {
+    if (!this.isCurrentSocket(socket, generation)) return;
+    this.socket = null;
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = null;
+    const authenticationFailure3 = 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") {
+      this.shouldReconnect = false;
+      this.setState("disconnected");
+      return;
+    }
+    if (code === 4400 || code === 4403) {
+      this.shouldReconnect = false;
+      if (!authenticationFailure3) {
+        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",
+          false
+        );
+      }
+      this.setState("disconnected");
+      return;
+    }
+    if (authenticationFailure3?.retryMode === "availability" || code === 1013) {
+      if (!authenticationFailure3) {
+        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) {
+        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) {
+        this.shouldReconnect = false;
+        this.emitError("AUTHENTICATION_FAILED", "\u4EBA\u5DE5\u5BA2\u670D\u8EAB\u4EFD\u9A8C\u8BC1\u5931\u8D25\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55\u540E\u518D\u8BD5\u3002", false);
+        this.setState("disconnected");
+        return;
+      }
+      this.tokenReconnectAttempt += 1;
+    }
+    this.scheduleReconnect();
+  }
+  scheduleAvailabilityReconnect() {
+    if (this.availabilityReconnectAttempt >= MAX_AVAILABILITY_RECONNECTS2) {
+      this.shouldReconnect = false;
+      this.emitError("REALTIME_UNAVAILABLE", "\u5BA2\u670D\u5B9E\u65F6\u9274\u6743\u670D\u52A1\u6301\u7EED\u4E0D\u53EF\u7528\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002", false);
+      this.setState("disconnected");
+      return;
+    }
+    this.availabilityReconnectAttempt += 1;
+    this.scheduleReconnect();
+  }
+  scheduleReconnect() {
+    if (!this.shouldReconnect || this.destroyed || this.reconnectTimer) return;
+    const base = Math.min(
+      this.reconnectOptions.maximumDelayMs,
+      this.reconnectOptions.initialDelayMs * this.reconnectOptions.factor ** this.reconnectAttempt++
+    );
+    const jitter = base * this.reconnectOptions.jitter * (Math.random() * 2 - 1);
+    this.reconnectTimer = setTimeout(
+      () => {
+        this.reconnectTimer = null;
+        this.openSocket(true);
+      },
+      Math.max(0, base + jitter)
+    );
+  }
+  clearTimers() {
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    this.heartbeatTimer = null;
+    this.reconnectTimer = null;
+  }
+  isCurrentSocket(socket, generation) {
+    return !this.destroyed && this.socket === socket && this.socketGeneration === generation;
+  }
+  setState(current) {
+    if (this.currentState === current) return;
+    const previous = this.currentState;
+    this.currentState = current;
+    this.emit("connection-state-change", { previous, current });
+  }
+  emitError(code, message, recoverable) {
+    const detail = { code, message, recoverable };
+    this.emit("error", detail);
+    return detail;
+  }
+  emit(type, detail) {
+    for (const listener of this.listeners.get(type) ?? []) listener(detail);
+  }
+  assertUsable() {
+    if (this.destroyed) {
+      throw new CustomerSupportClientError("CLIENT_DESTROYED", "\u5BA2\u670D\u5BA2\u6237\u7AEF\u5DF2\u7ECF\u9500\u6BC1\u3002");
+    }
+  }
+};
+function validateRealtimeUrl2(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new CustomerSupportClientError("INVALID_CONFIGURATION", "\u5BA2\u670D\u5B9E\u65F6\u5730\u5740\u65E0\u6548\u3002");
+  }
+  if (!["ws:", "wss:"].includes(url.protocol) || url.search || url.hash || url.username) {
+    throw new CustomerSupportClientError("INVALID_CONFIGURATION", "\u5BA2\u670D\u5B9E\u65F6\u5730\u5740\u4E0D\u5B89\u5168\u3002");
+  }
+  return url.href;
+}
+function normalizeReconnect(value) {
+  return {
+    initialDelayMs: Math.max(0, value?.initialDelayMs ?? DEFAULT_RECONNECT2.initialDelayMs),
+    maximumDelayMs: Math.max(1, value?.maximumDelayMs ?? DEFAULT_RECONNECT2.maximumDelayMs),
+    factor: Math.max(1, value?.factor ?? DEFAULT_RECONNECT2.factor),
+    jitter: Math.min(1, Math.max(0, value?.jitter ?? DEFAULT_RECONNECT2.jitter))
+  };
+}
+function compareMessages(left, right) {
+  const leftSequence = Number(left.sequence);
+  const rightSequence = Number(right.sequence);
+  if (Number.isFinite(leftSequence) && Number.isFinite(rightSequence)) {
+    return leftSequence - rightSequence;
+  }
+  return left.createdAt.localeCompare(right.createdAt);
+}
+function normalizeReadCursor(value) {
+  const cursor = normalizedText(value);
+  if (!/^\d+$/.test(cursor)) return null;
+  return cursor.replace(/^0+(?=\d)/, "");
+}
+function compareReadCursors(left, right) {
+  if (left.length !== right.length) return left.length < right.length ? -1 : 1;
+  if (left === right) return 0;
+  return left < right ? -1 : 1;
+}
+function maxReadCursor(left, right) {
+  return left && compareReadCursors(left, right) >= 0 ? left : right;
+}
+function hasCustomerSupportMessages(session) {
+  return session.lastMessage.trim().length > 0;
+}
+function requiredText2(value, field) {
+  const normalized = normalizedText(value);
+  if (!normalized) {
+    throw new CustomerSupportClientError("INVALID_CONFIGURATION", `${field} \u4E0D\u80FD\u4E3A\u7A7A\u3002`);
+  }
+  return normalized;
+}
+function requiredRequestId2(value) {
+  return requiredText2(value, "requestId");
+}
+function normalizedText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function record2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function numberValue2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+function createRequestId2() {
+  return typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : `request-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+function authenticationFailure2(code) {
+  if (code === "UNAUTHORIZED") {
+    return {
+      code: "AUTHENTICATION_FAILED",
+      message: "\u5BA2\u670D\u8FDE\u63A5\u51ED\u8BC1\u5DF2\u5931\u6548\uFF0C\u6B63\u5728\u91CD\u65B0\u8FDE\u63A5\u3002",
+      retryMode: "token"
+    };
+  }
+  if (code === "ORGANIZATION_CONTEXT_REQUIRED") {
+    return {
+      code: "ORGANIZATION_CONTEXT_REQUIRED",
+      message: "\u8BF7\u9009\u62E9\u4F01\u4E1A/\u56E2\u961F\u540E\u518D\u8054\u7CFB\u4EBA\u5DE5\u5BA2\u670D\u3002",
+      retryMode: "never"
+    };
+  }
+  if (code === "INVALID_ARGUMENT") {
+    return {
+      code: "PROTOCOL_ERROR",
+      message: "\u5BA2\u670D\u5B9E\u65F6\u8FDE\u63A5\u534F\u8BAE\u4E0D\u53D7\u652F\u6301\u3002",
+      retryMode: "never"
+    };
+  }
+  if (code === "REALTIME_UNAVAILABLE" || code === "KANBAN_AUTH_FAILED" || code.startsWith("SERVICE_")) {
+    return {
+      code: "REALTIME_UNAVAILABLE",
+      message: "\u5BA2\u670D\u5B9E\u65F6\u9274\u6743\u670D\u52A1\u6682\u4E0D\u53EF\u7528\uFF0C\u6B63\u5728\u91CD\u8BD5\u3002",
+      retryMode: "availability"
+    };
+  }
+  if (code === "ACCESS_DENIED" || code === "ORIGIN_NOT_ALLOWED" || code === "CHANNEL_ACCESS_DENIED") {
+    return {
+      code: "AUTHENTICATION_FAILED",
+      message: "\u5F53\u524D\u8EAB\u4EFD\u65E0\u6743\u4F7F\u7528\u4EBA\u5DE5\u5BA2\u670D\u3002",
+      retryMode: "never"
+    };
+  }
+  return {
+    code: "AUTHENTICATION_FAILED",
+    message: "\u4EBA\u5DE5\u5BA2\u670D\u5B9E\u65F6\u8FDE\u63A5\u8BA4\u8BC1\u5931\u8D25\u3002",
+    retryMode: "never"
+  };
+}
+
+// src/notification-center-client.ts
+var DEFAULT_PAGE_SIZE = 20;
+var NotificationCenterClientError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "NotificationCenterClientError";
+    this.code = code;
+  }
+};
+var NotificationCenterClient = class {
+  transport;
+  applicationName;
+  pageSize;
+  readStatus;
+  preferredTypeOrder;
+  listeners = /* @__PURE__ */ new Map();
+  items = [];
+  hasMore = false;
+  nextId = null;
+  unreadCount = 0;
+  notificationTypes = [];
+  availableTypes = [];
+  typeCatalogFromBackend = false;
+  inboxGeneration = 0;
+  destroyed = false;
+  loadingInbox = false;
+  pendingResync = false;
+  constructor(options) {
+    if (!options?.transport) {
+      throw new NotificationCenterClientError(
+        "INVALID_CONFIGURATION",
+        "\u7F3A\u5C11\u901A\u77E5\u4E2D\u5FC3 transport \u914D\u7F6E\u3002"
+      );
+    }
+    this.transport = options.transport;
+    this.applicationName = normalizedText2(options.applicationName);
+    this.pageSize = Math.max(1, Math.floor(options.pageSize ?? DEFAULT_PAGE_SIZE));
+    this.readStatus = ["all", "unread", "read"].includes(options.readStatus ?? "") ? options.readStatus : "all";
+    this.preferredTypeOrder = (options.preferredTypeOrder ?? []).map((value) => normalizedText2(value)).filter(Boolean);
+  }
+  get notifications() {
+    return [...this.items];
+  }
+  get unread() {
+    return this.unreadCount;
+  }
+  /** 数据中实际存在的通知分类，供 UI 渲染页签；不是写死的枚举。 */
+  get types() {
+    return this.availableTypes.map((entry) => ({ ...entry }));
+  }
+  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);
+  }
+  async start() {
+    this.assertUsable();
+    await Promise.all([this.reloadInbox(), this.refreshUnreadCount()]);
+    this.emit("ready", {});
+  }
+  async setTypeFilter(types) {
+    this.assertUsable();
+    this.notificationTypes = [...types].map((value) => normalizedText2(value)).filter(Boolean);
+    await this.reloadInbox();
+  }
+  getTypeFilter() {
+    return [...this.notificationTypes];
+  }
+  async loadMore() {
+    this.assertUsable();
+    if (!this.hasMore || this.loadingInbox || !this.nextId) return;
+    const generation = this.inboxGeneration;
+    this.loadingInbox = true;
+    try {
+      const result = await this.transport.listInbox({
+        pageSize: this.pageSize,
+        beforeId: this.nextId,
+        notificationTypes: this.notificationTypes,
+        readStatus: this.readStatus,
+        applicationName: this.applicationName
+      });
+      if (this.destroyed || generation !== this.inboxGeneration) return;
+      const existing = new Set(this.items.map((item) => item.id));
+      const merged = [...this.items];
+      for (const item of result.items) {
+        if (!existing.has(item.id)) {
+          existing.add(item.id);
+          merged.push(item);
+        }
+      }
+      this.items = merged;
+      this.hasMore = result.hasMore;
+      this.nextId = result.nextId;
+      this.rememberTypes(result.items);
+      this.emitInbox();
+    } catch {
+      this.emitError("INBOX_LOAD_FAILED", "\u901A\u77E5\u52A0\u8F7D\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002", true);
+    } finally {
+      if (generation === this.inboxGeneration) this.finishInboxLoad();
+    }
+  }
+  async refresh() {
+    this.assertUsable();
+    await Promise.all([this.reloadInbox(), this.refreshUnreadCount()]);
+  }
+  /**
+   * Consume a notification realtime event captured by the host socket.
+   *
+   * The raw event is mapped through the transport so the DTO contract stays in
+   * this SDK; anything that cannot be mapped degrades to a full refresh. Events
+   * that arrive while an inbox request is in flight are replaced by a resync so a
+   * late server page cannot drop them.
+   */
+  applyRealtimeEvent(event) {
+    if (this.destroyed) return;
+    if (this.loadingInbox) {
+      this.pendingResync = true;
+      return;
+    }
+    const parse = this.transport.parseRealtimeEvent;
+    let change = null;
+    if (parse) {
+      try {
+        change = parse.call(this.transport, event);
+      } catch {
+        change = null;
+      }
+    }
+    if (!change) {
+      void this.refreshFromRealtime();
+      return;
+    }
+    this.applyRealtimeChange(change);
+  }
+  async markRead(notificationId) {
+    this.assertUsable();
+    const id = requiredText3(notificationId, "notificationId");
+    const target = this.items.find((item) => item.id === id);
+    if (target && target.readStatus === "read") return;
+    try {
+      const result = await this.transport.markRead({
+        notificationId: id,
+        applicationName: this.applicationName
+      });
+      if (this.destroyed) return;
+      this.applyRead([id], result.readAt);
+      this.setUnreadCount(result.unreadCount);
+      this.emit("notification-read", { notificationId: id });
+    } catch {
+      this.emitError("MARK_READ_FAILED", "\u901A\u77E5\u6807\u8BB0\u5DF2\u8BFB\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002", true);
+    }
+  }
+  async markAllRead() {
+    this.assertUsable();
+    try {
+      const result = await this.transport.markAllRead({
+        applicationName: this.applicationName
+      });
+      if (this.destroyed) return;
+      const readAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.items = this.items.map(
+        (item) => item.readStatus === "read" ? item : { ...item, readStatus: "read", readAt }
+      );
+      this.emitInbox();
+      this.setUnreadCount(result.unreadCount);
+    } catch {
+      this.emitError("MARK_READ_FAILED", "\u901A\u77E5\u6807\u8BB0\u5DF2\u8BFB\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002", true);
+    }
+  }
+  async downloadAttachment(fileId, name) {
+    this.assertUsable();
+    const id = requiredText3(fileId, "fileId");
+    try {
+      return await this.transport.downloadAttachment({ fileId: id, name });
+    } catch {
+      const detail = this.emitError("DOWNLOAD_FAILED", "\u9644\u4EF6\u4E0B\u8F7D\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002", true);
+      throw new NotificationCenterClientError(detail.code, detail.message);
+    }
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    this.pendingResync = false;
+    this.inboxGeneration += 1;
+    this.listeners.clear();
+    this.items = [];
+  }
+  async reloadInbox() {
+    const generation = ++this.inboxGeneration;
+    this.loadingInbox = true;
+    try {
+      const result = await this.transport.listInbox({
+        pageSize: this.pageSize,
+        beforeId: null,
+        // 分类目录随首屏/刷新/切换页签的请求一并取回，不额外发请求。
+        includeTypeFacets: true,
+        notificationTypes: this.notificationTypes,
+        readStatus: this.readStatus,
+        applicationName: this.applicationName
+      });
+      if (this.destroyed || generation !== this.inboxGeneration) return;
+      const unique = /* @__PURE__ */ new Map();
+      for (const item of result.items) {
+        if (item.id) unique.set(item.id, item);
+      }
+      this.items = [...unique.values()];
+      this.hasMore = result.hasMore;
+      this.nextId = result.nextId;
+      this.applyTypeCatalog(result.types);
+      this.rememberTypes(result.items);
+      this.emitInbox();
+    } catch {
+      if (generation === this.inboxGeneration) {
+        this.emitError("INBOX_LOAD_FAILED", "\u901A\u77E5\u52A0\u8F7D\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\u3002", true);
+      }
+    } finally {
+      if (generation === this.inboxGeneration) this.finishInboxLoad();
+    }
+  }
+  finishInboxLoad() {
+    this.loadingInbox = false;
+    if (!this.pendingResync || this.destroyed) return;
+    this.pendingResync = false;
+    void this.refreshFromRealtime();
+  }
+  /**
+   * 分类页签的数据来源。
+   *
+   * `notification_type` 是后端自由文本列，展示名来自后端字典（`notification_type_name`），
+   * 前端不维护 code 到中文名的映射。权威目录是 `inbox` 在 `includeTypeFacets` 下返回的
+   * `types`（后端按收件人可见范围统计，忽略类型筛选与分页）；后端未提供时退回累积已加载
+   * 页面里出现过的分类——这在分页深处才出现的分类上会暂时缺页签，属已知取舍。
+   */
+  applyTypeCatalog(types) {
+    if (!Array.isArray(types)) return;
+    const normalized = types.map((entry) => ({
+      type: normalizedText2(entry?.type),
+      name: normalizedText2(entry?.name)
+    })).filter((entry) => entry.type);
+    this.typeCatalogFromBackend = true;
+    this.setAvailableTypes(normalized, true);
+  }
+  rememberTypes(items) {
+    const discovered = items.map((item) => ({ type: normalizedText2(item.type), name: normalizedText2(item.typeName) })).filter((entry) => entry.type);
+    if (!discovered.length) return;
+    this.setAvailableTypes(discovered, false, this.typeCatalogFromBackend);
+  }
+  setAvailableTypes(candidates, replace, namesOnly = false) {
+    const merged = /* @__PURE__ */ new Map();
+    if (!replace) {
+      for (const entry of this.availableTypes) merged.set(entry.type, entry.name);
+    }
+    for (const entry of candidates) {
+      if (namesOnly && !merged.has(entry.type)) continue;
+      const existing = merged.get(entry.type);
+      merged.set(entry.type, existing || entry.name);
+    }
+    const codes = [...merged.keys()];
+    const preferred = this.preferredTypeOrder.filter((value) => merged.has(value));
+    const ordered = [...preferred, ...codes.filter((value) => !preferred.includes(value))].map(
+      (type) => ({ type, name: merged.get(type) ?? "" })
+    );
+    if (ordered.length === this.availableTypes.length && ordered.every(
+      (entry, index) => entry.type === this.availableTypes[index]?.type && entry.name === this.availableTypes[index]?.name
+    )) {
+      return;
+    }
+    this.availableTypes = ordered;
+    this.emit("types-change", { types: this.types });
+  }
+  async refreshUnreadCount() {
+    try {
+      const result = await this.transport.getUnreadCount({ applicationName: this.applicationName });
+      if (this.destroyed) return;
+      this.setUnreadCount(result.unreadCount);
+    } catch {
+    }
+  }
+  applyRealtimeChange(change) {
+    if (change.kind === "created") {
+      const incoming = change.notification;
+      if (!incoming.id) return;
+      if (!this.items.some((item) => item.id === incoming.id)) {
+        this.items = [incoming, ...this.items];
+        this.rememberTypes([incoming]);
+        this.emitInbox();
+      }
+      this.syncRealtimeUnreadCount(change.unreadCount);
+      return;
+    }
+    if (change.kind === "read") {
+      this.applyRead(change.notificationIds, change.readAt ?? null);
+      this.syncRealtimeUnreadCount(change.unreadCount);
+      return;
+    }
+    const removed = new Set(change.notificationIds);
+    if (removed.size) {
+      const next = this.items.filter((item) => !removed.has(item.id));
+      if (next.length !== this.items.length) {
+        this.items = next;
+        this.emitInbox();
+      }
+    }
+    this.syncRealtimeUnreadCount(change.unreadCount);
+  }
+  syncRealtimeUnreadCount(value) {
+    if (this.applicationName && typeof value === "number") this.setUnreadCount(value);
+    else void this.refreshUnreadCount();
+  }
+  applyRead(ids, readAt) {
+    const target = new Set(ids);
+    if (!target.size) return;
+    let changed = false;
+    const next = this.items.map((item) => {
+      if (target.has(item.id) && item.readStatus !== "read") {
+        changed = true;
+        return { ...item, readStatus: "read", readAt: readAt ?? item.readAt };
+      }
+      return item;
+    });
+    if (changed) {
+      this.items = next;
+      this.emitInbox();
+    }
+  }
+  async refreshFromRealtime() {
+    await this.reloadInbox();
+    await this.refreshUnreadCount();
+  }
+  emitInbox() {
+    this.emit("inbox", {
+      items: [...this.items],
+      hasMore: this.hasMore,
+      nextId: this.nextId
+    });
+  }
+  setUnreadCount(value) {
+    const normalized = Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+    if (normalized === this.unreadCount) return;
+    this.unreadCount = normalized;
+    this.emit("unread-count-change", { unreadCount: normalized });
+  }
+  emitError(code, message, recoverable) {
+    const detail = { code, message, recoverable };
+    this.emit("error", detail);
+    return detail;
+  }
+  emit(type, detail) {
+    for (const listener of this.listeners.get(type) ?? []) listener(detail);
+  }
+  assertUsable() {
+    if (this.destroyed) {
+      throw new NotificationCenterClientError("CLIENT_DESTROYED", "\u901A\u77E5\u4E2D\u5FC3\u5BA2\u6237\u7AEF\u5DF2\u7ECF\u9500\u6BC1\u3002");
+    }
+  }
+};
+function requiredText3(value, field) {
+  const normalized = normalizedText2(value);
+  if (!normalized) {
+    throw new NotificationCenterClientError("INVALID_CONFIGURATION", `${field} \u4E0D\u80FD\u4E3A\u7A7A\u3002`);
+  }
+  return normalized;
+}
+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 };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map