fmode-ng 0.0.243 → 0.0.245

package/esm2022/lib/core/agent/chat/message/message-manager.mjs

@@ -9,8 +9,17 @@ export class MessageManager {
     constructor(options) {
         this._messageList = []; // 统一的消息列表
         this._isLoaded = false;
+        options.limitHistory = options?.limitHistory || 10;
         this.options = options;
     }
+    getCompanyPointer() {
+        let cid = this.options?.company?.objectId || this.options?.company?.id || localStorage.getItem("company");
+        return {
+            __type: "Pointer",
+            className: "Company",
+            objectId: cid
+        };
+    }
     /**
      * 获取统一的消息列表
      */
@@ -55,43 +64,34 @@ export class MessageManager {
             messageObj.set("status", "sent");
             messageObj.set("createdAt", message.createdAt || new Date());
             messageObj.set("complete", message.complete || false);
-            // 设置内容
-            if (message.content) {
-                if (typeof message.content === "string") {
-                    messageObj.set("content", {
-                        type: "text",
-                        text: message.content
-                    });
-                }
-                else if (Array.isArray(message.content)) {
-                    messageObj.set("content", {
-                        type: "mixed",
-                        items: message.content
-                    });
-                }
-                else {
-                    messageObj.set("content", message.content);
-                }
-            }
-            // 设置角色
+            // 设置消息角色（user/assistant/system）- 这是消息的发送者角色
             if (message.role) {
-                messageObj.set("role", message.role);
+                messageObj.set("role", this.options.role.toPointer());
+            }
+            // 设置内容 - 保持原始格式兼容（string 或 Array）
+            // 同时扩展存储格式，支持更多元数据
+            if (message.content !== undefined) {
+                messageObj.set("content", message);
             }
-            // 设置其他属性
-            if (message.json)
-                messageObj.set("json", message.json);
-            if (message.hidden)
-                messageObj.set("hidden", message.hidden);
-            if (message.voice)
-                messageObj.set("voice", message.voice);
-            if (message.cid)
-                messageObj.set("cid", message.cid);
             // 根据场景设置关联对象
+            // avatarRole：指向 AvatarRole 表的指针（智能体角色）
             if (targetScene === MessageScene.ROLE && this.options.role) {
-                messageObj.set("role", this.options.role.toPointer());
+                messageObj.set("avatarRole", this.options.role.toPointer());
             }
+            // company：指向 Company 表的指针
             if (this.options.company) {
-                messageObj.set("company", this.options.company.toPointer());
+                messageObj.set("company", this.getCompanyPointer());
+            }
+            // 关键：如果chatSession已存在且有id，立即关联
+            // 如果chatSession还没有id（新会话），标记为待关联
+            if (this.options.chatSession) {
+                if (this.options.chatSession.id) {
+                    messageObj.set("session", this.options.chatSession.toPointer());
+                }
+                else {
+                    // 新会话，标记待关联，等待session保存后再关联
+                    messageObj.set("_pendingSession", true);
+                }
             }
             // 直接添加到列表末尾
             this._messageList.push(messageObj);
@@ -104,50 +104,90 @@ export class MessageManager {
     }
     /**
      * 异步保存消息对象
+     * 增强版：处理session关联和延迟保存
      */
     async saveMessage(messageObj) {
-        if (!messageObj.id) {
-            try {
-                await messageObj.save();
+        if (!messageObj)
+            return;
+        try {
+            // 检查是否需要关联session（对于新会话的消息）
+            if (!messageObj.get("session") && this.options.chatSession?.id) {
+                messageObj.set("session", this.options.chatSession.toPointer());
+            }
+            // 确保消息有关联的session才保存到Message表
+            // 如果没有session且不是老消息转换的，先不保存（只存在于内存）
+            if (!messageObj.get("session") && !messageObj.get("isLegacy")) {
+                // 没有session的消息暂时不保存到Message表
+                // 等session创建后会再次调用saveMessage
+                console.log("消息等待session创建后保存");
+                return;
             }
-            catch (error) {
-                console.error("保存消息对象失败:", error);
+            await messageObj.save();
+        }
+        catch (error) {
+            console.error("保存消息对象失败:", error);
+        }
+    }
+    /**
+     * 在session创建/更新后，保存所有待关联的消息
+     * 关键方法：在chatSession保存成功后调用
+     */
+    async savePendingMessages() {
+        if (!this.options.chatSession?.id) {
+            console.warn("session未保存，无法保存待处理消息");
+            return;
+        }
+        const savePromises = [];
+        for (const messageObj of this._messageList) {
+            // 处理待关联的消息
+            // if (messageObj.get("_pendingSession")) {
+            messageObj.set("session", messageObj?.get("session") || this.options.chatSession.toPointer());
+            // messageObj.set("_pendingSession", undefined);
+            // }
+            // 保存所有没有id的消息（新消息）
+            if (!messageObj.id) {
+                if (!messageObj?.get("hidden")) {
+                    savePromises.push(this.saveMessage(messageObj));
+                }
             }
         }
+        if (savePromises.length > 0) {
+            await Promise.all(savePromises);
+            console.log(`保存了 ${savePromises.length} 条待处理消息`);
+        }
+    }
+    /**
+     * 更新chatSession引用（当新会话第一次保存后）
+     */
+    updateChatSession(chatSession) {
+        this.options.chatSession = chatSession;
     }
     /**
      * 更新消息（优化版）
-     * 直接通过下标更新消息对象属性
+     * 直接通过下标更新消息对象属性，返回是否成功
      */
     updateMessage(index, message) {
         if (index < 0 || index >= this._messageList.length)
-            return;
+            return null;
         const messageObj = this._messageList[index];
         if (!messageObj)
-            return;
-        // 更新内容
+            return null;
+        // 更新消息角色
+        if (message.role) {
+            messageObj.set("role", this.options.role.toPointer());
+        }
+        // 更新内容 - 保持原始格式兼容
+        // 从现有 content 中获取完整的 FmodeChatMessage 对象，然后更新字段
         if (message.content !== undefined) {
-            if (typeof message.content === "string") {
-                messageObj.set("content", {
-                    type: "text",
-                    text: message.content
-                });
-            }
-            else if (Array.isArray(message.content)) {
-                messageObj.set("content", {
-                    type: "mixed",
-                    items: message.content
-                });
-            }
-            else {
-                messageObj.set("content", message.content);
-            }
+            const existingContent = messageObj.get("content") || {};
+            messageObj.set("content", {
+                ...existingContent,
+                content: message.content
+            });
         }
         // 更新其他属性
         if (message.complete !== undefined)
             messageObj.set("complete", message.complete);
-        if (message.role)
-            messageObj.set("role", message.role);
         if (message.json)
             messageObj.set("json", message.json);
         if (message.hidden)
@@ -156,6 +196,16 @@ export class MessageManager {
             messageObj.set("voice", message.voice);
         if (message.cid)
             messageObj.set("cid", message.cid);
+        return messageObj;
+    }
+    /**
+     * 更新消息并异步保存
+     */
+    async updateMessageAndSave(index, message) {
+        const messageObj = this.updateMessage(index, message);
+        if (!messageObj?.get("hidden")) {
+            await this.saveMessage(messageObj);
+        }
     }
     /**
      * 重新加载消息
@@ -178,20 +228,35 @@ export class MessageManager {
                 const MessageClass = Parse.Object.extend("Message");
                 const messageObj = new MessageClass();
                 // 复制老版消息属性
-                messageObj.set("role", legacyMsg.role);
+                messageObj.set("role", this.options.role.toPointer());
                 messageObj.set("content", legacyMsg.content);
                 messageObj.set("complete", legacyMsg.complete);
                 messageObj.set("createdAt", legacyMsg.createdAt);
                 messageObj.set("voice", legacyMsg.voice);
                 messageObj.set("cid", legacyMsg.cid);
                 messageObj.set("isLegacy", true);
+                // 为老消息同步创建 contentData，保持格式统一
+                if (typeof legacyMsg.content === "string") {
+                    messageObj.set("contentData", {
+                        type: "text",
+                        text: legacyMsg.content,
+                        role: legacyMsg.role
+                    });
+                }
+                else if (Array.isArray(legacyMsg.content)) {
+                    messageObj.set("contentData", {
+                        type: "mixed",
+                        items: legacyMsg.content,
+                        role: legacyMsg.role
+                    });
+                }
                 this._messageList.push(messageObj);
             }
             // 2. 加载新版消息
             let newMessages = [];
             switch (this.options.scene) {
                 case MessageScene.ROLE:
-                    if (this.options.chatSession) {
+                    if (this.options.role) {
                         newMessages = await this.loadRoleMessages();
                     }
                     break;
@@ -224,10 +289,11 @@ export class MessageManager {
      * 加载角色对话消息
      */
     async loadRoleMessages() {
-        if (!this.options.chatSession)
+        if (!this.options.role?.id)
             return [];
         const query = new Parse.Query("Message");
-        query.equalTo("session", this.options.chatSession);
+        query.exists("content");
+        query.equalTo("role", this.options.role?.id);
         query.addAscending("createdAt");
         query.limit(1000); // 限制数量避免性能问题
         return await query.find();
@@ -239,6 +305,7 @@ export class MessageManager {
         if (!this.options.group)
             return [];
         const query = new Parse.Query("Message");
+        query.exists("content");
         query.equalTo("group", this.options.group);
         query.addAscending("createdAt");
         query.limit(1000);
@@ -251,6 +318,7 @@ export class MessageManager {
         if (!this.options.userFrom || !this.options.userTo)
             return [];
         const query = new Parse.Query("Message");
+        query.exists("content");
         query.containedIn("userFrom", [this.options.userFrom, this.options.userTo]);
         query.containedIn("userTo", [this.options.userFrom, this.options.userTo]);
         query.addAscending("createdAt");
@@ -264,6 +332,7 @@ export class MessageManager {
         if (!this.options.contact)
             return [];
         const query = new Parse.Query("Message");
+        query.exists("content");
         query.equalTo("contact", this.options.contact);
         query.addAscending("createdAt");
         query.limit(1000);
@@ -321,4 +390,4 @@ export class MessageManager {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message-manager.js","sourceRoot":"","sources":["../../../../../../../../projects/fmode-ng/src/lib/core/agent/chat/message/message-manager.ts"],"names":[],"mappings":"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","sourcesContent":["import { FmodeObject, FmodeParse } from \"../../../../core/parse\";\r\nimport { FmodeChatMessage } from \"../interface\";\r\nimport { MessageScene } from \"./message\";\r\nconst Parse = FmodeParse.with(\"nova\");\r\n\r\n/**\r\n * MessageManagerOptions - 消息管理器配置\r\n */\r\nexport interface MessageManagerOptions {\r\n    chatSession?: FmodeObject;     // 可选的会话对象（智能体对话场景）\r\n    role?: FmodeObject;            // 可选的角色对象（智能体对话场景）\r\n    company: FmodeObject;          // 必需的企业对象\r\n    group?: FmodeObject;          // 群聊对象（群聊场景）\r\n    userFrom?: FmodeObject;       // 发送者（私聊场景）\r\n    userTo?: FmodeObject;         // 接收者（私聊场景）\r\n    contact?: FmodeObject;        // 联系人（客服场景）\r\n    scene?: MessageScene;         // 消息场景\r\n}\r\n\r\n/**\r\n * MessageManager - 优化版消息管理器\r\n * 职责：统一管理消息列表，支持高效的增量更新和下标访问\r\n */\r\nexport class MessageManager {\r\n    private options: MessageManagerOptions;\r\n    private _messageList: FmodeObject[] = []; // 统一的消息列表\r\n    private _isLoaded: boolean = false;\r\n\r\n    constructor(options: MessageManagerOptions) {\r\n        this.options = options;\r\n    }\r\n\r\n    /**\r\n     * 获取统一的消息列表\r\n     */\r\n    async getMessages(): Promise<FmodeObject[]> {\r\n        if (!this._isLoaded) {\r\n            await this.loadMessages();\r\n            this._isLoaded = true;\r\n        }\r\n        return [...this._messageList];\r\n    }\r\n\r\n    /**\r\n     * 获取缓存的消息列表（同步方法，用于组件绑定）\r\n     * 直接返回当前消息列表，不进行异步加载\r\n     */\r\n    getCachedMessages(): FmodeObject[] {\r\n        return [...this._messageList];\r\n    }\r\n\r\n    /**\r\n     * 直接访问消息列表（用于下标访问）\r\n     */\r\n    getMessageList(): FmodeObject[] {\r\n        return this._messageList;\r\n    }\r\n\r\n    /**\r\n     * 通过下标获取消息\r\n     */\r\n    getMessage(index: number): FmodeObject | undefined {\r\n        return this._messageList[index];\r\n    }\r\n\r\n    /**\r\n     * 添加新消息（优化版）\r\n     * 直接创建FmodeObject并添加到列表末尾，延迟保存\r\n     */\r\n    addMessage(message: FmodeChatMessage, scene?: MessageScene): FmodeObject {\r\n        const targetScene = scene || this.options.scene || MessageScene.ROLE;\r\n\r\n        try {\r\n            // 创建新的消息对象（未保存）\r\n            const MessageClass = Parse.Object.extend(\"Message\");\r\n            const messageObj = new MessageClass();\r\n\r\n            // 设置基本信息\r\n            messageObj.set(\"scene\", targetScene);\r\n            messageObj.set(\"status\", \"sent\");\r\n            messageObj.set(\"createdAt\", message.createdAt || new Date());\r\n            messageObj.set(\"complete\", message.complete || false);\r\n\r\n            // 设置内容\r\n            if (message.content) {\r\n                if (typeof message.content === \"string\") {\r\n                    messageObj.set(\"content\", {\r\n                        type: \"text\",\r\n                        text: message.content\r\n                    });\r\n                } else if (Array.isArray(message.content)) {\r\n                    messageObj.set(\"content\", {\r\n                        type: \"mixed\",\r\n                        items: message.content\r\n                    });\r\n                } else {\r\n                    messageObj.set(\"content\", message.content);\r\n                }\r\n            }\r\n\r\n            // 设置角色\r\n            if (message.role) {\r\n                messageObj.set(\"role\", message.role);\r\n            }\r\n\r\n            // 设置其他属性\r\n            if (message.json) messageObj.set(\"json\", message.json);\r\n            if (message.hidden) messageObj.set(\"hidden\", message.hidden);\r\n            if (message.voice) messageObj.set(\"voice\", message.voice);\r\n            if (message.cid) messageObj.set(\"cid\", message.cid);\r\n\r\n            // 根据场景设置关联对象\r\n            if (targetScene === MessageScene.ROLE && this.options.role) {\r\n                messageObj.set(\"role\", this.options.role.toPointer());\r\n            }\r\n            if (this.options.company) {\r\n                messageObj.set(\"company\", this.options.company.toPointer());\r\n            }\r\n\r\n            // 直接添加到列表末尾\r\n            this._messageList.push(messageObj);\r\n\r\n            return messageObj;\r\n        } catch (error) {\r\n            console.error(\"创建新消息失败:\", error);\r\n            throw error;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * 异步保存消息对象\r\n     */\r\n    async saveMessage(messageObj: FmodeObject): Promise<void> {\r\n        if (!messageObj.id) {\r\n            try {\r\n                await messageObj.save();\r\n            } catch (error) {\r\n                console.error(\"保存消息对象失败:\", error);\r\n            }\r\n        }\r\n    }\r\n\r\n    /**\r\n     * 更新消息（优化版）\r\n     * 直接通过下标更新消息对象属性\r\n     */\r\n    updateMessage(index: number, message: Partial<FmodeChatMessage>): void {\r\n        if (index < 0 || index >= this._messageList.length) return;\r\n\r\n        const messageObj = this._messageList[index];\r\n        if (!messageObj) return;\r\n\r\n        // 更新内容\r\n        if (message.content !== undefined) {\r\n            if (typeof message.content === \"string\") {\r\n                messageObj.set(\"content\", {\r\n                    type: \"text\",\r\n                    text: message.content\r\n                });\r\n            } else if (Array.isArray(message.content)) {\r\n                messageObj.set(\"content\", {\r\n                    type: \"mixed\",\r\n                    items: message.content\r\n                });\r\n            } else {\r\n                messageObj.set(\"content\", message.content);\r\n            }\r\n        }\r\n\r\n        // 更新其他属性\r\n        if (message.complete !== undefined) messageObj.set(\"complete\", message.complete);\r\n        if (message.role) messageObj.set(\"role\", message.role);\r\n        if (message.json) messageObj.set(\"json\", message.json);\r\n        if (message.hidden) messageObj.set(\"hidden\", message.hidden);\r\n        if (message.voice) messageObj.set(\"voice\", message.voice);\r\n        if (message.cid) messageObj.set(\"cid\", message.cid);\r\n    }\r\n\r\n    /**\r\n     * 重新加载消息\r\n     */\r\n    async reloadMessages(): Promise<void> {\r\n        this._messageList = [];\r\n        this._isLoaded = false;\r\n        await this.getMessages(); // 触发重新加载\r\n    }\r\n\r\n    /**\r\n     * 加载消息（优化版）\r\n     */\r\n    private async loadMessages(): Promise<void> {\r\n        this._messageList = [];\r\n\r\n        try {\r\n            // 1. 首先加载老版消息（如果有）\r\n            const legacyMessages = this.options.chatSession?.get(\"messageList\") || [];\r\n\r\n            // 转换老版消息为FmodeObject（仅用于展示）\r\n            for (const legacyMsg of legacyMessages) {\r\n                const MessageClass = Parse.Object.extend(\"Message\");\r\n                const messageObj = new MessageClass();\r\n\r\n                // 复制老版消息属性\r\n                messageObj.set(\"role\", legacyMsg.role);\r\n                messageObj.set(\"content\", legacyMsg.content);\r\n                messageObj.set(\"complete\", legacyMsg.complete);\r\n                messageObj.set(\"createdAt\", legacyMsg.createdAt);\r\n                messageObj.set(\"voice\", legacyMsg.voice);\r\n                messageObj.set(\"cid\", legacyMsg.cid);\r\n                messageObj.set(\"isLegacy\", true);\r\n\r\n                this._messageList.push(messageObj);\r\n            }\r\n\r\n            // 2. 加载新版消息\r\n            let newMessages: FmodeObject[] = [];\r\n\r\n            switch (this.options.scene) {\r\n                case MessageScene.ROLE:\r\n                    if (this.options.chatSession) {\r\n                        newMessages = await this.loadRoleMessages();\r\n                    }\r\n                    break;\r\n                case MessageScene.GROUP:\r\n                    if (this.options.group) {\r\n                        newMessages = await this.loadGroupMessages();\r\n                    }\r\n                    break;\r\n                case MessageScene.USER:\r\n                    if (this.options.userFrom && this.options.userTo) {\r\n                        newMessages = await this.loadUserMessages();\r\n                    }\r\n                    break;\r\n                case MessageScene.SERVICE:\r\n                    if (this.options.contact) {\r\n                        newMessages = await this.loadServiceMessages();\r\n                    }\r\n                    break;\r\n                default:\r\n                    newMessages = [];\r\n            }\r\n\r\n            // 3. 将新消息添加到列表末尾\r\n            this._messageList.push(...newMessages);\r\n\r\n        } catch (error) {\r\n            console.error(\"加载消息失败:\", error);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * 加载角色对话消息\r\n     */\r\n    private async loadRoleMessages(): Promise<FmodeObject[]> {\r\n        if (!this.options.chatSession) return [];\r\n\r\n        const query = new Parse.Query(\"Message\");\r\n        query.equalTo(\"session\", this.options.chatSession);\r\n        query.addAscending(\"createdAt\");\r\n        query.limit(1000); // 限制数量避免性能问题\r\n\r\n        return await query.find();\r\n    }\r\n\r\n    /**\r\n     * 加载群聊消息（简化版）\r\n     */\r\n    private async loadGroupMessages(): Promise<FmodeObject[]> {\r\n        if (!this.options.group) return [];\r\n\r\n        const query = new Parse.Query(\"Message\");\r\n        query.equalTo(\"group\", this.options.group);\r\n        query.addAscending(\"createdAt\");\r\n        query.limit(1000);\r\n\r\n        return await query.find();\r\n    }\r\n\r\n    /**\r\n     * 加载私聊消息（简化版）\r\n     */\r\n    private async loadUserMessages(): Promise<FmodeObject[]> {\r\n        if (!this.options.userFrom || !this.options.userTo) return [];\r\n\r\n        const query = new Parse.Query(\"Message\");\r\n        query.containedIn(\"userFrom\", [this.options.userFrom, this.options.userTo]);\r\n        query.containedIn(\"userTo\", [this.options.userFrom, this.options.userTo]);\r\n        query.addAscending(\"createdAt\");\r\n        query.limit(1000);\r\n\r\n        return await query.find();\r\n    }\r\n\r\n    /**\r\n     * 加载客服消息（简化版）\r\n     */\r\n    private async loadServiceMessages(): Promise<FmodeObject[]> {\r\n        if (!this.options.contact) return [];\r\n\r\n        const query = new Parse.Query(\"Message\");\r\n        query.equalTo(\"contact\", this.options.contact);\r\n        query.addAscending(\"createdAt\");\r\n        query.limit(1000);\r\n\r\n        return await query.find();\r\n    }\r\n\r\n    /**\r\n     * 获取消息统计\r\n     */\r\n    getStats(): {\r\n        total: number;\r\n        user: number;\r\n        assistant: number;\r\n        system: number;\r\n    } {\r\n        const stats = {\r\n            total: this._messageList.length,\r\n            user: 0,\r\n            assistant: 0,\r\n            system: 0\r\n        };\r\n\r\n        this._messageList.forEach(msg => {\r\n            const role = msg.get(\"role\");\r\n            if (role === \"user\") stats.user++;\r\n            if (role === \"assistant\") stats.assistant++;\r\n            if (role === \"system\") stats.system++;\r\n        });\r\n\r\n        return stats;\r\n    }\r\n\r\n    /**\r\n     * 清空消息列表\r\n     */\r\n    clearCache(): void {\r\n        this._messageList = [];\r\n        this._isLoaded = false;\r\n    }\r\n\r\n    /**\r\n     * 获取最新消息\r\n     */\r\n    getLastMessage(): FmodeObject | undefined {\r\n        return this._messageList.length > 0 ? this._messageList[this._messageList.length - 1] : undefined;\r\n    }\r\n\r\n    /**\r\n     * 获取消息数量\r\n     */\r\n    getMessageCount(): number {\r\n        return this._messageList.length;\r\n    }\r\n\r\n    /**\r\n     * 创建静态工厂方法（保持兼容性）\r\n     */\r\n    static createForRole(chatSession: FmodeObject, role: FmodeObject, company: FmodeObject): MessageManager {\r\n        return new MessageManager({\r\n            chatSession,\r\n            role,\r\n            company,\r\n            scene: MessageScene.ROLE\r\n        });\r\n    }\r\n}"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"message-manager.js","sourceRoot":"","sources":["../../../../../../../../projects/fmode-ng/src/lib/core/agent/chat/message/message-manager.ts"],"names":[],"mappings":"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","sourcesContent":["import { FmodeObject, FmodeParse } from \"../../../../core/parse\";\r\nimport { FmodeChatMessage } from \"../interface\";\r\nimport { MessageScene } from \"./message\";\r\nconst Parse = FmodeParse.with(\"nova\");\r\n\r\n/**\r\n * MessageManagerOptions - 消息管理器配置\r\n */\r\nexport interface MessageManagerOptions {\r\n    chatSession?: FmodeObject;     // 可选的会话对象（智能体对话场景）\r\n    role?: FmodeObject;            // 可选的角色对象（智能体对话场景）\r\n    company: FmodeObject;          // 必需的企业对象\r\n    group?: FmodeObject;          // 群聊对象（群聊场景）\r\n    userFrom?: FmodeObject;       // 发送者（私聊场景）\r\n    userTo?: FmodeObject;         // 接收者（私聊场景）\r\n    contact?: FmodeObject;        // 联系人（客服场景）\r\n    scene?: MessageScene;         // 消息场景\r\n    limitHistory?:number; // 历史消息数量限制 默认10\r\n}\r\n\r\n/**\r\n * MessageManager - 优化版消息管理器\r\n * 职责：统一管理消息列表，支持高效的增量更新和下标访问\r\n */\r\nexport class MessageManager {\r\n    private options: MessageManagerOptions;\r\n    private _messageList: FmodeObject[] = []; // 统一的消息列表\r\n    private _isLoaded: boolean = false;\r\n\r\n    constructor(options: MessageManagerOptions) {\r\n        options.limitHistory = options?.limitHistory || 10\r\n        this.options = options;\r\n    }\r\n\r\n    getCompanyPointer(){\r\n        let cid = (this as any).options?.company?.objectId || this.options?.company?.id || localStorage.getItem(\"company\")\r\n        return {\r\n            __type:\"Pointer\",\r\n            className:\"Company\",\r\n            objectId:cid\r\n        }\r\n    }\r\n    /**\r\n     * 获取统一的消息列表\r\n     */\r\n    async getMessages(): Promise<FmodeObject[]> {\r\n        if (!this._isLoaded) {\r\n            await this.loadMessages();\r\n            this._isLoaded = true;\r\n        }\r\n        return [...this._messageList];\r\n    }\r\n\r\n    /**\r\n     * 获取缓存的消息列表（同步方法，用于组件绑定）\r\n     * 直接返回当前消息列表，不进行异步加载\r\n     */\r\n    getCachedMessages(): FmodeObject[] {\r\n        return [...this._messageList];\r\n    }\r\n\r\n    /**\r\n     * 直接访问消息列表（用于下标访问）\r\n     */\r\n    getMessageList(): FmodeObject[] {\r\n        return this._messageList;\r\n    }\r\n\r\n    /**\r\n     * 通过下标获取消息\r\n     */\r\n    getMessage(index: number): FmodeObject | undefined {\r\n        return this._messageList[index];\r\n    }\r\n\r\n    /**\r\n     * 添加新消息（优化版）\r\n     * 直接创建FmodeObject并添加到列表末尾，延迟保存\r\n     */\r\n    addMessage(message: FmodeChatMessage, scene?: MessageScene): FmodeObject {\r\n        const targetScene = scene || this.options.scene || MessageScene.ROLE;\r\n\r\n        try {\r\n            // 创建新的消息对象（未保存）\r\n            const MessageClass = Parse.Object.extend(\"Message\");\r\n            const messageObj = new MessageClass();\r\n\r\n            // 设置基本信息\r\n            messageObj.set(\"scene\", targetScene);\r\n            messageObj.set(\"status\", \"sent\");\r\n            messageObj.set(\"createdAt\", message.createdAt || new Date());\r\n            messageObj.set(\"complete\", message.complete || false);\r\n\r\n            // 设置消息角色（user/assistant/system）- 这是消息的发送者角色\r\n            if (message.role) {\r\n                messageObj.set(\"role\", this.options.role.toPointer());\r\n            }\r\n\r\n            // 设置内容 - 保持原始格式兼容（string 或 Array）\r\n            // 同时扩展存储格式，支持更多元数据\r\n            if (message.content !== undefined) {\r\n                messageObj.set(\"content\", message);\r\n            }\r\n\r\n\r\n            // 根据场景设置关联对象\r\n            // avatarRole：指向 AvatarRole 表的指针（智能体角色）\r\n            if (targetScene === MessageScene.ROLE && this.options.role) {\r\n                messageObj.set(\"avatarRole\", this.options.role.toPointer());\r\n            }\r\n            // company：指向 Company 表的指针\r\n            if (this.options.company) {\r\n                messageObj.set(\"company\", this.getCompanyPointer());\r\n            }\r\n\r\n            // 关键：如果chatSession已存在且有id，立即关联\r\n            // 如果chatSession还没有id（新会话），标记为待关联\r\n            if (this.options.chatSession) {\r\n                if (this.options.chatSession.id) {\r\n                    messageObj.set(\"session\", this.options.chatSession.toPointer());\r\n                } else {\r\n                    // 新会话，标记待关联，等待session保存后再关联\r\n                    messageObj.set(\"_pendingSession\", true);\r\n                }\r\n            }\r\n\r\n            // 直接添加到列表末尾\r\n            this._messageList.push(messageObj);\r\n\r\n            return messageObj;\r\n        } catch (error) {\r\n            console.error(\"创建新消息失败:\", error);\r\n            throw error;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * 异步保存消息对象\r\n     * 增强版：处理session关联和延迟保存\r\n     */\r\n    async saveMessage(messageObj: FmodeObject): Promise<void> {\r\n        if (!messageObj) return;\r\n\r\n        try {\r\n            // 检查是否需要关联session（对于新会话的消息）\r\n            if (!messageObj.get(\"session\") && this.options.chatSession?.id) {\r\n                messageObj.set(\"session\", this.options.chatSession.toPointer());\r\n            }\r\n\r\n            // 确保消息有关联的session才保存到Message表\r\n            // 如果没有session且不是老消息转换的，先不保存（只存在于内存）\r\n            if (!messageObj.get(\"session\") && !messageObj.get(\"isLegacy\")) {\r\n                // 没有session的消息暂时不保存到Message表\r\n                // 等session创建后会再次调用saveMessage\r\n                console.log(\"消息等待session创建后保存\");\r\n                return;\r\n            }\r\n\r\n            await messageObj.save();\r\n        } catch (error) {\r\n            console.error(\"保存消息对象失败:\", error);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * 在session创建/更新后，保存所有待关联的消息\r\n     * 关键方法：在chatSession保存成功后调用\r\n     */\r\n    async savePendingMessages(): Promise<void> {\r\n        if (!this.options.chatSession?.id) {\r\n            console.warn(\"session未保存，无法保存待处理消息\");\r\n            return;\r\n        }\r\n\r\n        const savePromises: Promise<void>[] = [];\r\n\r\n        for (const messageObj of this._messageList) {\r\n            // 处理待关联的消息\r\n            // if (messageObj.get(\"_pendingSession\")) {\r\n                messageObj.set(\"session\", messageObj?.get(\"session\")||this.options.chatSession.toPointer());\r\n                // messageObj.set(\"_pendingSession\", undefined);\r\n            // }\r\n\r\n            // 保存所有没有id的消息（新消息）\r\n            if (!messageObj.id) {\r\n                if(!messageObj?.get(\"hidden\")){\r\n                    savePromises.push(this.saveMessage(messageObj));\r\n                }\r\n            }\r\n        }\r\n\r\n        if (savePromises.length > 0) {\r\n            await Promise.all(savePromises);\r\n            console.log(`保存了 ${savePromises.length} 条待处理消息`);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * 更新chatSession引用（当新会话第一次保存后）\r\n     */\r\n    updateChatSession(chatSession: FmodeObject): void {\r\n        this.options.chatSession = chatSession;\r\n    }\r\n\r\n    /**\r\n     * 更新消息（优化版）\r\n     * 直接通过下标更新消息对象属性，返回是否成功\r\n     */\r\n    updateMessage(index: number, message: Partial<FmodeChatMessage>): FmodeObject | null {\r\n        if (index < 0 || index >= this._messageList.length) return null;\r\n\r\n        const messageObj = this._messageList[index];\r\n        if (!messageObj) return null;\r\n\r\n        // 更新消息角色\r\n        if (message.role) {\r\n            messageObj.set(\"role\", this.options.role.toPointer());\r\n        }\r\n\r\n        // 更新内容 - 保持原始格式兼容\r\n        // 从现有 content 中获取完整的 FmodeChatMessage 对象，然后更新字段\r\n        if (message.content !== undefined) {\r\n            const existingContent = messageObj.get(\"content\") || {};\r\n            messageObj.set(\"content\", {\r\n                ...existingContent,\r\n                content: message.content\r\n            });\r\n        }\r\n\r\n        // 更新其他属性\r\n        if (message.complete !== undefined) messageObj.set(\"complete\", message.complete);\r\n        if (message.json) messageObj.set(\"json\", message.json);\r\n        if (message.hidden) messageObj.set(\"hidden\", message.hidden);\r\n        if (message.voice) messageObj.set(\"voice\", message.voice);\r\n        if (message.cid) messageObj.set(\"cid\", message.cid);\r\n\r\n        return messageObj;\r\n    }\r\n\r\n    /**\r\n     * 更新消息并异步保存\r\n     */\r\n    async updateMessageAndSave(index: number, message: Partial<FmodeChatMessage>): Promise<void> {\r\n        const messageObj = this.updateMessage(index, message);\r\n        if (!messageObj?.get(\"hidden\")) {\r\n            await this.saveMessage(messageObj);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * 重新加载消息\r\n     */\r\n    async reloadMessages(): Promise<void> {\r\n        this._messageList = [];\r\n        this._isLoaded = false;\r\n        await this.getMessages(); // 触发重新加载\r\n    }\r\n\r\n    /**\r\n     * 加载消息（优化版）\r\n     */\r\n    private async loadMessages(): Promise<void> {\r\n        this._messageList = [];\r\n\r\n        try {\r\n            // 1. 首先加载老版消息（如果有）\r\n            const legacyMessages = this.options.chatSession?.get(\"messageList\") || [];\r\n\r\n            // 转换老版消息为FmodeObject（仅用于展示）\r\n            for (const legacyMsg of legacyMessages) {\r\n                const MessageClass = Parse.Object.extend(\"Message\");\r\n                const messageObj = new MessageClass();\r\n\r\n                // 复制老版消息属性\r\n                messageObj.set(\"role\", this.options.role.toPointer());\r\n                messageObj.set(\"content\", legacyMsg.content);\r\n                messageObj.set(\"complete\", legacyMsg.complete);\r\n                messageObj.set(\"createdAt\", legacyMsg.createdAt);\r\n                messageObj.set(\"voice\", legacyMsg.voice);\r\n                messageObj.set(\"cid\", legacyMsg.cid);\r\n                messageObj.set(\"isLegacy\", true);\r\n\r\n                // 为老消息同步创建 contentData，保持格式统一\r\n                if (typeof legacyMsg.content === \"string\") {\r\n                    messageObj.set(\"contentData\", {\r\n                        type: \"text\",\r\n                        text: legacyMsg.content,\r\n                        role: legacyMsg.role\r\n                    });\r\n                } else if (Array.isArray(legacyMsg.content)) {\r\n                    messageObj.set(\"contentData\", {\r\n                        type: \"mixed\",\r\n                        items: legacyMsg.content,\r\n                        role: legacyMsg.role\r\n                    });\r\n                }\r\n\r\n                this._messageList.push(messageObj);\r\n            }\r\n\r\n            // 2. 加载新版消息\r\n            let newMessages: FmodeObject[] = [];\r\n\r\n            switch (this.options.scene) {\r\n                case MessageScene.ROLE:\r\n                    if (this.options.role) {\r\n                        newMessages = await this.loadRoleMessages();\r\n                    }\r\n                    break;\r\n                case MessageScene.GROUP:\r\n                    if (this.options.group) {\r\n                        newMessages = await this.loadGroupMessages();\r\n                    }\r\n                    break;\r\n                case MessageScene.USER:\r\n                    if (this.options.userFrom && this.options.userTo) {\r\n                        newMessages = await this.loadUserMessages();\r\n                    }\r\n                    break;\r\n                case MessageScene.SERVICE:\r\n                    if (this.options.contact) {\r\n                        newMessages = await this.loadServiceMessages();\r\n                    }\r\n                    break;\r\n                default:\r\n                    newMessages = [];\r\n            }\r\n\r\n            // 3. 将新消息添加到列表末尾\r\n            this._messageList.push(...newMessages);\r\n\r\n        } catch (error) {\r\n            console.error(\"加载消息失败:\", error);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * 加载角色对话消息\r\n     */\r\n    private async loadRoleMessages(): Promise<FmodeObject[]> {\r\n        if (!this.options.role?.id) return [];\r\n\r\n        const query = new Parse.Query(\"Message\");\r\n        query.exists(\"content\")\r\n        query.equalTo(\"role\", this.options.role?.id);\r\n        query.addAscending(\"createdAt\");\r\n        query.limit(1000); // 限制数量避免性能问题\r\n\r\n        return await query.find();\r\n    }\r\n\r\n    /**\r\n     * 加载群聊消息（简化版）\r\n     */\r\n    private async loadGroupMessages(): Promise<FmodeObject[]> {\r\n        if (!this.options.group) return [];\r\n\r\n        const query = new Parse.Query(\"Message\");\r\n        query.exists(\"content\")\r\n        query.equalTo(\"group\", this.options.group);\r\n        query.addAscending(\"createdAt\");\r\n        query.limit(1000);\r\n\r\n        return await query.find();\r\n    }\r\n\r\n    /**\r\n     * 加载私聊消息（简化版）\r\n     */\r\n    private async loadUserMessages(): Promise<FmodeObject[]> {\r\n        if (!this.options.userFrom || !this.options.userTo) return [];\r\n\r\n        const query = new Parse.Query(\"Message\");\r\n        query.exists(\"content\")\r\n        query.containedIn(\"userFrom\", [this.options.userFrom, this.options.userTo]);\r\n        query.containedIn(\"userTo\", [this.options.userFrom, this.options.userTo]);\r\n        query.addAscending(\"createdAt\");\r\n        query.limit(1000);\r\n\r\n        return await query.find();\r\n    }\r\n\r\n    /**\r\n     * 加载客服消息（简化版）\r\n     */\r\n    private async loadServiceMessages(): Promise<FmodeObject[]> {\r\n        if (!this.options.contact) return [];\r\n\r\n        const query = new Parse.Query(\"Message\");\r\n        query.exists(\"content\")\r\n        query.equalTo(\"contact\", this.options.contact);\r\n        query.addAscending(\"createdAt\");\r\n        query.limit(1000);\r\n\r\n        return await query.find();\r\n    }\r\n\r\n    /**\r\n     * 获取消息统计\r\n     */\r\n    getStats(): {\r\n        total: number;\r\n        user: number;\r\n        assistant: number;\r\n        system: number;\r\n    } {\r\n        const stats = {\r\n            total: this._messageList.length,\r\n            user: 0,\r\n            assistant: 0,\r\n            system: 0\r\n        };\r\n\r\n        this._messageList.forEach(msg => {\r\n            const role = msg.get(\"role\");\r\n            if (role === \"user\") stats.user++;\r\n            if (role === \"assistant\") stats.assistant++;\r\n            if (role === \"system\") stats.system++;\r\n        });\r\n\r\n        return stats;\r\n    }\r\n\r\n    /**\r\n     * 清空消息列表\r\n     */\r\n    clearCache(): void {\r\n        this._messageList = [];\r\n        this._isLoaded = false;\r\n    }\r\n\r\n    /**\r\n     * 获取最新消息\r\n     */\r\n    getLastMessage(): FmodeObject | undefined {\r\n        return this._messageList.length > 0 ? this._messageList[this._messageList.length - 1] : undefined;\r\n    }\r\n\r\n    /**\r\n     * 获取消息数量\r\n     */\r\n    getMessageCount(): number {\r\n        return this._messageList.length;\r\n    }\r\n\r\n    /**\r\n     * 创建静态工厂方法（保持兼容性）\r\n     */\r\n    static createForRole(chatSession: FmodeObject, role: FmodeObject, company: FmodeObject): MessageManager {\r\n        return new MessageManager({\r\n            chatSession,\r\n            role,\r\n            company,\r\n            scene: MessageScene.ROLE\r\n        });\r\n    }\r\n}"]}

package/esm2022/lib/core/parse/fmode.cloud.mjs

@@ -72,7 +72,8 @@ export class FmodeCloud {
     }
     async function(params = {}, options = {}) {
         const config = this.currentConfig;
-        const url = `${config.serverURL}/../api/functions`;
+        let u = new URL(config.serverURL);
+        let url = u.origin + "/api/functions";
         const requestBody = {
             ...params,
             _ApplicationId: config.appId,
@@ -100,7 +101,20 @@ export class FmodeCloud {
             if (!response.ok) {
                 throw new Error(`HTTP error! status: ${response.status}`);
             }
-            const data = await response.json();
+            // const data = await response.json();
+            // 【关键】直接从 body 获取 reader，只读取一次
+            const reader = response.body?.getReader();
+            if (!reader) {
+                throw new Error('No body reader available');
+            }
+            // 只读取一次！
+            const { value, done } = await reader.read();
+            if (!value) {
+                throw new Error('Empty response body');
+            }
+            const decoder = new TextDecoder();
+            const text = decoder.decode(value);
+            const data = JSON.parse(text);
             if (data.error) {
                 throw new Error(data.error.message || 'Cloud function error');
             }
@@ -145,4 +159,4 @@ export class FmodeCloud {
 }
 export const Cloud = FmodeCloud.getInstance();
 export default Cloud;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fmode.cloud.js","sourceRoot":"","sources":["../../../../../../projects/fmode-ng/src/lib/core/parse/fmode.cloud.ts"],"names":[],"mappings":"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","sourcesContent":["import { FmodeConfig } from './types';\r\n\r\nexport interface CloudFunctionRequest {\r\n  params: any;\r\n  user?: any;\r\n  installationId?: string;\r\n  log?: any;\r\n}\r\n\r\nexport interface CloudFunctionResponse {\r\n  success: (result?: any) => void;\r\n  error: (error?: any) => void;\r\n}\r\n\r\nexport type CloudFunction = (request: CloudFunctionRequest, response: CloudFunctionResponse) => void;\r\n\r\nexport class FmodeCloud {\r\n  private static _singletonInstance: FmodeCloud | null = null;\r\n  private _cloudFunctions: Map<string, CloudFunction> = new Map();\r\n\r\n  protected constructor() {} // 改为 protected 以允许子类继承\r\n\r\n  static getInstance(): FmodeCloud {\r\n    if (!this._singletonInstance) {\r\n      this._singletonInstance = new FmodeCloud();\r\n    }\r\n    return this._singletonInstance;\r\n  }\r\n\r\n  // 支持静态实例绑定 - 与FmodeObject和FmodeQuery保持一致\r\n  static _instance: any = null;\r\n\r\n  static bindInstance(instance: any): void {\r\n    this._instance = instance;\r\n  }\r\n\r\n  // 获取当前实例配置 - 使用 protected 以允许子类重写\r\n  protected get currentConfig(): FmodeConfig {\r\n    const parseInstance = FmodeCloud._instance;\r\n    if (!parseInstance) {\r\n      throw new Error('FmodeCloud not initialized. Call FmodeParse.initialize() first.');\r\n    }\r\n    return parseInstance.config;\r\n  }\r\n\r\n  // 静态方法获取实例\r\n  static get instance(): any {\r\n    return this._instance;\r\n  }\r\n\r\n  define(functionName: string, cloudFunction: CloudFunction): void {\r\n    this._cloudFunctions.set(functionName, cloudFunction);\r\n  }\r\n\r\n  async run(functionName: string, params: any = {}, options: any = {}): Promise<any> {\r\n    const config = this.currentConfig;\r\n    const url = `${config.serverURL}/functions/${functionName}`;\r\n\r\n    const requestBody = {\r\n      ...params,\r\n      _ApplicationId: config.appId,\r\n      // _ClientVersion: 'js' + (config.javascriptKey || ''),\r\n      _InstallationId: options.installationId || this.generateInstallationId(),\r\n    };\r\n\r\n    // Add session token if available\r\n    const sessionToken = config.sessionToken;\r\n    if (sessionToken) {\r\n      requestBody._SessionToken = sessionToken;\r\n    }\r\n\r\n    try {\r\n      console.log(url)\r\n      const response = await fetch(url, {\r\n        method: 'POST',\r\n        headers: {\r\n          'Content-Type': 'application/json',\r\n          'X-Parse-Application-Id': config.appId,\r\n          ...(config.javascriptKey && { 'X-Parse-JavaScript-Key': config.javascriptKey }),\r\n          ...(config.masterKey && { 'X-Parse-Master-Key': config.masterKey }),\r\n          ...(sessionToken && { 'X-Parse-Session-Token': sessionToken }),\r\n        },\r\n        body: JSON.stringify(requestBody),\r\n      });\r\n\r\n      if (!response.ok) {\r\n        throw new Error(`HTTP error! status: ${response.status}`);\r\n      }\r\n\r\n      const data = await response.json();\r\n\r\n      if (data.error) {\r\n        throw new Error(data.error.message || 'Cloud function error');\r\n      }\r\n\r\n      return data.result;\r\n    } catch (error) {\r\n      console.error(`Cloud function ${functionName} failed:`, error);\r\n      throw error;\r\n    }\r\n  }\r\n\r\n  async function(params: any = {}, options: any = {}): Promise<any> {\r\n    const config = this.currentConfig;\r\n    const url = `${config.serverURL}/../api/functions`;\r\n\r\n    const requestBody = {\r\n      ...params,\r\n      _ApplicationId: config.appId,\r\n      // _ClientVersion: 'js' + (config.javascriptKey || ''),\r\n      _InstallationId: options.installationId || this.generateInstallationId(),\r\n    };\r\n\r\n\r\n\r\n    // Add session token if available\r\n    const sessionToken = config.sessionToken;\r\n    if (sessionToken) {\r\n      requestBody._SessionToken = sessionToken;\r\n    }\r\n\r\n    try {\r\n      console.log(url)\r\n      const response = await fetch(url, {\r\n        method: 'POST',\r\n        headers: {\r\n          'Content-Type': 'application/json',\r\n          'X-Parse-Application-Id': config.appId,\r\n          ...(config.javascriptKey && { 'X-Parse-JavaScript-Key': config.javascriptKey }),\r\n          ...(config.masterKey && { 'X-Parse-Master-Key': config.masterKey }),\r\n          ...(sessionToken && { 'X-Parse-Session-Token': sessionToken }),\r\n        },\r\n        body: JSON.stringify(requestBody),\r\n      });\r\n\r\n      if (!response.ok) {\r\n        throw new Error(`HTTP error! status: ${response.status}`);\r\n      }\r\n\r\n      const data = await response.json();\r\n\r\n      if (data.error) {\r\n        throw new Error(data.error.message || 'Cloud function error');\r\n      }\r\n\r\n      return data;\r\n    } catch (error) {\r\n      console.error(`Cloud function failed:`, error);\r\n      throw error;\r\n    }\r\n  }\r\n\r\n  async afterDelete(className: string, func: CloudFunction): Promise<void> {\r\n    this.define(`afterDelete_${className}`, func);\r\n  }\r\n\r\n  async afterSave(className: string, func: CloudFunction): Promise<void> {\r\n    this.define(`afterSave_${className}`, func);\r\n  }\r\n\r\n  async beforeDelete(className: string, func: CloudFunction): Promise<void> {\r\n    this.define(`beforeDelete_${className}`, func);\r\n  }\r\n\r\n  async beforeSave(className: string, func: CloudFunction): Promise<void> {\r\n    this.define(`beforeSave_${className}`, func);\r\n  }\r\n\r\n  async beforeFind(className: string, func: CloudFunction): Promise<void> {\r\n    this.define(`beforeFind_${className}`, func);\r\n  }\r\n\r\n  async afterFind(className: string, func: CloudFunction): Promise<void> {\r\n    this.define(`afterFind_${className}`, func);\r\n  }\r\n\r\n  async job(jobName: string, func: CloudFunction): Promise<void> {\r\n    this.define(`job_${jobName}`, func);\r\n  }\r\n\r\n  private generateInstallationId(): string {\r\n    if (typeof crypto !== 'undefined' && crypto.randomUUID) {\r\n      return crypto.randomUUID();\r\n    }\r\n    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {\r\n      const r = Math.random() * 16 | 0;\r\n      const v = c === 'x' ? r : (r & 0x3 | 0x8);\r\n      return v.toString(16);\r\n    });\r\n  }\r\n}\r\n\r\nexport const Cloud = FmodeCloud.getInstance();\r\nexport default Cloud;"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fmode.cloud.js","sourceRoot":"","sources":["../../../../../../projects/fmode-ng/src/lib/core/parse/fmode.cloud.ts"],"names":[],"mappings":"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","sourcesContent":["import { FmodeConfig } from './types';\r\n\r\nexport interface CloudFunctionRequest {\r\n  params: any;\r\n  user?: any;\r\n  installationId?: string;\r\n  log?: any;\r\n}\r\n\r\nexport interface CloudFunctionResponse {\r\n  success: (result?: any) => void;\r\n  error: (error?: any) => void;\r\n}\r\n\r\nexport type CloudFunction = (request: CloudFunctionRequest, response: CloudFunctionResponse) => void;\r\n\r\nexport class FmodeCloud {\r\n  private static _singletonInstance: FmodeCloud | null = null;\r\n  private _cloudFunctions: Map<string, CloudFunction> = new Map();\r\n\r\n  protected constructor() {} // 改为 protected 以允许子类继承\r\n\r\n  static getInstance(): FmodeCloud {\r\n    if (!this._singletonInstance) {\r\n      this._singletonInstance = new FmodeCloud();\r\n    }\r\n    return this._singletonInstance;\r\n  }\r\n\r\n  // 支持静态实例绑定 - 与FmodeObject和FmodeQuery保持一致\r\n  static _instance: any = null;\r\n\r\n  static bindInstance(instance: any): void {\r\n    this._instance = instance;\r\n  }\r\n\r\n  // 获取当前实例配置 - 使用 protected 以允许子类重写\r\n  protected get currentConfig(): FmodeConfig {\r\n    const parseInstance = FmodeCloud._instance;\r\n    if (!parseInstance) {\r\n      throw new Error('FmodeCloud not initialized. Call FmodeParse.initialize() first.');\r\n    }\r\n    return parseInstance.config;\r\n  }\r\n\r\n  // 静态方法获取实例\r\n  static get instance(): any {\r\n    return this._instance;\r\n  }\r\n\r\n  define(functionName: string, cloudFunction: CloudFunction): void {\r\n    this._cloudFunctions.set(functionName, cloudFunction);\r\n  }\r\n\r\n  async run(functionName: string, params: any = {}, options: any = {}): Promise<any> {\r\n    const config = this.currentConfig;\r\n    const url = `${config.serverURL}/functions/${functionName}`;\r\n\r\n    const requestBody = {\r\n      ...params,\r\n      _ApplicationId: config.appId,\r\n      // _ClientVersion: 'js' + (config.javascriptKey || ''),\r\n      _InstallationId: options.installationId || this.generateInstallationId(),\r\n    };\r\n\r\n    // Add session token if available\r\n    const sessionToken = config.sessionToken;\r\n    if (sessionToken) {\r\n      requestBody._SessionToken = sessionToken;\r\n    }\r\n\r\n    try {\r\n      console.log(url)\r\n      const response = await fetch(url, {\r\n        method: 'POST',\r\n        headers: {\r\n          'Content-Type': 'application/json',\r\n          'X-Parse-Application-Id': config.appId,\r\n          ...(config.javascriptKey && { 'X-Parse-JavaScript-Key': config.javascriptKey }),\r\n          ...(config.masterKey && { 'X-Parse-Master-Key': config.masterKey }),\r\n          ...(sessionToken && { 'X-Parse-Session-Token': sessionToken }),\r\n        },\r\n        body: JSON.stringify(requestBody),\r\n      });\r\n\r\n      if (!response.ok) {\r\n        throw new Error(`HTTP error! status: ${response.status}`);\r\n      }\r\n\r\n      const data = await response.json();\r\n\r\n      if (data.error) {\r\n        throw new Error(data.error.message || 'Cloud function error');\r\n      }\r\n\r\n      return data.result;\r\n    } catch (error) {\r\n      console.error(`Cloud function ${functionName} failed:`, error);\r\n      throw error;\r\n    }\r\n  }\r\n\r\n  async function(params: any = {}, options: any = {}): Promise<any> {\r\n    const config = this.currentConfig;\r\n    let u = new URL(config.serverURL);\r\n    let url = u.origin + \"/api/functions\"\r\n\r\n    const requestBody = {\r\n      ...params,\r\n      _ApplicationId: config.appId,\r\n      // _ClientVersion: 'js' + (config.javascriptKey || ''),\r\n      _InstallationId: options.installationId || this.generateInstallationId(),\r\n    };\r\n\r\n\r\n\r\n    // Add session token if available\r\n    const sessionToken = config.sessionToken;\r\n    if (sessionToken) {\r\n      requestBody._SessionToken = sessionToken;\r\n    }\r\n\r\n    try {\r\n      console.log(url)\r\n      const response = await fetch(url, {\r\n        method: 'POST',\r\n        headers: {\r\n          'Content-Type': 'application/json',\r\n          'X-Parse-Application-Id': config.appId,\r\n          ...(config.javascriptKey && { 'X-Parse-JavaScript-Key': config.javascriptKey }),\r\n          ...(config.masterKey && { 'X-Parse-Master-Key': config.masterKey }),\r\n          ...(sessionToken && { 'X-Parse-Session-Token': sessionToken }),\r\n        },\r\n        body: JSON.stringify(requestBody),\r\n      });\r\n\r\n      if (!response.ok) {\r\n        throw new Error(`HTTP error! status: ${response.status}`);\r\n      }\r\n\r\n      // const data = await response.json();\r\n      // 【关键】直接从 body 获取 reader，只读取一次\r\n      const reader = response.body?.getReader();\r\n      if (!reader) {\r\n        throw new Error('No body reader available');\r\n      }\r\n\r\n      // 只读取一次！\r\n      const { value, done } = await reader.read();\r\n\r\n      if (!value) {\r\n        throw new Error('Empty response body');\r\n      }\r\n\r\n      const decoder = new TextDecoder();\r\n      const text = decoder.decode(value);\r\n      const data = JSON.parse(text);\r\n\r\n      if (data.error) {\r\n        throw new Error(data.error.message || 'Cloud function error');\r\n      }\r\n\r\n      return data;\r\n    } catch (error) {\r\n      console.error(`Cloud function failed:`, error);\r\n      throw error;\r\n    }\r\n  }\r\n\r\n  async afterDelete(className: string, func: CloudFunction): Promise<void> {\r\n    this.define(`afterDelete_${className}`, func);\r\n  }\r\n\r\n  async afterSave(className: string, func: CloudFunction): Promise<void> {\r\n    this.define(`afterSave_${className}`, func);\r\n  }\r\n\r\n  async beforeDelete(className: string, func: CloudFunction): Promise<void> {\r\n    this.define(`beforeDelete_${className}`, func);\r\n  }\r\n\r\n  async beforeSave(className: string, func: CloudFunction): Promise<void> {\r\n    this.define(`beforeSave_${className}`, func);\r\n  }\r\n\r\n  async beforeFind(className: string, func: CloudFunction): Promise<void> {\r\n    this.define(`beforeFind_${className}`, func);\r\n  }\r\n\r\n  async afterFind(className: string, func: CloudFunction): Promise<void> {\r\n    this.define(`afterFind_${className}`, func);\r\n  }\r\n\r\n  async job(jobName: string, func: CloudFunction): Promise<void> {\r\n    this.define(`job_${jobName}`, func);\r\n  }\r\n\r\n  private generateInstallationId(): string {\r\n    if (typeof crypto !== 'undefined' && crypto.randomUUID) {\r\n      return crypto.randomUUID();\r\n    }\r\n    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {\r\n      const r = Math.random() * 16 | 0;\r\n      const v = c === 'x' ? r : (r & 0x3 | 0x8);\r\n      return v.toString(16);\r\n    });\r\n  }\r\n}\r\n\r\nexport const Cloud = FmodeCloud.getInstance();\r\nexport default Cloud;"]}