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

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

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