@glodon-aiot/chat-app-sdk 0.0.15 → 0.0.16

package/es/index.esm.js

@@ -267864,6 +267864,43 @@ class PreSendLocalMessageFactory {
     }
 }
 
+;// CONCATENATED MODULE: ../../../../../common/temp/default/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isEqual.js
+
+
+/**
+ * Performs a deep comparison between two values to determine if they are
+ * equivalent.
+ *
+ * **Note:** This method supports comparing arrays, array buffers, booleans,
+ * date objects, error objects, maps, numbers, `Object` objects, regexes,
+ * sets, strings, symbols, and typed arrays. `Object` objects are compared
+ * by their own, not inherited, enumerable properties. Functions and DOM
+ * nodes are compared by strict equality, i.e. `===`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.isEqual(object, other);
+ * // => true
+ *
+ * object === other;
+ * // => false
+ */
+function lodash_es_isEqual_isEqual(value, other) {
+  return _baseIsEqual(value, other);
+}
+
+/* ESM default export */ const lodash_es_isEqual = (lodash_es_isEqual_isEqual);
+
 ;// CONCATENATED MODULE: ../../../../../common/temp/default/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseLodash.js
 /**
  * The function whose prototype chain sequence wrappers inherit from.
@@ -268366,10 +268403,126 @@ var flow = _createFlow();
 
 class StreamBufferHelper {
     /**
+   * 合并两个 JSON 对象（深度合并）
+   * - 如果两个值都是对象，递归合并
+   * - 如果两个值都是字符串，追加字符串
+   * - 如果两个值都是数组，合并数组（按索引合并）
+   * - 否则使用 curr 的值（覆盖）
+   */ mergeJsonObjects(prev, curr) {
+        const merged = {
+            ...prev
+        };
+        for(const key in curr){
+            if (Object.prototype.hasOwnProperty.call(curr, key)) {
+                const prevValue = prev[key];
+                const currValue = curr[key];
+                // 如果两个值都是对象，递归合并
+                if (typeof prevValue === 'object' && prevValue !== null && !Array.isArray(prevValue) && typeof currValue === 'object' && currValue !== null && !Array.isArray(currValue)) {
+                    merged[key] = this.mergeJsonObjects(prevValue, currValue);
+                } else if (typeof prevValue === 'string' && typeof currValue === 'string') {
+                    // 如果两个值都是字符串，追加字符串
+                    merged[key] = prevValue + currValue;
+                } else if (Array.isArray(prevValue) && Array.isArray(currValue)) {
+                    // 如果两个值都是数组，按索引合并
+                    const mergedArray = [
+                        ...prevValue
+                    ];
+                    for(let i = 0; i < currValue.length; i++){
+                        const currItem = currValue[i];
+                        if (i < mergedArray.length) {
+                            // 如果索引已存在，尝试合并
+                            const prevItem = mergedArray[i];
+                            if (typeof prevItem === 'object' && prevItem !== null && !Array.isArray(prevItem) && typeof currItem === 'object' && currItem !== null && !Array.isArray(currItem)) {
+                                mergedArray[i] = this.mergeJsonObjects(prevItem, currItem);
+                            } else {
+                                mergedArray[i] = currItem;
+                            }
+                        } else {
+                            // 如果索引超出范围，追加新元素
+                            mergedArray.push(currItem);
+                        }
+                    }
+                    merged[key] = mergedArray;
+                } else {
+                    // 否则使用 curr 的值（覆盖）
+                    merged[key] = currValue;
+                }
+            }
+        }
+        return merged;
+    }
+    /**
    * Added Chunk message cache
    */ pushChunk(chunk) {
         this.streamChunkBuffer.push(chunk);
     }
+    /**
+   * Merge item_list arrays by index, handling JSON items specially
+   */ mergeItemList(prevItemList, currItemList) {
+        const mergedItemList = [
+            ...prevItemList
+        ];
+        for(let i = 0; i < currItemList.length; i++){
+            const currItem = currItemList[i];
+            if (i < mergedItemList.length) {
+                const prevItem = mergedItemList[i];
+                // Special handling: if both items are JSON items, merge their json fields
+                if (typeof prevItem === 'object' && prevItem !== null && typeof currItem === 'object' && currItem !== null && 'type' in prevItem && 'type' in currItem && prevItem.type === types_ContentType.Json && currItem.type === types_ContentType.Json && 'json' in prevItem && 'json' in currItem) {
+                    const prevJson = prevItem.json;
+                    const currJson = currItem.json;
+                    // If both json fields are arrays, merge arrays by index
+                    if (Array.isArray(prevJson) && Array.isArray(currJson)) {
+                        const prevJsonArray = prevJson;
+                        const currJsonArray = currJson;
+                        const mergedJsonArray = [
+                            ...prevJsonArray
+                        ];
+                        for(let j = 0; j < currJsonArray.length; j++){
+                            if (j < mergedJsonArray.length) {
+                                mergedJsonArray[j] = currJsonArray[j];
+                            } else {
+                                mergedJsonArray.push(currJsonArray[j]);
+                            }
+                        }
+                        mergedItemList[i] = {
+                            ...currItem,
+                            json: mergedJsonArray
+                        };
+                    } else if (typeof prevJson === 'object' && prevJson !== null && !Array.isArray(prevJson) && typeof currJson === 'object' && currJson !== null && !Array.isArray(currJson)) {
+                        // If both json fields are objects, deep merge them
+                        const mergedJson = this.mergeJsonObjects(prevJson, currJson);
+                        mergedItemList[i] = {
+                            ...currItem,
+                            json: mergedJson
+                        };
+                    } else if (!lodash_es_isEqual(prevItem, currItem)) {
+                        mergedItemList[i] = currItem;
+                    }
+                } else if (!lodash_es_isEqual(prevItem, currItem)) {
+                    mergedItemList[i] = currItem;
+                }
+            } else {
+                mergedItemList.push(currItem);
+            }
+        }
+        return mergedItemList;
+    }
+    /**
+   * Merge refer_items arrays by index
+   */ mergeReferItems(prevReferItems, currReferItems) {
+        const mergedReferItems = [
+            ...prevReferItems
+        ];
+        for(let i = 0; i < currReferItems.length; i++){
+            const currReferItem = currReferItems[i];
+            if (i < mergedReferItems.length) {
+                mergedReferItems[i] = currReferItem;
+            } else {
+                mergedReferItems.push(currReferItem);
+            }
+        }
+        return mergedReferItems;
+    }
     concatContentAndUpdateMessage(message) {
         const previousIndex = this.streamMessageBuffer.findIndex((item)=>item.message_id === message.message_id);
         // new
@@ -268379,27 +268532,45 @@ class StreamBufferHelper {
         }
         // update
         const previousMessage = this.streamMessageBuffer.at(previousIndex);
+        // 如果是 completed 消息（is_finish = true），直接替换，不合并
+        if (message.is_finish) {
+            this.streamMessageBuffer[previousIndex] = message;
+            return;
+        }
         // For Mix type (object_string), merge item_list arrays instead of string concatenation
+        // Support streaming messages: when receiving message.delta data with object_string content,
+        // merge it with previous data of the same message using append rule
+        // IMPORTANT: Current content may contain the full accumulated array, so we need to compare
+        // and only add new items that don't exist in the previous content
         if (message.content_type === types_ContentType.Mix) {
             try {
-                var _prevContent_value, _currContent_value;
+                var _prevContent_value, _currContent_value, _prevContent_value1, _currContent_value1;
                 const prevContent = safeJSONParse((previousMessage === null || previousMessage === void 0 ? void 0 : previousMessage.content) || '{}', {
-                    item_list: []
+                    item_list: [],
+                    refer_items: []
                 });
                 const currContent = safeJSONParse(message.content, {
-                    item_list: []
+                    item_list: [],
+                    refer_items: []
                 });
+                const prevItemList = ((_prevContent_value = prevContent.value) === null || _prevContent_value === void 0 ? void 0 : _prevContent_value.item_list) || [];
+                const currItemList = ((_currContent_value = currContent.value) === null || _currContent_value === void 0 ? void 0 : _currContent_value.item_list) || [];
+                const prevReferItems = ((_prevContent_value1 = prevContent.value) === null || _prevContent_value1 === void 0 ? void 0 : _prevContent_value1.refer_items) || [];
+                const currReferItems = ((_currContent_value1 = currContent.value) === null || _currContent_value1 === void 0 ? void 0 : _currContent_value1.refer_items) || [];
+                // Merge item_list by index: update items at the same index, keep previous items if not updated
+                // For arrays, merge by index position: update existing items, keep others unchanged
+                // Special handling: if both prevItem and currItem are JSON items with array json fields, merge the arrays
+                const mergedItemList = this.mergeItemList(prevItemList, currItemList);
+                const mergedReferItems = this.mergeReferItems(prevReferItems, currReferItems);
                 const mergedContent = {
-                    item_list: [
-                        ...((_prevContent_value = prevContent.value) === null || _prevContent_value === void 0 ? void 0 : _prevContent_value.item_list) || [],
-                        ...((_currContent_value = currContent.value) === null || _currContent_value === void 0 ? void 0 : _currContent_value.item_list) || []
-                    ],
-                    refer_items: []
+                    item_list: mergedItemList,
+                    refer_items: mergedReferItems
                 };
                 message.content = JSON.stringify(mergedContent);
                 message.content_obj = mergedContent;
             } catch (e) {
                 // Fallback to string concatenation if parsing fails
+                // Error is intentionally ignored as we fallback to string concatenation
                 message.content = ((previousMessage === null || previousMessage === void 0 ? void 0 : previousMessage.content) || '') + message.content;
                 message.content_obj = message.content;
             }
@@ -268510,7 +268681,8 @@ class ChunkProcessor {
         const { message } = chunk;
         // Find all corresponding replies
         const replyMessages = this.getReplyMessagesByReplyId(message.reply_id);
-        // Find if there is a verbose message, and identify the end of the answer, and filter out the finish of the interrupt scene
+        // Find if there is a verbose message, and identify the end of the answer,
+        // and filter out the finish of the interrupt scene
         const finalAnswerVerboseMessage = replyMessages.find((replyMessage)=>{
             const { type, content } = replyMessage;
             if (type !== 'verbose') {
@@ -268521,7 +268693,9 @@ class ChunkProcessor {
                 return false;
             }
             const { value: verboseContentData } = safeJSONParse(verboseContent.data, null);
-            // At present, there may be a finish package in a group. If you need to filter out the interrupt scene through finish_reason, you will get the finish that answers all the ends.
+            // At present, there may be a finish package in a group.
+            // If you need to filter out the interrupt scene through finish_reason,
+            // you will get the finish that answers all the ends.
             return verboseContent.msg_type === types_VerboseMsgType.GENERATE_ANSWER_FINISH && (verboseContentData === null || verboseContentData === void 0 ? void 0 : verboseContentData.finish_reason) !== types_FinishReasonType.INTERRUPT;
         });
         return Boolean(finalAnswerVerboseMessage);
@@ -269345,6 +269519,14 @@ class HttpChunk extends CustomEventEmitter {
             }
             await fetchStream(channelFetchInfo.url, {
                 onStart: (response)=>{
+                    // 如果状态码是错误状态码（>= HTTP_BAD_REQUEST），尝试读取响应体以获取错误信息
+                    const HTTP_BAD_REQUEST = 400;
+                    if (response.status >= HTTP_BAD_REQUEST) {
+                        const cloneResponse = response.clone();
+                        cloneResponse.text().catch(()=>{
+                        // 忽略读取错误
+                        });
+                    }
                     fetchDataHelper.setLogID(response.headers.get('x-tt-logid'));
                     return Promise.resolve();
                 },
@@ -269392,7 +269574,8 @@ class HttpChunk extends CustomEventEmitter {
                 streamParser: (onGetMessageStreamParser === null || onGetMessageStreamParser === void 0 ? void 0 : onGetMessageStreamParser(value)) || utils_streamParser,
                 dataClump: fetchDataHelper,
                 body: channelFetchInfo.body,
-                headers: channelFetchInfo.headers,
+                // 将 headers 数组转换为 Headers 对象，因为 fetch API 需要 Headers 对象或普通对象
+                headers: new Headers(channelFetchInfo.headers),
                 method: channelFetchInfo.method,
                 signal: fetchDataHelper.abortSignal.signal,
                 totalFetchTimeout: fetchDataHelper.totalFetchTimeout,
@@ -269418,7 +269601,8 @@ class HttpChunk extends CustomEventEmitter {
             }
             this.customEmit(http_chunk_events_HttpChunkEvents.READ_STREAM_ERROR, errorInfo);
             return;
-        // TODO: The following should be the logic to re-pull the message. The server level did not have time to do it in this issue.
+        // TODO: The following should be the logic to re-pull the message.
+        // The server level did not have time to do it in this issue.
         // if (dataClump.retryCounter.matchMaxRetryAttempts()) {
         //   this.customOnError?.(errorInfo);
         //   //give up trying and try again
@@ -271827,43 +272011,6 @@ function isError_isError(value) {
 
 /* ESM default export */ const lodash_es_isError = (isError_isError);
 
-;// CONCATENATED MODULE: ../../../../../common/temp/default/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isEqual.js
-
-
-/**
- * Performs a deep comparison between two values to determine if they are
- * equivalent.
- *
- * **Note:** This method supports comparing arrays, array buffers, booleans,
- * date objects, error objects, maps, numbers, `Object` objects, regexes,
- * sets, strings, symbols, and typed arrays. `Object` objects are compared
- * by their own, not inherited, enumerable properties. Functions and DOM
- * nodes are compared by strict equality, i.e. `===`.
- *
- * @static
- * @memberOf _
- * @since 0.1.0
- * @category Lang
- * @param {*} value The value to compare.
- * @param {*} other The other value to compare.
- * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
- * @example
- *
- * var object = { 'a': 1 };
- * var other = { 'a': 1 };
- *
- * _.isEqual(object, other);
- * // => true
- *
- * object === other;
- * // => false
- */
-function lodash_es_isEqual_isEqual(value, other) {
-  return _baseIsEqual(value, other);
-}
-
-/* ESM default export */ const lodash_es_isEqual = (lodash_es_isEqual_isEqual);
-
 ;// CONCATENATED MODULE: ../../../../../common/temp/default/node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/head.js
 /**
  * Gets the first element of `array`.
@@ -297547,6 +297694,9 @@ const JsonItemList = (param)=>{
     }
     return /*#__PURE__*/ (0,jsx_runtime.jsx)(jsx_runtime.Fragment, {
         children: jsonItemList.map((item, idx)=>{
+            // Use a stable key based on item content and index to avoid React reusing components incorrectly
+            // This ensures that when items are updated, React correctly updates the component instead of reusing it
+            const itemKey = `json-${message.message_id}-${idx}-${JSON.stringify(item.json).slice(0, 50)}`;
             if (JsonItem) {
                 return /*#__PURE__*/ (0,jsx_runtime.jsx)("div", {
                     // className={typeSafeMessageBoxInnerVariants({
@@ -297563,7 +297713,7 @@ const JsonItemList = (param)=>{
                         schemaVersion: item.schema_version,
                         message: message
                     })
-                }, `json-${idx}`);
+                }, itemKey);
             }
             // Default fallback: use built-in JSON viewer
             return /*#__PURE__*/ (0,jsx_runtime.jsx)("div", {
@@ -297574,7 +297724,7 @@ const JsonItemList = (param)=>{
                     data: item.json,
                     schemaVersion: item.schema_version
                 })
-            }, `json-${idx}`);
+            }, itemKey);
         })
     });
 };
@@ -407437,6 +407587,8 @@ const usePaginationRequest = (param)=>{
     const [currentPage, setCurrentPage] = (0,react.useState)(initialPageNum);
     const [allData, setAllData] = (0,react.useState)([]);
     const [hasMore, setHasMore] = (0,react.useState)(true);
+    // 使用 ref 跟踪是否已经自动加载过，避免重复请求
+    const hasAutoLoadedRef = (0,react.useRef)(false);
     const { loading, error, run } = es_useRequest(async (pageNum)=>{
         const targetPage = pageNum ?? currentPage;
         const params = {
@@ -407526,8 +407678,10 @@ const usePaginationRequest = (param)=>{
         });
     }, []);
     // 组件挂载时自动加载第一页
+    // 修复：使用 ref 跟踪是否已加载，避免重复请求
     (0,react.useEffect)(()=>{
-        if (autoLoad) {
+        if (autoLoad && !hasAutoLoadedRef.current) {
+            hasAutoLoadedRef.current = true;
             run(initialPageNum);
         }
     }, [
@@ -407551,7 +407705,7 @@ const usePaginationRequest = (param)=>{
 };
 
 ;// CONCATENATED MODULE: ../open-chat/src/components/studio-open-chat/hooks/use-conversation-list.ts
-/*
+/* eslint-disable max-lines -- This file handles complex conversation list synchronization logic that requires many lines */ /*
  * Copyright 2025 coze-dev Authors
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -407581,7 +407735,7 @@ const usePaginationRequest = (param)=>{
 
 
 
-// eslint-disable-next-line @coze-arch/max-line-per-function
+// eslint-disable-next-line @coze-arch/max-line-per-function -- This hook handles complex conversation list management logic that requires many lines
 const useConversationList = (conversationListParams)=>{
     const { pageSize = 20, initialPageNum = 1, order = 'updated_at' } = conversationListParams ?? {};
     const { chatConfig: { bot_id: botId, appInfo, type: chatType, auth: { connectorId } = {} } } = context_useChatAppProps();
@@ -407601,15 +407755,29 @@ const useConversationList = (conversationListParams)=>{
     // 使用 ref 来跟踪是否正在同步，避免循环更新
     const isSyncingRef = (0,react.useRef)(false);
     const lastStoreIdsRef = (0,react.useRef)('');
+    // 使用 ref 原子性地跟踪 App 模式的加载状态，防止竞态条件
+    const appModeLoadingRef = (0,react.useRef)(false);
     // App 模式：使用基于 before_updated_at 和 limit 的加载逻辑
     const [appModeData, setAppModeData] = (0,react.useState)([]);
     const [appModeLoading, setAppModeLoading] = (0,react.useState)(false);
     const [appModeHasMore, setAppModeHasMore] = (0,react.useState)(true);
     const [beforeUpdatedAt, setBeforeUpdatedAt] = (0,react.useState)(undefined);
+    // 同步 appModeLoading 状态到 ref
+    (0,react.useEffect)(()=>{
+        appModeLoadingRef.current = appModeLoading;
+    }, [
+        appModeLoading
+    ]);
     const loadAppModeConversations = (0,react.useCallback)(async (beforeTimestamp)=>{
-        if (!cozeApiSdk || !hasValidId || !isAppType || appModeLoading) {
+        if (!cozeApiSdk || !hasValidId || !isAppType) {
+            return;
+        }
+        // 原子性检查：如果已经在加载，直接返回
+        if (appModeLoadingRef.current) {
             return;
         }
+        // 原子性设置：立即设置 ref，防止并发调用
+        appModeLoadingRef.current = true;
         setAppModeLoading(true);
         try {
             var _res_data, _res_data1;
@@ -407674,6 +407842,8 @@ const useConversationList = (conversationListParams)=>{
             console.error(e);
             setAppModeHasMore(false);
         } finally{
+            // 原子性重置：先重置 ref，再更新状态
+            appModeLoadingRef.current = false;
             setAppModeLoading(false);
         }
     }, [
@@ -407787,18 +407957,36 @@ const useConversationList = (conversationListParams)=>{
     // 同步 finalData 到 store（只在本地数据源变化时更新 store，避免循环）
     // 注意：这个 useEffect 只在从服务器加载数据时触发，不会在 store 同步到本地数据源时触发
     (0,react.useEffect)(()=>{
-        if (finalData && !isSyncingRef.current) {
+        // 如果正在同步，跳过，避免循环更新
+        if (isSyncingRef.current) {
+            return;
+        }
+        if (finalData && finalData.length > 0) {
             // 比较数据是否真的变化了，避免不必要的更新
             const currentIds = conversations.map((c)=>c.id).sort().join(',');
             const newIds = finalData.map((c)=>c.id).sort().join(',');
+            // 只有在 ID 列表真的发生变化时才更新 store
+            // 这样可以避免因为对象引用变化导致的重复更新
             if (currentIds !== newIds) {
-                // 只有在本地数据源是从服务器加载的新数据时才更新 store
-                // 如果是因为 store 同步导致的 finalData 变化，不应该再次更新 store
-                isSyncingRef.current = true;
-                updateConversations(finalData, 'replace');
-                setTimeout(()=>{
-                    isSyncingRef.current = false;
-                }, 0);
+                // 检查是否是store新增了会话（store的ID数量增加了）
+                // 如果是store新增，不应该在这里更新store，应该让监听store的useEffect处理
+                const storeCount = conversations.length;
+                const finalDataCount = finalData.length;
+                const isStoreNewer = storeCount > finalDataCount;
+                // 只有在finalData比store新（从服务器加载了新数据）时才更新store
+                // 如果store比finalData新（store新增了会话），不应该更新store
+                if (!isStoreNewer) {
+                    // 只有在本地数据源是从服务器加载的新数据时才更新 store
+                    // 如果是因为 store 同步导致的 finalData 变化，不应该再次更新 store
+                    isSyncingRef.current = true;
+                    updateConversations(finalData, 'replace');
+                    // 使用 requestAnimationFrame 确保在下一个事件循环中重置标志
+                    requestAnimationFrame(()=>{
+                        setTimeout(()=>{
+                            isSyncingRef.current = false;
+                        }, 0);
+                    });
+                }
             }
         }
     }, [
@@ -407806,99 +407994,182 @@ const useConversationList = (conversationListParams)=>{
         updateConversations,
         conversations
     ]);
+    // 检查会话是否有更新的辅助函数
+    const checkConversationUpdates = (0,react.useCallback)((storeConversations, localConversations)=>{
+        const localMap = new Map(localConversations.map((c)=>[
+                c.id,
+                c
+            ]));
+        return storeConversations.some((storeConv)=>{
+            const localConv = localMap.get(storeConv.id);
+            if (!localConv) {
+                return false;
+            }
+            const storeConvWithTitle = storeConv;
+            const localConvWithTitle = localConv;
+            return storeConvWithTitle.title !== localConvWithTitle.title || storeConv.name !== localConv.name || storeConv.updated_at !== localConv.updated_at;
+        });
+    }, []);
+    // 同步 App 模式更新的辅助函数
+    const syncAppModeUpdates = (0,react.useCallback)(()=>{
+        isSyncingRef.current = true;
+        setAppModeData((prev)=>{
+            const prevMap = new Map(prev.map((c)=>[
+                    c.id,
+                    c
+                ]));
+            return conversations.map((storeConv)=>{
+                const prevConv = prevMap.get(storeConv.id);
+                return prevConv ? {
+                    ...prevConv,
+                    ...storeConv
+                } : storeConv;
+            });
+        });
+        requestAnimationFrame(()=>{
+            setTimeout(()=>{
+                isSyncingRef.current = false;
+            }, 0);
+        });
+    }, [
+        conversations
+    ]);
+    // 同步 Bot 模式更新的辅助函数
+    const syncBotModeUpdates = (0,react.useCallback)(()=>{
+        isSyncingRef.current = true;
+        const localMap = new Map(data.map((c)=>[
+                c.id,
+                c
+            ]));
+        const updatedConversations = conversations.filter((storeConv)=>localMap.has(storeConv.id)).map((storeConv)=>{
+            const localConv = localMap.get(storeConv.id);
+            return localConv ? {
+                ...localConv,
+                ...storeConv
+            } : storeConv;
+        });
+        updatedConversations.forEach((conv)=>{
+            removeBotModeItem((c)=>c.id === conv.id);
+        });
+        updatedConversations.reverse().forEach((conv)=>{
+            addBotModeItem(conv, 'start');
+        });
+        requestAnimationFrame(()=>{
+            setTimeout(()=>{
+                isSyncingRef.current = false;
+            }, 0);
+        });
+    }, [
+        conversations,
+        data,
+        removeBotModeItem,
+        addBotModeItem
+    ]);
+    // 处理删除的辅助函数
+    const handleDeletions = (0,react.useCallback)((storeIds, localIds)=>{
+        const deletedIds = Array.from(localIds).filter((id)=>!storeIds.has(id));
+        if (deletedIds.length === 0) {
+            return;
+        }
+        isSyncingRef.current = true;
+        if (isAppType) {
+            setAppModeData((prev)=>prev.filter((c)=>!deletedIds.includes(c.id)));
+        } else {
+            removeBotModeItem((c)=>deletedIds.includes(c.id));
+        }
+        requestAnimationFrame(()=>{
+            setTimeout(()=>{
+                isSyncingRef.current = false;
+            }, 0);
+        });
+    }, [
+        isAppType,
+        removeBotModeItem
+    ]);
+    // 处理新增会话的辅助函数
+    const handleNewConversations = (0,react.useCallback)((newConversations)=>{
+        if (newConversations.length === 0) {
+            return;
+        }
+        isSyncingRef.current = true;
+        try {
+            if (isAppType) {
+                setAppModeData((prev)=>[
+                        ...newConversations,
+                        ...prev
+                    ]);
+            } else {
+                newConversations.forEach((conv)=>{
+                    addBotModeItem(conv, 'start');
+                });
+            }
+        } finally{
+            requestAnimationFrame(()=>{
+                setTimeout(()=>{
+                    isSyncingRef.current = false;
+                }, 50);
+            });
+        }
+    }, [
+        isAppType,
+        addBotModeItem
+    ]);
     // 监听 store 的 conversations 变化，同步更新本地数据源
     // 只在 store 有新增会话时才同步，避免循环更新
     (0,react.useEffect)(()=>{
+        if (isSyncingRef.current) {
+            return;
+        }
         const currentStoreIds = conversations.map((c)=>c.id).sort().join(',');
-        // 如果 store 的 ID 列表没有变化，跳过
-        if (currentStoreIds === lastStoreIdsRef.current) {
+        const localConversations = isAppType ? appModeData : data;
+        const hasUpdates = checkConversationUpdates(conversations, localConversations);
+        if (currentStoreIds === lastStoreIdsRef.current && currentStoreIds !== '' && !hasUpdates) {
+            return;
+        }
+        if (hasUpdates && (currentStoreIds === lastStoreIdsRef.current && currentStoreIds !== '' || lastStoreIdsRef.current === '' && currentStoreIds !== '')) {
+            if (isAppType) {
+                syncAppModeUpdates();
+            } else {
+                syncBotModeUpdates();
+            }
+            lastStoreIdsRef.current = currentStoreIds;
             return;
         }
-        // 检查是否有新增（store 的数量增加了）
         const storeCount = conversations.length;
-        const lastStoreCount = lastStoreIdsRef.current.split(',').filter(Boolean).length;
+        const lastStoreCount = lastStoreIdsRef.current ? lastStoreIdsRef.current.split(',').filter(Boolean).length : 0;
         const hasNewConversations = storeCount > lastStoreCount;
         const hasDeletedConversations = storeCount < lastStoreCount;
-        // 更新 ref
         lastStoreIdsRef.current = currentStoreIds;
-        // 如果有删除，同步到本地数据源
         if (hasDeletedConversations) {
-            // 如果正在同步（可能是删除操作触发的），跳过
-            if (isSyncingRef.current) {
-                return;
-            }
-            if (isAppType) {
-                const storeIds = new Set(conversations.map((c)=>c.id));
-                const localIds = new Set(appModeData.map((c)=>c.id));
-                const deletedIds = Array.from(localIds).filter((id)=>!storeIds.has(id));
-                if (deletedIds.length > 0) {
-                    isSyncingRef.current = true;
-                    setAppModeData((prev)=>prev.filter((c)=>!deletedIds.includes(c.id)));
-                    setTimeout(()=>{
-                        isSyncingRef.current = false;
-                    }, 0);
-                }
-            } else {
-                const storeIds = new Set(conversations.map((c)=>c.id));
-                const localIds = new Set(data.map((c)=>c.id));
-                const deletedIds = Array.from(localIds).filter((id)=>!storeIds.has(id));
-                if (deletedIds.length > 0) {
-                    isSyncingRef.current = true;
-                    removeBotModeItem((c)=>deletedIds.includes(c.id));
-                    setTimeout(()=>{
-                        isSyncingRef.current = false;
-                    }, 0);
-                }
-            }
+            const storeIds = new Set(conversations.map((c)=>c.id));
+            const localIds = new Set(localConversations.map((c)=>c.id));
+            handleDeletions(storeIds, localIds);
             return;
         }
-        // 只在有新增会话时才同步，避免其他变化导致的循环
         if (!hasNewConversations && storeCount === lastStoreCount) {
-            // 可能是更新，不需要同步
-            return;
-        }
-        // 有新增会话，同步到本地数据源
-        // 注意：即使 isSyncingRef.current 为 true，也要处理新增，因为删除和新增可能同时发生
-        isSyncingRef.current = true;
-        try {
-            if (isAppType) {
-                // App 模式：检查 store 中是否有新会话不在本地数据源中
-                const localIds = new Set(appModeData.map((c)=>c.id));
-                // 找出 store 中有但本地没有的会话（新添加的）
-                const newConversations = conversations.filter((c)=>!localIds.has(c.id));
-                if (newConversations.length > 0) {
-                    // 将新会话添加到本地数据源的开头（最新的会话应该在前面）
-                    setAppModeData((prev)=>[
-                            ...newConversations,
-                            ...prev
-                        ]);
-                }
-            } else {
-                // Bot 模式：检查 store 中是否有新会话不在本地数据源中
-                const localIds = new Set(data.map((c)=>c.id));
-                // 找出 store 中有但本地没有的会话（新添加的）
-                const newConversations = conversations.filter((c)=>!localIds.has(c.id));
-                if (newConversations.length > 0) {
-                    // 将新会话添加到本地数据源的开头（最新的会话应该在前面）
-                    newConversations.forEach((conv)=>{
-                        addBotModeItem(conv, 'start');
-                    });
+            const hasLocalUpdates = checkConversationUpdates(conversations, localConversations);
+            if (hasLocalUpdates) {
+                if (isAppType) {
+                    syncAppModeUpdates();
+                } else {
+                    syncBotModeUpdates();
                 }
             }
-        } finally{
-            // 使用 setTimeout 确保状态更新完成后再重置标志
-            // 延迟时间稍微长一点，确保第一个 useEffect 不会触发
-            setTimeout(()=>{
-                isSyncingRef.current = false;
-            }, 100);
+            return;
         }
+        const localIds = new Set(localConversations.map((c)=>c.id));
+        const newConversations = conversations.filter((c)=>!localIds.has(c.id));
+        handleNewConversations(newConversations);
     }, [
         conversations,
         isAppType,
         appModeData,
         data,
-        removeBotModeItem,
-        addBotModeItem
+        checkConversationUpdates,
+        syncAppModeUpdates,
+        syncBotModeUpdates,
+        handleDeletions,
+        handleNewConversations
     ]);
     (0,react.useEffect)(()=>{
         if (!currentConversationInfo) {
@@ -407935,7 +408206,7 @@ const useConversationList = (conversationListParams)=>{
         updateCurrentConversationInfo
     ]);
     return {
-        conversations,
+        conversations: finalData,
         loading: finalLoading,
         hasMore: finalHasMore,
         loadMore: finalLoadMore,
@@ -408046,12 +408317,12 @@ const isUUID = (str)=>{
 };
 /**
  * 获取会话显示名称
- * 优先级：title > name（如果不是UUID）> 新创建的会话
+ * 优先级：title（如果不是UUID）> name（如果不是UUID）> 新创建的会话
  * @param item 会话项
  * @returns 显示名称
  */ const getConversationDisplayName = (item)=>{
-    // 优先使用title
-    if (item.title) {
+    // 优先使用title，但需要检查是否是UUID
+    if (item.title && !isUUID(item.title)) {
         return item.title;
     }
     // 如果name存在且不是UUID格式，使用name
@@ -408059,7 +408330,7 @@ const isUUID = (str)=>{
         return item.name;
     }
     // 否则显示"新创建的会话"
-    return intl_i18n.t('web_sdk_conversation_default_name');
+    return intl_i18n.t('web_sdk_conversation_default_name', {}, '新创建的会话');
 };
 
 ;// CONCATENATED MODULE: ../open-chat/src/components/conversation-list-sider/conversation-item/mobile/operate/index.tsx
@@ -408555,6 +408826,16 @@ const ConversationList = /*#__PURE__*/ (0,react.forwardRef)(// eslint-disable-ne
     ]);
     const listContainerRef = (0,react.useRef)(null);
     const loadMoreRef = (0,react.useRef)(null);
+    // 使用 ref 存储 loadMore 函数，避免 useEffect 依赖项变化导致 observer 重新创建
+    const loadMoreRefFn = (0,react.useRef)(loadMore);
+    // 使用 ref 跟踪是否正在加载，防止重复调用
+    const isLoadingRef = (0,react.useRef)(false);
+    // 更新 loadMoreRefFn 当 loadMore 变化时
+    (0,react.useEffect)(()=>{
+        loadMoreRefFn.current = loadMore;
+    }, [
+        loadMore
+    ]);
     const handleCreateConversation = ()=>{
         if (!currentConversationInfo) {
             return Promise.resolve();
@@ -408696,11 +408977,21 @@ const ConversationList = /*#__PURE__*/ (0,react.forwardRef)(// eslint-disable-ne
             handleCreateConversation,
             handleDeleteConversation
         }));
+    // 同步 loading 状态到 ref
+    (0,react.useEffect)(()=>{
+        isLoadingRef.current = loading;
+    }, [
+        loading
+    ]);
     (0,react.useEffect)(()=>{
         const observer = new IntersectionObserver((entries)=>{
             const [entry] = entries;
-            if (entry.isIntersecting && hasMore && !loading) {
-                loadMore();
+            // 使用 ref 中的最新值，避免闭包问题
+            // 注意：loadMore 函数内部已经有原子性检查，这里只需要检查基本条件
+            if (entry.isIntersecting && hasMore && !isLoadingRef.current) {
+                // 使用 ref 中的最新函数
+                // loadMore 函数内部已经有原子性检查，可以安全地多次调用
+                loadMoreRefFn.current();
             }
         }, {
             root: listContainerRef.current,
@@ -408711,15 +409002,12 @@ const ConversationList = /*#__PURE__*/ (0,react.forwardRef)(// eslint-disable-ne
             observer.observe(loadMoreRef.current);
         }
         return ()=>{
-            if (loadMoreRef.current) {
-                observer.unobserve(loadMoreRef.current);
-            }
+            // 确保完全断开 observer 连接，防止旧的 observer 继续工作
+            observer.disconnect();
         };
     }, [
-        hasMore,
-        loading,
-        loadMore
-    ]);
+        hasMore
+    ]); // 只依赖 hasMore，不依赖 loading 和 loadMore
     return /*#__PURE__*/ (0,jsx_runtime.jsxs)("div", {
         className: conversation_list_sider_conversation_list_index_module.conversations,
         style: {
@@ -409219,6 +409507,13 @@ const storageUtil = {
 
 
 
+
+
+
+
+
+
+
 const getDefaultUserInfo = (userInfo)=>{
     if (userInfo === null || userInfo === void 0 ? void 0 : userInfo.id) {
         return userInfo;
@@ -409230,6 +409525,7 @@ const getDefaultUserInfo = (userInfo)=>{
         url: ''
     };
 };
+// eslint-disable-next-line @coze-arch/max-line-per-function -- Store creation function contains comprehensive state management logic
 const createChatStore = (chatConfig, userInfo)=>{
     var _chatConfig_auth, _chatConfig_auth1;
     const isNeedToken = (chatConfig === null || chatConfig === void 0 ? void 0 : (_chatConfig_auth = chatConfig.auth) === null || _chatConfig_auth === void 0 ? void 0 : _chatConfig_auth.type) === client_AuthType.TOKEN;
@@ -409413,20 +409709,28 @@ const createChatStore = (chatConfig, userInfo)=>{
                             ]));
                         s.conversations = conversations.map((newConv)=>{
                             const existingConv = existingConversationsMap.get(newConv.id);
-                            if (existingConv && existingConv.title) {
+                            const existingConvWithTitle = existingConv;
+                            if (existingConvWithTitle === null || existingConvWithTitle === void 0 ? void 0 : existingConvWithTitle.title) {
                                 // 如果store中已有该会话且有title，保留title
-                                return {
-                                    ...newConv,
-                                    title: existingConv.title
-                                };
+                                return Object.assign({
+                                    ...newConv
+                                }, {
+                                    title: existingConvWithTitle.title
+                                });
                             }
                             return newConv;
                         });
                     } else if (operate === 'add') {
-                        s.conversations = [
-                            ...s.conversations,
-                            ...conversations
-                        ];
+                        // 修复：添加去重逻辑，避免重复添加相同的会话
+                        const existingIds = new Set(s.conversations.map((c)=>c.id));
+                        const newConversations = conversations.filter((c)=>c.id && !existingIds.has(c.id));
+                        if (newConversations.length > 0) {
+                            // 将新会话添加到列表开头（最新的会话应该在前面）
+                            s.conversations = [
+                                ...newConversations,
+                                ...s.conversations
+                            ];
+                        }
                     } else if (operate === 'remove') {
                         conversations.forEach((conversation)=>{
                             const index = s.conversations.findIndex((c)=>c.id === conversation.id);
@@ -417060,6 +417364,7 @@ const convertShortcutData = (shortcutCommands, botInfo)=>//@ts-expect-error: 不
 
 
 
+
 const microSeconds = 1000;
 /**
  * 从URL中提取文件名
@@ -417098,6 +417403,55 @@ const microSeconds = 1000;
 };
 // 消息转换成 Coze的消息，主要用于消息接收后，在页面显示。
 class MessageConverseToCoze {
+    /**
+   * 合并两个 JSON 对象（深度合并）
+   * - 如果两个值都是对象，递归合并
+   * - 如果两个值都是字符串，追加字符串
+   * - 如果两个值都是数组，合并数组（按索引合并）
+   * - 否则使用 curr 的值（覆盖）
+   */ mergeJsonObjects(prev, curr) {
+        const merged = {
+            ...prev
+        };
+        for(const key in curr){
+            if (Object.prototype.hasOwnProperty.call(curr, key)) {
+                const prevValue = prev[key];
+                const currValue = curr[key];
+                // 如果两个值都是对象，递归合并
+                if (typeof prevValue === 'object' && prevValue !== null && !Array.isArray(prevValue) && typeof currValue === 'object' && currValue !== null && !Array.isArray(currValue)) {
+                    merged[key] = this.mergeJsonObjects(prevValue, currValue);
+                } else if (typeof prevValue === 'string' && typeof currValue === 'string') {
+                    // 如果两个值都是字符串，追加字符串
+                    merged[key] = prevValue + currValue;
+                } else if (Array.isArray(prevValue) && Array.isArray(currValue)) {
+                    // 如果两个值都是数组，按索引合并
+                    const mergedArray = [
+                        ...prevValue
+                    ];
+                    for(let i = 0; i < currValue.length; i++){
+                        const currItem = currValue[i];
+                        if (i < mergedArray.length) {
+                            // 如果索引已存在，尝试合并
+                            const prevItem = mergedArray[i];
+                            if (typeof prevItem === 'object' && prevItem !== null && !Array.isArray(prevItem) && typeof currItem === 'object' && currItem !== null && !Array.isArray(currItem)) {
+                                mergedArray[i] = this.mergeJsonObjects(prevItem, currItem);
+                            } else {
+                                mergedArray[i] = currItem;
+                            }
+                        } else {
+                            // 如果索引超出范围，追加新元素
+                            mergedArray.push(currItem);
+                        }
+                    }
+                    merged[key] = mergedArray;
+                } else {
+                    // 否则使用 curr 的值（覆盖）
+                    merged[key] = currValue;
+                }
+            }
+        }
+        return merged;
+    }
     convertMessageListResponse(res) {
         let botId = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : '';
         const { data: messageList = [], has_more: hasMore, first_id: firstId, last_id: lastId } = res;
@@ -417116,7 +417470,11 @@ class MessageConverseToCoze {
         const { content_type, content } = this.convertContent(message.content_type, message.content) || {};
         const isQuestion = message.type === 'question';
         const replyId = message.chat_id || `--custom-replyId--${index_browser_nanoid()}`;
-        const messageId = isQuestion ? replyId : message.id || `--custom-messageId-${index_browser_nanoid()}`; // 无messageId，输出一个默认的
+        // 对于流式的 object_string 消息，使用 message.id 作为 message_id
+        // 这样可以确保不同 id 的消息不会被合并
+        const isStreamingObjectString = message.content_type === 'object_string' && message.type === 'answer';
+        const messageId = isQuestion ? replyId : isStreamingObjectString ? message.id || `--custom-messageId-${index_browser_nanoid()}` // 对于流式 object_string，使用 message.id 作为 message_id
+         : message.id || `--custom-messageId-${index_browser_nanoid()}`; // 无messageId，输出一个默认的
         const senderId = isQuestion ? '' : message.bot_id || botId;
         if (!content_type || !messageId || !replyId) {
             return {};
@@ -417207,12 +417565,30 @@ class MessageConverseToCoze {
         }
     }
     convertMixContent(content) {
-        const contentObj = catchParse(content);
-        if (!contentObj) {
+        // 先尝试解析 JSON 字符串为数组
+        // 对于流式 object_string 消息，content 可能是 JSON 数组字符串，需要先解析
+        let parsedContent;
+        try {
+            const trimmedContent = content.trim();
+            // 尝试解析为 JSON 数组
+            const parsed = JSON.parse(trimmedContent);
+            if (Array.isArray(parsed)) {
+                parsedContent = parsed;
+            } else {
+                // 如果不是数组，尝试作为单个对象解析
+                parsedContent = [
+                    parsed
+                ];
+            }
+        } catch (e) {
+            // 解析失败，尝试使用 catchParse（可能是不完整的 JSON）
+            parsedContent = catchParse(content);
+        }
+        if (!parsedContent) {
             return;
         }
-        console.log('convertMixContent contentObj', contentObj);
-        const itemList = contentObj === null || contentObj === void 0 ? void 0 : contentObj.map((item)=>{
+        console.log('convertMixContent parsedContent', parsedContent);
+        const itemList = parsedContent === null || parsedContent === void 0 ? void 0 : parsedContent.map((item)=>{
             switch(item.type){
                 case 'text':
                     {
@@ -417281,9 +417657,52 @@ class MessageConverseToCoze {
                     }
             }
         }).filter((item)=>!!item);
+        // 合并所有 JSON item 为一个 item
+        // 如果 item_list 中有多个 JSON item，将它们合并为一个 JSON item
+        const jsonItems = itemList.filter((item)=>item.type === types_ContentType.Json);
+        const nonJsonItems = itemList.filter((item)=>item.type !== types_ContentType.Json);
+        let mergedJsonItem;
+        if (jsonItems.length > 0) {
+            // 如果只有一个 JSON item，直接使用它
+            if (jsonItems.length === 1) {
+                mergedJsonItem = jsonItems[0];
+            } else {
+                // 如果有多个 JSON item，合并它们的 json 字段
+                // 如果所有 json 字段都是对象，深度合并它们；否则合并为数组
+                const jsonValues = jsonItems.map((item)=>item.json);
+                const allAreObjects = jsonValues.every((json)=>typeof json === 'object' && json !== null && !Array.isArray(json));
+                let mergedJson;
+                if (allAreObjects) {
+                    // 深度合并所有对象
+                    mergedJson = jsonValues.reduce((acc, curr)=>{
+                        if (typeof acc === 'object' && acc !== null && !Array.isArray(acc) && typeof curr === 'object' && curr !== null && !Array.isArray(curr)) {
+                            return this.mergeJsonObjects(acc, curr);
+                        }
+                        return curr;
+                    }, jsonValues[0]);
+                } else {
+                    // 如果有一个不是对象，合并为数组
+                    mergedJson = jsonValues.length === 1 ? jsonValues[0] : jsonValues;
+                }
+                // 使用第一个 JSON item 的 schema_version
+                const schemaVersion = jsonItems[0].schema_version;
+                mergedJsonItem = {
+                    type: types_ContentType.Json,
+                    json: mergedJson,
+                    schema_version: schemaVersion
+                };
+            }
+        }
+        // 合并所有 item：非 JSON item + 合并后的 JSON item
+        const finalItemList = [
+            ...nonJsonItems
+        ];
+        if (mergedJsonItem) {
+            finalItemList.push(mergedJsonItem);
+        }
         const contentResult = {
-            item_list: itemList.filter((item)=>!item.is_refer),
-            refer_items: itemList.filter((item)=>item.is_refer)
+            item_list: finalItemList.filter((item)=>!item.is_refer),
+            refer_items: finalItemList.filter((item)=>item.is_refer)
         };
         return JSON.stringify(contentResult);
     }
@@ -417551,11 +417970,19 @@ const useRequestInit = ()=>{
     const updateShortcuts = context_useChatAppStore((s)=>s.updateShortcuts);
     const setIsStartBotVoiceCall = context_useChatAppStore((s)=>s.setIsStartBotVoiceCall);
     const updateBackgroundInfo = context_useChatAppStore((s)=>s.updateBackgroundInfo);
-    const { currentConversationInfo, updateCurrentConversationInfo, conversations } = context_useChatAppStore(shallow_useShallow((s)=>({
-            currentConversationInfo: s.currentConversationInfo,
-            updateCurrentConversationInfo: s.updateCurrentConversationInfo,
-            conversations: s.conversations
+    const { updateCurrentConversationInfo } = context_useChatAppStore(shallow_useShallow((s)=>({
+            updateCurrentConversationInfo: s.updateCurrentConversationInfo
         })));
+    // 使用 ref 来存储最新的 currentConversationInfo 和 conversations
+    // 这样可以避免将它们放在依赖数组中，从而避免 title/name 更新时触发重新初始化
+    const currentConversationInfoRef = (0,react.useRef)();
+    const conversationsRef = (0,react.useRef)([]);
+    // 通过 hook 获取值并更新 ref
+    context_useChatAppStore(shallow_useShallow((s)=>{
+        currentConversationInfoRef.current = s.currentConversationInfo;
+        conversationsRef.current = s.conversations;
+        return null; // 不返回任何值，只用于同步 ref
+    }));
     const getMessageListByPairs = useGetMessageListByPairs();
     const connectorId = (chatConfig === null || chatConfig === void 0 ? void 0 : (_chatConfig_auth = chatConfig.auth) === null || _chatConfig_auth === void 0 ? void 0 : _chatConfig_auth.connectorId) || '';
     const { bot_id: botId = '', type: chatType, appInfo } = chatConfig;
@@ -417603,6 +418030,9 @@ const useRequestInit = ()=>{
             const actualSectionId = requestDataConversationInfo.lastSectionId || '';
             // 如果从 openRequestInit 返回了 conversationName，使用它
             const actualConversationName = conversationName || '';
+            // 从 ref 中获取最新的 currentConversationInfo 和 conversations
+            const currentConversationInfo = currentConversationInfoRef.current;
+            const conversations = conversationsRef.current;
             if (actualConversationId) {
                 // 检查 currentConversationInfo 是否与实际的 conversationId 一致
                 // 如果 currentConversationInfo.id 为空字符串，说明是从空会话创建的，此时不应该更新
@@ -417650,14 +418080,21 @@ const useRequestInit = ()=>{
                         });
                     }
                 } else {
-                    // 如果 conversationId 一致，更新 sectionId 和 name（如果有）
+                    // 如果 conversationId 一致，只更新 sectionId（如果有变化）
+                    // 不更新 name，因为 name 会通过 conversation.update 事件自动更新
+                    // 这样可以避免 title/name 更新时触发重新初始化
                     const updates = {};
                     if (currentConversationInfo.last_section_id !== actualSectionId && actualSectionId) {
                         updates.last_section_id = actualSectionId;
                     }
-                    if (actualConversationName && currentConversationInfo.name !== actualConversationName) {
-                        updates.name = actualConversationName;
-                    }
+                    // 移除 name 的更新，因为 name 会通过 conversation.update 事件自动更新
+                    // 这样可以避免 title/name 更新时触发重新初始化
+                    // if (
+                    //   actualConversationName &&
+                    //   currentConversationInfo.name !== actualConversationName
+                    // ) {
+                    //   updates.name = actualConversationName;
+                    // }
                     if (Object.keys(updates).length > 0) {
                         updateCurrentConversationInfo({
                             ...currentConversationInfo,
@@ -417711,8 +418148,8 @@ const useRequestInit = ()=>{
         onDefaultHistoryClear,
         chatType,
         appInfo,
-        currentConversationInfo,
-        conversations,
+        // 不再依赖 currentConversationInfo 和 conversations
+        // 在函数内部通过 getState() 获取最新值，避免 title/name 更新时触发重新初始化
         updateCurrentConversationInfo,
         userInfo,
         openRequestInit
@@ -418056,7 +418493,27 @@ class MessageConverterToSdk {
         const contentType = messageBody.content_type;
         const content = messageBody.query;
         const shortcutCommand = messageBody.shortcut_command;
-        return JSON.stringify({
+        // API 要求 parameters 是 string 类型，如果传入的是对象，需要转换为 JSON 字符串
+        // 如果 parameters 是对象，需要递归序列化所有嵌套对象（包括 SETTING 等字段）
+        let parametersString;
+        if (parameters) {
+            if (typeof parameters === 'string') {
+                // 如果已经是字符串，尝试解析并重新序列化，确保内部对象（如 SETTING）也被序列化
+                try {
+                    const parsed = JSON.parse(parameters);
+                    parametersString = JSON.stringify(parsed);
+                } catch  {
+                    // 如果解析失败，说明不是有效的 JSON 字符串，直接使用原值
+                    parametersString = parameters;
+                }
+            } else if (typeof parameters === 'object') {
+                // 如果是对象，直接序列化（JSON.stringify 会递归序列化所有嵌套对象）
+                parametersString = JSON.stringify(parameters);
+            } else {
+                parametersString = String(parameters);
+            }
+        }
+        const requestBody = {
             bot_id: messageBody.bot_id,
             user_id: userInfo === null || userInfo === void 0 ? void 0 : userInfo.id,
             stream: true,
@@ -418064,10 +418521,11 @@ class MessageConverterToSdk {
             additional_messages: [
                 this.convertRequestMessage(contentType, content)
             ],
-            parameters,
+            parameters: parametersString,
             shortcut_command: this.convertShortcuts(shortcuts || [], shortcutCommand),
             enable_card: true
-        });
+        };
+        return JSON.stringify(requestBody);
     }
     // 替换 chat请求中的 message部分
     convertRequestMessage(contentType, content) {
@@ -419730,7 +420188,7 @@ const src_timeoutPromise = (ms)=>new Promise((resolve)=>{
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */ function message_parser_define_property(obj, key, value) {
+ */ /* eslint-disable max-lines */ function message_parser_define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -419752,6 +420210,7 @@ const src_timeoutPromise = (ms)=>new Promise((resolve)=>{
 
 
 
+
 // 消息解析，主要用于从服务端获取到消息后，解析成coze能适配的数据结构
 var message_parser_ChunkEvent = /*#__PURE__*/ (/* unused pure expression or super */ null && (function(ChunkEvent) {
     ChunkEvent["ERROR"] = "error";
@@ -419776,7 +420235,8 @@ class MessageParser {
                 }
             case "conversation.message.delta":
                 {
-                    const message = this.createMessage(data, false);
+                    // conversation.message.delta 不应该累积和合并，应该直接使用新内容
+                    const message = this.createMessage(data, false, false);
                     if (!message) {
                         return;
                     }
@@ -419784,7 +420244,8 @@ class MessageParser {
                 }
             case "conversation.message.completed":
                 {
-                    const messageResult = this.createMessage(data, true);
+                    // conversation.message.completed 不应该累积和合并，应该直接使用新内容
+                    const messageResult = this.createMessage(data, true, false);
                     // 清理流式 JSON 累积内容
                     if (messageResult && typeof messageResult === 'object' && 'data' in messageResult) {
                         const messageData = messageResult.data;
@@ -419795,6 +420256,8 @@ class MessageParser {
                             if (contentKey) {
                                 this.streamingJsonContent.delete(contentKey);
                                 this.lastValidJsonContent.delete(contentKey);
+                                this.lastReturnedParsedContent.delete(contentKey);
+                                this.lastReturnedAccumulatedContent.delete(contentKey);
                             }
                         }
                     }
@@ -419841,7 +420304,7 @@ class MessageParser {
         }
     }
     createMessage(data) {
-        let isComplete = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+        let isComplete = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false, shouldAccumulate = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : true;
         const dataValue = catchParse(data);
         if (!dataValue) {
             return;
@@ -419852,31 +420315,124 @@ class MessageParser {
         // 处理流式 JSON：当 content_type 是 object_string 且 type 是 answer 时
         const isStreamingJson = dataValue.content_type === 'object_string' && dataValue.type === 'answer';
         if (isStreamingJson && dataValue.content) {
-            // 使用 messageId 或 chatId 作为 key 来累积内容
-            const contentKey = dataValue.id || dataValue.chat_id || '';
+            // 对于流式 object_string 消息，使用 id 作为 key 来累积内容
+            // 这样可以确保不同 id 的消息不会被合并
+            // 但是，只有 shouldAccumulate 为 true 时才累积（conversation.chat.* 事件）
+            // conversation.message.delta 不应该累积，应该直接使用新内容
+            const contentKey = dataValue.id || '';
             if (contentKey) {
-                // 累积流式 JSON 内容
-                const accumulatedContent = this.streamingJsonContent.get(contentKey) || '';
-                const newContent = accumulatedContent + dataValue.content;
-                this.streamingJsonContent.set(contentKey, newContent);
-                // 尝试解析累积的内容
-                const parsedContent = this.tryParseStreamingJson(newContent);
-                if (parsedContent !== null) {
-                    // 如果解析成功，使用解析后的内容，并保存为最后一次有效内容
-                    dataValue.content = parsedContent;
-                    this.lastValidJsonContent.set(contentKey, parsedContent);
+                let newContent;
+                if (shouldAccumulate) {
+                    // 累积流式 JSON 内容（conversation.chat.* 事件）
+                    const accumulatedContent = this.streamingJsonContent.get(contentKey) || '';
+                    newContent = accumulatedContent + dataValue.content;
+                    this.streamingJsonContent.set(contentKey, newContent);
                 } else {
-                    // 如果解析失败（JSON 不完整），使用上一次成功解析的内容（如果有）
-                    // 这样可以避免每次 delta 都创建新消息，导致重复渲染
-                    const lastValidContent = this.lastValidJsonContent.get(contentKey);
-                    if (lastValidContent) {
-                        // 使用上一次成功解析的内容，避免重复渲染
-                        dataValue.content = lastValidContent;
-                    } else {
-                        // 如果完全没有成功解析的内容，使用累积的原始内容
-                        // 但这样可能会导致 convertMixContent 失败，返回 undefined
-                        dataValue.content = newContent;
+                    // 不累积，直接使用新内容（conversation.message.delta 事件）
+                    newContent = dataValue.content;
+                }
+                // 对于流式数组，我们需要传递完整的累积内容，而不是部分解析的内容
+                // 检查数组是否完整（以 ] 结尾）
+                const trimmedContent = newContent.trim();
+                const isArrayComplete = trimmedContent.startsWith('[') && trimmedContent.endsWith(']');
+                if (isArrayComplete) {
+                    // 数组完整，尝试解析完整的数组
+                    try {
+                        const parsed = JSON.parse(trimmedContent);
+                        if (Array.isArray(parsed)) {
+                            // 解析成功
+                            // 如果是 completed 消息，直接使用新的内容，不合并
+                            // 如果是 delta 消息，合并数组中元素的 json 字段
+                            let mergedArray = parsed;
+                            if (!isComplete && shouldAccumulate) {
+                                // 只对 delta 消息且 shouldAccumulate 为 true 时进行合并
+                                // 获取上一次解析的内容
+                                const lastValidContent = this.lastValidJsonContent.get(contentKey);
+                                if (lastValidContent) {
+                                    try {
+                                        const lastParsed = JSON.parse(lastValidContent);
+                                        if (Array.isArray(lastParsed) && lastParsed.length > 0 && parsed.length > 0) {
+                                            // 合并第一个元素的 json 字段
+                                            const lastFirstItem = lastParsed[0];
+                                            const currFirstItem = parsed[0];
+                                            if (typeof lastFirstItem === 'object' && lastFirstItem !== null && typeof currFirstItem === 'object' && currFirstItem !== null && 'json' in lastFirstItem && 'json' in currFirstItem && typeof lastFirstItem.json === 'object' && lastFirstItem.json !== null && typeof currFirstItem.json === 'object' && currFirstItem.json !== null) {
+                                                // 合并 json 字段（深度合并对象）
+                                                const mergedJson = this.mergeJsonObjects(lastFirstItem.json, currFirstItem.json);
+                                                // 创建合并后的第一个元素
+                                                mergedArray = [
+                                                    {
+                                                        ...currFirstItem,
+                                                        json: mergedJson
+                                                    },
+                                                    ...parsed.slice(1)
+                                                ];
+                                            }
+                                        }
+                                    } catch (parseError) {
+                                        // 解析上一次内容失败，使用当前解析的内容
+                                        // Error is intentionally ignored as we fallback to current parsed content
+                                        void parseError;
+                                    }
+                                }
+                            } else {
+                            // completed 消息：直接使用新的内容，不合并
+                            }
+                            const parsedContent = JSON.stringify(mergedArray);
+                            dataValue.content = parsedContent;
+                            this.lastValidJsonContent.set(contentKey, parsedContent);
+                        } else {
+                            // 不是数组，使用原始内容
+                            dataValue.content = newContent;
+                        }
+                    } catch (e) {
+                        // 解析失败，可能是多个数组拼接（如 [{...}][{...}]），尝试合并
+                        const mergedArray = this.mergeStreamingArrays(trimmedContent);
+                        if (mergedArray !== null) {
+                            // 如果是 completed 消息，直接使用新的内容，不合并
+                            // 如果是 delta 消息，合并数组中元素的 json 字段
+                            let finalMergedArray = mergedArray;
+                            if (!isComplete && shouldAccumulate) {
+                                // 只对 delta 消息且 shouldAccumulate 为 true 时进行合并
+                                const lastValidContent = this.lastValidJsonContent.get(contentKey);
+                                if (lastValidContent) {
+                                    try {
+                                        const lastParsed = JSON.parse(lastValidContent);
+                                        if (Array.isArray(lastParsed) && lastParsed.length > 0 && mergedArray.length > 0) {
+                                            // 合并第一个元素的 json 字段
+                                            const lastFirstItem = lastParsed[0];
+                                            const currFirstItem = mergedArray[0];
+                                            if (typeof lastFirstItem === 'object' && lastFirstItem !== null && typeof currFirstItem === 'object' && currFirstItem !== null && 'json' in lastFirstItem && 'json' in currFirstItem && typeof lastFirstItem.json === 'object' && lastFirstItem.json !== null && typeof currFirstItem.json === 'object' && currFirstItem.json !== null) {
+                                                // 合并 json 字段（深度合并对象）
+                                                const mergedJson = this.mergeJsonObjects(lastFirstItem.json, currFirstItem.json);
+                                                // 创建合并后的第一个元素
+                                                finalMergedArray = [
+                                                    {
+                                                        ...currFirstItem,
+                                                        json: mergedJson
+                                                    },
+                                                    ...mergedArray.slice(1)
+                                                ];
+                                            }
+                                        }
+                                    } catch (parseError) {
+                                        // 解析上一次内容失败，使用当前合并的数组
+                                        // Error is intentionally ignored as we fallback to current merged array
+                                        void parseError;
+                                    }
+                                }
+                            }
+                            const parsedContent = JSON.stringify(finalMergedArray);
+                            dataValue.content = parsedContent;
+                            this.lastValidJsonContent.set(contentKey, parsedContent);
+                        } else {
+                            // 合并失败，使用原始内容
+                            dataValue.content = newContent;
+                        }
                     }
+                } else {
+                    // 数组不完整，使用累积的原始内容
+                    // convertMixContent 会尝试解析部分数组，如果失败会返回 undefined
+                    dataValue.content = newContent;
                 }
             }
         }
@@ -419887,7 +420443,8 @@ class MessageParser {
         // 对于流式 JSON，如果 convertMixContent 返回 undefined（JSON 不完整），
         // 且没有上一次成功解析的内容，不返回消息，避免重复渲染
         if (isStreamingJson && !isComplete && message.content_type === types_ContentType.Mix && (!message.content || message.content === 'undefined')) {
-            const contentKey = dataValue.id || dataValue.chat_id || '';
+            // 对于流式 object_string 消息，使用 id 作为 key
+            const contentKey = dataValue.id || '';
             const lastValidContent = contentKey ? this.lastValidJsonContent.get(contentKey) : undefined;
             // 如果没有上一次成功解析的内容，不返回消息
             if (!lastValidContent) {
@@ -419896,15 +420453,30 @@ class MessageParser {
             // 如果有上一次成功解析的内容，使用它
             message.content = lastValidContent;
         }
+        // 对于流式 object_string 消息，检查内容是否真正变化
+        // 如果内容没有变化，且不是完成消息，则不返回消息，避免重复渲染
+        if (isStreamingJson && !isComplete && message.message_id) {
+            // 对于流式 object_string 消息，使用 id 作为 key
+            const contentKey = dataValue.id || '';
+            if (contentKey) {
+                // 比较转换后的 message.content（这是最终传递给 UI 的内容）
+                const currentMessageContent = message.content || '';
+                const lastReturnedMessageContent = this.lastReturnedParsedContent.get(contentKey) || '';
+                // 如果转换后的内容没有变化，不返回消息
+                if (currentMessageContent && lastReturnedMessageContent && currentMessageContent === lastReturnedMessageContent) {
+                    // 内容没有变化，不返回消息
+                    return;
+                }
+                // 更新上一次返回的转换后的内容
+                if (currentMessageContent) {
+                    this.lastReturnedParsedContent.set(contentKey, currentMessageContent);
+                }
+            }
+        }
         if (isComplete && message.content_type === types_ContentType.Text && message.type === 'answer') {
             message.content = '';
-        } else if (isComplete && message.content_type === types_ContentType.Mix && message.type === 'answer') {
-            message.content = JSON.stringify({
-                item_list: []
-            });
         }
         message.section_id = message.section_id || this.sectionId;
-        console.log('createMessage message', message);
         return {
             event: 'message',
             data: {
@@ -419920,6 +420492,127 @@ class MessageParser {
         };
     }
     /**
+   * 合并两个 JSON 对象（深度合并）
+   * - 如果两个值都是对象，递归合并
+   * - 如果两个值都是字符串，追加字符串
+   * - 如果两个值都是数组，合并数组（按索引合并）
+   * - 否则使用 curr 的值（覆盖）
+   */ mergeJsonObjects(prev, curr) {
+        const merged = {
+            ...prev
+        };
+        for(const key in curr){
+            if (Object.prototype.hasOwnProperty.call(curr, key)) {
+                const prevValue = prev[key];
+                const currValue = curr[key];
+                // 如果两个值都是对象，递归合并
+                if (typeof prevValue === 'object' && prevValue !== null && !Array.isArray(prevValue) && typeof currValue === 'object' && currValue !== null && !Array.isArray(currValue)) {
+                    merged[key] = this.mergeJsonObjects(prevValue, currValue);
+                } else if (typeof prevValue === 'string' && typeof currValue === 'string') {
+                    // 如果两个值都是字符串，追加字符串
+                    merged[key] = prevValue + currValue;
+                } else if (Array.isArray(prevValue) && Array.isArray(currValue)) {
+                    // 如果两个值都是数组，按索引合并
+                    const mergedArray = [
+                        ...prevValue
+                    ];
+                    for(let i = 0; i < currValue.length; i++){
+                        const currItem = currValue[i];
+                        if (i < mergedArray.length) {
+                            // 如果索引已存在，尝试合并
+                            const prevItem = mergedArray[i];
+                            if (typeof prevItem === 'object' && prevItem !== null && !Array.isArray(prevItem) && typeof currItem === 'object' && currItem !== null && !Array.isArray(currItem)) {
+                                mergedArray[i] = this.mergeJsonObjects(prevItem, currItem);
+                            } else {
+                                mergedArray[i] = currItem;
+                            }
+                        } else {
+                            // 如果索引超出范围，追加新元素
+                            mergedArray.push(currItem);
+                        }
+                    }
+                    merged[key] = mergedArray;
+                } else {
+                    // 否则使用 curr 的值（覆盖）
+                    merged[key] = currValue;
+                }
+            }
+        }
+        return merged;
+    }
+    /**
+   * 合并多个流式数组（如 [{...}][{...}] 合并为 [{...},{...}]）
+   * 返回合并后的数组，如果无法合并则返回 null
+   */ mergeStreamingArrays(content) {
+        if (!content || !content.trim().startsWith('[')) {
+            return null;
+        }
+        const trimmed = content.trim();
+        const arrays = [];
+        let currentIndex = 0;
+        while(currentIndex < trimmed.length){
+            // 跳过空白字符
+            while(currentIndex < trimmed.length && /\s/.test(trimmed[currentIndex])){
+                currentIndex++;
+            }
+            if (currentIndex >= trimmed.length || trimmed[currentIndex] !== '[') {
+                break;
+            }
+            // 找到完整的数组
+            let bracketCount = 0;
+            let inString = false;
+            let escapeNext = false;
+            let arrayEndIndex = -1;
+            for(let i = currentIndex; i < trimmed.length; i++){
+                const char = trimmed[i];
+                if (escapeNext) {
+                    escapeNext = false;
+                    continue;
+                }
+                if (char === '\\') {
+                    escapeNext = true;
+                    continue;
+                }
+                if (char === '"') {
+                    inString = !inString;
+                    continue;
+                }
+                if (inString) {
+                    continue;
+                }
+                if (char === '[') {
+                    bracketCount++;
+                } else if (char === ']') {
+                    bracketCount--;
+                    if (bracketCount === 0) {
+                        arrayEndIndex = i;
+                        break;
+                    }
+                }
+            }
+            if (arrayEndIndex > currentIndex) {
+                try {
+                    const arrayStr = trimmed.substring(currentIndex, arrayEndIndex + 1);
+                    const parsed = JSON.parse(arrayStr);
+                    if (Array.isArray(parsed)) {
+                        arrays.push(...parsed);
+                    } else {
+                        arrays.push(parsed);
+                    }
+                    currentIndex = arrayEndIndex + 1;
+                } catch (parseError) {
+                    // 解析失败，停止合并
+                    // Error is intentionally ignored as we break the loop
+                    void parseError;
+                    break;
+                }
+            } else {
+                break;
+            }
+        }
+        return arrays.length > 0 ? arrays : null;
+    }
+    /**
    * 尝试解析流式 JSON 内容
    * 如果 JSON 不完整，返回 null；如果解析成功，返回完整的 JSON 字符串
    */ tryParseStreamingJson(content) {
@@ -420133,6 +420826,10 @@ class MessageParser {
         message_parser_define_property(this, "streamingJsonContent", new Map());
         // 用于存储上一次成功解析的完整 JSON 内容，避免重复渲染
         message_parser_define_property(this, "lastValidJsonContent", new Map());
+        // 用于存储上一次返回的解析后的 JSON 内容，用于检测内容是否真正变化
+        message_parser_define_property(this, "lastReturnedParsedContent", new Map());
+        // 用于存储上一次返回的原始累积内容，用于检测 JSON 不完整时内容是否变化
+        message_parser_define_property(this, "lastReturnedAccumulatedContent", new Map());
         this.conversationId = requestMessageRawBody.conversation_id;
         this.localMessageId = requestMessageRawBody.local_message_id;
         this.sendMessageContent = requestMessageRawBody.query;
@@ -420217,6 +420914,7 @@ class MessageParser {
         const updateCurrentConversationInfoFn = refUpdateCurrentConversationInfo.current;
         const { title } = updates;
         if (title !== undefined) {
+            var _refPendingConversationInfo_current;
             // 更新会话列表中的会话名称
             // 注意：PC 端和 Mobile 端都优先使用 title，如果没有 title 则使用 name
             // 对于 App 模式，需要同时更新 name 和 title
@@ -420229,30 +420927,70 @@ class MessageParser {
                 title,
                 updated_at: Math.floor(updated_at / 1000)
             };
-            updateConversationsFn([
-                updatedConversationObj
-            ], 'update');
+            if (updateConversationsFn) {
+                updateConversationsFn([
+                    updatedConversationObj
+                ], 'update');
+            }
             // 如果当前会话是被更新的会话，同时更新 currentConversationInfo
             // 修复：无论ref是否是最新的，都更新currentConversationInfo，确保header能显示title
             // updateCurrentConversationInfo函数会合并字段，所以即使ref不是最新的，title也会被正确设置
             // 从conversations列表中查找对应的会话，如果找到说明这个会话存在，可能是当前会话
             const conversationsList = refConversations.current;
             const foundConversation = conversationsList.find((c)=>c.id === conversation_id);
+            // 检查是否是当前会话或待处理的会话
+            // 1. 如果 refCurrentConversationInfo.current.id 匹配，说明是当前会话
+            // 2. 如果 refPendingConversationInfo.current.conversationId 匹配，说明是新创建的会话，但 currentConversationInfo 还没有更新
+            const isCurrentConversation = (currentConversation === null || currentConversation === void 0 ? void 0 : currentConversation.id) === conversation_id;
+            const isPendingConversation = ((_refPendingConversationInfo_current = refPendingConversationInfo.current) === null || _refPendingConversationInfo_current === void 0 ? void 0 : _refPendingConversationInfo_current.conversationId) === conversation_id;
             // 如果ref中的id匹配，或者找到了对应的会话，就更新title
             // 这样可以确保即使ref不是最新的，也能正确更新title
-            if ((currentConversation === null || currentConversation === void 0 ? void 0 : currentConversation.id) === conversation_id || foundConversation) {
+            // 注意：只有当 conversation_id 与当前会话的 id 匹配时才更新 currentConversationInfo
+            // 这样可以避免在更新其他会话的 title 时触发当前会话的重新初始化
+            if (isCurrentConversation || isPendingConversation) {
                 // 优先使用ref中的currentConversationInfo，保留其所有字段
-                // 如果ref中没有，使用conversations列表中的信息
-                const baseInfo = currentConversation || foundConversation;
-                updateCurrentConversationInfoFn({
-                    ...baseInfo || {},
-                    id: conversation_id,
-                    name: title,
-                    title,
-                    // 保留currentConversationInfo特有的字段
-                    conversationListVisible: (currentConversation === null || currentConversation === void 0 ? void 0 : currentConversation.conversationListVisible) ?? false,
-                    isLargeWidth: (currentConversation === null || currentConversation === void 0 ? void 0 : currentConversation.isLargeWidth) ?? false
-                });
+                // 只更新 title 和 name，不改变其他字段，避免触发不必要的重新初始化
+                if (currentConversation) {
+                    // 只有当 title 或 name 真的发生变化时才更新，避免创建不必要的对象引用
+                    if (currentConversation.title !== title || currentConversation.name !== title) {
+                        updateCurrentConversationInfoFn({
+                            ...currentConversation,
+                            name: title,
+                            title,
+                            updated_at: Math.floor(updated_at / 1000)
+                        });
+                    }
+                } else if (foundConversation) {
+                    // 如果 currentConversation 不存在但找到了会话，使用找到的会话信息
+                    // 注意：foundConversation 是 Conversation 类型，不包含 conversationListVisible 和 isLargeWidth
+                    // 这些字段只在 currentConversationInfo 中存在，所以使用默认值
+                    updateCurrentConversationInfoFn({
+                        ...foundConversation,
+                        name: title,
+                        title,
+                        updated_at: Math.floor(updated_at / 1000),
+                        // 使用默认值，因为 foundConversation 不包含这些字段
+                        conversationListVisible: false,
+                        isLargeWidth: false
+                    });
+                } else if (isPendingConversation && refPendingConversationInfo.current) {
+                    // 如果是待处理的会话，但 currentConversation 和 foundConversation 都不存在
+                    // 使用 refPendingConversationInfo 中的信息创建新的 currentConversationInfo
+                    const pendingInfo = refPendingConversationInfo.current;
+                    // 从 refCurrentConversationInfo 获取保留的字段（如果存在）
+                    const existingInfo = refCurrentConversationInfo.current;
+                    updateCurrentConversationInfoFn({
+                        id: pendingInfo.conversationId,
+                        last_section_id: pendingInfo.sectionId,
+                        name: title,
+                        title,
+                        created_at: Math.floor(Date.now() / 1000),
+                        updated_at: Math.floor(updated_at / 1000),
+                        meta_data: {},
+                        conversationListVisible: (existingInfo === null || existingInfo === void 0 ? void 0 : existingInfo.conversationListVisible) ?? false,
+                        isLargeWidth: (existingInfo === null || existingInfo === void 0 ? void 0 : existingInfo.isLargeWidth) ?? false
+                    });
+                }
             }
         }
     };
@@ -420346,12 +421084,28 @@ class MessageParser {
                                     conversationName: conversationResult.conversationName
                                 });
                             }
-                            // 只更新 messageBody 中的 conversation_id
-                            // 不在这里更新 currentConversationInfo 或调用 setConversationId
-                            // 这些更新会在消息发送成功后通过消息解析器进行
-                            // 避免在消息发送前触发状态更新，导致 SDK 重新初始化
+                            // 选中新创建的会话：先更新 currentConversationInfo，确保会话被选中
+                            // 不立即调用 updateCurrentConversationInfo，避免触发组件卸载
+                            // 将在消息流完成（DONE 事件）时更新 currentConversationInfo
+                            // 这样可以避免触发 useRequestInit 的依赖变化，防止重新初始化
+                            // 会话列表中的新会话已经通过 updateConversations 添加，可以正常显示
+                            console.log('onBeforeSendMessage: Conversation created, will update currentConversationInfo after stream completes', {
+                                conversationId: conversationResult.conversationId
+                            });
+                            // 确保 pendingInfo 被设置，以便在 DONE 事件时更新
+                            if (refPendingConversationInfo) {
+                                refPendingConversationInfo.current = {
+                                    conversationId: conversationResult.conversationId,
+                                    sectionId: conversationResult.sectionId || ''
+                                };
+                            }
+                            // 注意：不在这里调用 setConversationId，因为它会触发额外的 updateConversations 调用
+                            // 这会导致 useConversationList 的同步逻辑被触发，设置 isSyncing = true
+                            // 当真正的 store 更新发生时，isSyncing 仍然是 true，导致 useEffect 被跳过
+                            // setConversationId 会在消息流完成时被调用（在 onGetMessageStreamParser 的 DONE 事件中）
+                            // 更新 messageBody 中的 conversation_id
                             messageBody.conversation_id = conversationId;
-                            console.log('onBeforeSendMessage: Conversation created, will update state after message sent', {
+                            console.log('onBeforeSendMessage: Conversation created and selected, ready to send message', {
                                 conversationId,
                                 pendingInfo: refPendingConversationInfo.current
                             });
@@ -420367,7 +421121,7 @@ class MessageParser {
                         throw new Error('conversationId is required for sending message');
                     }
                     // 使用计算后的 API URL
-                    const url = `${finalApiUrl}/v3/chat?conversation_id=${conversationId}`;
+                    const url = `${finalApiUrl}/v1/workflows/chat?conversation_id=${conversationId}`;
                     // 根据 chatType 选择正确的 parameters 来源
                     // App 模式使用 appInfo.parameters，Bot 模式使用 botInfo.parameters
                     const parameters = ((_refChatConfig_current = refChatConfig.current) === null || _refChatConfig_current === void 0 ? void 0 : _refChatConfig_current.type) === client_ChatType.APP ? (_refChatConfig_current_appInfo = refChatConfig.current.appInfo) === null || _refChatConfig_current_appInfo === void 0 ? void 0 : _refChatConfig_current_appInfo.parameters : (_refChatConfig_current_botInfo = refChatConfig.current.botInfo) === null || _refChatConfig_current_botInfo === void 0 ? void 0 : _refChatConfig_current_botInfo.parameters;
@@ -420512,6 +421266,8 @@ class MessageParser {
                             // 使用 setTimeout 确保在消息发送流程完全完成后更新状态
                             setTimeout(()=>{
                                 if (refUpdateCurrentConversationInfo.current) {
+                                    // 保留当前的 conversationListVisible 和 isLargeWidth，避免会话列表被收起
+                                    const currentInfo = refCurrentConversationInfo.current;
                                     refUpdateCurrentConversationInfo.current({
                                         id: pendingInfo.conversationId,
                                         last_section_id: pendingInfo.sectionId,
@@ -420520,8 +421276,10 @@ class MessageParser {
                                         created_at: Math.floor(Date.now() / 1000),
                                         updated_at: Math.floor(Date.now() / 1000),
                                         meta_data: {},
-                                        conversationListVisible: false,
-                                        isLargeWidth: false
+                                        // 保留当前的 conversationListVisible，避免会话列表被收起
+                                        conversationListVisible: (currentInfo === null || currentInfo === void 0 ? void 0 : currentInfo.conversationListVisible) ?? false,
+                                        // 保留当前的 isLargeWidth
+                                        isLargeWidth: (currentInfo === null || currentInfo === void 0 ? void 0 : currentInfo.isLargeWidth) ?? false
                                     });
                                 }
                                 if (refChatFunc === null || refChatFunc === void 0 ? void 0 : refChatFunc.current) {
@@ -423643,36 +424401,89 @@ const ChatProviderFuncComp = /*#__PURE__*/ (0,react.forwardRef)((param, ref)=>{
     // 监听 currentConversationInfo 的变化，同步更新 chat-area 的 conversationId 和 sectionId
     // 这样当切换会话时，可以避免出现"上下文已清除"提示
     // 注意：必须在消息加载之前更新 sectionId，否则会触发上下文分隔线
+    // 使用 ref 来存储上一次的 id 和 last_section_id，避免 title/name 更新时触发重新初始化
+    const prevConversationIdRef = (0,react.useRef)(undefined);
+    const prevSectionIdRef = (0,react.useRef)(undefined);
+    // 使用 useMemo 来稳定 id 和 last_section_id 的值，避免对象引用变化导致 useEffect 触发
+    const stableConversationId = (0,react.useMemo)(()=>currentConversationInfo === null || currentConversationInfo === void 0 ? void 0 : currentConversationInfo.id, [
+        currentConversationInfo === null || currentConversationInfo === void 0 ? void 0 : currentConversationInfo.id
+    ]);
+    const stableLastSectionId = (0,react.useMemo)(()=>currentConversationInfo === null || currentConversationInfo === void 0 ? void 0 : currentConversationInfo.last_section_id, [
+        currentConversationInfo === null || currentConversationInfo === void 0 ? void 0 : currentConversationInfo.last_section_id
+    ]);
+    // 更新 sectionId 的辅助函数
+    const updateSectionIdIfNeeded = useMemoizedFn((targetSectionId, currentSectionId)=>{
+        if (targetSectionId && targetSectionId !== currentSectionId) {
+            const { setLatestSectionId } = useSectionIdStore.getState();
+            setLatestSectionId(targetSectionId);
+        }
+    });
+    // 检查是否需要更新的辅助函数
+    const shouldSkipUpdate = useMemoizedFn((currentId, currentSectionId, refs)=>{
+        const isFirstRun = refs.prevIdRef.current === undefined && refs.prevSectionIdRef.current === undefined;
+        const hasIdChanged = !isFirstRun && currentId !== refs.prevIdRef.current;
+        const hasSectionIdChanged = !isFirstRun && currentSectionId !== refs.prevSectionIdRef.current;
+        if (!isFirstRun && !hasIdChanged && !hasSectionIdChanged) {
+            refs.prevIdRef.current = currentId;
+            refs.prevSectionIdRef.current = currentSectionId;
+            return true;
+        }
+        refs.prevIdRef.current = currentId;
+        refs.prevSectionIdRef.current = currentSectionId;
+        return false;
+    });
+    // 更新 conversationId 的辅助函数
+    const updateConversationId = useMemoizedFn((currentId, currentSectionId, isNewConversationFromEmpty)=>{
+        if (isNewConversationFromEmpty) {
+            // 只更新 chatCore 的 conversationId，不调用 setConversationIdInArea
+            // 这样可以避免触发重新初始化，导致正在进行的请求被中止
+            chatCore === null || chatCore === void 0 ? void 0 : chatCore.updateConversationId(currentId);
+            updateSectionIdIfNeeded(currentSectionId, sectionId);
+        } else {
+            // 正常切换会话，立即更新
+            setConversationIdInArea(currentId);
+            chatCore === null || chatCore === void 0 ? void 0 : chatCore.updateConversationId(currentId);
+            updateSectionIdIfNeeded(currentSectionId, sectionId);
+        }
+    });
     (0,react.useEffect)(()=>{
         var _chatConfig_ui_conversations, _chatConfig_ui;
-        if ((currentConversationInfo === null || currentConversationInfo === void 0 ? void 0 : currentConversationInfo.id) && ((_chatConfig_ui = chatConfig.ui) === null || _chatConfig_ui === void 0 ? void 0 : (_chatConfig_ui_conversations = _chatConfig_ui.conversations) === null || _chatConfig_ui_conversations === void 0 ? void 0 : _chatConfig_ui_conversations.isNeed)) {
-            const currentId = currentConversationInfo.id;
-            const currentConversationWithSectionId = currentConversationInfo;
-            const currentSectionId = currentConversationInfo.last_section_id || currentConversationWithSectionId.sectionId || '';
-            // 先更新 sectionId，再更新 conversationId，确保消息加载时使用正确的 sectionId
-            if (currentSectionId && currentSectionId !== sectionId) {
-                const { setLatestSectionId } = useSectionIdStore.getState();
-                setLatestSectionId(currentSectionId);
-            }
-            // 只有当 conversationId 发生变化时才更新
-            if (currentId !== conversationId) {
-                setConversationIdInArea(currentId);
-                chatCore === null || chatCore === void 0 ? void 0 : chatCore.updateConversationId(currentId);
-                // 如果 conversationId 变化了，确保 sectionId 也同步更新
-                if (currentSectionId && currentSectionId !== sectionId) {
-                    const { setLatestSectionId } = useSectionIdStore.getState();
-                    setLatestSectionId(currentSectionId);
-                }
-            }
+        if (!stableConversationId || !((_chatConfig_ui = chatConfig.ui) === null || _chatConfig_ui === void 0 ? void 0 : (_chatConfig_ui_conversations = _chatConfig_ui.conversations) === null || _chatConfig_ui_conversations === void 0 ? void 0 : _chatConfig_ui_conversations.isNeed)) {
+            return;
+        }
+        const currentId = stableConversationId;
+        const currentConversationWithSectionId = currentConversationInfo;
+        const currentSectionId = stableLastSectionId || currentConversationWithSectionId.sectionId || '';
+        // 先更新 sectionId，再更新 conversationId，确保消息加载时使用正确的 sectionId
+        updateSectionIdIfNeeded(currentSectionId, sectionId);
+        // 检查是否需要跳过更新
+        if (shouldSkipUpdate(currentId, currentSectionId, {
+            prevIdRef: prevConversationIdRef,
+            prevSectionIdRef
+        })) {
+            return;
+        }
+        // 只有当 conversationId 发生变化时才更新
+        if (currentId !== conversationId) {
+            // 如果 conversationId 从空字符串或null变为新ID，说明是从空会话创建的新会话
+            // 此时不应该立即调用 setConversationIdInArea，因为它可能触发重新初始化
+            // 导致正在进行的请求被中止
+            // setConversationIdInArea 会在消息流完成时被调用（在 onGetMessageStreamParser 的 DONE 事件中）
+            const isNewConversationFromEmpty = conversationId === '' || conversationId === null;
+            updateConversationId(currentId, currentSectionId, isNewConversationFromEmpty);
         }
     }, [
-        currentConversationInfo === null || currentConversationInfo === void 0 ? void 0 : currentConversationInfo.id,
-        currentConversationInfo === null || currentConversationInfo === void 0 ? void 0 : currentConversationInfo.last_section_id,
+        stableConversationId,
+        stableLastSectionId,
         conversationId,
         sectionId,
         setConversationIdInArea,
         chatCore,
-        (_chatConfig_ui = chatConfig.ui) === null || _chatConfig_ui === void 0 ? void 0 : (_chatConfig_ui_conversations = _chatConfig_ui.conversations) === null || _chatConfig_ui_conversations === void 0 ? void 0 : _chatConfig_ui_conversations.isNeed
+        (_chatConfig_ui = chatConfig.ui) === null || _chatConfig_ui === void 0 ? void 0 : (_chatConfig_ui_conversations = _chatConfig_ui.conversations) === null || _chatConfig_ui_conversations === void 0 ? void 0 : _chatConfig_ui_conversations.isNeed,
+        updateSectionIdIfNeeded,
+        shouldSkipUpdate,
+        updateConversationId,
+        currentConversationInfo
     ]);
     useUpdateConversationNameByMessage();
     const regenerateMessageByUserMessageId = useRegenerateMessageByUserMessageId();
@@ -435978,6 +436789,7 @@ var header_pc_index_module_update = injectStylesIntoStyleTag_default()(header_pc
 
 
 
+
 const ChatHeader = (param)=>{
     let { iconUrl = coze_logo_namespaceObject, title = 'Coze Bot', extra, theme, isShowConversations, isNeedLogo = true } = param;
     const { headerTopLeftOps } = useChatOpInfo();
@@ -435993,18 +436805,20 @@ const ChatHeader = (param)=>{
     const [renameInputValue, setRenameInputValue] = (0,react.useState)('');
     const [isRenameLoading, setIsRenameLoading] = (0,react.useState)(false);
     // 使用 useMemo 计算显示文本，确保 title 变化时能及时更新
-    const conversationTitle = currentConversationInfo === null || currentConversationInfo === void 0 ? void 0 : currentConversationInfo.title;
-    const conversationName = currentConversationInfo === null || currentConversationInfo === void 0 ? void 0 : currentConversationInfo.name;
     const conversationId = currentConversationInfo === null || currentConversationInfo === void 0 ? void 0 : currentConversationInfo.id;
     const displayTitle = (0,react.useMemo)(()=>{
         if (conversationId === '') {
             return title;
         }
-        return conversationTitle || conversationName || title;
+        if (!currentConversationInfo) {
+            return title;
+        }
+        // 使用 getConversationDisplayName 处理 UUID 检查
+        const conversationItem = currentConversationInfo;
+        return getConversationDisplayName(conversationItem) || title;
     }, [
         conversationId,
-        conversationTitle,
-        conversationName,
+        currentConversationInfo,
         title
     ]);
     // 打开重命名弹窗
@@ -436230,6 +437044,7 @@ var header_mobile_index_module_update = injectStylesIntoStyleTag_default()(heade
 
 
 
+
 const ChatHeaderMobile = (param)=>{
     let { iconUrl = coze_logo_namespaceObject, title = 'Coze Bot', extra, theme, isShowConversations, isNeedLogo = true } = param;
     const { headerTopLeftOps } = useChatOpInfo();
@@ -436245,18 +437060,20 @@ const ChatHeaderMobile = (param)=>{
     const [renameInputValue, setRenameInputValue] = (0,react.useState)('');
     const [isRenameLoading, setIsRenameLoading] = (0,react.useState)(false);
     // 使用 useMemo 计算显示文本，确保 title 变化时能及时更新
-    const conversationTitle = currentConversationInfo === null || currentConversationInfo === void 0 ? void 0 : currentConversationInfo.title;
-    const conversationName = currentConversationInfo === null || currentConversationInfo === void 0 ? void 0 : currentConversationInfo.name;
     const conversationId = currentConversationInfo === null || currentConversationInfo === void 0 ? void 0 : currentConversationInfo.id;
     const displayTitle = (0,react.useMemo)(()=>{
         if (conversationId === '') {
             return title;
         }
-        return conversationTitle || conversationName || title;
+        if (!currentConversationInfo) {
+            return title;
+        }
+        // 使用 getConversationDisplayName 处理 UUID 检查
+        const conversationItem = currentConversationInfo;
+        return getConversationDisplayName(conversationItem) || title;
     }, [
         conversationId,
-        conversationTitle,
-        conversationName,
+        currentConversationInfo,
         title
     ]);
     // 打开重命名弹窗
@@ -437699,7 +438516,20 @@ const use_core_manager_useCoreManager = (props)=>{
                                 bodyData.additional_messages = bodyDataOld.additional_messages || [];
                                 bodyData.connector_id = bodyDataOld.connector_id;
                                 bodyData.workflow_id = refProps === null || refProps === void 0 ? void 0 : (_refProps_current = refProps.current) === null || _refProps_current === void 0 ? void 0 : (_refProps_current_workflow = _refProps_current.workflow) === null || _refProps_current_workflow === void 0 ? void 0 : _refProps_current_workflow.id;
-                                bodyData.parameters = refProps === null || refProps === void 0 ? void 0 : (_refProps_current1 = refProps.current) === null || _refProps_current1 === void 0 ? void 0 : (_refProps_current_workflow1 = _refProps_current1.workflow) === null || _refProps_current_workflow1 === void 0 ? void 0 : _refProps_current_workflow1.parameters;
+                                // parameters 应该是一个对象，但 SETTING 字段的值需要序列化为字符串
+                                const workflowParameters = refProps === null || refProps === void 0 ? void 0 : (_refProps_current1 = refProps.current) === null || _refProps_current1 === void 0 ? void 0 : (_refProps_current_workflow1 = _refProps_current1.workflow) === null || _refProps_current_workflow1 === void 0 ? void 0 : _refProps_current_workflow1.parameters;
+                                if (workflowParameters && typeof workflowParameters === 'object') {
+                                    // 复制 parameters 对象，只序列化 SETTING 字段的值
+                                    const processedParameters = {
+                                        ...workflowParameters
+                                    };
+                                    if (processedParameters.SETTING && typeof processedParameters.SETTING === 'object') {
+                                        processedParameters.SETTING = JSON.stringify(processedParameters.SETTING);
+                                    }
+                                    bodyData.parameters = processedParameters;
+                                } else {
+                                    bodyData.parameters = workflowParameters;
+                                }
                                 bodyData.version = (refProps === null || refProps === void 0 ? void 0 : (_refProps_current2 = refProps.current) === null || _refProps_current2 === void 0 ? void 0 : (_refProps_current_project = _refProps_current2.project) === null || _refProps_current_project === void 0 ? void 0 : _refProps_current_project.version) || undefined;
                                 bodyData.execute_mode = (refProps === null || refProps === void 0 ? void 0 : (_refProps_current3 = refProps.current) === null || _refProps_current3 === void 0 ? void 0 : (_refProps_current_project1 = _refProps_current3.project) === null || _refProps_current_project1 === void 0 ? void 0 : _refProps_current_project1.mode) === 'draft' ? 'DEBUG' : undefined;
                                 bodyData.app_id = (refProps === null || refProps === void 0 ? void 0 : (_refProps_current4 = refProps.current) === null || _refProps_current4 === void 0 ? void 0 : (_refProps_current_project2 = _refProps_current4.project) === null || _refProps_current_project2 === void 0 ? void 0 : _refProps_current_project2.type) === 'app' ? refProps === null || refProps === void 0 ? void 0 : (_refProps_current5 = refProps.current) === null || _refProps_current5 === void 0 ? void 0 : (_refProps_current_project3 = _refProps_current5.project) === null || _refProps_current_project3 === void 0 ? void 0 : _refProps_current_project3.id : undefined;
@@ -437715,8 +438545,13 @@ const use_core_manager_useCoreManager = (props)=>{
                                     customized_suggest_prompt: (_refAppData_current2 = refAppData.current) === null || _refAppData_current2 === void 0 ? void 0 : (_refAppData_current_suggestPromoteInfo1 = _refAppData_current2.suggestPromoteInfo) === null || _refAppData_current_suggestPromoteInfo1 === void 0 ? void 0 : _refAppData_current_suggestPromoteInfo1.customizedSuggestPrompt
                                 } : undefined;
                                 requestConfig.body = JSON.stringify(bodyData);
-                                // 使用计算后的 finalApiUrl
-                                requestConfig.url = `${finalApiUrl}/v1/workflows/chat`;
+                                // 只有在URL还没有被其他hook设置时才设置URL
+                                // 如果URL已经包含conversation_id参数（说明已经被useSendMessageAdapter设置了），保留原URL
+                                const urlHasConversationId = new URL(requestConfig.url, 'http://dummy.com').searchParams.has('conversation_id');
+                                if (!urlHasConversationId) {
+                                    // 使用计算后的 finalApiUrl
+                                    requestConfig.url = `${finalApiUrl}/v1/workflows/chat`;
+                                }
                                 requestConfig.headers.push(...Object.entries(((_refProps_current9 = refProps.current) === null || _refProps_current9 === void 0 ? void 0 : (_refProps_current_workflow2 = _refProps_current9.workflow) === null || _refProps_current_workflow2 === void 0 ? void 0 : _refProps_current_workflow2.header) || {}));
                                 return {
                                     ...requestConfig