@glodon-aiot/chat-app-sdk 0.0.7 → 0.0.8

package/es/index.esm.js

@@ -395273,7 +395273,9 @@ const DeferredMessageBoxProvider = (param)=>{
         } : originalMeta, [
         originalMeta
     ]);
-    return /*#__PURE__*/ (0,jsx_runtime.jsx)("div", {
+    return(// 使用 renderIndex 作为 CSS order 值
+    // 正数区域（正常渲染）：renderIndex 越大，order 越大，元素越靠上
+    /*#__PURE__*/ (0,jsx_runtime.jsx)("div", {
         style: {
             order: renderIndex ?? 0
         },
@@ -395288,7 +395290,7 @@ const DeferredMessageBoxProvider = (param)=>{
             },
             children: children
         })
-    });
+    }));
 };
 // 正常消息的 MessageBoxProvider，确保第一个正常消息显示头像
 const NormalMessageBoxProvider = (param)=>{
@@ -395315,7 +395317,9 @@ const NormalMessageBoxProvider = (param)=>{
         originalMeta,
         isFirstNormalMessage
     ]);
-    return /*#__PURE__*/ (0,jsx_runtime.jsx)("div", {
+    return(// 使用 renderIndex 作为 CSS order 值
+    // 正数区域（正常渲染）：renderIndex 越大，order 越大，元素越靠上
+    /*#__PURE__*/ (0,jsx_runtime.jsx)("div", {
         style: {
             order: renderIndex ?? 0
         },
@@ -395330,7 +395334,7 @@ const NormalMessageBoxProvider = (param)=>{
             },
             children: children
         })
-    });
+    }));
 };
 // Hook for debugging message meta info
 function useMessageDebugLog(normalMessages, deferredMessages) {
@@ -395409,7 +395413,8 @@ const DeferredMessages = (param)=>{
 const NormalMessages = (param)=>{
     let { normalMessages, deferredMessages, groupId, regenerateMessage, functionCallMessageIdList } = param;
     const regenerateMessagePromise = ()=>Promise.resolve(regenerateMessage());
-    // 找到 renderIndex 最大的消息（order 最大，会显示在最前面）
+    // 找到 renderIndex 最大的消息（CSS order 最大）
+    // 注意：由于 flex-direction: column-reverse，order 最大的消息在视觉上最靠上
     const maxRenderIndex = (0,react.useMemo)(()=>{
         if (normalMessages.length === 0) {
             return -Infinity;
@@ -395418,12 +395423,20 @@ const NormalMessages = (param)=>{
     }, [
         normalMessages
     ]);
-    // 找到第一个具有最大 renderIndex 的消息的索引
+    // 找到最后一个具有最大 renderIndex 的消息的索引
+    // 由于 flex-direction: column-reverse，数组中的最后一个元素在视觉上最靠上
     const maxRenderIndexMessageIndex = (0,react.useMemo)(()=>{
         if (normalMessages.length === 0) {
             return -1;
         }
-        return normalMessages.findIndex((m)=>m.renderIndex === maxRenderIndex);
+        // 从后往前找，找到最后一个具有最大 renderIndex 的消息
+        for(let i = normalMessages.length - 1; i >= 0; i--){
+            const message = normalMessages[i];
+            if (message && message.renderIndex === maxRenderIndex) {
+                return i;
+            }
+        }
+        return -1;
     }, [
         normalMessages,
         maxRenderIndex
@@ -395431,7 +395444,8 @@ const NormalMessages = (param)=>{
     return /*#__PURE__*/ (0,jsx_runtime.jsx)(jsx_runtime.Fragment, {
         children: normalMessages.map((param, index)=>{
             let { messageId, renderIndex } = param;
-            // order 最大的消息显示头像（renderIndex 最大的消息，如果有多个则只显示第一个）
+            // CSS order 最大的消息，且在视觉上最靠上的（数组中的最后一个）显示头像
+            // 由于 flex-direction: column-reverse，数组中的最后一个元素在视觉上最靠上
             const isFirstNormalMessage = renderIndex === maxRenderIndex && index === maxRenderIndexMessageIndex;
             const isFirst = isFirstNormalMessage;
             const isLast = index === 0 && deferredMessages.length === 0 && !functionCallMessageIdList.length;
@@ -395482,7 +395496,8 @@ const MessageGroupBody = /*#__PURE__*/ (0,react.memo)((param)=>{
     });
     // 分离正常渲染和延迟渲染的消息
     // 不再排序，使用 CSS order 属性来控制顺序
-    // renderIndex 值越小，order 越小，在 flex 容器中会显示越靠后
+    // 正数区域（正常渲染）：renderIndex 值越大，order 越大，在 flex 容器中会显示越靠上
+    // 负数区域（延迟渲染）：renderIndex 值越小（绝对值越大），order 越小，在 flex 容器中会显示越靠后
     const normalMessages = messagesWithRenderInfo.filter((item)=>!item.shouldDefer);
     const deferredMessages = messagesWithRenderInfo.filter((item)=>item.shouldDefer);
     // 打印正常消息和延迟消息的 meta 信息用于调试
@@ -405578,8 +405593,9 @@ const chatflowDraftConnectorId = '10000010';
  */ 
 var conversations_ConversationSort = /*#__PURE__*/ function(ConversationSort) {
     ConversationSort[ConversationSort["Today"] = 0] = "Today";
-    ConversationSort[ConversationSort["In30days"] = 1] = "In30days";
-    ConversationSort[ConversationSort["Others"] = 999] = "Others";
+    ConversationSort[ConversationSort["Yesterday"] = 1] = "Yesterday";
+    ConversationSort[ConversationSort["In30days"] = 2] = "In30days";
+    ConversationSort[ConversationSort["MonthGroup"] = 999] = "MonthGroup";
     return ConversationSort;
 }({});
 const conversationSortMap = new Map([
@@ -405589,11 +405605,15 @@ const conversationSortMap = new Map([
     ],
     [
         1,
+        intl_i18n.t('profile_history_yesterday', {}, '昨天')
+    ],
+    [
+        2,
         intl_i18n.t('log_pay_wall_date_filter_30_days', {}, '过去30天')
     ],
     [
         999,
-        intl_i18n.t('web_sdk_past', {}, '过往')
+        ''
     ]
 ]);
 
@@ -406594,6 +406614,30 @@ const usePaginationRequest = (param)=>{
     }, [
         initialPageNum
     ]);
+    const removeItem = (0,react.useCallback)((predicate)=>{
+        setAllData((prev)=>prev.filter((item)=>!predicate(item)));
+    }, []);
+    const addItem = (0,react.useCallback)(function(item) {
+        let position = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 'start';
+        setAllData((prev)=>{
+            // 检查是否已存在，避免重复添加
+            if (prev.some((existing)=>{
+                // 假设 T 有 id 属性，如果没有则使用对象引用比较
+                const existingItem = existing;
+                const newItem = item;
+                return existingItem.id !== undefined && newItem.id !== undefined ? existingItem.id === newItem.id : existing === item;
+            })) {
+                return prev;
+            }
+            return position === 'start' ? [
+                item,
+                ...prev
+            ] : [
+                ...prev,
+                item
+            ];
+        });
+    }, []);
     // 组件挂载时自动加载第一页
     (0,react.useEffect)(()=>{
         if (autoLoad) {
@@ -406613,7 +406657,9 @@ const usePaginationRequest = (param)=>{
         loadMore,
         refresh,
         setPageNum,
-        reset
+        reset,
+        removeItem,
+        addItem
     };
 };
 
@@ -406640,6 +406686,15 @@ const usePaginationRequest = (param)=>{
 
 
 
+
+
+
+
+
+
+
+
+// eslint-disable-next-line @coze-arch/max-line-per-function
 const useConversationList = (conversationListParams)=>{
     const { pageSize = 20, initialPageNum = 1, order = 'updated_at' } = conversationListParams ?? {};
     const { chatConfig: { bot_id: botId, appInfo, type: chatType, auth: { connectorId } = {} } } = useChatAppProps();
@@ -406656,6 +406711,9 @@ const useConversationList = (conversationListParams)=>{
     // draft_mode 转换为 create_env：draft_mode: true -> create_env: 1, draft_mode: false -> create_env: 2
     const createEnv = (appInfo === null || appInfo === void 0 ? void 0 : appInfo.draft_mode) !== undefined ? appInfo.draft_mode ? 1 : 2 : undefined;
     const hasValidId = isAppType ? !!appId && !!workflowId : !!botId;
+    // 使用 ref 来跟踪是否正在同步，避免循环更新
+    const isSyncingRef = (0,react.useRef)(false);
+    const lastStoreIdsRef = (0,react.useRef)('');
     // App 模式：使用基于 before_updated_at 和 limit 的加载逻辑
     const [appModeData, setAppModeData] = (0,react.useState)([]);
     const [appModeLoading, setAppModeLoading] = (0,react.useState)(false);
@@ -406763,8 +406821,20 @@ const useConversationList = (conversationListParams)=>{
         beforeUpdatedAt,
         loadAppModeConversations
     ]);
+    // App 模式：refresh 函数，重新加载第一页数据
+    const appModeRefresh = (0,react.useCallback)(async ()=>{
+        // 重置状态，确保可以重新加载
+        setAppModeData([]);
+        setBeforeUpdatedAt(undefined);
+        setAppModeHasMore(true);
+        setAppModeLoading(false);
+        // 重新加载第一页数据
+        await loadAppModeConversations();
+    }, [
+        loadAppModeConversations
+    ]);
     // Bot 模式：继续使用原有的分页逻辑
-    const { data, hasMore, loadMore, loading } = usePaginationRequest({
+    const { data, hasMore, loadMore, loading, refresh: refreshBotMode, removeItem: removeBotModeItem, addItem: addBotModeItem } = usePaginationRequest({
         requestFn: async (params)=>{
             if (!cozeApiSdk || !hasValidId) {
                 return {
@@ -406796,18 +406866,146 @@ const useConversationList = (conversationListParams)=>{
         initialPageNum,
         autoLoad: !!cozeApiSdk && hasValidId && !isAppType
     });
+    // 从本地数据源移除会话
+    const removeConversation = (0,react.useCallback)((conversationId)=>{
+        // 设置同步标志，防止 useEffect 干扰删除操作
+        isSyncingRef.current = true;
+        if (isAppType) {
+            // App模式：直接更新本地状态
+            setAppModeData((prev)=>prev.filter((c)=>c.id !== conversationId));
+        } else {
+            // Bot模式：从本地数据源移除
+            removeBotModeItem((c)=>c.id === conversationId);
+        }
+        // 延迟重置同步标志，确保删除操作完成
+        setTimeout(()=>{
+            isSyncingRef.current = false;
+        }, 100);
+    }, [
+        isAppType,
+        removeBotModeItem
+    ]);
     // 根据模式选择数据源
     const finalData = isAppType ? appModeData : data;
     const finalLoading = isAppType ? appModeLoading : loading;
     const finalHasMore = isAppType ? appModeHasMore : hasMore;
     const finalLoadMore = isAppType ? appModeLoadMore : loadMore;
+    const finalRefresh = isAppType ? appModeRefresh : refreshBotMode;
+    // 同步 finalData 到 store（只在本地数据源变化时更新 store，避免循环）
+    // 注意：这个 useEffect 只在从服务器加载数据时触发，不会在 store 同步到本地数据源时触发
     (0,react.useEffect)(()=>{
-        if (finalData) {
-            updateConversations(finalData, 'replace');
+        if (finalData && !isSyncingRef.current) {
+            // 比较数据是否真的变化了，避免不必要的更新
+            const currentIds = conversations.map((c)=>c.id).sort().join(',');
+            const newIds = finalData.map((c)=>c.id).sort().join(',');
+            if (currentIds !== newIds) {
+                // 只有在本地数据源是从服务器加载的新数据时才更新 store
+                // 如果是因为 store 同步导致的 finalData 变化，不应该再次更新 store
+                isSyncingRef.current = true;
+                updateConversations(finalData, 'replace');
+                setTimeout(()=>{
+                    isSyncingRef.current = false;
+                }, 0);
+            }
         }
     }, [
         finalData,
-        updateConversations
+        updateConversations,
+        conversations
+    ]);
+    // 监听 store 的 conversations 变化，同步更新本地数据源
+    // 只在 store 有新增会话时才同步，避免循环更新
+    (0,react.useEffect)(()=>{
+        const currentStoreIds = conversations.map((c)=>c.id).sort().join(',');
+        // 如果 store 的 ID 列表没有变化，跳过
+        if (currentStoreIds === lastStoreIdsRef.current) {
+            return;
+        }
+        // 检查是否有新增（store 的数量增加了）
+        const storeCount = conversations.length;
+        const lastStoreCount = lastStoreIdsRef.current.split(',').filter(Boolean).length;
+        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);
+                }
+            }
+            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');
+                    });
+                }
+            }
+        } finally{
+            // 使用 setTimeout 确保状态更新完成后再重置标志
+            // 延迟时间稍微长一点，确保第一个 useEffect 不会触发
+            setTimeout(()=>{
+                isSyncingRef.current = false;
+            }, 100);
+        }
+    }, [
+        conversations,
+        isAppType,
+        appModeData,
+        data,
+        removeBotModeItem,
+        addBotModeItem
     ]);
     (0,react.useEffect)(()=>{
         if (!currentConversationInfo) {
@@ -406846,53 +407044,80 @@ const useConversationList = (conversationListParams)=>{
         conversations,
         loading: finalLoading,
         hasMore: finalHasMore,
-        loadMore: finalLoadMore
+        loadMore: finalLoadMore,
+        refresh: finalRefresh,
+        removeConversation
     };
 };
 const useGroupedConversations = (conversations)=>{
     const sortedConversations = (0,react.useMemo)(()=>{
-        const today = new Date();
-        const oneDay = 24 * 60 * 60 * 1000;
-        const thirtyDays = 30 * oneDay;
+        const now = dayjs_min_default()();
+        const today = now.startOf('day');
+        const yesterday = today.subtract(1, 'day');
+        const thirtyDaysAgo = today.subtract(30, 'day');
         const newConversationList = conversations.map((item)=>{
-            const dateString = item.updated_at || item.created_at || 0;
-            const date = dayjs_min_default().unix(Number(dateString)).toDate();
-            const diff = today.getTime() - date.getTime();
-            if (today.toLocaleDateString() === date.toLocaleDateString()) {
+            // 使用 updated_at 排序
+            const updatedAt = item.updated_at || item.created_at || 0;
+            const date = dayjs_min_default().unix(Number(updatedAt));
+            // 今天
+            if (date.isSame(today, 'day')) {
                 return {
                     ...item,
                     sort: conversations_ConversationSort.Today
                 };
-            } else if (diff < thirtyDays) {
+            } else if (date.isSame(yesterday, 'day')) {
+                return {
+                    ...item,
+                    sort: conversations_ConversationSort.Yesterday
+                };
+            } else if (date.isAfter(thirtyDaysAgo)) {
                 return {
                     ...item,
                     sort: conversations_ConversationSort.In30days
                 };
             } else {
+                const monthKey = date.format('YYYY-MM');
                 return {
                     ...item,
-                    sort: conversations_ConversationSort.Others
+                    sort: conversations_ConversationSort.MonthGroup,
+                    monthKey
                 };
             }
         }).sort((a, b)=>{
+            // 先按分组排序
             if (a.sort !== b.sort) {
                 return a.sort - b.sort;
-            } else {
-                return dayjs_min_default().unix(Number(b.updated_at || b.created_at || 0)).valueOf() - dayjs_min_default().unix(Number(a.updated_at || a.created_at || 0)).valueOf();
             }
+            // 如果是月份分组，先按月份倒序排序（最新的月份在前）
+            if (a.sort === conversations_ConversationSort.MonthGroup && 'monthKey' in a && 'monthKey' in b && a.monthKey && b.monthKey) {
+                if (a.monthKey !== b.monthKey) {
+                    return b.monthKey.localeCompare(a.monthKey);
+                }
+            }
+            // 同一分组内，按 updated_at 倒序排序（最新的在前）
+            return dayjs_min_default().unix(Number(b.updated_at || b.created_at || 0)).valueOf() - dayjs_min_default().unix(Number(a.updated_at || a.created_at || 0)).valueOf();
         });
         return newConversationList;
     }, [
         conversations
     ]);
     const groupedConversations = (0,react.useMemo)(()=>{
+        // 使用 Map<string, SortedConversationItem[]>，key 可以是 ConversationSort 或月份字符串
         const groups = new Map();
         sortedConversations.forEach((conversation)=>{
             var _groups_get;
-            if (!groups.has(conversation.sort)) {
-                groups.set(conversation.sort, []);
+            let groupKey;
+            if (conversation.sort === conversations_ConversationSort.MonthGroup && conversation.monthKey) {
+                // 月份分组使用月份字符串作为 key
+                groupKey = conversation.monthKey;
+            } else {
+                // 其他分组使用 ConversationSort 枚举值作为 key
+                groupKey = String(conversation.sort);
             }
-            (_groups_get = groups.get(conversation.sort)) === null || _groups_get === void 0 ? void 0 : _groups_get.push(conversation);
+            if (!groups.has(groupKey)) {
+                groups.set(groupKey, []);
+            }
+            (_groups_get = groups.get(groupKey)) === null || _groups_get === void 0 ? void 0 : _groups_get.push(conversation);
         });
         return groups;
     }, [
@@ -407017,7 +407242,7 @@ var mobile_index_module_update = injectStylesIntoStyleTag_default()(mobile_index
 
 
 const MobileConversationItem = (param)=>{
-    let { isActive, item, shouldDisplayTime, onConversationChange, onRename, onDelete } = param;
+    let { isActive, item, shouldDisplayTime, groupTitle, onConversationChange, onRename, onDelete } = param;
     const [visible, setVisible] = (0,react.useState)(false);
     const [isTouched, setIsTouched] = (0,react.useState)(false);
     const longPressTimerRef = (0,react.useRef)(null);
@@ -407064,7 +407289,7 @@ const MobileConversationItem = (param)=>{
         children: [
             shouldDisplayTime ? /*#__PURE__*/ (0,jsx_runtime.jsx)("div", {
                 className: conversation_item_mobile_index_module["conversation-item-time"],
-                children: conversationSortMap.get(item.sort)
+                children: groupTitle || conversationSortMap.get(item.sort)
             }) : null,
             /*#__PURE__*/ (0,jsx_runtime.jsx)(MobileConversationOperate, {
                 onRename: ()=>{
@@ -407101,7 +407326,7 @@ const MobileConversationItem = (param)=>{
                         ellipsis: {
                             showTooltip: {
                                 opts: {
-                                    content: item.title || item.name,
+                                    content: item.title || intl_i18n.t('web_sdk_conversation_default_name'),
                                     style: {
                                         wordBreak: 'break-all'
                                     },
@@ -407110,7 +407335,7 @@ const MobileConversationItem = (param)=>{
                                 }
                             }
                         },
-                        children: item.title || item.name || intl_i18n.t('web_sdk_conversation_default_name', {}, '新创建的会话')
+                        children: item.title || intl_i18n.t('web_sdk_conversation_default_name')
                     })
                 })
             }),
@@ -407242,7 +407467,7 @@ var pc_index_module_update = injectStylesIntoStyleTag_default()(pc_index_module/
 
 
 const PcConversationItem = (param)=>{
-    let { isActive, item, shouldDisplayTime, onConversationChange, onRename, onDelete } = param;
+    let { isActive, item, shouldDisplayTime, groupTitle, onConversationChange, onRename, onDelete } = param;
     const [visible, setVisible] = (0,react.useState)(false);
     const handleClick = (e)=>{
         e.stopPropagation();
@@ -407254,7 +407479,7 @@ const PcConversationItem = (param)=>{
         children: [
             shouldDisplayTime ? /*#__PURE__*/ (0,jsx_runtime.jsx)("div", {
                 className: conversation_item_pc_index_module["conversation-item-time"],
-                children: conversationSortMap.get(item.sort)
+                children: groupTitle || conversationSortMap.get(item.sort)
             }) : null,
             /*#__PURE__*/ (0,jsx_runtime.jsxs)("div", {
                 className: classnames_default()(conversation_item_pc_index_module["conversation-item-content"], {
@@ -407278,7 +407503,7 @@ const PcConversationItem = (param)=>{
                                 }
                             }
                         },
-                        children: item.title || intl_i18n.t('web_sdk_conversation_default_name', {}, '新创建的会话')
+                        children: item.title || intl_i18n.t('web_sdk_conversation_default_name')
                     }),
                     /*#__PURE__*/ (0,jsx_runtime.jsx)(Operate, {
                         onRename: ()=>{
@@ -407361,8 +407586,10 @@ var conversation_list_index_module_update = injectStylesIntoStyleTag_default()(c
 
 
 
-const ConversationList = /*#__PURE__*/ (0,react.forwardRef)((param, ref)=>{
-    let { onRename, onDelete, loading, groupedConversations, conversations, hasMore, loadMore } = param;
+
+const ConversationList = /*#__PURE__*/ (0,react.forwardRef)(// eslint-disable-next-line @coze-arch/max-line-per-function
+(param, ref)=>{
+    let { onRename, onDelete, loading, groupedConversations, conversations, hasMore, loadMore, removeConversation } = param;
     const { currentConversationInfo, updateCurrentConversationInfo, cozeApi, updateConversations } = useChatAppStore(shallow_useShallow((state)=>({
             currentConversationInfo: state.currentConversationInfo,
             updateCurrentConversationInfo: state.updateCurrentConversationInfo,
@@ -407488,7 +407715,11 @@ const ConversationList = /*#__PURE__*/ (0,react.forwardRef)((param, ref)=>{
             if (res.code !== 0) {
                 return false;
             }
-            await updateConversations([
+            // 删除成功后，同时更新store和本地数据源
+            // 先更新本地数据源，确保UI立即更新
+            removeConversation(conversation.id);
+            // 然后更新store，确保数据一致性
+            updateConversations([
                 conversation
             ], 'remove');
             return true;
@@ -407595,13 +407826,29 @@ const ConversationList = /*#__PURE__*/ (0,react.forwardRef)((param, ref)=>{
                 className: conversation_list_sider_conversation_list_index_module["conversations-list"],
                 children: [
                     Array.from(groupedConversations.entries()).map((param)=>{
-                        let [sort, conversationList] = param;
+                        let [sortKey, conversationList] = param;
+                        // 获取分组标题
+                        const sort = Number(sortKey);
+                        let groupTitle;
+                        if (!isNaN(sort)) {
+                            // 是 ConversationSort 枚举值
+                            groupTitle = conversationSortMap.get(sort) || '';
+                        } else {
+                            // 是月份字符串 (YYYY-MM)
+                            const [year, month] = sortKey.split('-');
+                            const monthDate = new Date(Number(year), Number(month) - 1);
+                            groupTitle = monthDate.toLocaleDateString('zh-CN', {
+                                year: 'numeric',
+                                month: 'long'
+                            });
+                        }
                         return /*#__PURE__*/ (0,jsx_runtime.jsx)("div", {
                             className: conversation_list_sider_conversation_list_index_module["conversations-list-group"],
                             children: conversationList.map((conversation, index)=>isMobile ? /*#__PURE__*/ (0,jsx_runtime.jsx)(MobileConversationItem, {
                                     isActive: conversation.id === (currentConversationInfo === null || currentConversationInfo === void 0 ? void 0 : currentConversationInfo.id),
                                     item: conversation,
                                     shouldDisplayTime: index === 0,
+                                    groupTitle: groupTitle,
                                     onConversationChange: handleConversationChange,
                                     onRename: onRename,
                                     onDelete: onDelete
@@ -407609,11 +407856,12 @@ const ConversationList = /*#__PURE__*/ (0,react.forwardRef)((param, ref)=>{
                                     isActive: conversation.id === (currentConversationInfo === null || currentConversationInfo === void 0 ? void 0 : currentConversationInfo.id),
                                     item: conversation,
                                     shouldDisplayTime: index === 0,
+                                    groupTitle: groupTitle,
                                     onConversationChange: handleConversationChange,
                                     onRename: onRename,
                                     onDelete: onDelete
                                 }, conversation.id))
-                        }, sort);
+                        }, sortKey);
                     }),
                     /*#__PURE__*/ (0,jsx_runtime.jsx)("div", {
                         ref: loadMoreRef,
@@ -407701,7 +407949,7 @@ var conversation_list_sider_index_module_update = injectStylesIntoStyleTag_defau
             cozeApi: state.cozeApi
         })));
     const { chatConfig: { type: chatType } } = useChatAppProps();
-    const { loading, conversations, hasMore, loadMore } = useConversationList();
+    const { loading, conversations, hasMore, loadMore, removeConversation } = useConversationList();
     const groupedConversations = useGroupedConversations(conversations);
     const [isModalLoading, setIsModalLoading] = (0,react.useState)(false);
     const [modalInfo, setModalInfo] = (0,react.useState)(null);
@@ -407840,7 +408088,8 @@ var conversation_list_sider_index_module_update = injectStylesIntoStyleTag_defau
                 groupedConversations: groupedConversations,
                 conversations: conversations,
                 hasMore: hasMore,
-                loadMore: loadMore
+                loadMore: loadMore,
+                removeConversation: removeConversation
             }) : null,
             /*#__PURE__*/ (0,jsx_runtime.jsx)(react.Fragment, {
                 children: children
@@ -407870,7 +408119,8 @@ var conversation_list_sider_index_module_update = injectStylesIntoStyleTag_defau
                     groupedConversations: groupedConversations,
                     conversations: conversations,
                     hasMore: hasMore,
-                    loadMore: loadMore
+                    loadMore: loadMore,
+                    removeConversation: removeConversation
                 })
             }),
             /*#__PURE__*/ (0,jsx_runtime.jsx)(esm_webpack_exports_Modal, {
@@ -415903,9 +416153,14 @@ class MessageConverseToCoze {
             case 'object_string':
                 {
                     console.log('convertContent object_string');
+                    const mixContent = this.convertMixContent(content);
+                    // 如果 convertMixContent 返回 undefined（JSON 不完整），也返回 undefined
+                    if (mixContent === undefined) {
+                        return undefined;
+                    }
                     return {
                         content_type: types_ContentType.Mix,
-                        content: this.convertMixContent(content)
+                        content: mixContent
                     };
                 }
             case 'card':
@@ -418387,7 +418642,7 @@ class MessageParser {
                 }
             case "conversation.message.delta":
                 {
-                    const message = this.createMessage(data);
+                    const message = this.createMessage(data, false);
                     if (!message) {
                         return;
                     }
@@ -418395,7 +418650,21 @@ class MessageParser {
                 }
             case "conversation.message.completed":
                 {
-                    return this.createMessage(data, true);
+                    const messageResult = this.createMessage(data, true);
+                    // 清理流式 JSON 累积内容
+                    if (messageResult && typeof messageResult === 'object' && 'data' in messageResult) {
+                        const messageData = messageResult.data;
+                        // 检查是否是 ChunkRaw 类型（包含 message 字段）
+                        if (messageData && typeof messageData === 'object' && 'message' in messageData && messageData.message && typeof messageData.message === 'object') {
+                            const msg = messageData.message;
+                            const contentKey = msg.message_id || msg.reply_id || '';
+                            if (contentKey) {
+                                this.streamingJsonContent.delete(contentKey);
+                                this.lastValidJsonContent.delete(contentKey);
+                            }
+                        }
+                    }
+                    return messageResult;
                 }
             case "conversation.chat.completed":
             case "done":
@@ -418446,10 +418715,53 @@ class MessageParser {
         const messageType = (dataValue === null || dataValue === void 0 ? void 0 : dataValue.type) || '';
         dataValue.chat_id = !dataValue.chat_id || dataValue.chat_id === '0' ? '' : dataValue.chat_id;
         dataValue.id = !dataValue.id || dataValue.id === '0' ? '' : dataValue.id;
+        // 处理流式 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 || '';
+            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);
+                } else {
+                    // 如果解析失败（JSON 不完整），使用上一次成功解析的内容（如果有）
+                    // 这样可以避免每次 delta 都创建新消息，导致重复渲染
+                    const lastValidContent = this.lastValidJsonContent.get(contentKey);
+                    if (lastValidContent) {
+                        // 使用上一次成功解析的内容，避免重复渲染
+                        dataValue.content = lastValidContent;
+                    } else {
+                        // 如果完全没有成功解析的内容，使用累积的原始内容
+                        // 但这样可能会导致 convertMixContent 失败，返回 undefined
+                        dataValue.content = newContent;
+                    }
+                }
+            }
+        }
         const message = messageConverterToCoze.convertMessage(dataValue, this.botId);
         if (!message) {
             return;
         }
+        // 对于流式 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 || '';
+            const lastValidContent = contentKey ? this.lastValidJsonContent.get(contentKey) : undefined;
+            // 如果没有上一次成功解析的内容，不返回消息
+            if (!lastValidContent) {
+                return;
+            }
+            // 如果有上一次成功解析的内容，使用它
+            message.content = lastValidContent;
+        }
         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') {
@@ -418473,6 +418785,123 @@ class MessageParser {
             }
         };
     }
+    /**
+   * 尝试解析流式 JSON 内容
+   * 如果 JSON 不完整，返回 null；如果解析成功，返回完整的 JSON 字符串
+   */ tryParseStreamingJson(content) {
+        if (!content || content.trim() === '') {
+            return null;
+        }
+        const trimmed = content.trim();
+        try {
+            // 尝试解析为完整的 JSON
+            const parsed = JSON.parse(trimmed);
+            // 如果解析成功，返回格式化的 JSON 字符串
+            return JSON.stringify(parsed);
+        } catch (e) {
+            // 如果解析失败，可能是 JSON 不完整
+            // 检查是否以 [ 开头，可能是数组
+            if (trimmed.startsWith('[')) {
+                // 尝试找到最后一个完整的 JSON 对象或数组
+                let bracketCount = 0;
+                let braceCount = 0;
+                let inString = false;
+                let escapeNext = false;
+                let lastValidIndex = -1;
+                for(let i = 0; 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++;
+                    }
+                    if (char === ']') {
+                        bracketCount--;
+                    }
+                    if (char === '{') {
+                        braceCount++;
+                    }
+                    if (char === '}') {
+                        braceCount--;
+                    }
+                    // 如果所有括号都匹配了，说明找到了一个完整的 JSON
+                    if (bracketCount === 0 && braceCount === 0 && i > 0) {
+                        lastValidIndex = i;
+                        break;
+                    }
+                }
+                if (lastValidIndex > 0) {
+                    try {
+                        const partialContent = trimmed.substring(0, lastValidIndex + 1);
+                        JSON.parse(partialContent);
+                        return partialContent;
+                    } catch (parseError) {
+                        // JSON 解析失败，继续返回 null，表示 JSON 不完整
+                        void parseError;
+                    }
+                }
+            } else if (trimmed.startsWith('{')) {
+                // 如果是对象，尝试找到最后一个完整的对象
+                let braceCount = 0;
+                let inString = false;
+                let escapeNext = false;
+                let lastValidIndex = -1;
+                for(let i = 0; 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 === '{') {
+                        braceCount++;
+                    }
+                    if (char === '}') {
+                        braceCount--;
+                    }
+                    if (braceCount === 0 && i > 0) {
+                        lastValidIndex = i;
+                        break;
+                    }
+                }
+                if (lastValidIndex > 0) {
+                    try {
+                        const partialContent = trimmed.substring(0, lastValidIndex + 1);
+                        JSON.parse(partialContent);
+                        return partialContent;
+                    } catch (parseError) {
+                        // JSON 解析失败，继续返回 null，表示 JSON 不完整
+                        void parseError;
+                    }
+                }
+            }
+            // 如果无法解析，返回 null，表示 JSON 不完整，需要继续累积
+            return null;
+        }
+    }
     createAckMessage(data) {
         var _dataValue_inserted_additional_messages_lastItem, _dataValue_inserted_additional_messages, _this_userInfo;
         const messageType = 'ack';
@@ -418566,6 +418995,10 @@ class MessageParser {
         message_parser_define_property(this, "botVersion", '');
         message_parser_define_property(this, "userInfo", void 0);
         message_parser_define_property(this, "onConversationUpdate", void 0);
+        // 用于累积流式 JSON 内容，key 为 messageId 或 replyId
+        message_parser_define_property(this, "streamingJsonContent", new Map());
+        // 用于存储上一次成功解析的完整 JSON 内容，避免重复渲染
+        message_parser_define_property(this, "lastValidJsonContent", new Map());
         this.conversationId = requestMessageRawBody.conversation_id;
         this.localMessageId = requestMessageRawBody.local_message_id;
         this.sendMessageContent = requestMessageRawBody.query;
@@ -418747,6 +419180,30 @@ class MessageParser {
                                 sectionId: conversationResult.sectionId || '',
                                 conversationName: conversationResult.conversationName
                             };
+                            // 立即添加会话到列表，使用创建时返回的名称
+                            const existingConversation = refConversations.current.find((c)=>c.id === conversationResult.conversationId);
+                            if (!existingConversation && refUpdateConversations.current) {
+                                // 重用外部作用域已声明的 chatType 和 isAppType
+                                const newConversation = {
+                                    id: conversationResult.conversationId,
+                                    last_section_id: conversationResult.sectionId || '',
+                                    name: conversationResult.conversationName || '',
+                                    created_at: Math.floor(Date.now() / 1000),
+                                    updated_at: Math.floor(Date.now() / 1000),
+                                    meta_data: {},
+                                    // App 模式需要 title 字段，但从空会话创建的新会话 title 应该为空
+                                    ...isAppType && {
+                                        title: ''
+                                    }
+                                };
+                                refUpdateConversations.current([
+                                    newConversation
+                                ], 'add');
+                                console.log('onBeforeSendMessage: Conversation added to list immediately', {
+                                    conversationId: conversationResult.conversationId,
+                                    conversationName: conversationResult.conversationName
+                                });
+                            }
                             // 只更新 messageBody 中的 conversation_id
                             // 不在这里更新 currentConversationInfo 或调用 setConversationId
                             // 这些更新会在消息发送成功后通过消息解析器进行
@@ -418854,15 +419311,22 @@ class MessageParser {
                             // 检查会话是否已经存在于列表中，避免重复添加
                             const existingConversation = refConversations.current.find((c)=>c.id === pendingInfo.conversationId);
                             // 如果会话不存在，才更新会话列表
+                            // 注意：会话已经在创建时添加到列表了，这里主要是为了兼容性检查
                             if (!existingConversation) {
+                                const chatType = refChatConfig.current.type;
+                                const isAppType = chatType === client_ChatType.APP;
                                 const newConversation = {
                                     id: pendingInfo.conversationId,
                                     last_section_id: pendingInfo.sectionId,
-                                    // 不设置 name，让 useUpdateConversationNameByMessage hook 自动更新
-                                    name: '',
+                                    // 使用创建时返回的名称
+                                    name: pendingInfo.conversationName || '',
                                     created_at: Math.floor(Date.now() / 1000),
                                     updated_at: Math.floor(Date.now() / 1000),
-                                    meta_data: {}
+                                    meta_data: {},
+                                    // App 模式需要 title 字段
+                                    ...isAppType && pendingInfo.conversationName && {
+                                        title: pendingInfo.conversationName
+                                    }
                                 };
                                 if (refUpdateConversations.current) {
                                     refUpdateConversations.current([