cx-chat 0.0.1 → 0.0.3

package/src/contexts/ChatContext.tsx

@@ -1,839 +0,0 @@
-import {
-    CHAT_STREAM_HANDLED_JSON_ERROR,
-    getChatTitleAPI,
-    postChatStreamRequest,
-    updateChatTitleAPI,
-} from '@/api/chat';
-import {
-    markMessagePreparationDone,
-    mergeMessagePreparationDelta,
-    omitMessagePreparationForPersist,
-    resolveMessageTurnIdForFeedback,
-    resolveThreadDisplayTitle,
-} from '@/utils/chatUtils';
-import { useQueryClient, type QueryClient } from '@tanstack/react-query';
-import React, { createContext, useCallback, useContext, useRef, useState } from 'react';
-import { flushSync } from 'react-dom';
-import { useTranslation } from 'react-i18next';
-import type { Message, Thread } from '../types';
-import { useAuth } from './AuthContext';
-import { useToast } from './ToastContext';
-
-export interface ChatStreamSendOptions {
-    enableNetwork?: boolean;
-    enableKnowledgeBase?: boolean;
-    enableDataAnalysis?: boolean;
-}
-
-/** 会话流式：联网 / 知识库 / 数据分析 开关对应权限码（与后端菜单权限一致） */
-export const CHAT_PERM_ENABLE_NETWORK = 'system:chat:enable-network';
-export const CHAT_PERM_ENABLE_KNOWLEDGE = 'system:chat:enable-knowledge';
-export const CHAT_PERM_ENABLE_DATA_ANALYSIS = 'system:chat:enable-data-analysis';
-
-/** 无权限则强制为 false，避免仅靠前端开关或 localStorage 绕过 */
-export function clampChatStreamFeatureFlags(
-    options: ChatStreamSendOptions | undefined,
-    hasPermission: (code: string) => boolean,
-): {
-    enableNetwork: boolean;
-    enableKnowledgeBase: boolean;
-    enableDataAnalysis: boolean;
-} {
-    return {
-        enableNetwork:
-            Boolean(options?.enableNetwork) &&
-            hasPermission(CHAT_PERM_ENABLE_NETWORK),
-        enableKnowledgeBase:
-            Boolean(options?.enableKnowledgeBase) &&
-            hasPermission(CHAT_PERM_ENABLE_KNOWLEDGE),
-        enableDataAnalysis:
-            Boolean(options?.enableDataAnalysis) &&
-            hasPermission(CHAT_PERM_ENABLE_DATA_ANALYSIS),
-    };
-}
-
-interface ChatContextType {
-    activeThreadId: string | null;
-    isStreaming: boolean;
-    streamingContent: Message | null;
-    /** 新会话乐观插入的列表行；流式结束并刷新列表后清除，供侧栏在接口未返回前合并展示 */
-    streamingPlaceholderThread: Thread | null;
-    sendMessage: (
-        content: string,
-        threadId: string,
-        options?: ChatStreamSendOptions,
-    ) => Promise<void>;
-    /** 按 turn 重新生成助手回复：POST /chat/stream/regenerate */
-    regenerateMessage: (
-        sessionId: string,
-        turnId: string,
-        options?: ChatStreamSendOptions,
-    ) => Promise<void>;
-    stopStream: () => Promise<void>;
-    resetStream: () => void;
-}
-
-/** 会话列表接口落库略晚于首条消息：流结束后再延迟拉列表，降低「新会话被刷掉」概率 */
-const THREADS_LIST_REFETCH_DELAY_MS = 600
-
-/** 不重拉整表：仅把当前会话置顶并更新 updated_at，避免回答结束后侧栏整表刷新闪动 */
-function bumpThreadToTopInCache(queryClient: QueryClient, threadId: string) {
-    queryClient.setQueryData<Thread[]>(['threads'], (old) => {
-        const list = old ?? [];
-        const idx = list.findIndex((t) => t.id === threadId);
-        if (idx < 0) return list;
-        const cur = list[idx];
-        const next: Thread = {
-            ...cur,
-            updated_at: new Date().toISOString(),
-        };
-        return [next, ...list.filter((_, i) => i !== idx)];
-    });
-}
-
-const ChatContext = createContext<ChatContextType | undefined>(undefined);
-
-function pickGeneratedChatTitle(res: unknown): string {
-    const r = res as Record<string, unknown> | null | undefined
-    const d = r?.data as Record<string, unknown> | undefined
-    const nested = d?.data as Record<string, unknown> | undefined
-    const title =
-        (typeof nested?.title === 'string' && nested.title) ||
-        (typeof d?.title === 'string' && d.title) ||
-        (typeof r?.title === 'string' && r.title) ||
-        ''
-    return String(title).trim()
-}
-
-type SseStreamRefs = {
-    thisStreamGen: number;
-    streamGenerationRef: React.MutableRefObject<number>;
-    setStreamingContent: React.Dispatch<React.SetStateAction<Message | null>>;
-    setIsStreaming: React.Dispatch<React.SetStateAction<boolean>>;
-    streamingContentRef: React.MutableRefObject<Message | null>;
-    /** 发送新消息时：message_start 拿到后端 turn_id 后，把乐观插入的最后一条用户消息 id 同步为 `{turnId}-10` */
-    syncLastUserMessageTurnId?: (turnKey: string) => void;
-};
-
-/** 消费流式接口返回的 SSE（data: JSON 行），更新 streamingContent / isStreaming */
-async function readSseStreamBody(
-    response: Response,
-    refs: SseStreamRefs,
-): Promise<void> {
-    if (!response.body) throw new Error('No response body');
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let startBuffer = '';
-    const {
-        thisStreamGen,
-        streamGenerationRef,
-        setStreamingContent,
-        setIsStreaming,
-        streamingContentRef,
-        syncLastUserMessageTurnId,
-    } = refs;
-
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-
-        const chunk = decoder.decode(value, { stream: true });
-        startBuffer += chunk;
-        const lines = startBuffer.split('\n');
-        startBuffer = lines.pop() || '';
-
-        for (const line of lines) {
-            const trimmed = line.replace(/\r$/, '').trim();
-            if (!trimmed.startsWith('data:')) continue;
-
-            const dataStr = trimmed.slice(5).trimStart();
-
-            try {
-                const parsedData: Record<string, unknown> = JSON.parse(dataStr);
-                if (thisStreamGen !== streamGenerationRef.current) {
-                    continue;
-                }
-                const eventType = parsedData.type as string | undefined;
-
-                if (eventType === 'message_start') {
-                    const turnId = parsedData.turn_id;
-                    const turnKey =
-                        turnId != null && String(turnId) ? String(turnId) : '';
-                    setStreamingContent((prev) => {
-                        if (!prev) return prev;
-                        const nextId = turnKey ? `${turnKey}-20` : prev.id;
-                        const updated = {
-                            ...prev,
-                            id: nextId,
-                            turn_id: turnKey || prev.turn_id,
-                        };
-                        streamingContentRef.current = updated;
-                        return updated;
-                    });
-                    if (turnKey) {
-                        syncLastUserMessageTurnId?.(turnKey);
-                    }
-                    continue;
-                }
-
-                if (eventType === 'preparation') {
-                    const delta = parsedData.delta as
-                        | Record<string, unknown>
-                        | undefined;
-                    setStreamingContent((prev) => {
-                        if (!prev) return null;
-                        const preparation_items = mergeMessagePreparationDelta(
-                            prev.preparation_items,
-                            delta,
-                        );
-                        const updated = { ...prev, preparation_items };
-                        streamingContentRef.current = updated;
-                        return updated;
-                    });
-                    continue;
-                }
-
-                if (eventType === 'content_block_delta') {
-                    const delta = parsedData.delta as
-                        | { text?: string }
-                        | undefined;
-                    const piece = delta?.text ?? '';
-                    if (piece) {
-                        flushSync(() => {
-                            setStreamingContent((prev) => {
-                                if (!prev) return null;
-                                const updated = {
-                                    ...prev,
-                                    content: prev.content + piece,
-                                };
-                                streamingContentRef.current = updated;
-                                return updated;
-                            });
-                        });
-                    }
-                    continue;
-                }
-
-                if (eventType === 'content_block_stop') {
-                    setStreamingContent((prev) => {
-                        if (!prev) return prev;
-                        const updated = markMessagePreparationDone({
-                            ...prev,
-                            is_streaming: false,
-                        });
-                        streamingContentRef.current = updated;
-                        return updated;
-                    });
-                    setIsStreaming(false);
-                    continue;
-                }
-
-                if (
-                    eventType === 'suggested_replies' &&
-                    Array.isArray(parsedData.items)
-                ) {
-                    setStreamingContent((prev) => {
-                        if (!prev) return null;
-                        const updated = {
-                            ...prev,
-                            options: parsedData.items as string[],
-                        };
-                        streamingContentRef.current = updated;
-                        return updated;
-                    });
-                    continue;
-                }
-
-                if (
-                    eventType === 'references_knowledge' &&
-                    Array.isArray(parsedData.items)
-                ) {
-                    setStreamingContent((prev) => {
-                        if (!prev) return null;
-                        const updated = {
-                            ...prev,
-                            references_knowledge_items: parsedData.items as any[],
-                        };
-                        streamingContentRef.current = updated;
-                        return updated;
-                    });
-                    continue;
-                }
-
-                if (eventType === 'message_end') {
-                    setStreamingContent((prev) => {
-                        if (!prev) return prev;
-                        const updated = markMessagePreparationDone({
-                            ...prev,
-                            is_streaming: false,
-                        });
-                        streamingContentRef.current = updated;
-                        return updated;
-                    });
-                    continue;
-                }
-            } catch (e) {
-                console.error('解析 SSE 数据错误', e);
-            }
-        }
-    }
-}
-
-
-export const ChatProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
-    const [activeThreadId, setActiveThreadId] = useState<string | null>(null);
-    const [isStreaming, setIsStreaming] = useState(false);
-    const [streamingContent, setStreamingContent] = useState<Message | null>(null);
-    const [streamingPlaceholderThread, setStreamingPlaceholderThread] =
-        useState<Thread | null>(null);
-    const abortControllerRef = useRef<AbortController | null>(null);
-
-    // 在异步/事件循环内部访问状态时，如果闭包过期可能需要 refs
-    // 但这里我们主要更新状态。streamingContentRef 对清理很有用。
-    const streamingContentRef = useRef<Message | null>(null);
-    /** 每次发起流式请求递增；用于丢弃被新请求取代的旧 SSE / finally，避免串状态 */
-    const streamGenerationRef = useRef(0);
-    /** 当前流式请求对应的会话 id（用于被新请求打断时把上一条助手消息写入缓存） */
-    const streamingThreadIdRef = useRef<string | null>(null);
-
-    const queryClient = useQueryClient();
-    const { showToast } = useToast();
-    const { t } = useTranslation();
-    const { hasPermission } = useAuth();
-
-    const resetStream = useCallback(() => {
-        setActiveThreadId(null);
-        setIsStreaming(false);
-        setStreamingContent(null);
-        setStreamingPlaceholderThread(null);
-        abortControllerRef.current = null;
-        streamingContentRef.current = null;
-        streamingThreadIdRef.current = null;
-    }, []);
-
-    const stopStream = useCallback(async () => {
-        if (abortControllerRef.current) {
-            abortControllerRef.current.abort();
-            abortControllerRef.current = null;
-
-            // 更新 UI 状态为已停止
-            setIsStreaming(false);
-
-            // 如果需要，在本地状态中将消息标记为已中止
-            if (streamingContentRef.current) {
-                // 在缓存中将消息最终化为已中止 (?) 或让它作为部分内容存在
-                // 目前，我们只停止加载动画。`sendMessage` 中的 `handleError` 或 `finally` 块
-                // 通常处理“中止”清理，但由于我们手动中止，可能需要触发它。
-            }
-        }
-    }, [activeThreadId]);
-
-    const sendMessage = useCallback(async (
-        message: string,
-        threadId: string,
-        options?: ChatStreamSendOptions,
-    ) => {
-        if (isStreaming) {
-            console.warn("正在流式传输中，忽略发送请求");
-            return;
-        }
-
-        // 新建会话：navigate 后会立刻拉 messages，若与乐观更新并发，返回体会覆盖缓存导致首条用户消息消失
-        await queryClient.cancelQueries({ queryKey: ['messages', threadId] })
-
-        const staleThreadId = streamingThreadIdRef.current;
-        const staleAssistant = streamingContentRef.current;
-
-        streamGenerationRef.current += 1;
-        const thisStreamGen = streamGenerationRef.current;
-
-        if (abortControllerRef.current) {
-            abortControllerRef.current.abort();
-            abortControllerRef.current = null;
-            if (
-                staleAssistant?.role === 'assistant' &&
-                staleAssistant.content &&
-                staleThreadId
-            ) {
-                const toMerge = omitMessagePreparationForPersist(
-                    markMessagePreparationDone({
-                        ...staleAssistant,
-                        is_streaming: false,
-                    }),
-                );
-                queryClient.setQueryData<Message[]>(
-                    ['messages', staleThreadId],
-                    (old) => {
-                        const prev = old ?? [];
-                        const exists = prev.some((m) => m.id === toMerge.id);
-                        if (!exists) return [...prev, toMerge];
-                        return prev.map((m) =>
-                            m.id === toMerge.id ? toMerge : m,
-                        );
-                    },
-                );
-            }
-        }
-
-        streamingThreadIdRef.current = threadId;
-
-        setActiveThreadId(threadId);
-        setIsStreaming(true);
-        setStreamingContent(null);
-        streamingContentRef.current = null;
-
-        const controller = new AbortController();
-        abortControllerRef.current = controller;
-
-        const prevMessages = queryClient.getQueryData<Message[]>(['messages', threadId]) ?? [];
-        const isFirstSessionTurn = prevMessages.length === 0;
-        let streamFinishedOk = false;
-
-        // 乐观更新：立即添加用户消息
-        const optimisticUserMessage: Message = {
-            id: (typeof crypto.randomUUID === 'function') ? crypto.randomUUID() : `u-${Date.now()}`,
-            role: 'user',
-            content: message,
-            created_at: new Date().toISOString(),
-        };
-
-        // 初始化流式消息
-        const initialStreamingMessage: Message = {
-            id: (typeof crypto.randomUUID === 'function') ? `temp-${crypto.randomUUID()}` : `temp-ai-stream-${Date.now()}`,
-            role: 'assistant',
-            content: '',
-            thoughts: [],
-            options: [],
-            preparation_items: [],
-            is_streaming: true,
-            created_at: new Date().toISOString(),
-        };
-
-        setStreamingContent(initialStreamingMessage);
-        streamingContentRef.current = initialStreamingMessage;
-
-        // 追加用户消息，并清除历史里助手消息的搜索建议（避免跟新一轮对话叠在一起）
-        queryClient.setQueryData<Message[]>(['messages', threadId], (old) => {
-            const prev = old ?? [];
-            const cleared = prev.map((m) =>
-                m.role === 'assistant' && m.options && m.options.length > 0
-                    ? { ...m, options: [] as string[] }
-                    : m,
-            );
-            return [...cleared, optimisticUserMessage];
-        });
-
-        // 左侧会话列表：立即插入/更新当前会话（避免新会话要等 refetch 才出现）
-        // 新会话首轮在助手回答前不用提问当标题，避免先预览再被 getChatTitle 替换造成闪烁
-        const now = new Date().toISOString();
-        const trimmed = message.trim();
-        const preview =
-            trimmed.length > 60 ? `${trimmed.slice(0, 60)}…` : trimmed;
-        const untitledLabel = t('chat.untitled_session');
-        let threadsPlaceholder: Thread | null = null;
-        queryClient.setQueryData<Thread[]>(['threads'], (old) => {
-            const list = [...(old ?? [])];
-            const idx = list.findIndex((t) => t.id === threadId);
-            if (idx >= 0) {
-                const cur = list[idx];
-                const nextTitle = isFirstSessionTurn
-                    ? resolveThreadDisplayTitle(cur.title, untitledLabel)
-                    : resolveThreadDisplayTitle(
-                          preview || cur.title,
-                          untitledLabel,
-                      );
-                list[idx] = {
-                    ...cur,
-                    title: nextTitle,
-                    updated_at: now,
-                };
-                threadsPlaceholder = null;
-                return list;
-            }
-            const inserted: Thread = {
-                id: threadId,
-                title: isFirstSessionTurn
-                    ? resolveThreadDisplayTitle('', untitledLabel)
-                    : resolveThreadDisplayTitle(preview, untitledLabel),
-                created_at: now,
-                updated_at: now,
-                user_id: '',
-                top_status: 0,
-            };
-            list.unshift(inserted);
-            threadsPlaceholder = inserted;
-            return list;
-        });
-        setStreamingPlaceholderThread(threadsPlaceholder);
-
-        try {
-            const streamFlags = clampChatStreamFeatureFlags(options, hasPermission);
-            const response = await postChatStreamRequest(
-                {
-                    message,
-                    session_id: threadId,
-                    enableNetwork: streamFlags.enableNetwork,
-                    enableKnowledgeBase: streamFlags.enableKnowledgeBase,
-                    enableDataAnalysis: streamFlags.enableDataAnalysis,
-                },
-                { signal: controller.signal },
-            );
-
-            await readSseStreamBody(response, {
-                thisStreamGen,
-                streamGenerationRef,
-                setStreamingContent,
-                setIsStreaming,
-                streamingContentRef,
-                syncLastUserMessageTurnId: (turnKey: string) => {
-                    queryClient.setQueryData<Message[]>(
-                        ['messages', threadId],
-                        (old) => {
-                            const prev = old ?? [];
-                            for (let i = prev.length - 1; i >= 0; i--) {
-                                if (prev[i].role === 'user') {
-                                    const u = prev[i];
-                                    const next = [...prev];
-                                    next[i] = {
-                                        ...u,
-                                        id: `${turnKey}-10`,
-                                        turn_id: turnKey,
-                                    };
-                                    return next;
-                                }
-                            }
-                            return prev;
-                        },
-                    );
-                },
-            });
-
-            streamFinishedOk = true;
-
-        } catch (err: any) {
-            if (thisStreamGen !== streamGenerationRef.current) {
-                // 已被新请求取代
-            } else if (err.name === 'AbortError') {
-                console.log('请求已中止');
-                // 在本地/全局状态中标记为已中止
-                setStreamingContent(prev => {
-                    if (!prev) return prev;
-                    const updated = { ...prev, is_aborted: true, is_streaming: false };
-                    streamingContentRef.current = updated;
-                    return updated;
-                });
-            } else if (err?.message === CHAT_STREAM_HANDLED_JSON_ERROR) {
-                // 已在 postChatStreamRequest 内 toast / 未登录跳转
-            } else {
-                console.error('流式错误:', err);
-                showToast(t('chat.send_failed') || '发送消息失败', 'error');
-                // 回滚用户消息？还是保留并显示错误状态？
-                // 当前逻辑保留消息。
-            }
-        } finally {
-            if (thisStreamGen !== streamGenerationRef.current) {
-                if (abortControllerRef.current === controller) {
-                    abortControllerRef.current = null;
-                }
-                setStreamingPlaceholderThread(null);
-                return;
-            }
-
-            setIsStreaming(false);
-            if (abortControllerRef.current === controller) {
-                abortControllerRef.current = null;
-            }
-
-            // 在缓存中最终确定消息
-            if (streamingContentRef.current && streamingContentRef.current.content) {
-                const finalMsg = omitMessagePreparationForPersist(
-                    streamingContentRef.current,
-                );
-                queryClient.setQueryData<Message[]>(['messages', threadId], (old) => {
-                    const prev = old ?? [];
-                    const exists = prev.some((m) => m.id === finalMsg.id);
-                    if (!exists) return [...prev, finalMsg];
-                    return prev.map((m) => (m.id === finalMsg.id ? finalMsg : m));
-                });
-            }
-
-            // 须先于 isFirstSessionTurn 内的 await：否则 index-session 会同时展示「缓存中的助手条 + streamingContent」
-            // 新会话首轮流式约 0.6s+ 的列表刷新窗口内会叠成两个回答
-            setStreamingContent(null);
-            streamingContentRef.current = null;
-
-            if (isFirstSessionTurn) {
-                const beforeThreads = queryClient.getQueryData<Thread[]>(['threads']) ?? [];
-                try {
-                    await new Promise<void>((r) => {
-                        window.setTimeout(r, THREADS_LIST_REFETCH_DELAY_MS);
-                    });
-                    await queryClient.refetchQueries({ queryKey: ['threads'] });
-                    const afterThreads = queryClient.getQueryData<Thread[]>(['threads']) ?? [];
-                    const afterIds = new Set(afterThreads.map((x) => x.id));
-                    const orphan = beforeThreads.filter((x) => !afterIds.has(x.id));
-                    if (orphan.length > 0) {
-                        queryClient.setQueryData<Thread[]>(['threads'], [...orphan, ...afterThreads]);
-                    }
-                } catch (e) {
-                    console.error('[ChatContext] threads refetch failed', e);
-                    queryClient.invalidateQueries({ queryKey: ['threads'] });
-                }
-            }
-            setStreamingPlaceholderThread(null);
-
-            /** 新会话首轮流式成功后：先 AI 生成标题，失败或空则用提问前 20 字更新 */
-            if (streamFinishedOk && isFirstSessionTurn) {
-                const questionTrimmed = message.trim()
-                const titleFromQuestion =
-                    questionTrimmed.length > 20
-                        ? questionTrimmed.slice(0, 20)
-                        : questionTrimmed
-
-                void (async () => {
-                    let applied = false
-                    try {
-                        const titleRes = await getChatTitleAPI({
-                            sessionId: threadId,
-                        })
-                        const title = pickGeneratedChatTitle(titleRes)
-                        if (title) {
-                            await updateChatTitleAPI({
-                                sessionId: threadId,
-                                title,
-                            })
-                            applied = true
-                        }
-                    } catch (e) {
-                        console.error(
-                            '[ChatContext] getChatTitleAPI failed',
-                            e,
-                        )
-                    }
-                    if (!applied && titleFromQuestion) {
-                        try {
-                            await updateChatTitleAPI({
-                                sessionId: threadId,
-                                title: titleFromQuestion,
-                            })
-                            applied = true
-                        } catch (e) {
-                            console.error(
-                                '[ChatContext] fallback title update failed',
-                                e,
-                            )
-                        }
-                    }
-                    if (applied) {
-                        await queryClient.invalidateQueries({
-                            queryKey: ['threads'],
-                        })
-                    }
-                })();
-            }
-
-            streamingThreadIdRef.current = null;
-            setActiveThreadId(null);
-        }
-
-    }, [queryClient, showToast, t, isStreaming, hasPermission]);
-
-    const regenerateMessage = useCallback(async (
-        sessionId: string,
-        turnId: string,
-        options?: ChatStreamSendOptions,
-    ) => {
-        const tid = String(turnId ?? '').trim();
-        if (!sessionId || !tid) return;
-
-        if (isStreaming) {
-            console.warn('正在流式传输中，忽略重新生成请求');
-            return;
-        }
-
-        await queryClient.cancelQueries({ queryKey: ['messages', sessionId] });
-
-        const staleThreadId = streamingThreadIdRef.current;
-        const staleAssistant = streamingContentRef.current;
-
-        streamGenerationRef.current += 1;
-        const thisStreamGen = streamGenerationRef.current;
-
-        if (abortControllerRef.current) {
-            abortControllerRef.current.abort();
-            abortControllerRef.current = null;
-            if (
-                staleAssistant?.role === 'assistant' &&
-                staleAssistant.content &&
-                staleThreadId
-            ) {
-                const toMerge = omitMessagePreparationForPersist(
-                    markMessagePreparationDone({
-                        ...staleAssistant,
-                        is_streaming: false,
-                    }),
-                );
-                queryClient.setQueryData<Message[]>(
-                    ['messages', staleThreadId],
-                    (old) => {
-                        const prev = old ?? [];
-                        const exists = prev.some((m) => m.id === toMerge.id);
-                        if (!exists) return [...prev, toMerge];
-                        return prev.map((m) =>
-                            m.id === toMerge.id ? toMerge : m,
-                        );
-                    },
-                );
-            }
-        }
-
-        streamingThreadIdRef.current = sessionId;
-
-        setActiveThreadId(sessionId);
-        setIsStreaming(true);
-        setStreamingContent(null);
-        streamingContentRef.current = null;
-
-        const controller = new AbortController();
-        abortControllerRef.current = controller;
-
-        let streamFinishedOk = false;
-
-        const initialStreamingMessage: Message = {
-            id: (typeof crypto.randomUUID === 'function')
-                ? `temp-${crypto.randomUUID()}`
-                : `temp-ai-stream-${Date.now()}`,
-            role: 'assistant',
-            content: '',
-            thoughts: [],
-            options: [],
-            preparation_items: [],
-            is_streaming: true,
-            created_at: new Date().toISOString(),
-        };
-
-        setStreamingContent(initialStreamingMessage);
-        streamingContentRef.current = initialStreamingMessage;
-
-        queryClient.setQueryData<Message[]>(['messages', sessionId], (old) => {
-            const prev = old ?? [];
-            const cleared = prev.map((m) =>
-                m.role === 'assistant' && m.options && m.options.length > 0
-                    ? { ...m, options: [] as string[] }
-                    : m,
-            );
-            return cleared.filter((m) => {
-                if (m.role !== 'assistant') return true;
-                return resolveMessageTurnIdForFeedback(m) !== tid;
-            });
-        });
-
-        try {
-            const streamFlags = clampChatStreamFeatureFlags(options, hasPermission);
-            const response = await postChatStreamRequest(
-                {
-                    sessionId,
-                    turnId: tid,
-                    enableNetwork: streamFlags.enableNetwork,
-                    enableKnowledgeBase: streamFlags.enableKnowledgeBase,
-                    enableDataAnalysis: streamFlags.enableDataAnalysis,
-                },
-                { signal: controller.signal, regenerate: true },
-            );
-
-            await readSseStreamBody(response, {
-                thisStreamGen,
-                streamGenerationRef,
-                setStreamingContent,
-                setIsStreaming,
-                streamingContentRef,
-            });
-
-            streamFinishedOk = true;
-        } catch (err: any) {
-            if (thisStreamGen !== streamGenerationRef.current) {
-                // 已被新请求取代
-            } else if (err.name === 'AbortError') {
-                console.log('请求已中止');
-                setStreamingContent((prev) => {
-                    if (!prev) return prev;
-                    const updated = {
-                        ...prev,
-                        is_aborted: true,
-                        is_streaming: false,
-                    };
-                    streamingContentRef.current = updated;
-                    return updated;
-                });
-            } else if (err?.message === CHAT_STREAM_HANDLED_JSON_ERROR) {
-                void queryClient.invalidateQueries({
-                    queryKey: ['messages', sessionId],
-                });
-            } else {
-                console.error('流式重新生成错误:', err);
-                showToast(t('chat.send_failed') || '发送消息失败', 'error');
-                void queryClient.invalidateQueries({
-                    queryKey: ['messages', sessionId],
-                });
-            }
-        } finally {
-            if (thisStreamGen !== streamGenerationRef.current) {
-                if (abortControllerRef.current === controller) {
-                    abortControllerRef.current = null;
-                }
-                return;
-            }
-
-            setIsStreaming(false);
-            if (abortControllerRef.current === controller) {
-                abortControllerRef.current = null;
-            }
-
-            if (
-                streamFinishedOk &&
-                streamingContentRef.current &&
-                streamingContentRef.current.content
-            ) {
-                const finalMsg = omitMessagePreparationForPersist(
-                    streamingContentRef.current,
-                );
-                queryClient.setQueryData<Message[]>(['messages', sessionId], (old) => {
-                    const prev = old ?? [];
-                    const exists = prev.some((m) => m.id === finalMsg.id);
-                    if (!exists) return [...prev, finalMsg];
-                    return prev.map((m) => (m.id === finalMsg.id ? finalMsg : m));
-                });
-            }
-
-            bumpThreadToTopInCache(queryClient, sessionId);
-
-            setStreamingContent(null);
-            streamingContentRef.current = null;
-            streamingThreadIdRef.current = null;
-            setActiveThreadId(null);
-        }
-    }, [queryClient, showToast, t, isStreaming, hasPermission]);
-
-    return (
-        <ChatContext.Provider value={{
-            activeThreadId,
-            isStreaming,
-            streamingContent,
-            streamingPlaceholderThread,
-            sendMessage,
-            regenerateMessage,
-            stopStream,
-            resetStream
-        }}>
-            {children}
-        </ChatContext.Provider>
-    );
-};
-
-export const useChatContext = () => {
-    const context = useContext(ChatContext);
-    if (!context) {
-        throw new Error('useChatContext 必须在 ChatProvider 内使用');
-    }
-    return context;
-};