@gientech/modual 2.2.3-fix.5 → 2.2.3-fix.6

package/src/utils/gientechCommon/hooks/AichatUseController.tsx

@@ -0,0 +1,761 @@
+import { EventSourceMessage, fetchEventSource } from '@microsoft/fetch-event-source';
+import axios from 'axios';
+import { uid } from 'uid';
+import { AppStatusManager } from '@mxmweb/aichat';
+import { mergeLiveChunkToNodes } from '@mxmweb/rtext';
+import type { ThoughtNode } from '@mxmweb/rtext';
+
+interface Api_Chat {
+  sessionId: string;
+  queryId: string;
+  name: string;
+  lastDate: string | number;
+  type: string;
+  content: string;
+  configId: string;
+  audioUrl: string;
+  fileUids: any[];
+  signal?: AbortSignal;
+  sysType?: 'KNO_INDEX' | 'INT_SESSION' | 'TEMPORARY';
+}
+
+export enum StatusType {
+  Pending = 0,
+  Process, // 1: 对话正文输出中
+  Done, // 2: 整个对话完成
+  Error, // 3: 整个对话出现异常
+  ThoughtChain = 4, // 4: 思维链输出中
+}
+
+class FatalError extends Error {}
+
+let currentStreamController: AbortController | null = null;
+// 记录当前流式请求的 sessionId，用于在切换会话时判断是否需要取消请求
+let currentStreamSessionId: string | null = null;
+// 记录当前流式请求的 queryId，用于调用停止接口
+let currentQueryId: string | null = null;
+// 记录当前流式请求的思维链节点，用于实时聚合
+let currentThoughtNodes: ThoughtNode[] = [];
+// 记录当前流式请求的 enableCot 和 chainRespTime
+let currentEnableCot: number | undefined = undefined;
+let currentChainRespTime: number | undefined = undefined;
+// 记录每个节点的 chainRespTime，用于最后累加计算总耗时
+let nodeChainRespTimes: Map<string, number> = new Map();
+
+const AichatUseController = ({
+  baseUrl,
+  token,
+  CSRFToken,
+  setChatData,
+  activeSessionId,
+  setAppStatus,
+  setConversationList,
+}: {
+  baseUrl: string;
+  token: string;
+  CSRFToken?: string;
+  setChatData: (arg: any[] | ((prev: any[]) => any[])) => void;
+  activeSessionId: string | undefined;
+  setAppStatus: React.Dispatch<React.SetStateAction<AppStatusManager>>;
+  setConversationList: React.Dispatch<React.SetStateAction<any[]>>;
+}) => {
+  // 判断 graphReference 是否有有效值
+  const isValidGraphReference = (ref: any): boolean => {
+    if (!ref) return false;
+    if (typeof ref === 'string') {
+      const trimmed = ref.trim();
+      return trimmed !== '' && trimmed !== '[]' && trimmed !== 'null';
+    }
+    return true;
+  };
+
+  const reset_chat = ({
+    content,
+    status,
+    respTime,
+    filePaths,
+    reference,
+    webReference,
+    knowledgeBases,
+    graphReference,
+    databaseReference,
+    llmType,
+    resultType,
+    queryId,
+    tokens,
+    chain,
+    thoughtChainNodes,
+    enableCot,
+    chainRespTime,
+  }: {
+    content: string;
+    status: StatusType;
+    respTime: number;
+    filePaths: any[];
+    reference: string;
+    knowledgeBases: string;
+    webReference: string;
+    graphReference?: string;
+    databaseReference?: any;
+    llmType: number;
+    resultType: number;
+    queryId?: string;
+    tokens: number;
+    chain?: any[];
+    thoughtChainNodes?: ThoughtNode[];
+    enableCot?: number;
+    chainRespTime?: number;
+    [key: string]: any;
+  }) => {
+    setChatData((chatList: any) => {
+      if (!chatList[0]) return chatList;
+      const current = chatList[0];
+      const messages = current.messages || [];
+      const lastIndex = messages.length - 1;
+      if (lastIndex < 0) return chatList;
+      const lastMessage = messages[lastIndex];
+      if (lastMessage.istype !== 'ai') return chatList;
+
+      // 更新上一条 user 的 filePaths（不可变）
+      let newMessages = messages.slice();
+      if (filePaths?.length) {
+        const lastSecondIndex = messages.length - 2;
+        if (lastSecondIndex >= 0 && messages[lastSecondIndex]?.istype === 'user') {
+          const lastSecond = { ...messages[lastSecondIndex], filePaths };
+          newMessages[lastSecondIndex] = lastSecond;
+        }
+      }
+
+      // 检测是否是新的 queryId（新消息开始）
+      const isNewQuery = queryId && queryId !== lastMessage.queryId;
+
+      const isRestart = status === StatusType.Process && lastMessage.status === StatusType.Done;
+
+      // 只有当 graphReference 有有效值时才更新，否则保留之前的值
+      // 如果传入的 graphReference 是 undefined，说明本次没有更新，保留之前的值
+      // 如果传入的 graphReference 是 null 或无效值，也保留之前的值
+      // 但是，如果是新的 queryId 或重新开始，应该清空 graphReference
+      const finalGraphReference =
+        isNewQuery || isRestart
+          ? isValidGraphReference(graphReference)
+            ? graphReference
+            : null
+          : graphReference !== undefined
+            ? isValidGraphReference(graphReference)
+              ? graphReference
+              : lastMessage.graphReference
+            : lastMessage.graphReference;
+      // 调试：检查 reset_chat 中的 graphReference 处理
+      if (status === StatusType.Done && graphReference !== undefined) {
+        console.log('[AichatUseController] reset_chat status=2 时的 graphReference:', {
+          graphReference,
+          isValid: isValidGraphReference(graphReference),
+          lastMessageGraphReference: lastMessage.graphReference,
+          finalGraphReference,
+          isNewQuery,
+          isRestart,
+        });
+      }
+
+      // status=4 (思维链输出中) 时，不累加 content，只更新思维链数据
+      // 注意：status=4 时，如果传入的 content 是空字符串，应该保持之前的正文内容不变
+      // 但如果之前错误地累加了思维链内容到正文，这里需要确保不会继续累加
+      const shouldUpdateContent = status !== StatusType.ThoughtChain;
+
+      // status=4 时，如果传入的 content 是空字符串，保持之前的正文内容不变
+      // 但如果传入的 content 不是空字符串（理论上不应该发生），则使用传入的值
+      // 如果是新的 queryId（新消息开始），应该重置 content
+      let finalContent: string;
+      if (isNewQuery) {
+        // 新消息开始，使用新的 content
+        finalContent = content;
+      } else if (isRestart) {
+        // 重新开始，清空 content
+        finalContent = '';
+      } else if (status === StatusType.ThoughtChain) {
+        // status=4 时，不累加 content，保持之前的正文内容不变
+        finalContent = lastMessage.content || '';
+      } else {
+        // status=1 或其他状态时，累加 content
+        // status=2 且 content 为空字符串时，表示只是收尾，不应清空或追加“undefined”，保持之前的正文
+        if (status === StatusType.Done && !content) {
+          finalContent = lastMessage.content || '';
+        } else {
+          finalContent = (lastMessage.content || '') + content;
+        }
+      }
+
+      const updatedLast = {
+        ...lastMessage,
+        content: finalContent,
+        status,
+        respTime,
+        filePaths,
+        // 如果是新的 queryId 或重新开始，应该清空引用数据
+        reference: isNewQuery || isRestart ? reference || '[]' : reference,
+        webReference: isNewQuery || isRestart ? webReference || '[]' : webReference,
+        knowledgeBases: isNewQuery || isRestart ? knowledgeBases || '[]' : knowledgeBases,
+        graphReference: finalGraphReference,
+        // 流式阶段若后端带来了 databaseReference，写入当前 AI 消息
+        // 如果是新的 queryId 或重新开始，应该清空 databaseReference
+        // 如果 databaseReference 是 null，应该清空（不使用 ?? 运算符，因为 null 也是有效值）
+        databaseReference:
+          isNewQuery || isRestart
+            ? databaseReference !== undefined
+              ? databaseReference
+              : null
+            : databaseReference !== undefined
+              ? databaseReference
+              : lastMessage.databaseReference,
+        resultType,
+        llmType,
+        tokens,
+        queryId: queryId || lastMessage.queryId || uid(32),
+        // 思维链数据：如果有传入 chain，使用传入的；否则保留之前的
+        // 如果是新的 queryId 或重新开始，应该清空 chain
+        // 如果 chain 是 undefined，应该清空（不使用 ?? 运算符，因为 undefined 也是有效值）
+        chain:
+          isNewQuery || isRestart
+            ? chain !== undefined
+              ? chain
+              : undefined
+            : chain !== undefined
+              ? chain
+              : lastMessage.chain,
+        // 实时思维链节点（用于实时流式场景，优先使用此字段）
+        thoughtChainNodes:
+          isNewQuery || isRestart
+            ? thoughtChainNodes !== undefined
+              ? thoughtChainNodes
+              : undefined
+            : thoughtChainNodes !== undefined
+              ? thoughtChainNodes
+              : lastMessage.thoughtChainNodes,
+        // enableCot 和 chainRespTime：从 SSE 流中获取，用于控制思维链渲染模式
+        enableCot: enableCot !== undefined ? enableCot : lastMessage.enableCot,
+        chainRespTime: chainRespTime !== undefined ? chainRespTime : lastMessage.chainRespTime,
+      } as any;
+      updatedLast.clientSideId = updatedLast.clientSideId || updatedLast.queryId + '-ai';
+      newMessages[lastIndex] = updatedLast;
+
+      const newChat0 = { ...current, isNew: false, messages: newMessages };
+      return [newChat0, ...chatList.slice(1)];
+    });
+  };
+
+  const onErrorCallback = (err: any) => {
+    if (err instanceof FatalError) {
+      setAppStatus((pre: any) => ({ ...pre, display: 'error', sender: 'ready' }));
+      if (currentStreamController) {
+        currentStreamController.abort();
+        currentStreamController = null;
+      }
+      currentStreamSessionId = null;
+      currentQueryId = null;
+      throw err;
+    }
+    // 其他错误可选处理
+  };
+
+  const api_startChat_re = (data: Api_Chat, onSuccess?: (gmtModified: number) => void) => {
+    if (currentStreamController) {
+      currentStreamController.abort();
+    }
+    currentStreamController = new AbortController();
+    // 记录当前流式请求的 sessionId 和 queryId
+    currentStreamSessionId = data.sessionId;
+    currentQueryId = data.queryId;
+    // 重置思维链节点和相关状态，为新请求做准备
+    currentThoughtNodes = [];
+    currentEnableCot = undefined;
+    currentChainRespTime = undefined;
+    nodeChainRespTimes = new Map();
+    const eventSourceUrl = `${baseUrl}/qa/ai/question_re`;
+    //const eventSourceUrl = `${baseUrl}/qa/ai/question_re`;
+    console.log('data', data);
+    const params = { ...data };
+    fetchEventSource(eventSourceUrl, {
+      method: 'post',
+      signal: currentStreamController.signal,
+      headers: {
+        'Content-Type': 'application/json',
+        Accept: 'text/event-stream',
+        Authorization: token || '',
+        'X-CSRF-TOKEN-IN': CSRFToken || '',
+      },
+      openWhenHidden: true,
+      body: JSON.stringify(params),
+      onopen: async response => {
+        if (response.status === 500) {
+          throw new FatalError('Internal Server Error');
+        }
+        if (!response.ok) {
+          throw new FatalError(`HTTP error: ${response.status}`);
+        }
+        // 其他状态可根据需要处理
+      },
+      onmessage: event => {
+        const curData = JSON.parse(event.data);
+        // 检查当前请求的 sessionId 是否仍然匹配，如果不匹配则忽略所有后续数据
+        if (currentStreamSessionId !== curData.sessionId) {
+          console.log('[AichatUseController] 流式请求的 sessionId 已不匹配，忽略数据', {
+            currentStreamSessionId,
+            receivedSessionId: curData.sessionId,
+            activeSessionId,
+          });
+          return;
+        }
+        if (activeSessionId !== curData.sessionId) return;
+        const {
+          reply,
+          resultType,
+          respTime,
+          reference,
+          webReference,
+          graphReference,
+          knowledgeBases,
+          filePaths,
+          status,
+          docs,
+          llmType,
+          databaseReference,
+          businessType,
+          nodeStatus,
+          enableCot,
+          chainRespTime,
+        } = curData;
+
+        // 处理思维链数据：只有 status=4 (思维链输出中) 时才聚合思维链数据
+        // status=1 (对话正文输出中) 时，即使有 businessType，也不应该聚合到思维链节点
+        // 注意：status=1 时，businessType 只是标识当前处于哪个阶段，但内容应该去正文，不是思维链
+        if (status === StatusType.ThoughtChain && businessType) {
+          // 只有 status=4 时才聚合思维链数据
+          // 当节点完成（nodeStatus=2）时，提取该节点的 chainRespTime 作为独立时间
+          if (nodeStatus === 2 && typeof chainRespTime === 'number' && chainRespTime > 0) {
+            // 保存节点的独立时间
+            nodeChainRespTimes.set(businessType, chainRespTime);
+          }
+
+          // 当节点完成（nodeStatus=2）时，提取该节点的 chainRespTime 作为独立时间
+          const nodeRespTime =
+            nodeStatus === 2 && typeof chainRespTime === 'number' && chainRespTime > 0
+              ? chainRespTime
+              : undefined;
+
+          currentThoughtNodes = mergeLiveChunkToNodes(currentThoughtNodes, {
+            businessType,
+            nodeStatus,
+            reply,
+            respTime: nodeRespTime, // mergeLiveChunkToNodes 使用 respTime 字段
+            chainRespTime: nodeRespTime, // 兼容字段
+          });
+          console.log('[AichatUseController] status=4 聚合思维链数据:', {
+            businessType,
+            nodeStatus,
+            content: reply?.content?.substring(0, 50),
+            currentThoughtNodesCount: currentThoughtNodes.length,
+            chainRespTime: nodeStatus === 2 ? chainRespTime : undefined,
+          });
+        } else if (status === StatusType.Process && businessType) {
+          // status=1 时，即使有 businessType，也不聚合到思维链，只用于调试日志
+          console.log('[AichatUseController] status=1 跳过思维链聚合:', {
+            businessType,
+            content: reply?.content?.substring(0, 50),
+            note: 'status=1 的内容应该去正文，不是思维链',
+          });
+        }
+
+        // 收集 enableCot
+        if (typeof enableCot === 'number') {
+          currentEnableCot = enableCot;
+        }
+
+        // 在 status=1 或 status=2 时，累加所有节点的 chainRespTime 作为总耗时
+        if (status === StatusType.Process || status === StatusType.Done) {
+          // 累加所有节点的 chainRespTime
+          const totalTime = Array.from(nodeChainRespTimes.values()).reduce(
+            (sum, time) => sum + time,
+            0
+          );
+          if (totalTime > 0) {
+            currentChainRespTime = totalTime;
+          }
+        }
+
+        const _filePaths = filePaths ? JSON.parse(filePaths) : [];
+        // === 新增：流式错误兜底 ===
+        if (
+          status === StatusType.Done &&
+          reply &&
+          reply.content &&
+          (reply.content.includes('模型暂无法返回') ||
+            reply.content.includes('失败') ||
+            reply.content.includes('错误') ||
+            reply.content.includes('请稍后再试'))
+        ) {
+          setAppStatus((pre: any) => ({ ...pre, display: 'ready', sender: 'ready' }));
+        }
+        // 处理 graphReference：只有当有有效值时才传递，否则传递 undefined 让 reset_chat 保留之前的值
+        const finalGraphReference = isValidGraphReference(graphReference)
+          ? graphReference
+          : undefined;
+        // 调试：检查最后一条消息的 graphReference
+        if (status === StatusType.Done) {
+          console.log('[AichatUseController] status=2 时的 graphReference:', {
+            graphReference,
+            type: typeof graphReference,
+            isValid: isValidGraphReference(graphReference),
+            finalGraphReference,
+          });
+        }
+
+        // status=4 (思维链输出中)：只更新思维链数据，不更新对话正文 content
+        if (status === StatusType.ThoughtChain) {
+          // 将实时聚合的思维链节点转换为 chain 格式
+          const chain =
+            currentThoughtNodes.length > 0
+              ? currentThoughtNodes.map(node => ({
+                  businessType: node.businessType,
+                  nodeStatus: node.nodeStatus,
+                  content: node.content,
+                }))
+              : undefined;
+
+          console.log('[AichatUseController] status=4 更新思维链:', {
+            businessType,
+            chainLength: chain?.length || 0,
+            replyContentLength: reply?.content?.length || 0,
+            note: 'status=4 时，reply.content 应该聚合到思维链，不更新正文',
+          });
+
+          reset_chat({
+            content: '', // status=4 时，不更新对话正文，只更新思维链
+            status: status,
+            respTime: respTime,
+            filePaths: _filePaths,
+            reference: reference || docs || '',
+            webReference: webReference || '',
+            knowledgeBases: knowledgeBases || '',
+            graphReference: finalGraphReference,
+            databaseReference,
+            llmType,
+            resultType,
+            queryId: curData.queryId,
+            tokens: curData.tokens,
+            chain,
+            thoughtChainNodes: currentThoughtNodes.length > 0 ? [...currentThoughtNodes] : undefined, // 传递实时思维链节点
+            enableCot: currentEnableCot,
+            chainRespTime: currentChainRespTime,
+          });
+        } else if (status === StatusType.Process) {
+          // status=1 (对话正文输出中)：只更新对话正文，不更新思维链数据
+          // 同时，将思维链节点的状态更新为完成（nodeStatus = 2），因为思维链已经结束，开始输出正文
+          // 注意：即使有 businessType，status=1 时也不应该聚合到思维链节点
+          // 因为 status=1 的 reply.content 是对话正文，不是思维链内容
+          if (currentThoughtNodes.length > 0) {
+            // 将所有思维链节点状态更新为完成（nodeStatus = 2）
+            currentThoughtNodes = currentThoughtNodes.map(node => ({
+              ...node,
+              nodeStatus: 2 as const, // 标记为完成
+            }));
+          }
+
+          console.log('[AichatUseController] status=1 更新正文:', {
+            businessType,
+            content: reply?.content?.substring(0, 50),
+            thoughtNodesCount: currentThoughtNodes.length,
+            note: 'status=1 时，reply.content 应该去正文，思维链节点状态更新为完成',
+          });
+
+          // 将更新后的思维链节点转换为 chain 格式
+          const chain =
+            currentThoughtNodes.length > 0
+              ? currentThoughtNodes.map(node => ({
+                  businessType: node.businessType,
+                  nodeStatus: node.nodeStatus,
+                  content: node.content,
+                }))
+              : undefined;
+
+          reset_chat({
+            content: reply.content || '',
+            status: status,
+            respTime: respTime,
+            filePaths: _filePaths,
+            reference: reference || docs || '',
+            webReference: webReference || '',
+            graphReference: finalGraphReference,
+            knowledgeBases: knowledgeBases || '',
+            // 如果 databaseReference 是 undefined，传入 null 以清空旧值
+            databaseReference: databaseReference ?? null,
+            llmType,
+            resultType,
+            queryId: curData.queryId,
+            tokens: curData.tokens,
+            // status=1 时，更新思维链节点状态为完成，并传递更新后的 chain
+            // 如果 chain 是 undefined，传入 undefined 以清空旧值
+            chain: chain ?? undefined,
+            thoughtChainNodes: currentThoughtNodes.length > 0 ? [...currentThoughtNodes] : undefined, // 传递实时思维链节点
+            enableCot: currentEnableCot,
+            chainRespTime: currentChainRespTime,
+          });
+        } else if (status === StatusType.Done) {
+          // status=2 (整个对话完成)：确保所有思维链节点状态都是完成
+          if (currentThoughtNodes.length > 0) {
+            currentThoughtNodes = currentThoughtNodes.map(node => ({
+              ...node,
+              nodeStatus: 2 as const, // 标记为完成
+            }));
+          }
+
+          // 将聚合后的思维链节点转换为 chain 格式
+          const chain =
+            currentThoughtNodes.length > 0
+              ? currentThoughtNodes.map(node => ({
+                  businessType: node.businessType,
+                  nodeStatus: node.nodeStatus,
+                  content: node.content,
+                }))
+              : undefined;
+
+          reset_chat({
+            // 注意：有些后端实现中，最后一条 status=2 的 SSE 只用于收尾，
+            // reply.content 可能是空串，此时应该保持之前累积的正文不变。
+            // reset_chat 内部会在 status=Done 且 content 为空字符串时，保留 lastMessage.content。
+            content: reply.content || '',
+            status: StatusType.Done, // 流式完成时，消息状态应该是 Done
+            respTime: respTime,
+            filePaths: _filePaths,
+            reference: reference || docs || '',
+            webReference: webReference || '',
+            knowledgeBases: knowledgeBases || '',
+            graphReference: finalGraphReference,
+            databaseReference,
+            llmType,
+            resultType,
+            queryId: curData.queryId,
+            tokens: curData.tokens,
+            chain,
+            thoughtChainNodes: currentThoughtNodes.length > 0 ? [...currentThoughtNodes] : undefined, // 传递实时思维链节点
+            enableCot: currentEnableCot,
+            chainRespTime: currentChainRespTime,
+          });
+
+          // 重置思维链节点，为下次请求做准备
+          currentThoughtNodes = [];
+          setAppStatus((pre: any) => {
+            return {
+              ...pre,
+              display: 'ready',
+              sender: 'ready',
+            };
+          });
+          if (onSuccess) {
+            const gmtModified = respTime || Date.now();
+            console.log('[AichatUseController] 消息发送成功，gmtModified:', gmtModified);
+            onSuccess(gmtModified);
+          }
+        } else {
+          // 流式过程中，将实时聚合的思维链节点转换为 chain 格式
+          // 包含 respTime（节点的独立时间）和 chainRespTime（用于兼容）
+          const chain =
+            currentThoughtNodes.length > 0
+              ? currentThoughtNodes.map(node => ({
+                  businessType: node.businessType,
+                  nodeStatus: node.nodeStatus,
+                  content: node.content,
+                  respTime: node.respTime,
+                  chainRespTime: node.respTime, // 兼容字段
+                }))
+              : undefined;
+
+          reset_chat({
+            content: reply.content || '',
+            status: status,
+            respTime: respTime,
+            filePaths: _filePaths,
+            reference: reference || docs || '',
+            knowledgeBases: knowledgeBases || '',
+            webReference: webReference || '',
+            graphReference: finalGraphReference, // 流式过程中保持之前的graphReference值
+            databaseReference,
+            llmType,
+            resultType,
+            queryId: curData.queryId,
+            tokens: curData.tokens,
+            chain,
+            thoughtChainNodes: currentThoughtNodes.length > 0 ? [...currentThoughtNodes] : undefined, // 传递实时思维链节点
+            enableCot: currentEnableCot,
+            chainRespTime: currentChainRespTime,
+          });
+        }
+      },
+      onerror: onErrorCallback,
+      onclose: () => {
+        // 流式请求结束时，清理 sessionId 和 queryId 记录
+        if (currentStreamSessionId === data.sessionId) {
+          currentStreamSessionId = null;
+          currentQueryId = null;
+        }
+      },
+    });
+  };
+
+  const setLastEmptyMessage = ({ now }: { now: number }) => {
+    setChatData((chatList: any[]) => {
+      if (!chatList[0]) return chatList;
+      const current = chatList[0];
+      const messages = current.messages || [];
+      if (!messages.length) return chatList;
+      const lastIndex = messages.length - 1;
+      if (lastIndex < 0) return chatList;
+      const lastMessage = messages[lastIndex];
+      if (lastMessage.istype !== 'ai') return chatList;
+      const newMessages = messages.slice();
+      newMessages[lastIndex] = {
+        ...lastMessage,
+        istype: 'ai',
+        content: '',
+        time: now,
+        streaming: true,
+        status: StatusType.Pending,
+      } as any;
+      const newChat0 = { ...current, messages: newMessages };
+      return [newChat0, ...chatList.slice(1)];
+    });
+  };
+
+  const addEmptyMessage = ({
+    queryId,
+    content,
+    filePaths,
+    currentFiles,
+  }: {
+    queryId: string;
+    content: string;
+    filePaths?: string;
+    currentFiles?: any[];
+  }) => {
+    setChatData((chatList: any[]) => {
+      const now = new Date().toISOString();
+      const _queryId = queryId || uid(32); // 保证只生成一次
+      const userMessage = {
+        istype: 'user',
+        content: content,
+        time: now,
+        queryId: _queryId,
+        clientSideId: _queryId + '-user',
+        filePaths: filePaths || '',
+        currentFiles: currentFiles || [],
+      };
+      const aiMessage = {
+        istype: 'ai',
+        content: '', // AI回复流式填充
+        time: new Date(Date.now() + 1).toISOString(),
+        streaming: true,
+        status: StatusType.Pending,
+        queryId: _queryId,
+        clientSideId: _queryId + '-ai',
+      };
+
+      // 找到当前激活的对话
+      const activeChat = chatList.find(chat => chat.id === activeSessionId);
+
+      if (activeChat) {
+        // 如果激活的对话存在，则向其添加新消息
+        activeChat.messages.push(userMessage, aiMessage);
+      } else {
+        // 如果没有激活的对话（例如首次加载），则需要特殊处理
+        // 这里的逻辑可能需要根据产品需求调整，是创建新对话还是报错
+        // 假设我们总是有一个激活的对话
+        console.warn('addEmptyMessage called without an active session.');
+      }
+      return [...chatList];
+    });
+  };
+
+  // 主动终止当前 stream（调用后端接口）
+  const stopStream = async () => {
+    // 调用后端接口停止流式请求
+    if (currentQueryId) {
+      try {
+        await axios.delete(`${baseUrl}/qa/ai/abortStream?queryId=${currentQueryId}`, {
+          headers: {
+            Authorization: token || '',
+            'X-CSRF-TOKEN-IN': CSRFToken || '',
+          },
+        });
+        console.log('[AichatUseController] 已调用后端接口停止流式请求', currentQueryId);
+      } catch (error) {
+        console.error('[AichatUseController] 调用停止接口失败', error);
+      }
+    } else {
+      console.warn('[AichatUseController] 停止流式请求时未找到 queryId');
+    }
+
+    // 清理状态
+    currentStreamController = null;
+    currentStreamSessionId = null;
+    currentQueryId = null;
+    setAppStatus((pre: any) => ({ ...pre, display: 'ready', sender: 'ready' }));
+  };
+
+  // 根据 sessionId 取消流式请求（用于切换会话时）
+  const cancelStreamBySessionId = async (sessionId: string) => {
+    if (currentStreamController && currentStreamSessionId === sessionId) {
+      console.log('[AichatUseController] 切换会话，取消正在进行的流式请求', sessionId);
+
+      // 调用后端接口停止流式请求
+      if (currentQueryId) {
+        try {
+          await axios.delete(`${baseUrl}/qa/ai/abortStream?queryId=${currentQueryId}`, {
+            headers: {
+              Authorization: token || '',
+              'X-CSRF-TOKEN-IN': CSRFToken || '',
+            },
+          });
+          console.log('[AichatUseController] 切换会话时已调用后端接口停止流式请求', currentQueryId);
+        } catch (error) {
+          console.error('[AichatUseController] 切换会话时调用停止接口失败', error);
+        }
+      } else {
+        console.warn('[AichatUseController] 切换会话时未找到 queryId');
+      }
+
+      currentStreamController = null;
+      currentStreamSessionId = null;
+      currentQueryId = null;
+      setAppStatus((pre: any) => ({ ...pre, display: 'ready', sender: 'ready' }));
+      return true;
+    }
+    return false;
+  };
+
+  const updateUserFilesMessage = ({ currentFiles }: { currentFiles: any[] }) => {
+    setChatData((chatList: any[]) => {
+      if (!chatList[0]) return chatList;
+      const current = chatList[0];
+      const messages = current.messages || [];
+      if (!messages.length) return chatList;
+      const lastIndex = messages.length - 2;
+      if (lastIndex < 0) return chatList;
+      const lastMessage = messages[lastIndex];
+      if (lastMessage.istype !== 'user') return chatList;
+      const newMessages = messages.slice();
+      newMessages[lastIndex] = { ...messages[lastIndex], currentFiles } as any;
+      const newChat0 = { ...current, messages: newMessages };
+      return [newChat0, ...chatList.slice(1)];
+    });
+  };
+
+  return {
+    updateUserFilesMessage,
+    api_startChat_re,
+    addEmptyMessage,
+    setLastEmptyMessage,
+    stopStream,
+    cancelStreamBySessionId,
+  };
+};
+
+export default AichatUseController;