cx-chat 0.0.1

package/src/contexts/ChatContext.tsx

@@ -0,0 +1,839 @@
+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;
+};