tgo-widget-miniprogram 1.0.0 → 1.1.1

package/miniprogram_dist/core/chatStore.js

@@ -1,30 +1,965 @@
-/**
- * Chat state management (Observable singleton)
- * Ported from tgo-widget-app chatStore.ts
- */
-var IMService = require('../services/wukongim')
-var visitorService = require('../services/visitor')
-var historyService = require('../services/messageHistory')
-var chatService = require('../services/chat')
-var uploadService = require('../services/upload')
-var systemInfoAdapter = require('../adapters/systemInfo')
-var types = require('./types')
-var platformStore = require('./platformStore')
-var uidUtil = require('../utils/uid')
-var jsonRenderUtils = require('../utils/jsonRender')
-
-// Module-level unsub guards
-var offMsg = null
-var offStatus = null
-var offCustom = null
-
-// Stream timeout
-var streamTimer = null
-var STREAM_TIMEOUT_MS = 60000
-
-// Per-clientMsgNo MixedStreamParser instances
-var activeParsers = {}
-
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// node_modules/easyjssdk/dist/cjs/index.js
+var require_cjs = __commonJS({
+  "node_modules/easyjssdk/dist/cjs/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.WKIMDeviceFlag = exports2.WKIMEvent = exports2.WKIMChannelType = exports2.WKIM = exports2.DeviceFlag = exports2.ReasonCode = exports2.Event = exports2.ChannelType = exports2.currentPlatform = exports2.PlatformType = void 0;
+    var WS_CONNECTING = 0;
+    var WS_OPEN = 1;
+    var WS_CLOSING = 2;
+    var WS_CLOSED = 3;
+    var PlatformType;
+    (function(PlatformType2) {
+      PlatformType2["Browser"] = "browser";
+      PlatformType2["NodeJS"] = "nodejs";
+      PlatformType2["WeChat"] = "wechat";
+      PlatformType2["Alipay"] = "alipay";
+      PlatformType2["UniApp"] = "uniapp";
+    })(PlatformType || (exports2.PlatformType = PlatformType = {}));
+    var WeChatWebSocketAdapter = class {
+      constructor(url) {
+        this.socketTask = null;
+        this._readyState = WS_CONNECTING;
+        this.onopen = null;
+        this.onmessage = null;
+        this.onerror = null;
+        this.onclose = null;
+        if (typeof wx === "undefined") {
+          throw new Error("WeChat Mini Program environment not detected");
+        }
+        this.socketTask = wx.connectSocket({
+          url,
+          success: () => {
+            console.log("WeChat WebSocket connecting...");
+          },
+          fail: (err) => {
+            console.error("WeChat WebSocket connection failed:", err);
+            this._readyState = WS_CLOSED;
+            if (this.onerror) {
+              this.onerror({ message: err.errMsg || "Connection failed" });
+            }
+          }
+        });
+        this.socketTask.onOpen((res) => {
+          this._readyState = WS_OPEN;
+          if (this.onopen) {
+            this.onopen(res);
+          }
+        });
+        this.socketTask.onMessage((res) => {
+          if (this.onmessage) {
+            const data = res.data instanceof ArrayBuffer ? new TextDecoder().decode(res.data) : res.data;
+            this.onmessage({ data });
+          }
+        });
+        this.socketTask.onError((res) => {
+          console.error("WeChat WebSocket error:", res);
+          if (this.onerror) {
+            this.onerror({ message: res.errMsg || "WebSocket error" });
+          }
+        });
+        this.socketTask.onClose((res) => {
+          this._readyState = WS_CLOSED;
+          if (this.onclose) {
+            this.onclose({ code: res.code || 1e3, reason: res.reason || "" });
+          }
+        });
+      }
+      get readyState() {
+        return this._readyState;
+      }
+      send(data) {
+        if (this._readyState !== WS_OPEN || !this.socketTask) {
+          throw new Error("WebSocket is not open");
+        }
+        this.socketTask.send({
+          data,
+          fail: (err) => {
+            console.error("WeChat WebSocket send failed:", err);
+            if (this.onerror) {
+              this.onerror({ message: "Send failed" });
+            }
+          }
+        });
+      }
+      close(code, reason) {
+        if (this._readyState === WS_CLOSED || this._readyState === WS_CLOSING) {
+          return;
+        }
+        this._readyState = WS_CLOSING;
+        if (this.socketTask) {
+          this.socketTask.close({
+            code: code || 1e3,
+            reason: reason || "",
+            fail: (err) => {
+              console.error("WeChat WebSocket close failed:", err);
+            }
+          });
+        }
+      }
+    };
+    var AlipayWebSocketAdapter = class {
+      constructor(url) {
+        this._readyState = WS_CONNECTING;
+        this.boundOnOpen = null;
+        this.boundOnMessage = null;
+        this.boundOnError = null;
+        this.boundOnClose = null;
+        this.onopen = null;
+        this.onmessage = null;
+        this.onerror = null;
+        this.onclose = null;
+        if (typeof my === "undefined") {
+          throw new Error("Alipay Mini Program environment not detected");
+        }
+        this.boundOnOpen = (res) => {
+          this._readyState = WS_OPEN;
+          if (this.onopen) {
+            this.onopen(res);
+          }
+        };
+        this.boundOnMessage = (res) => {
+          if (this.onmessage) {
+            const data = res.data instanceof ArrayBuffer ? new TextDecoder().decode(res.data) : res.data;
+            this.onmessage({ data });
+          }
+        };
+        this.boundOnError = (res) => {
+          console.error("Alipay WebSocket error:", res);
+          if (this.onerror) {
+            this.onerror({ message: res.errorMessage || "WebSocket error" });
+          }
+        };
+        this.boundOnClose = (res) => {
+          this._readyState = WS_CLOSED;
+          this.cleanup();
+          if (this.onclose) {
+            this.onclose({ code: res.code || 1e3, reason: res.reason || "" });
+          }
+        };
+        my.onSocketOpen(this.boundOnOpen);
+        my.onSocketMessage(this.boundOnMessage);
+        my.onSocketError(this.boundOnError);
+        my.onSocketClose(this.boundOnClose);
+        my.connectSocket({
+          url,
+          success: () => {
+            console.log("Alipay WebSocket connecting...");
+          },
+          fail: (err) => {
+            console.error("Alipay WebSocket connection failed:", err);
+            this._readyState = WS_CLOSED;
+            this.cleanup();
+            if (this.onerror) {
+              this.onerror({ message: err.errorMessage || "Connection failed" });
+            }
+          }
+        });
+      }
+      get readyState() {
+        return this._readyState;
+      }
+      send(data) {
+        if (typeof my === "undefined") {
+          throw new Error("Alipay Mini Program environment not detected");
+        }
+        if (this._readyState !== WS_OPEN) {
+          throw new Error("WebSocket is not open");
+        }
+        my.sendSocketMessage({
+          data,
+          fail: (err) => {
+            console.error("Alipay WebSocket send failed:", err);
+            if (this.onerror) {
+              this.onerror({ message: "Send failed" });
+            }
+          }
+        });
+      }
+      close(code, reason) {
+        if (typeof my === "undefined") {
+          return;
+        }
+        if (this._readyState === WS_CLOSED || this._readyState === WS_CLOSING) {
+          return;
+        }
+        this._readyState = WS_CLOSING;
+        my.closeSocket({
+          code: code || 1e3,
+          reason: reason || "",
+          fail: (err) => {
+            console.error("Alipay WebSocket close failed:", err);
+          }
+        });
+      }
+      cleanup() {
+        if (typeof my !== "undefined") {
+          my.offSocketOpen(this.boundOnOpen);
+          my.offSocketMessage(this.boundOnMessage);
+          my.offSocketError(this.boundOnError);
+          my.offSocketClose(this.boundOnClose);
+          this.boundOnOpen = null;
+          this.boundOnMessage = null;
+          this.boundOnError = null;
+          this.boundOnClose = null;
+        }
+      }
+    };
+    var UniAppWebSocketAdapter = class {
+      constructor(url) {
+        this.socketTask = null;
+        this._readyState = WS_CONNECTING;
+        this.onopen = null;
+        this.onmessage = null;
+        this.onerror = null;
+        this.onclose = null;
+        if (typeof uni === "undefined") {
+          throw new Error("UniApp environment not detected");
+        }
+        this.socketTask = uni.connectSocket({
+          url,
+          success: () => {
+            console.log("UniApp WebSocket connecting...");
+          },
+          fail: (err) => {
+            console.error("UniApp WebSocket connection failed:", err);
+            this._readyState = WS_CLOSED;
+            if (this.onerror) {
+              this.onerror({ message: err.errMsg || "Connection failed" });
+            }
+          }
+        });
+        this.socketTask.onOpen((res) => {
+          this._readyState = WS_OPEN;
+          if (this.onopen) {
+            this.onopen(res);
+          }
+        });
+        this.socketTask.onMessage((res) => {
+          if (this.onmessage) {
+            const data = res.data instanceof ArrayBuffer ? new TextDecoder().decode(res.data) : res.data;
+            this.onmessage({ data });
+          }
+        });
+        this.socketTask.onError((res) => {
+          console.error("UniApp WebSocket error:", res);
+          if (this.onerror) {
+            this.onerror({ message: res.errMsg || "WebSocket error" });
+          }
+        });
+        this.socketTask.onClose((res) => {
+          this._readyState = WS_CLOSED;
+          if (this.onclose) {
+            this.onclose({ code: res.code || 1e3, reason: res.reason || "" });
+          }
+        });
+      }
+      get readyState() {
+        return this._readyState;
+      }
+      send(data) {
+        if (this._readyState !== WS_OPEN || !this.socketTask) {
+          throw new Error("WebSocket is not open");
+        }
+        this.socketTask.send({
+          data,
+          fail: (err) => {
+            console.error("UniApp WebSocket send failed:", err);
+            if (this.onerror) {
+              this.onerror({ message: "Send failed" });
+            }
+          }
+        });
+      }
+      close(code, reason) {
+        if (this._readyState === WS_CLOSED || this._readyState === WS_CLOSING) {
+          return;
+        }
+        this._readyState = WS_CLOSING;
+        if (this.socketTask) {
+          this.socketTask.close({
+            code: code || 1e3,
+            reason: reason || "",
+            fail: (err) => {
+              console.error("UniApp WebSocket close failed:", err);
+            }
+          });
+        }
+      }
+    };
+    function detectPlatform() {
+      if (typeof uni !== "undefined" && typeof uni.connectSocket === "function") {
+        return PlatformType.UniApp;
+      }
+      if (typeof wx !== "undefined" && typeof wx.connectSocket === "function") {
+        return PlatformType.WeChat;
+      }
+      if (typeof my !== "undefined" && typeof my.connectSocket === "function") {
+        return PlatformType.Alipay;
+      }
+      if (typeof WebSocket !== "undefined") {
+        return PlatformType.Browser;
+      }
+      return PlatformType.NodeJS;
+    }
+    var currentPlatform = detectPlatform();
+    exports2.currentPlatform = currentPlatform;
+    function createWebSocket(url) {
+      switch (currentPlatform) {
+        case PlatformType.UniApp:
+          return new UniAppWebSocketAdapter(url);
+        case PlatformType.WeChat:
+          return new WeChatWebSocketAdapter(url);
+        case PlatformType.Alipay:
+          return new AlipayWebSocketAdapter(url);
+        case PlatformType.Browser:
+          return new WebSocket(url);
+        case PlatformType.NodeJS:
+        default:
+          try {
+            const dynamicRequire = new Function("mod", "return require(mod)");
+            const Ws = dynamicRequire("ws");
+            const WsImpl = Ws.WebSocket || Ws;
+            return new WsImpl(url);
+          } catch (e) {
+            throw new Error("WebSocket is not available in this environment. Install 'ws' package for Node.js.");
+          }
+      }
+    }
+    var ChannelType;
+    (function(ChannelType2) {
+      ChannelType2[ChannelType2["Person"] = 1] = "Person";
+      ChannelType2[ChannelType2["Group"] = 2] = "Group";
+      ChannelType2[ChannelType2["CustomerService"] = 3] = "CustomerService";
+      ChannelType2[ChannelType2["Community"] = 4] = "Community";
+      ChannelType2[ChannelType2["CommunityTopic"] = 5] = "CommunityTopic";
+      ChannelType2[ChannelType2["Info"] = 6] = "Info";
+      ChannelType2[ChannelType2["Data"] = 7] = "Data";
+      ChannelType2[ChannelType2["Temp"] = 8] = "Temp";
+      ChannelType2[ChannelType2["Live"] = 9] = "Live";
+      ChannelType2[ChannelType2["Visitors"] = 10] = "Visitors";
+    })(ChannelType || (exports2.WKIMChannelType = exports2.ChannelType = ChannelType = {}));
+    var Event;
+    (function(Event2) {
+      Event2["Connect"] = "connect";
+      Event2["Disconnect"] = "disconnect";
+      Event2["Message"] = "message";
+      Event2["Error"] = "error";
+      Event2["SendAck"] = "sendack";
+      Event2["Reconnecting"] = "reconnecting";
+      Event2["CustomEvent"] = "customevent";
+    })(Event || (exports2.WKIMEvent = exports2.Event = Event = {}));
+    var ReasonCode;
+    (function(ReasonCode2) {
+      ReasonCode2[ReasonCode2["Unknown"] = 0] = "Unknown";
+      ReasonCode2[ReasonCode2["Success"] = 1] = "Success";
+      ReasonCode2[ReasonCode2["AuthFail"] = 2] = "AuthFail";
+      ReasonCode2[ReasonCode2["SubscriberNotExist"] = 3] = "SubscriberNotExist";
+      ReasonCode2[ReasonCode2["InBlacklist"] = 4] = "InBlacklist";
+      ReasonCode2[ReasonCode2["ChannelNotExist"] = 5] = "ChannelNotExist";
+      ReasonCode2[ReasonCode2["UserNotOnNode"] = 6] = "UserNotOnNode";
+      ReasonCode2[ReasonCode2["SenderOffline"] = 7] = "SenderOffline";
+      ReasonCode2[ReasonCode2["MsgKeyError"] = 8] = "MsgKeyError";
+      ReasonCode2[ReasonCode2["PayloadDecodeError"] = 9] = "PayloadDecodeError";
+      ReasonCode2[ReasonCode2["ForwardSendPacketError"] = 10] = "ForwardSendPacketError";
+      ReasonCode2[ReasonCode2["NotAllowSend"] = 11] = "NotAllowSend";
+      ReasonCode2[ReasonCode2["ConnectKick"] = 12] = "ConnectKick";
+      ReasonCode2[ReasonCode2["NotInWhitelist"] = 13] = "NotInWhitelist";
+      ReasonCode2[ReasonCode2["QueryTokenError"] = 14] = "QueryTokenError";
+      ReasonCode2[ReasonCode2["SystemError"] = 15] = "SystemError";
+      ReasonCode2[ReasonCode2["ChannelIDError"] = 16] = "ChannelIDError";
+      ReasonCode2[ReasonCode2["NodeMatchError"] = 17] = "NodeMatchError";
+      ReasonCode2[ReasonCode2["NodeNotMatch"] = 18] = "NodeNotMatch";
+      ReasonCode2[ReasonCode2["Ban"] = 19] = "Ban";
+      ReasonCode2[ReasonCode2["NotSupportHeader"] = 20] = "NotSupportHeader";
+      ReasonCode2[ReasonCode2["ClientKeyIsEmpty"] = 21] = "ClientKeyIsEmpty";
+      ReasonCode2[ReasonCode2["RateLimit"] = 22] = "RateLimit";
+      ReasonCode2[ReasonCode2["NotSupportChannelType"] = 23] = "NotSupportChannelType";
+      ReasonCode2[ReasonCode2["Disband"] = 24] = "Disband";
+      ReasonCode2[ReasonCode2["SendBan"] = 25] = "SendBan";
+    })(ReasonCode || (exports2.ReasonCode = ReasonCode = {}));
+    var DeviceFlag;
+    (function(DeviceFlag2) {
+      DeviceFlag2[DeviceFlag2["App"] = 0] = "App";
+      DeviceFlag2[DeviceFlag2["Web"] = 1] = "Web";
+      DeviceFlag2[DeviceFlag2["Desktop"] = 2] = "Desktop";
+    })(DeviceFlag || (exports2.WKIMDeviceFlag = exports2.DeviceFlag = DeviceFlag = {}));
+    var WKIM = class _WKIM {
+      constructor(url, auth) {
+        this.ws = null;
+        this.isConnected = false;
+        this.connectionPromise = null;
+        this.pingInterval = null;
+        this.pingTimeout = null;
+        this.PING_INTERVAL_MS = 25 * 1e3;
+        this.PONG_TIMEOUT_MS = 10 * 1e3;
+        this.pendingRequests = /* @__PURE__ */ new Map();
+        this.eventListeners = /* @__PURE__ */ new Map();
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 5;
+        this.initialReconnectDelay = 1e3;
+        this.isReconnecting = false;
+        this.manualDisconnect = false;
+        this.beforeUnloadHandler = null;
+        this.url = url;
+        this.auth = auth || {};
+        this.sessionId = this.generateUUID();
+        if (!this.auth.deviceId || this.auth.deviceId === "") {
+          this.auth.deviceId = `web_${this.sessionId.slice(0, 8)}_${Date.now()}`;
+        }
+        Object.values(Event).forEach((event) => this.eventListeners.set(event, []));
+        this.setupBeforeUnloadHandler();
+      }
+      /**
+       * Initializes the WKIM instance.
+       * @param url WebSocket server URL (e.g., "ws://localhost:5100")
+       * @param auth Authentication options { uid, token, ... }
+       * @param options Configuration options { singleton: boolean }
+       * @returns A WKIM instance
+       */
+      static init(url, auth, options = {}) {
+        if (!url || !auth || !auth.uid || !auth.token) {
+          throw new Error("URL, uid, and token are required for initialization.");
+        }
+        if (options.singleton && _WKIM.globalInstance) {
+          console.log("Destroying previous global instance...");
+          _WKIM.globalInstance.destroy();
+        }
+        const instance = new _WKIM(url, auth);
+        if (options.singleton !== false) {
+          _WKIM.globalInstance = instance;
+        }
+        return instance;
+      }
+      /**
+       * Establishes connection and authenticates with the server.
+       * Returns a Promise that resolves on successful connection/authentication,
+       * or rejects on failure.
+       */
+      connect() {
+        return new Promise((resolve, reject) => {
+          var _a;
+          if (this.isConnected || ((_a = this.ws) === null || _a === void 0 ? void 0 : _a.readyState) === WS_CONNECTING) {
+            console.warn("Connection already established or in progress.");
+            if (this.isConnected) {
+              resolve();
+            } else if (this.connectionPromise) {
+              this.connectionPromise.resolve = resolve;
+              this.connectionPromise.reject = reject;
+            } else {
+              reject(new Error("Already connecting, but no connection promise found."));
+            }
+            return;
+          }
+          this.manualDisconnect = false;
+          this.connectionPromise = { resolve, reject };
+          try {
+            console.log(`Connecting to ${this.url}... (Platform: ${currentPlatform})`);
+            this.ws = createWebSocket(this.url);
+            this.ws.onopen = () => {
+              console.log("WebSocket connection opened. Authenticating...");
+              this.sendConnectRequest();
+            };
+            this.ws.onmessage = (event) => {
+              this.handleMessage(event.data);
+            };
+            this.ws.onerror = (event) => {
+              const errorMessage = event.message || (event.error ? event.error.message : "WebSocket error");
+              console.error("WebSocket error:", errorMessage, event);
+              this.emit(Event.Error, event.error || new Error(errorMessage));
+            };
+            this.ws.onclose = (event) => {
+              const wasConnected = this.isConnected;
+              console.log(`WebSocket connection closed. Code: ${event.code}, Reason: ${event.reason}`);
+              if (this.connectionPromise && !this.isConnected) {
+                this.connectionPromise.reject(new Error(`Connection closed before authentication (Code: ${event.code})`));
+              }
+              this.cleanupConnection();
+              this.emit(Event.Disconnect, { code: event.code, reason: event.reason });
+              if (wasConnected && !this.manualDisconnect) {
+                this.tryReconnect();
+              }
+            };
+          } catch (error) {
+            console.error("Failed to create WebSocket:", error);
+            this.emit(Event.Error, error);
+            if (this.connectionPromise) {
+              this.connectionPromise.reject(error);
+              this.connectionPromise = null;
+            }
+            this.cleanupConnection();
+          }
+        });
+      }
+      /**
+       * Disconnects from the server.
+       */
+      disconnect() {
+        console.log("Manual disconnect initiated.");
+        this.manualDisconnect = true;
+        this.isReconnecting = false;
+        this.cleanupBeforeUnloadHandler();
+        this.handleDisconnect(true, "Manual disconnection");
+      }
+      /**
+       * Completely destroys the SDK instance, cleaning up all resources.
+       * Call this when you no longer need the SDK instance.
+       */
+      destroy() {
+        console.log("Destroying SDK instance...");
+        this.disconnect();
+        this.eventListeners.clear();
+        this.pendingRequests.clear();
+        if (_WKIM.globalInstance === this) {
+          _WKIM.globalInstance = null;
+        }
+      }
+      /**
+       * Sends a message to a specific channel.
+       * @param channelId Target channel ID
+       * @param channelType Target channel type (e.g., WKIM.ChannelType.Person)
+       * @param payload Message payload (must be a JSON-serializable object)
+       * @param options Optional: { clientMsgNo, header, setting, msgKey, expire, topic }
+       * @returns Promise resolving with { messageId, messageSeq } on server ack, or rejecting on error.
+       */
+      send(channelId, channelType, payload, options = {}) {
+        if (!this.isConnected || !this.ws || this.ws.readyState !== WS_OPEN) {
+          return Promise.reject(new Error("Not connected. Call connect() first."));
+        }
+        if (typeof payload !== "object" || payload === null) {
+          return Promise.reject(new Error("Payload must be a non-null object."));
+        }
+        const header = options.header || {};
+        header.redDot = true;
+        const clientMsgNo = options.clientMsgNo || this.generateUUID();
+        const params = {
+          clientMsgNo,
+          channelId,
+          channelType,
+          payload: this._encodePayloadToBase64(payload),
+          header,
+          topic: options.topic,
+          setting: options.setting
+        };
+        return this.sendRequest("send", params);
+      }
+      /**
+       * Registers an event listener.
+       * @param eventName The event to listen for (e.g., WKIM.Event.Message)
+       * @param callback The function to call when the event occurs
+       */
+      on(eventName, callback) {
+        var _a;
+        if (this.eventListeners.has(eventName)) {
+          (_a = this.eventListeners.get(eventName)) === null || _a === void 0 ? void 0 : _a.push(callback);
+        } else {
+          console.warn(`Attempted to register listener for unknown event: ${eventName}`);
+        }
+      }
+      /**
+      * Removes an event listener.
+      * @param eventName The event to stop listening for
+      * @param callback The specific callback function to remove
+      */
+      off(eventName, callback) {
+        if (this.eventListeners.has(eventName)) {
+          const listeners = this.eventListeners.get(eventName);
+          if (listeners) {
+            const index = listeners.indexOf(callback);
+            if (index > -1) {
+              listeners.splice(index, 1);
+            }
+          }
+        }
+      }
+      // --- Private Methods ---
+      emit(eventName, ...args) {
+        const listeners = this.eventListeners.get(eventName);
+        if (listeners) {
+          listeners.forEach((callback) => {
+            try {
+              callback(...args);
+            } catch (error) {
+              console.error(`Error in event listener for ${eventName}:`, error);
+            }
+          });
+        }
+      }
+      generateUUID() {
+        return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+          const r = Math.random() * 16 | 0, v = c === "x" ? r : r & 3 | 8;
+          return v.toString(16);
+        });
+      }
+      sendConnectRequest() {
+        var _a;
+        const params = {
+          uid: this.auth.uid,
+          token: this.auth.token,
+          deviceId: this.auth.deviceId,
+          deviceFlag: (_a = this.auth.deviceFlag) !== null && _a !== void 0 ? _a : DeviceFlag.Web,
+          // Default to WEB
+          clientTimestamp: Date.now()
+          // Add version, clientKey if needed
+        };
+        this.sendRequest("connect", params, 5e3).then((result) => {
+          console.log("Authentication successful:", result);
+          this.isConnected = true;
+          this.reconnectAttempts = 0;
+          this.isReconnecting = false;
+          this.manualDisconnect = false;
+          this.startPing();
+          this.emit(Event.Connect, result);
+          if (this.connectionPromise) {
+            this.connectionPromise.resolve();
+            this.connectionPromise = null;
+          }
+        }).catch((error) => {
+          console.error("Authentication failed:", error);
+          this.emit(Event.Error, new Error(`Authentication failed: ${error.message || JSON.stringify(error)}`));
+          if (this.connectionPromise) {
+            this.connectionPromise.reject(error);
+            this.connectionPromise = null;
+          }
+          this.handleDisconnect(false, "Authentication failed");
+          this.cleanupConnection();
+        });
+      }
+      sendRequest(method, params, timeoutMs = 15e3) {
+        return new Promise((resolve, reject) => {
+          if (!this.ws || this.ws.readyState !== WS_OPEN) {
+            return reject(new Error("WebSocket is not open."));
+          }
+          const requestId = this.generateUUID();
+          const request = {
+            method,
+            params,
+            id: requestId
+          };
+          const timeoutTimer = setTimeout(() => {
+            this.pendingRequests.delete(requestId);
+            reject(new Error(`Request timeout for method ${method} (id: ${requestId})`));
+          }, timeoutMs);
+          this.pendingRequests.set(requestId, { resolve, reject, timeoutTimer });
+          try {
+            console.debug(`--> Sending request (id: ${requestId}):`, JSON.stringify(request));
+            this.ws.send(JSON.stringify(request));
+          } catch (error) {
+            clearTimeout(timeoutTimer);
+            this.pendingRequests.delete(requestId);
+            console.error(`Error sending request (id: ${requestId}):`, error);
+            reject(error);
+          }
+        });
+      }
+      sendNotification(method, params) {
+        if (!this.ws || this.ws.readyState !== WS_OPEN) {
+          console.error("Cannot send notification, WebSocket is not open.");
+          return;
+        }
+        const notification = {
+          method,
+          params
+        };
+        console.debug(`--> Sending notification:`, JSON.stringify(notification));
+        try {
+          this.ws.send(JSON.stringify(notification));
+        } catch (error) {
+          console.error(`Error sending notification (${method}):`, error);
+          this.emit(Event.Error, new Error(`Failed to send notification ${method}: ${error}`));
+        }
+      }
+      handleMessage(data) {
+        console.debug("<-- Received raw:", data);
+        let message;
+        try {
+          message = JSON.parse(data.toString());
+        } catch (error) {
+          console.error("Failed to parse incoming message:", error, data);
+          this.emit(Event.Error, new Error(`Failed to parse message: ${error}`));
+          return;
+        }
+        if ("id" in message) {
+          this.handleResponse(message);
+        } else if ("method" in message) {
+          this.handleNotification(message);
+        } else {
+          console.warn("Received unknown message format:", message);
+        }
+      }
+      handleResponse(response) {
+        console.debug(`<-- Handling response (id: ${response.id}):`, response);
+        const pending = this.pendingRequests.get(response.id);
+        if (pending) {
+          clearTimeout(pending.timeoutTimer);
+          this.pendingRequests.delete(response.id);
+          if (response.error) {
+            pending.reject(response.error);
+          } else {
+            pending.resolve(response.result);
+          }
+        } else {
+          console.warn(`Received response for unknown request ID: ${response.id}`);
+        }
+      }
+      handleNotification(notification) {
+        var _a, _b;
+        console.debug(`<-- Handling notification (${notification.method}):`, notification.params);
+        switch (notification.method) {
+          case "recv":
+            const messageData = notification.params;
+            if (typeof messageData.payload === "string") {
+              try {
+                messageData.payload = JSON.parse(this._decodeBase64ToStr(messageData.payload));
+              } catch (e) {
+              }
+            }
+            this.emit(Event.Message, messageData);
+            this.sendRecvAck(messageData.header, messageData.messageId, messageData.messageSeq);
+            break;
+          case "pong":
+            this.handlePong();
+            break;
+          case "disconnect":
+            console.warn("Server initiated disconnect:", notification.params);
+            this.emit(Event.Disconnect, notification.params);
+            this.handleDisconnect(false, `Server disconnected: ${((_a = notification.params) === null || _a === void 0 ? void 0 : _a.reason) || ((_b = notification.params) === null || _b === void 0 ? void 0 : _b.reasonCode)}`);
+            break;
+          case "event":
+            this.handleEventNotification(notification.params);
+            break;
+          // Handle other notifications if needed
+          default:
+            console.warn(`Received unhandled notification method: ${notification.method}`);
+        }
+      }
+      /**
+       * Encode payload object to base64 string.
+       * WuKongIM server expects payload as []byte (base64 in JSON).
+       */
+      _encodePayloadToBase64(payload) {
+        const json = JSON.stringify(payload);
+        if (typeof TextEncoder !== "undefined" && typeof btoa !== "undefined") {
+          const bytes = new TextEncoder().encode(json);
+          let binary = "";
+          for (let i = 0; i < bytes.length; i++) {
+            binary += String.fromCharCode(bytes[i]);
+          }
+          return btoa(binary);
+        }
+        if (typeof Buffer !== "undefined") {
+          return Buffer.from(json, "utf-8").toString("base64");
+        }
+        if (typeof wx !== "undefined" && (wx === null || wx === void 0 ? void 0 : wx.arrayBufferToBase64)) {
+          const encoder = new TextEncoder();
+          const bytes = encoder.encode(json);
+          return wx.arrayBufferToBase64(bytes.buffer);
+        }
+        throw new Error("No base64 encoding method available");
+      }
+      /**
+       * Decode base64 string to UTF-8 string.
+       */
+      _decodeBase64ToStr(base64Str) {
+        if (typeof atob !== "undefined" && typeof TextDecoder !== "undefined") {
+          const binary = atob(base64Str);
+          const bytes = new Uint8Array(binary.length);
+          for (let i = 0; i < binary.length; i++) {
+            bytes[i] = binary.charCodeAt(i);
+          }
+          return new TextDecoder().decode(bytes);
+        }
+        if (typeof Buffer !== "undefined") {
+          return Buffer.from(base64Str, "base64").toString("utf-8");
+        }
+        if (typeof wx !== "undefined" && (wx === null || wx === void 0 ? void 0 : wx.base64ToArrayBuffer)) {
+          const buf = wx.base64ToArrayBuffer(base64Str);
+          return new TextDecoder().decode(new Uint8Array(buf));
+        }
+        throw new Error("No base64 decoding method available");
+      }
+      sendRecvAck(header, messageId, messageSeq) {
+        const params = { header, messageId, messageSeq };
+        this.sendNotification("recvack", params);
+      }
+      /**
+       * Handles incoming event notifications from the server
+       * @param params Event notification parameters
+       */
+      handleEventNotification(params) {
+        try {
+          const eventData = {
+            header: params.header,
+            id: params.id,
+            type: params.type,
+            timestamp: params.timestamp,
+            data: params.data
+          };
+          if (!eventData.id || !eventData.type) {
+            console.error("Invalid event notification: missing required fields", params);
+            this.emit(Event.Error, new Error("Invalid event notification: missing required fields"));
+            return;
+          }
+          if (typeof eventData.data === "string") {
+            try {
+              eventData.data = JSON.parse(eventData.data);
+            } catch (e) {
+              console.debug("Event data is not JSON, keeping as string");
+            }
+          }
+          console.log(`Event notification received: type=${eventData.type}, id=${eventData.id}`);
+          this.emit(Event.CustomEvent, eventData);
+        } catch (error) {
+          console.error("Error handling event notification:", error);
+          this.emit(Event.Error, new Error(`Failed to handle event notification: ${error}`));
+        }
+      }
+      startPing() {
+        this.stopPing();
+        this.pingInterval = setInterval(() => {
+          if (this.ws && this.ws.readyState === WS_OPEN) {
+            this.sendRequest("ping", {}, this.PONG_TIMEOUT_MS).then(this.handlePong.bind(this)).catch((err) => {
+              console.error("Ping failed or timed out:", err);
+              this.emit(Event.Error, new Error(`Ping timeout: ${(err === null || err === void 0 ? void 0 : err.message) || err}`));
+              if (!this.manualDisconnect) {
+                this.handleDisconnect(false, "Ping timeout");
+                this.tryReconnect();
+              }
+            });
+          } else {
+            this.stopPing();
+          }
+        }, this.PING_INTERVAL_MS);
+        console.log(`Ping interval started (${this.PING_INTERVAL_MS}ms).`);
+      }
+      stopPing() {
+        if (this.pingInterval) {
+          clearInterval(this.pingInterval);
+          this.pingInterval = null;
+          console.log("Ping interval stopped.");
+        }
+        if (this.pingTimeout) {
+          clearTimeout(this.pingTimeout);
+          this.pingTimeout = null;
+        }
+      }
+      handlePong() {
+      }
+      handleDisconnect(graceful, reason) {
+        console.log(`Handling disconnect. Graceful: ${graceful}, Reason: ${reason}`);
+        if (this.ws) {
+          this.stopPing();
+          if (graceful && this.ws.readyState === WS_OPEN) {
+            this.ws.close(1e3, "Client disconnected");
+          } else if (this.ws.readyState === WS_CONNECTING || this.ws.readyState === WS_OPEN) {
+            this.ws.close(3001, reason.substring(0, 123));
+          }
+        }
+        this.cleanupConnection();
+      }
+      cleanupConnection() {
+        console.log("Cleaning up connection resources.");
+        this.isConnected = false;
+        this.stopPing();
+        this.pendingRequests.forEach((pending) => {
+          clearTimeout(pending.timeoutTimer);
+          pending.reject(new Error("Connection closed"));
+        });
+        this.pendingRequests.clear();
+        if (this.connectionPromise) {
+          if (!this.isReconnecting && !this.isConnected) {
+            this.connectionPromise.reject(new Error("Connection closed during operation"));
+          }
+          this.connectionPromise = null;
+        }
+        if (this.ws) {
+          this.ws.onopen = null;
+          this.ws.onmessage = null;
+          this.ws.onerror = null;
+          this.ws.onclose = null;
+        }
+      }
+      // --- Reconnection Methods ---
+      setupBeforeUnloadHandler() {
+        if (typeof window !== "undefined") {
+          this.beforeUnloadHandler = () => {
+            console.log("Page unloading, closing WebSocket connection...");
+            this.manualDisconnect = true;
+            this.isReconnecting = false;
+            if (this.ws && this.ws.readyState === WS_OPEN) {
+              this.ws.close(1e3, "Page unloaded");
+            }
+          };
+          window.addEventListener("beforeunload", this.beforeUnloadHandler);
+          window.addEventListener("pagehide", this.beforeUnloadHandler);
+        }
+      }
+      cleanupBeforeUnloadHandler() {
+        if (typeof window !== "undefined" && this.beforeUnloadHandler) {
+          window.removeEventListener("beforeunload", this.beforeUnloadHandler);
+          window.removeEventListener("pagehide", this.beforeUnloadHandler);
+          this.beforeUnloadHandler = null;
+        }
+      }
+      tryReconnect() {
+        if (this.isReconnecting || this.manualDisconnect) {
+          return;
+        }
+        this.isReconnecting = true;
+        this.scheduleReconnect();
+      }
+      scheduleReconnect() {
+        if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+          console.error("Max reconnect attempts reached. Giving up.");
+          this.isReconnecting = false;
+          this.reconnectAttempts = 0;
+          this.emit(Event.Error, new Error("Reconnection failed."));
+          return;
+        }
+        const delay = this.initialReconnectDelay * Math.pow(2, this.reconnectAttempts);
+        this.reconnectAttempts++;
+        console.log(`Will attempt to reconnect in ${delay / 1e3}s (Attempt ${this.reconnectAttempts}).`);
+        this.emit(Event.Reconnecting, { attempt: this.reconnectAttempts, delay });
+        setTimeout(() => {
+          if (!this.isReconnecting) {
+            console.log("Reconnection aborted.");
+            return;
+          }
+          this.connect().catch(() => {
+            if (this.isReconnecting) {
+              this.scheduleReconnect();
+            }
+          });
+        }, delay);
+      }
+    };
+    exports2.WKIM = WKIM;
+    WKIM.globalInstance = null;
+  }
+});
+
+// miniprogram_dist/core/chatStore.js
+var IMService = require("../services/wukongim");
+var visitorService = require("../services/visitor");
+var historyService = require("../services/messageHistory");
+var chatService = require("../services/chat");
+var uploadService = require("../services/upload");
+var systemInfoAdapter = require("../adapters/systemInfo");
+var types = require("./types");
+var platformStore = require("./platformStore");
+var uidUtil = require("../utils/uid");
+var jsonRenderUtils = require("../utils/jsonRender");
+var offMsg = null;
+var offStatus = null;
+var offCustom = null;
+var streamTimer = null;
+var STREAM_TIMEOUT_MS = 6e4;
+var activeParsers = {};
 function ChatStore() {
   this._state = {
     messages: [],
@@ -37,329 +972,314 @@ function ChatStore() {
     historyError: null,
     earliestSeq: null,
     // identity
-    apiBase: '',
-    platformApiKey: '',
-    myUid: '',
-    channelId: '',
+    apiBase: "",
+    platformApiKey: "",
+    myUid: "",
+    channelId: "",
     channelType: 251,
     // streaming
     isStreaming: false,
     streamCanceling: false,
-    streamingClientMsgNo: ''
-  }
-  this._listeners = []
-  this._throttleTimer = null
-  this._pendingState = null
-}
-
-ChatStore.prototype.getState = function () {
-  return this._state
-}
-
-ChatStore.prototype._setState = function (partial) {
-  Object.assign(this._state, partial)
-  var state = this._state
-  this._listeners.forEach(function (fn) { try { fn(state) } catch (e) {} })
+    streamingClientMsgNo: ""
+  };
+  this._listeners = [];
+  this._throttleTimer = null;
+  this._pendingState = null;
 }
-
-/**
- * Throttled setState for streaming updates (50ms batch).
- * Mutates this._state immediately (so subsequent reads see latest data),
- * but defers listener notification to avoid excessive setData calls.
- */
-ChatStore.prototype._setStateThrottled = function (partial) {
-  var self = this
-  // Apply state mutation immediately so next read sees latest data
-  Object.assign(this._state, partial)
-  // Throttle listener notification
+ChatStore.prototype.getState = function() {
+  return this._state;
+};
+ChatStore.prototype._setState = function(partial) {
+  Object.assign(this._state, partial);
+  var state = this._state;
+  this._listeners.forEach(function(fn) {
+    try {
+      fn(state);
+    } catch (e) {
+    }
+  });
+};
+ChatStore.prototype._setStateThrottled = function(partial) {
+  var self = this;
+  Object.assign(this._state, partial);
   if (!this._throttleTimer) {
-    this._throttleTimer = setTimeout(function () {
-      self._throttleTimer = null
-      var state = self._state
-      self._listeners.forEach(function (fn) { try { fn(state) } catch (e) {} })
-    }, 50)
-  }
-}
-
-ChatStore.prototype.subscribe = function (fn) {
-  this._listeners.push(fn)
-  var self = this
-  return function () {
-    var idx = self._listeners.indexOf(fn)
-    if (idx >= 0) self._listeners.splice(idx, 1)
+    this._throttleTimer = setTimeout(function() {
+      self._throttleTimer = null;
+      var state = self._state;
+      self._listeners.forEach(function(fn) {
+        try {
+          fn(state);
+        } catch (e) {
+        }
+      });
+    }, 50);
   }
-}
-
-// ========== Initialization ==========
-
-ChatStore.prototype.initIM = function (cfg) {
-  if (!cfg || !cfg.apiBase || !cfg.platformApiKey) return Promise.resolve()
-  var self = this
-  var st = this._state
-  if (st.initializing || IMService.isReady()) return Promise.resolve()
-
-  this._setState({ initializing: true, error: null, apiBase: cfg.apiBase, platformApiKey: cfg.platformApiKey })
-
-  var apiBase = cfg.apiBase
-  var platformApiKey = cfg.platformApiKey
-
-  // Load or register visitor
-  var cached = visitorService.loadCachedVisitor(apiBase, platformApiKey)
-  var visitorPromise
+};
+ChatStore.prototype.subscribe = function(fn) {
+  this._listeners.push(fn);
+  var self = this;
+  return function() {
+    var idx = self._listeners.indexOf(fn);
+    if (idx >= 0) self._listeners.splice(idx, 1);
+  };
+};
+ChatStore.prototype.initIM = function(cfg) {
+  if (!cfg || !cfg.apiBase || !cfg.platformApiKey) return Promise.resolve();
+  var self = this;
+  var st = this._state;
+  if (st.initializing || IMService.isReady()) return Promise.resolve();
+  this._setState({ initializing: true, error: null, apiBase: cfg.apiBase, platformApiKey: cfg.platformApiKey });
+  var apiBase = cfg.apiBase;
+  var platformApiKey = cfg.platformApiKey;
+  var cached = visitorService.loadCachedVisitor(apiBase, platformApiKey);
+  var visitorPromise;
   if (cached) {
-    visitorPromise = Promise.resolve(cached)
+    visitorPromise = Promise.resolve(cached);
   } else {
-    var sysInfo = systemInfoAdapter.collectSystemInfo()
+    var sysInfo = systemInfoAdapter.collectSystemInfo();
     visitorPromise = visitorService.registerVisitor({
-      apiBase: apiBase,
-      platformApiKey: platformApiKey,
+      apiBase,
+      platformApiKey,
       extra: sysInfo ? { system_info: sysInfo } : {}
-    }).then(function (res) {
-      visitorService.saveCachedVisitor(apiBase, platformApiKey, res)
-      return visitorService.loadCachedVisitor(apiBase, platformApiKey)
-    })
+    }).then(function(res) {
+      visitorService.saveCachedVisitor(apiBase, platformApiKey, res);
+      return visitorService.loadCachedVisitor(apiBase, platformApiKey);
+    });
   }
-
-  return visitorPromise.then(function (visitor) {
-    var uid = String(visitor.visitor_id || '')
-    var uidForIM = uid.endsWith('-vtr') ? uid : uid + '-vtr'
-    var target = visitor.channel_id
-    var token = visitor.im_token
-
+  return visitorPromise.then(function(visitor) {
+    var uid = String(visitor.visitor_id || "");
+    var uidForIM = uid.endsWith("-vtr") ? uid : uid + "-vtr";
+    var target = visitor.channel_id;
+    var token = visitor.im_token;
     self._setState({
       myUid: uidForIM,
       channelId: target,
       channelType: visitor.channel_type || 251
-    })
-
+    });
     if (!token) {
-      throw new Error('[Chat] Missing im_token from visitor registration')
+      throw new Error("[Chat] Missing im_token from visitor registration");
     }
-
     return IMService.init({
-      apiBase: apiBase,
+      apiBase,
       uid: uidForIM,
-      token: token,
-      target: target,
-      channelType: 'group'
-    })
-  }).then(function () {
-    // Subscribe to IM events
-    self._bindIMEvents()
-    return IMService.connect()
-  }).then(function () {
-    // Load initial history
-    return self.loadInitialHistory(20)
-  }).catch(function (e) {
-    var errMsg = e && e.message ? e.message : String(e)
-    console.error('[Chat] IM initialization failed:', errMsg)
-    self._setState({ error: errMsg, online: false })
-  }).then(function () {
-    self._setState({ initializing: false })
-  })
-}
-
-ChatStore.prototype._bindIMEvents = function () {
-  var self = this
-  var uidForIM = this._state.myUid
-
-  // Status events
-  if (offStatus) { try { offStatus() } catch (e) {} ; offStatus = null }
-  offStatus = IMService.onStatus(function (s) {
-    self._setState({ online: s === 'connected' })
-  })
-
-  // Message events
-  if (offMsg) { try { offMsg() } catch (e) {} ; offMsg = null }
-  offMsg = IMService.onMessage(function (m) {
-    if (!m.fromUid || m.fromUid === uidForIM) return
-
+      token,
+      target,
+      channelType: "group"
+    });
+  }).then(function() {
+    self._bindIMEvents();
+    return IMService.connect();
+  }).then(function() {
+    return self.loadInitialHistory(20);
+  }).catch(function(e) {
+    var errMsg = e && e.message ? e.message : String(e);
+    console.error("[Chat] IM initialization failed:", errMsg);
+    self._setState({ error: errMsg, online: false });
+  }).then(function() {
+    self._setState({ initializing: false });
+  });
+};
+ChatStore.prototype._bindIMEvents = function() {
+  var self = this;
+  var uidForIM = this._state.myUid;
+  if (offStatus) {
+    try {
+      offStatus();
+    } catch (e) {
+    }
+    ;
+    offStatus = null;
+  }
+  offStatus = IMService.onStatus(function(s) {
+    self._setState({ online: s === "connected" });
+  });
+  if (offMsg) {
+    try {
+      offMsg();
+    } catch (e) {
+    }
+    ;
+    offMsg = null;
+  }
+  offMsg = IMService.onMessage(function(m) {
+    if (!m.fromUid || m.fromUid === uidForIM) return;
     var chat = {
       id: String(m.messageId),
-      role: 'agent',
+      role: "agent",
       payload: types.toPayloadFromAny(m && m.payload),
-      time: new Date(m.timestamp * 1000),
-      messageSeq: typeof m.messageSeq === 'number' ? m.messageSeq : undefined,
+      time: new Date(m.timestamp * 1e3),
+      messageSeq: typeof m.messageSeq === "number" ? m.messageSeq : void 0,
       clientMsgNo: m.clientMsgNo,
       fromUid: m.fromUid,
       channelId: m.channelId,
       channelType: m.channelType
-    }
-
-    var currentMessages = self._state.messages
+    };
+    var currentMessages = self._state.messages;
     for (var i = 0; i < currentMessages.length; i++) {
-      if (currentMessages[i].id === chat.id) return
+      if (currentMessages[i].id === chat.id) return;
     }
-
-    // Merge into streaming placeholder if exists
     if (chat.clientMsgNo) {
-      var idx = -1
+      var idx = -1;
       for (var j = 0; j < currentMessages.length; j++) {
         if (currentMessages[j].clientMsgNo && currentMessages[j].clientMsgNo === chat.clientMsgNo) {
-          idx = j
-          break
+          idx = j;
+          break;
         }
       }
       if (idx >= 0) {
-        var next = currentMessages.slice()
-        next[idx] = Object.assign({}, currentMessages[idx], chat, { streamData: undefined })
-        self._setState({ messages: next })
-        return
+        var next = currentMessages.slice();
+        next[idx] = Object.assign({}, currentMessages[idx], chat, { streamData: void 0 });
+        self._setState({ messages: next });
+        return;
       }
     }
-
-    self._setState({ messages: currentMessages.concat([chat]) })
-  })
-
-  // Custom stream events
-  if (offCustom) { try { offCustom() } catch (e) {} ; offCustom = null }
-  offCustom = IMService.onCustom(function (ev) {
+    self._setState({ messages: currentMessages.concat([chat]) });
+  });
+  if (offCustom) {
     try {
-      if (!ev) return
-      var customEvent = ev
-
-      // Parse event data
-      var eventData = null
-      if (customEvent.dataJson && typeof customEvent.dataJson === 'object') {
-        eventData = customEvent.dataJson
-      } else if (typeof customEvent.data === 'string') {
-        try { eventData = JSON.parse(customEvent.data) } catch (e) {}
-      } else if (customEvent.data && typeof customEvent.data === 'object') {
-        eventData = customEvent.data
+      offCustom();
+    } catch (e) {
+    }
+    ;
+    offCustom = null;
+  }
+  offCustom = IMService.onCustom(function(ev) {
+    try {
+      if (!ev) return;
+      var customEvent = ev;
+      var eventData = null;
+      if (customEvent.dataJson && typeof customEvent.dataJson === "object") {
+        eventData = customEvent.dataJson;
+      } else if (typeof customEvent.data === "string") {
+        try {
+          eventData = JSON.parse(customEvent.data);
+        } catch (e) {
+        }
+      } else if (customEvent.data && typeof customEvent.data === "object") {
+        eventData = customEvent.data;
       }
-
-      var newEventType = (eventData && eventData.event_type) || customEvent.type || ''
-      var clientMsgNo = (eventData && eventData.client_msg_no) ? String(eventData.client_msg_no) : (customEvent.id ? String(customEvent.id) : '')
-
-      // --- Stream API v2 ---
-      if (newEventType === 'stream.delta') {
-        if (!clientMsgNo) return
-        var payload = eventData && eventData.payload
-        var delta = payload && payload.delta
+      var newEventType = eventData && eventData.event_type || customEvent.type || "";
+      var clientMsgNo = eventData && eventData.client_msg_no ? String(eventData.client_msg_no) : customEvent.id ? String(customEvent.id) : "";
+      if (newEventType === "stream.delta") {
+        if (!clientMsgNo) return;
+        var payload = eventData && eventData.payload;
+        var delta = payload && payload.delta;
         if (delta) {
-          var parser = activeParsers[clientMsgNo]
+          var parser = activeParsers[clientMsgNo];
           if (!parser) {
             parser = jsonRenderUtils.createMixedStreamParser({
-              onText: function (t) { self.appendMixedPart(clientMsgNo, { type: 'text', text: t + '\n' }) },
-              onPatch: function (p) { self.appendMixedPart(clientMsgNo, { type: 'data-spec', data: { type: 'patch', patch: p } }) }
-            })
-            activeParsers[clientMsgNo] = parser
+              onText: function(t) {
+                self.appendMixedPart(clientMsgNo, { type: "text", text: t + "\n" });
+              },
+              onPatch: function(p) {
+                self.appendMixedPart(clientMsgNo, { type: "data-spec", data: { type: "patch", patch: p } });
+              }
+            });
+            activeParsers[clientMsgNo] = parser;
           }
-          parser.push(String(delta).replace(/([^\n])```spec/g, '$1\n```spec'))
+          parser.push(String(delta).replace(/([^\n])```spec/g, "$1\n```spec"));
         }
-        return
+        return;
       }
-
-      if (newEventType === 'stream.close') {
-        if (!clientMsgNo) return
-        var closeParser = activeParsers[clientMsgNo]
-        if (closeParser) { closeParser.flush(); delete activeParsers[clientMsgNo] }
-        var errMsg = (eventData && eventData.payload && eventData.payload.end_reason > 0) ? '流异常结束' : undefined
-        self.finalizeStreamMessage(clientMsgNo, errMsg)
-        self.markStreamingEnd()
-        return
+      if (newEventType === "stream.close") {
+        if (!clientMsgNo) return;
+        var closeParser = activeParsers[clientMsgNo];
+        if (closeParser) {
+          closeParser.flush();
+          delete activeParsers[clientMsgNo];
+        }
+        var errMsg = eventData && eventData.payload && eventData.payload.end_reason > 0 ? "\u6D41\u5F02\u5E38\u7ED3\u675F" : void 0;
+        self.finalizeStreamMessage(clientMsgNo, errMsg);
+        self.markStreamingEnd();
+        return;
       }
-
-      if (newEventType === 'stream.error') {
-        if (!clientMsgNo) return
-        var errParser = activeParsers[clientMsgNo]
-        if (errParser) { errParser.flush(); delete activeParsers[clientMsgNo] }
-        var errMessage = (eventData && eventData.payload && eventData.payload.error) || '未知错误'
-        self.finalizeStreamMessage(clientMsgNo, errMessage)
-        self.markStreamingEnd()
-        return
+      if (newEventType === "stream.error") {
+        if (!clientMsgNo) return;
+        var errParser = activeParsers[clientMsgNo];
+        if (errParser) {
+          errParser.flush();
+          delete activeParsers[clientMsgNo];
+        }
+        var errMessage = eventData && eventData.payload && eventData.payload.error || "\u672A\u77E5\u9519\u8BEF";
+        self.finalizeStreamMessage(clientMsgNo, errMessage);
+        self.markStreamingEnd();
+        return;
       }
-
-      if (newEventType === 'stream.cancel') {
-        if (!clientMsgNo) return
-        var cancelParser = activeParsers[clientMsgNo]
-        if (cancelParser) { cancelParser.flush(); delete activeParsers[clientMsgNo] }
-        self.finalizeStreamMessage(clientMsgNo)
-        self.markStreamingEnd()
-        return
+      if (newEventType === "stream.cancel") {
+        if (!clientMsgNo) return;
+        var cancelParser = activeParsers[clientMsgNo];
+        if (cancelParser) {
+          cancelParser.flush();
+          delete activeParsers[clientMsgNo];
+        }
+        self.finalizeStreamMessage(clientMsgNo);
+        self.markStreamingEnd();
+        return;
       }
-
-      if (newEventType === 'stream.finish') {
-        return
+      if (newEventType === "stream.finish") {
+        return;
       }
-
-      // --- Legacy event format ---
-      if (customEvent.type === '___TextMessageStart') {
-        var startId = customEvent.id ? String(customEvent.id) : ''
-        if (startId) self.markStreamingStart(startId)
-        return
+      if (customEvent.type === "___TextMessageStart") {
+        var startId = customEvent.id ? String(customEvent.id) : "";
+        if (startId) self.markStreamingStart(startId);
+        return;
       }
-
-      if (customEvent.type === '___TextMessageContent') {
-        var contentId = customEvent.id ? String(customEvent.id) : ''
-        if (!contentId) return
-        var chunk = typeof customEvent.data === 'string' ? customEvent.data : (customEvent.data != null ? String(customEvent.data) : '')
-        if (chunk) self.appendStreamData(contentId, chunk)
-        return
+      if (customEvent.type === "___TextMessageContent") {
+        var contentId = customEvent.id ? String(customEvent.id) : "";
+        if (!contentId) return;
+        var chunk = typeof customEvent.data === "string" ? customEvent.data : customEvent.data != null ? String(customEvent.data) : "";
+        if (chunk) self.appendStreamData(contentId, chunk);
+        return;
       }
-
-      if (customEvent.type === '___TextMessageEnd') {
-        var endId = customEvent.id ? String(customEvent.id) : ''
-        if (!endId) return
-        var endError = customEvent.data ? String(customEvent.data) : undefined
-        self.finalizeStreamMessage(endId, endError)
-        self.markStreamingEnd()
-        return
+      if (customEvent.type === "___TextMessageEnd") {
+        var endId = customEvent.id ? String(customEvent.id) : "";
+        if (!endId) return;
+        var endError = customEvent.data ? String(customEvent.data) : void 0;
+        self.finalizeStreamMessage(endId, endError);
+        self.markStreamingEnd();
+        return;
       }
     } catch (err) {
-      console.error('[Chat] Custom event handler error:', err)
+      console.error("[Chat] Custom event handler error:", err);
     }
-  })
-}
-
-// ========== Send Message ==========
-
-ChatStore.prototype.sendMessage = function (text) {
-  var v = (text || '').trim()
-  if (!v) return Promise.resolve()
-
-  var self = this
-  var clientMsgNo = uidUtil.generateClientMsgNo('cmn')
-  var id = 'u-' + Date.now()
+  });
+};
+ChatStore.prototype.sendMessage = function(text) {
+  var v = (text || "").trim();
+  if (!v) return Promise.resolve();
+  var self = this;
+  var clientMsgNo = uidUtil.generateClientMsgNo("cmn");
+  var id = "u-" + Date.now();
   var msg = {
-    id: id,
-    role: 'user',
+    id,
+    role: "user",
     payload: { type: 1, content: v },
-    time: new Date(),
-    status: 'sending',
-    clientMsgNo: clientMsgNo
-  }
-
-  // Add to messages immediately
-  this._setState({ messages: this._state.messages.concat([msg]) })
-
-  var st = this._state
+    time: /* @__PURE__ */ new Date(),
+    status: "sending",
+    clientMsgNo
+  };
+  this._setState({ messages: this._state.messages.concat([msg]) });
+  var st = this._state;
   if (!st.apiBase || !st.platformApiKey || !st.myUid) {
-    this._updateMessage(id, { status: undefined, errorMessage: 'Not initialized' })
-    return Promise.resolve()
+    this._updateMessage(id, { status: void 0, errorMessage: "Not initialized" });
+    return Promise.resolve();
   }
-
-  // Auto-cancel previous streaming
-  var cancelPromise = st.isStreaming ? this.cancelStreaming('auto_cancel_on_new_send') : Promise.resolve()
-
-  return cancelPromise.then(function () {
-    // Wait for IM ready
+  var cancelPromise = st.isStreaming ? this.cancelStreaming("auto_cancel_on_new_send") : Promise.resolve();
+  return cancelPromise.then(function() {
     if (!IMService.isReady()) {
-      return self._waitForIMReady(10000)
+      return self._waitForIMReady(1e4);
     }
-  }).then(function () {
+  }).then(function() {
     if (!IMService.isReady()) {
-      throw new Error('IM service is not ready')
+      throw new Error("IM service is not ready");
     }
-    return IMService.sendText(v, { clientMsgNo: clientMsgNo })
-  }).then(function (result) {
-    var ReasonCode = require('easyjssdk').ReasonCode
+    return IMService.sendText(v, { clientMsgNo });
+  }).then(function(result) {
+    var ReasonCode = require_cjs().ReasonCode;
     if (result.reasonCode !== ReasonCode.Success) {
-      self._updateMessage(id, { status: undefined, reasonCode: result.reasonCode })
-      return
+      self._updateMessage(id, { status: void 0, reasonCode: result.reasonCode });
+      return;
     }
-
-    // Call chat completion API
     return chatService.sendChatCompletion({
       apiBase: self._state.apiBase,
       platformApiKey: self._state.platformApiKey,
@@ -367,99 +1287,87 @@ ChatStore.prototype.sendMessage = function (text) {
       fromUid: self._state.myUid,
       channelId: self._state.channelId,
       channelType: self._state.channelType
-    }).then(function () {
-      self._updateMessage(id, { status: undefined, reasonCode: result.reasonCode })
-    })
-  }).catch(function (e) {
-    console.error('[Chat] Send failed:', e)
-    self.markStreamingEnd()
-    var ReasonCode = require('easyjssdk').ReasonCode
-    self._updateMessage(id, { status: undefined, reasonCode: ReasonCode.Unknown })
-    self._setState({ error: e && e.message ? e.message : String(e) })
-  })
-}
-
-ChatStore.prototype._waitForIMReady = function (timeoutMs) {
-  var start = Date.now()
-  return new Promise(function (resolve) {
-    var check = function () {
-      if (IMService.isReady() || (Date.now() - start) >= timeoutMs) {
-        resolve()
+    }).then(function() {
+      self._updateMessage(id, { status: void 0, reasonCode: result.reasonCode });
+    });
+  }).catch(function(e) {
+    console.error("[Chat] Send failed:", e);
+    self.markStreamingEnd();
+    var ReasonCode = require_cjs().ReasonCode;
+    self._updateMessage(id, { status: void 0, reasonCode: ReasonCode.Unknown });
+    self._setState({ error: e && e.message ? e.message : String(e) });
+  });
+};
+ChatStore.prototype._waitForIMReady = function(timeoutMs) {
+  var start = Date.now();
+  return new Promise(function(resolve) {
+    var check = function() {
+      if (IMService.isReady() || Date.now() - start >= timeoutMs) {
+        resolve();
       } else {
-        setTimeout(check, 120)
+        setTimeout(check, 120);
       }
-    }
-    check()
-  })
-}
-
-ChatStore.prototype._updateMessage = function (id, partial) {
-  var messages = this._state.messages.map(function (m) {
-    if (m.id === id) return Object.assign({}, m, partial)
-    return m
-  })
-  this._setState({ messages: messages })
-}
-
-// ========== Upload ==========
-
-ChatStore.prototype.uploadImage = function (tempFilePath) {
-  var self = this
-  var st = this._state
+    };
+    check();
+  });
+};
+ChatStore.prototype._updateMessage = function(id, partial) {
+  var messages = this._state.messages.map(function(m) {
+    if (m.id === id) return Object.assign({}, m, partial);
+    return m;
+  });
+  this._setState({ messages });
+};
+ChatStore.prototype.uploadImage = function(tempFilePath) {
+  var self = this;
+  var st = this._state;
   if (!st.apiBase || !st.channelId) {
-    this._setState({ error: '[Upload] Not initialized' })
-    return Promise.resolve()
+    this._setState({ error: "[Upload] Not initialized" });
+    return Promise.resolve();
   }
-
-  var clientMsgNo = uidUtil.generateClientMsgNo('um')
-  var id = 'u-up-' + Date.now() + '-' + Math.random().toString(36).slice(2, 6)
+  var clientMsgNo = uidUtil.generateClientMsgNo("um");
+  var id = "u-up-" + Date.now() + "-" + Math.random().toString(36).slice(2, 6);
   var placeholder = {
-    id: id,
-    role: 'user',
-    payload: { type: 1, content: '图片上传中…' },
-    time: new Date(),
-    status: 'uploading',
+    id,
+    role: "user",
+    payload: { type: 1, content: "\u56FE\u7247\u4E0A\u4F20\u4E2D\u2026" },
+    time: /* @__PURE__ */ new Date(),
+    status: "uploading",
     uploadProgress: 0,
-    clientMsgNo: clientMsgNo
-  }
-  this._setState({ messages: this._state.messages.concat([placeholder]) })
-
-  return uploadService.getImageInfo(tempFilePath).then(function (dims) {
+    clientMsgNo
+  };
+  this._setState({ messages: this._state.messages.concat([placeholder]) });
+  return uploadService.getImageInfo(tempFilePath).then(function(dims) {
     return uploadService.uploadChatFile({
       apiBase: st.apiBase,
       apiKey: st.platformApiKey,
       channelId: st.channelId,
       channelType: st.channelType,
       filePath: tempFilePath,
-      onProgress: function (p) {
-        self._updateMessage(id, { uploadProgress: p })
-      }
-    }).then(function (res) {
-      var w = dims ? Math.max(1, dims.width) : 1
-      var h = dims ? Math.max(1, dims.height) : 1
-      var payload = { type: 2, url: res.file_url, width: w, height: h }
-      self._updateMessage(id, { payload: payload, status: 'sending', uploadProgress: undefined })
-      return IMService.sendPayload(payload, { clientMsgNo: clientMsgNo })
-    }).then(function (result) {
-      self._updateMessage(id, { status: undefined, reasonCode: result && result.reasonCode })
-    })
-  }).catch(function (err) {
-    console.error('[Chat] Upload failed:', err)
-    self._updateMessage(id, { status: undefined, uploadError: err && err.message ? err.message : '上传失败' })
-  })
-}
-
-// ========== History ==========
-
-ChatStore.prototype.loadInitialHistory = function (limit) {
-  limit = limit || 20
-  var self = this
-  var st = this._state
-  if (!st.channelId || !st.channelType) return Promise.resolve()
-  if (st.historyLoading) return Promise.resolve()
-
-  this._setState({ historyLoading: true, historyError: null })
-
+      onProgress: function(p) {
+        self._updateMessage(id, { uploadProgress: p });
+      }
+    }).then(function(res) {
+      var w = dims ? Math.max(1, dims.width) : 1;
+      var h = dims ? Math.max(1, dims.height) : 1;
+      var payload = { type: 2, url: res.file_url, width: w, height: h };
+      self._updateMessage(id, { payload, status: "sending", uploadProgress: void 0 });
+      return IMService.sendPayload(payload, { clientMsgNo });
+    }).then(function(result) {
+      self._updateMessage(id, { status: void 0, reasonCode: result && result.reasonCode });
+    });
+  }).catch(function(err) {
+    console.error("[Chat] Upload failed:", err);
+    self._updateMessage(id, { status: void 0, uploadError: err && err.message ? err.message : "\u4E0A\u4F20\u5931\u8D25" });
+  });
+};
+ChatStore.prototype.loadInitialHistory = function(limit) {
+  limit = limit || 20;
+  var self = this;
+  var st = this._state;
+  if (!st.channelId || !st.channelType) return Promise.resolve();
+  if (st.historyLoading) return Promise.resolve();
+  this._setState({ historyLoading: true, historyError: null });
   return historyService.syncVisitorMessages({
     apiBase: st.apiBase,
     platformApiKey: st.platformApiKey,
@@ -467,58 +1375,50 @@ ChatStore.prototype.loadInitialHistory = function (limit) {
     channelType: st.channelType,
     startSeq: 0,
     endSeq: 0,
-    limit: limit,
+    limit,
     pullMode: 1
-  }).then(function (res) {
-    var myUid = self._state.myUid
-    var list = res.messages.slice().sort(function (a, b) {
-      return (a.message_seq || 0) - (b.message_seq || 0)
-    }).map(function (m) {
-      return types.mapHistoryToChatMessage(m, myUid)
-    })
-
-    // Dedup and prepend
-    var existingSeqs = {}
-    var existingIds = {}
-    self._state.messages.forEach(function (m) {
-      if (typeof m.messageSeq === 'number') existingSeqs[m.messageSeq] = true
-      existingIds[m.id] = true
-    })
-
-    var mergedHead = list.filter(function (m) {
-      if (m.messageSeq != null) return !existingSeqs[m.messageSeq]
-      return !existingIds[m.id]
-    })
-
-    var earliest = self._state.earliestSeq
-    mergedHead.forEach(function (m) {
+  }).then(function(res) {
+    var myUid = self._state.myUid;
+    var list = res.messages.slice().sort(function(a, b) {
+      return (a.message_seq || 0) - (b.message_seq || 0);
+    }).map(function(m) {
+      return types.mapHistoryToChatMessage(m, myUid);
+    });
+    var existingSeqs = {};
+    var existingIds = {};
+    self._state.messages.forEach(function(m) {
+      if (typeof m.messageSeq === "number") existingSeqs[m.messageSeq] = true;
+      existingIds[m.id] = true;
+    });
+    var mergedHead = list.filter(function(m) {
+      if (m.messageSeq != null) return !existingSeqs[m.messageSeq];
+      return !existingIds[m.id];
+    });
+    var earliest = self._state.earliestSeq;
+    mergedHead.forEach(function(m) {
       if (m.messageSeq != null) {
-        if (earliest === null || m.messageSeq < earliest) earliest = m.messageSeq
+        if (earliest === null || m.messageSeq < earliest) earliest = m.messageSeq;
       }
-    })
-
+    });
     self._setState({
       messages: mergedHead.concat(self._state.messages),
       earliestSeq: earliest,
       historyHasMore: res.more === 1
-    })
-  }).catch(function (e) {
-    self._setState({ historyError: e && e.message ? e.message : String(e) })
-  }).then(function () {
-    self._setState({ historyLoading: false })
-  })
-}
-
-ChatStore.prototype.loadMoreHistory = function (limit) {
-  limit = limit || 20
-  var self = this
-  var st = this._state
-  if (!st.channelId || !st.channelType) return Promise.resolve()
-  if (st.historyLoading) return Promise.resolve()
-
-  var start = st.earliestSeq || 0
-  this._setState({ historyLoading: true, historyError: null })
-
+    });
+  }).catch(function(e) {
+    self._setState({ historyError: e && e.message ? e.message : String(e) });
+  }).then(function() {
+    self._setState({ historyLoading: false });
+  });
+};
+ChatStore.prototype.loadMoreHistory = function(limit) {
+  limit = limit || 20;
+  var self = this;
+  var st = this._state;
+  if (!st.channelId || !st.channelType) return Promise.resolve();
+  if (st.historyLoading) return Promise.resolve();
+  var start = st.earliestSeq || 0;
+  this._setState({ historyLoading: true, historyError: null });
   return historyService.syncVisitorMessages({
     apiBase: st.apiBase,
     platformApiKey: st.platformApiKey,
@@ -526,233 +1426,236 @@ ChatStore.prototype.loadMoreHistory = function (limit) {
     channelType: st.channelType,
     startSeq: start,
     endSeq: 0,
-    limit: limit,
+    limit,
     pullMode: 0
-  }).then(function (res) {
-    var myUid = self._state.myUid
-    var listAsc = res.messages.slice().sort(function (a, b) {
-      return (a.message_seq || 0) - (b.message_seq || 0)
-    }).map(function (m) {
-      return types.mapHistoryToChatMessage(m, myUid)
-    })
-
-    var existingSeqs = {}
-    var existingIds = {}
-    self._state.messages.forEach(function (m) {
-      if (typeof m.messageSeq === 'number') existingSeqs[m.messageSeq] = true
-      existingIds[m.id] = true
-    })
-
-    var prepend = listAsc.filter(function (m) {
-      if (m.messageSeq != null) return !existingSeqs[m.messageSeq]
-      return !existingIds[m.id]
-    })
-
-    var earliest = self._state.earliestSeq
-    prepend.forEach(function (m) {
+  }).then(function(res) {
+    var myUid = self._state.myUid;
+    var listAsc = res.messages.slice().sort(function(a, b) {
+      return (a.message_seq || 0) - (b.message_seq || 0);
+    }).map(function(m) {
+      return types.mapHistoryToChatMessage(m, myUid);
+    });
+    var existingSeqs = {};
+    var existingIds = {};
+    self._state.messages.forEach(function(m) {
+      if (typeof m.messageSeq === "number") existingSeqs[m.messageSeq] = true;
+      existingIds[m.id] = true;
+    });
+    var prepend = listAsc.filter(function(m) {
+      if (m.messageSeq != null) return !existingSeqs[m.messageSeq];
+      return !existingIds[m.id];
+    });
+    var earliest = self._state.earliestSeq;
+    prepend.forEach(function(m) {
       if (m.messageSeq != null) {
-        if (earliest === null || m.messageSeq < earliest) earliest = m.messageSeq
+        if (earliest === null || m.messageSeq < earliest) earliest = m.messageSeq;
       }
-    })
-
+    });
     self._setState({
       messages: prepend.concat(self._state.messages),
       earliestSeq: earliest,
       historyHasMore: res.more === 1
-    })
-  }).catch(function (e) {
-    self._setState({ historyError: e && e.message ? e.message : String(e) })
-  }).then(function () {
-    self._setState({ historyLoading: false })
-  })
-}
-
-// ========== Streaming ==========
-
-ChatStore.prototype.markStreamingStart = function (clientMsgNo) {
-  if (!clientMsgNo) return
-  if (streamTimer) { try { clearTimeout(streamTimer) } catch (e) {} ; streamTimer = null }
-  var self = this
-  this._setState({ isStreaming: true, streamCanceling: false, streamingClientMsgNo: clientMsgNo })
-  streamTimer = setTimeout(function () {
-    var s = self._state
+    });
+  }).catch(function(e) {
+    self._setState({ historyError: e && e.message ? e.message : String(e) });
+  }).then(function() {
+    self._setState({ historyLoading: false });
+  });
+};
+ChatStore.prototype.markStreamingStart = function(clientMsgNo) {
+  if (!clientMsgNo) return;
+  if (streamTimer) {
+    try {
+      clearTimeout(streamTimer);
+    } catch (e) {
+    }
+    ;
+    streamTimer = null;
+  }
+  var self = this;
+  this._setState({ isStreaming: true, streamCanceling: false, streamingClientMsgNo: clientMsgNo });
+  streamTimer = setTimeout(function() {
+    var s = self._state;
     if (s.isStreaming && s.streamingClientMsgNo === clientMsgNo) {
-      self._setState({ isStreaming: false, streamingClientMsgNo: '', streamCanceling: false })
+      self._setState({ isStreaming: false, streamingClientMsgNo: "", streamCanceling: false });
     }
-  }, STREAM_TIMEOUT_MS)
-}
-
-ChatStore.prototype.markStreamingEnd = function () {
-  if (streamTimer) { try { clearTimeout(streamTimer) } catch (e) {} ; streamTimer = null }
-  this._setState({ isStreaming: false, streamCanceling: false, streamingClientMsgNo: '' })
-}
-
-ChatStore.prototype.cancelStreaming = function (reason) {
-  var self = this
-  var st = this._state
-  if (st.streamCanceling) return Promise.resolve()
-
-  this._setState({ streamCanceling: true })
-
+  }, STREAM_TIMEOUT_MS);
+};
+ChatStore.prototype.markStreamingEnd = function() {
+  if (streamTimer) {
+    try {
+      clearTimeout(streamTimer);
+    } catch (e) {
+    }
+    ;
+    streamTimer = null;
+  }
+  this._setState({ isStreaming: false, streamCanceling: false, streamingClientMsgNo: "" });
+};
+ChatStore.prototype.cancelStreaming = function(reason) {
+  var self = this;
+  var st = this._state;
+  if (st.streamCanceling) return Promise.resolve();
+  this._setState({ streamCanceling: true });
   if (!st.apiBase || !st.streamingClientMsgNo || !st.platformApiKey) {
-    this.markStreamingEnd()
-    return Promise.resolve()
+    this.markStreamingEnd();
+    return Promise.resolve();
   }
-
   return chatService.cancelStreaming({
     apiBase: st.apiBase,
     platformApiKey: st.platformApiKey,
     clientMsgNo: st.streamingClientMsgNo,
-    reason: reason || 'user_cancel'
-  }).catch(function (e) {
-    console.warn('[Chat] Cancel streaming error:', e)
-  }).then(function () {
-    self.markStreamingEnd()
-  })
-}
-
-ChatStore.prototype.appendStreamData = function (clientMsgNo, data) {
-  if (!clientMsgNo || !data) return
-
-  var messages = this._state.messages
-  var found = false
-  var updated = messages.map(function (m) {
+    reason: reason || "user_cancel"
+  }).catch(function(e) {
+    console.warn("[Chat] Cancel streaming error:", e);
+  }).then(function() {
+    self.markStreamingEnd();
+  });
+};
+ChatStore.prototype.appendStreamData = function(clientMsgNo, data) {
+  if (!clientMsgNo || !data) return;
+  var messages = this._state.messages;
+  var found = false;
+  var updated = messages.map(function(m) {
     if (m.clientMsgNo && m.clientMsgNo === clientMsgNo) {
-      found = true
-      return Object.assign({}, m, { streamData: (m.streamData || '') + data })
+      found = true;
+      return Object.assign({}, m, { streamData: (m.streamData || "") + data });
     }
-    return m
-  })
-
+    return m;
+  });
   if (!found) {
     var placeholder = {
-      id: 'stream-' + clientMsgNo,
-      role: 'agent',
-      payload: { type: 1, content: '' },
-      time: new Date(),
-      clientMsgNo: clientMsgNo,
+      id: "stream-" + clientMsgNo,
+      role: "agent",
+      payload: { type: 1, content: "" },
+      time: /* @__PURE__ */ new Date(),
+      clientMsgNo,
       streamData: data
-    }
-    updated = messages.concat([placeholder])
+    };
+    updated = messages.concat([placeholder]);
   }
-
-  this._setStateThrottled({ messages: updated })
-
+  this._setStateThrottled({ messages: updated });
   if (!this._state.isStreaming) {
-    this.markStreamingStart(clientMsgNo)
+    this.markStreamingStart(clientMsgNo);
   }
-}
-
-ChatStore.prototype.appendMixedPart = function (clientMsgNo, part) {
-  if (!clientMsgNo) return
-
-  var messages = this._state.messages
-  var found = false
-  var updated = messages.map(function (m) {
+};
+ChatStore.prototype.appendMixedPart = function(clientMsgNo, part) {
+  if (!clientMsgNo) return;
+  var messages = this._state.messages;
+  var found = false;
+  var updated = messages.map(function(m) {
     if (m.clientMsgNo && m.clientMsgNo === clientMsgNo) {
-      found = true
-      var parts = (m.uiParts || []).slice()
-      // Merge consecutive text parts
-      if (part.type === 'text' && parts.length > 0) {
-        var last = parts[parts.length - 1]
-        if (last.type === 'text') {
-          parts[parts.length - 1] = { type: 'text', text: (last.text || '') + (part.text || '') }
-          var textContent = ''
+      found = true;
+      var parts = (m.uiParts || []).slice();
+      if (part.type === "text" && parts.length > 0) {
+        var last = parts[parts.length - 1];
+        if (last.type === "text") {
+          parts[parts.length - 1] = { type: "text", text: (last.text || "") + (part.text || "") };
+          var textContent = "";
           for (var i = 0; i < parts.length; i++) {
-            if (parts[i].type === 'text') textContent += parts[i].text || ''
+            if (parts[i].type === "text") textContent += parts[i].text || "";
           }
-          return Object.assign({}, m, { uiParts: parts, streamData: textContent })
+          return Object.assign({}, m, { uiParts: parts, streamData: textContent });
         }
       }
-      parts.push(part)
-      var tc = ''
+      parts.push(part);
+      var tc = "";
       for (var j = 0; j < parts.length; j++) {
-        if (parts[j].type === 'text') tc += parts[j].text || ''
+        if (parts[j].type === "text") tc += parts[j].text || "";
       }
-      return Object.assign({}, m, { uiParts: parts, streamData: tc })
+      return Object.assign({}, m, { uiParts: parts, streamData: tc });
     }
-    return m
-  })
-
+    return m;
+  });
   if (!found) {
-    var initParts = [part]
+    var initParts = [part];
     var placeholder = {
-      id: 'stream-' + clientMsgNo,
-      role: 'agent',
-      payload: { type: 1, content: '' },
-      time: new Date(),
-      clientMsgNo: clientMsgNo,
+      id: "stream-" + clientMsgNo,
+      role: "agent",
+      payload: { type: 1, content: "" },
+      time: /* @__PURE__ */ new Date(),
+      clientMsgNo,
       uiParts: initParts,
-      streamData: part.type === 'text' ? (part.text || '') : ''
-    }
-    updated = messages.concat([placeholder])
+      streamData: part.type === "text" ? part.text || "" : ""
+    };
+    updated = messages.concat([placeholder]);
   }
-
-  this._setStateThrottled({ messages: updated })
-
+  this._setStateThrottled({ messages: updated });
   if (!this._state.isStreaming) {
-    this.markStreamingStart(clientMsgNo)
+    this.markStreamingStart(clientMsgNo);
   }
-}
-
-ChatStore.prototype.finalizeStreamMessage = function (clientMsgNo, errorMessage) {
-  if (!clientMsgNo) return
-
-  var messages = this._state.messages.map(function (m) {
+};
+ChatStore.prototype.finalizeStreamMessage = function(clientMsgNo, errorMessage) {
+  if (!clientMsgNo) return;
+  var messages = this._state.messages.map(function(m) {
     if (m.clientMsgNo && m.clientMsgNo === clientMsgNo) {
-      var finalPayload = m.streamData
-        ? { type: 1, content: m.streamData }
-        : m.payload
+      var finalPayload = m.streamData ? { type: 1, content: m.streamData } : m.payload;
       var result = Object.assign({}, m, {
         payload: finalPayload,
-        streamData: undefined,
-        errorMessage: errorMessage || undefined
-      })
-      // Preserve uiParts for json-render
-      if (m.uiParts) result.uiParts = m.uiParts
-      return result
+        streamData: void 0,
+        errorMessage: errorMessage || void 0
+      });
+      if (m.uiParts) result.uiParts = m.uiParts;
+      return result;
     }
-    return m
-  })
-
-  this._setState({ messages: messages })
-
+    return m;
+  });
+  this._setState({ messages });
   if (this._state.streamingClientMsgNo === clientMsgNo) {
-    this.markStreamingEnd()
+    this.markStreamingEnd();
   }
-}
-
-ChatStore.prototype.ensureWelcomeMessage = function (text) {
-  var t = (text || '').trim()
-  if (!t) return
-
-  var messages = this._state.messages
-  var idx = -1
+};
+ChatStore.prototype.ensureWelcomeMessage = function(text) {
+  var t = (text || "").trim();
+  if (!t) return;
+  var messages = this._state.messages;
+  var idx = -1;
   for (var i = 0; i < messages.length; i++) {
-    if (messages[i].id === 'welcome') { idx = i; break }
+    if (messages[i].id === "welcome") {
+      idx = i;
+      break;
+    }
   }
-
   if (idx >= 0) {
-    var next = messages.slice()
-    next[idx] = Object.assign({}, messages[idx], { payload: { type: 1, content: t } })
-    this._setState({ messages: next })
+    var next = messages.slice();
+    next[idx] = Object.assign({}, messages[idx], { payload: { type: 1, content: t } });
+    this._setState({ messages: next });
   } else {
     var welcome = {
-      id: 'welcome',
-      role: 'agent',
+      id: "welcome",
+      role: "agent",
       payload: { type: 1, content: t },
-      time: new Date()
+      time: /* @__PURE__ */ new Date()
+    };
+    this._setState({ messages: [welcome].concat(messages) });
+  }
+};
+ChatStore.prototype.disconnect = function() {
+  if (offMsg) {
+    try {
+      offMsg();
+    } catch (e) {
     }
-    this._setState({ messages: [welcome].concat(messages) })
+    ;
+    offMsg = null;
   }
-}
-
-ChatStore.prototype.disconnect = function () {
-  if (offMsg) { try { offMsg() } catch (e) {} ; offMsg = null }
-  if (offStatus) { try { offStatus() } catch (e) {} ; offStatus = null }
-  if (offCustom) { try { offCustom() } catch (e) {} ; offCustom = null }
-  this.markStreamingEnd()
-  IMService.disconnect()
-}
-
-module.exports = new ChatStore()
+  if (offStatus) {
+    try {
+      offStatus();
+    } catch (e) {
+    }
+    ;
+    offStatus = null;
+  }
+  if (offCustom) {
+    try {
+      offCustom();
+    } catch (e) {
+    }
+    ;
+    offCustom = null;
+  }
+  this.markStreamingEnd();
+  IMService.disconnect();
+};
+module.exports = new ChatStore();