fix：提质增效自动调用提问接口不传workFlowSessionId

src/pages/Chat/Chat.tsx

@@ -121,7 +121,6 @@ export const Chat: React.FC = () => {
   useEffect(() => {
     if (!debugInfo.href && !debugInfo.sessionToolId)
       return
-
     console.debug('[Chat] 当前链接 / 缓存 toolId:', debugInfo)
   }, [debugInfo])
 
@@ -284,13 +283,6 @@ export const Chat: React.FC = () => {
       // 重置欢迎语候选
       autoWelcomeCandidateRef.current = ''
       hasAutoWelcomeCandidateRef.current = false
-      console.log('[Chat] 提质增效自动调用 - handleSubmitQuestion 被调用', {
-        question,
-        resolvedToolId,
-        conversationId: currentIdRef.current,
-        isEmptyQuestion,
-        isQualityImprovement,
-      })
     }
     // 停止之前的请求
     if (abortControllerRef.current) {
@@ -358,11 +350,14 @@ export const Chat: React.FC = () => {
 
     // workFlowSessionId 的传递逻辑：
     // 1. 如果是重新问答（isReask === true），不传递 workFlowSessionId
-    // 2. 优先使用 extraParams 中的值
-    // 3. 其次使用直接传递的参数
-    // 4. 如果都没有，从会话历史中找到最后一个有 workFlowSessionId 的答案
+    // 2. 如果是提质增效模式的自动调用（空问题），不传递 workFlowSessionId
+    // 3. 优先使用 extraParams 中的值
+    // 4. 其次使用直接传递的参数
+    // 5. 如果都没有，从会话历史中找到最后一个有 workFlowSessionId 的答案
     const isReask = extraParams?.isReask === true
-    if (!isReask) {
+    // 判断是否为提质增效自动调用：空问题且 toolId 为提质增效
+    const isAutoQualityImprovement = isAutoSubmitQualityImprovementRef.current
+    if (!isReask && !isAutoQualityImprovement) {
       if (extraParams?.workFlowSessionId) {
         requestBody.workFlowSessionId = extraParams.workFlowSessionId
       }
@@ -456,7 +451,6 @@ export const Chat: React.FC = () => {
         // 正常的stream数据
         if (msg?.type === 'DATA' && msg?.content?.code === '00000000') {
           console.log('========================流式输出====================', msg)
-
           console.log('========================流式输出字符串====================', msg.content?.data)
           handleStreamMesageData(msg, question)
         }
@@ -553,10 +547,8 @@ export const Chat: React.FC = () => {
   const getUserQaRecordPage = useCallback(async (conversationId: string, toolId?: string) => {
     // 检查是否正在处理相同的 conversationId，避免重复调用
     if (processingConversationIdRef.current === conversationId) {
-      console.log('[Chat] 正在处理相同的 conversationId，跳过重复调用:', conversationId)
       return
     }
-
     setIsLoading(true)
     // 标记正在处理
     processingConversationIdRef.current = conversationId
@@ -566,7 +558,6 @@ export const Chat: React.FC = () => {
       // 检测是否从收藏页返回（优先使用 ref 中保存的值，避免 location.state 被清除后丢失）
       // 增加 sessionStorage 检查，用于 navigate(-1) 的情况
       const fromCollect = fromCollectRef.current || Boolean(location.state?.fromCollect) || Boolean(sessionStorage.getItem('fromCollect'))
-
       // 如果从收藏页返回，先调用 get_user_conversation_session 获取新的会话ID
       if (fromCollect && !fromCollectProcessedRef.current) {
         fromCollectProcessedRef.current = true
@@ -576,7 +567,6 @@ export const Chat: React.FC = () => {
           const sessionRes = await fetchSessionConversationId({ busiId: sessionToolId })
           if (sessionRes?.data?.conversationId) {
             finalConversationId = sessionRes.data.conversationId
-            console.log('[Chat] 从收藏返回 - 获取到新会话ID:', finalConversationId)
             // 如果获取到新会话ID，设置标记避免路由变化时重复调用
             toolHistoryLoadedRef.current.conversationId = finalConversationId
             // 更新 processingConversationIdRef 为新会话ID，避免使用旧ID重复调用
@@ -592,8 +582,6 @@ export const Chat: React.FC = () => {
       // 如果从收藏页返回，触发事件通知 HomeNew 刷新问题列表
       if (fromCollect) {
         const eventToolId = toolId || currentToolId || safeSessionStorageGetItem('currentToolId') || ''
-        console.log('[Chat] 检测到从收藏页返回 (fromCollect=true) - 准备触发 refreshQuestionsFromCollect 事件')
-        console.log('[Chat] refreshQuestionsFromCollect - 传递的 toolId:', eventToolId)
         // 清除 sessionStorage 中的标记，避免影响后续路由
         sessionStorage.removeItem('fromCollect')
         // 延迟触发事件，确保 Home 组件的监听器已注册
@@ -603,12 +591,10 @@ export const Chat: React.FC = () => {
               toolId: eventToolId,
             },
           }))
-          console.log('[Chat] refreshQuestionsFromCollect 事件已触发')
         }, 100)
       }
       await waitForToken()
       const res = await fetchUserQaRecordPage(finalConversationId, toolId || safeSessionStorageGetItem('currentToolId') || '')
-      console.log('qaRes chatEditor2222222', res)
       const qaRecords = res.data || []
       const messages = [{ role: 'system' } as ChatRecord, ...processApiResponse(qaRecords)]
       // 处理历史记录中的参考文档标记
@@ -631,10 +617,8 @@ export const Chat: React.FC = () => {
       // 优先从 qaRecords 中查找 toolId（这是实际使用的）
       const latestToolId = [...qaRecords].reverse().find(item => Boolean(item.toolId))?.toolId?.trim?.()
       const hasQaRecords = qaRecords.length > 0
-
       // 如果 qaRecords 中没有 toolId，尝试从 conversations 中查找当前会话的 toolId（会话级别）
       const conversationToolId = latestToolId || (conversations.find(conv => conv.conversationId === finalConversationId)?.toolId?.trim?.())
-
         // 优先使用从 location.state 传递的 toolId（如果存在），这是从历史记录点击传递过来的
       const toolIdFromState = toolIdFromStateRef.current !== undefined
         ? (toolIdFromStateRef.current ? String(toolIdFromStateRef.current) : null)
@@ -706,13 +690,6 @@ export const Chat: React.FC = () => {
       setIsLoading(false)
       // 标记该会话的历史记录已加载完成
       historyLoadedRef.current.conversationId = finalConversationId
-      console.log('[Chat] 历史记录加载完成:', {
-        finalConversationId,
-        currentIdRef: currentIdRef.current,
-        pendingQuestion: pendingQuestionRef.current,
-        lastSentQuestion: lastSentQuestionRef.current,
-      })
-      // 清除处理标记（支持新会话ID的情况）
       // finalConversationId 可能是新会话ID（从收藏返回时）或原来的 conversationId
       if (processingConversationIdRef.current === finalConversationId) {
         processingConversationIdRef.current = null
@@ -720,33 +697,17 @@ export const Chat: React.FC = () => {
       // 如果历史记录加载完成且有待发送的问题，触发自动发送
       if (pendingQuestionRef.current && finalConversationId === currentIdRef.current) {
         const questionToSend = pendingQuestionRef.current
-        console.log('[Chat] 历史记录加载完成，检查待发送问题:', {
-          questionToSend,
-          lastSentQuestion: lastSentQuestionRef.current,
-        })
         // 检查是否已经发送过相同的问题
         if (questionToSend !== lastSentQuestionRef.current) {
-          console.log('[Chat] 触发待发送问题的自动发送:', questionToSend)
           lastSentQuestionRef.current = questionToSend
           pendingQuestionRef.current = null
           // 清除 shouldSendQuestion（如果还存在）
           dispatch(clearShouldSendQuestion())
           // 延迟发送，确保状态已更新
           setTimeout(() => {
-            console.log('[Chat] 执行待发送问题的提交:', questionToSend)
             handleSubmitQuestion(questionToSend, undefined, currentToolId)
           }, 100)
         }
-        else {
-          console.log('[Chat] 待发送问题与已发送问题相同，跳过发送')
-        }
-      }
-      else if (pendingQuestionRef.current) {
-        console.log('[Chat] 有待发送问题但 conversationId 不匹配，等待:', {
-          pendingQuestion: pendingQuestionRef.current,
-          finalConversationId,
-          currentIdRef: currentIdRef.current,
-        })
       }
     }
   }, [dispatch, currentToolId, conversations, location.state])
@@ -767,7 +728,6 @@ export const Chat: React.FC = () => {
       // 检查是否已通过 toolHistoryLoaded 事件加载过相同会话的数据
       // 如果已加载，跳过接口调用，避免重复请求
       if (toolHistoryLoadedRef.current.conversationId === id) {
-        console.log('[Chat] 已通过 toolHistoryLoaded 加载，跳过历史记录接口调用')
         // 已加载，清除标记，避免影响后续正常的路由切换
         toolHistoryLoadedRef.current.conversationId = null
         // 更新 currentIdRef，确保状态一致
@@ -779,7 +739,6 @@ export const Chat: React.FC = () => {
       // 通过 sessionStorage 标记判断，避免时序问题导致的重复调用
       const toolHistoryLoadingId = sessionStorage.getItem('toolHistoryLoading')
       if (toolHistoryLoadingId === id) {
-        console.log('[Chat] 检测到 toolHistoryLoading 标记，ChatEditor 正在加载历史记录，跳过重复调用')
         currentIdRef.current = id
         // 更新 toolId 相关状态（如果有）
         if (initialToolId !== undefined) {
@@ -791,9 +750,6 @@ export const Chat: React.FC = () => {
       // 检查是否跳过历史记录加载（点击常见问题时）
       const skipHistoryLoad = Boolean((location.state as { skipHistoryLoad?: boolean } | null)?.skipHistoryLoad)
       if (skipHistoryLoad) {
-        console.log('[Chat] 检测到 skipHistoryLoad 标记，跳过历史记录加载，直接发送问题')
-        // 不清空已有对话：常见问题点击应在当前对话基础上继续追加
-        // 仅当当前为空时，确保存在 system 记录（欢迎语占位）
         setAllItems(prev => (prev.length > 0 ? prev : ([{ role: 'system' } as ChatRecord])))
         currentIdRef.current = id
         // 更新 toolId 相关状态（如果有）
@@ -807,23 +763,10 @@ export const Chat: React.FC = () => {
       if (currentIdRef.current === id) {
         // 检查是否从收藏页返回（需要重新加载历史记录）
         const fromCollect = Boolean(location.state?.fromCollect) || Boolean(sessionStorage.getItem('fromCollect'))
-        console.log('[Chat] conversationId 相同，检查是否需要重新加载:', {
-          fromCollect,
-          locationStateFromCollect: location.state?.fromCollect,
-          sessionStorageFromCollect: sessionStorage.getItem('fromCollect'),
-          allItemsLength: allItems.length,
-        })
         // 如果 allItems 为空，说明是首次加载，需要加载历史记录
         if (!fromCollect && allItems.length > 0) {
-          console.log('[Chat] 路由不变且非收藏页返回，跳过历史记录加载，只更新 toolId')
-          // 不是从收藏页返回，只是 location.state 变化（比如点击常见问题但路由不变），
-          // 不应该重新加载历史记录，只需要更新 toolId 相关状态
-          // toolId 的更新逻辑在 useEffect 中处理（120-134行）
           return
         }
-        console.log('[Chat] 从收藏页返回，即使 conversationId 相同也重新加载历史记录')
-        // 如果是从收藏页返回，即使 conversationId 相同，也需要重新加载历史记录
-        // 因为收藏页返回时可能会获取新的会话ID（在 getUserQaRecordPage 中处理）
       }
 
       // 停止之前的请求
@@ -831,8 +774,6 @@ export const Chat: React.FC = () => {
         abortControllerRef.current.abort()
         dispatch(setIsAsking(false))
       }
-
-      console.log('[Chat] 开始加载历史记录，重置相关状态')
       currentIdRef.current = id
       lastSentQuestionRef.current = '' // 重置标记
       pendingQuestionRef.current = null // 清除待发送的问题
@@ -848,7 +789,6 @@ export const Chat: React.FC = () => {
 
       // 等待 token 就绪后再调用接口
       waitForToken().then(() => {
-        console.log('[Chat] Token 就绪，调用 getUserQaRecordPage:', id)
         getUserQaRecordPage(id)
       })
     }
@@ -856,15 +796,6 @@ export const Chat: React.FC = () => {
 
   // 处理shouldSendQuestion的变化 - 自动发送问题
   useEffect(() => {
-    console.log('[Chat] shouldSendQuestion 变化检查:', {
-      shouldSendQuestion,
-      currentIdRef: currentIdRef.current,
-      isLoading,
-      lastSentQuestion: lastSentQuestionRef.current,
-      historyLoadedId: historyLoadedRef.current.conversationId,
-      allItemsLength: allItems.length,
-      pendingQuestion: pendingQuestionRef.current,
-    })
     if (
       shouldSendQuestion
       && currentIdRef.current
@@ -875,14 +806,8 @@ export const Chat: React.FC = () => {
       // 如果历史记录已加载完成（historyLoadedRef.current.conversationId === currentIdRef.current），可以立即发送
       // 如果是新会话（allItems.length <= 1），可以立即发送
       const canSend = historyLoadedRef.current.conversationId === currentIdRef.current || allItems.length <= 1
-      console.log('[Chat] 自动发送问题判断:', {
-        canSend,
-        historyLoaded: historyLoadedRef.current.conversationId === currentIdRef.current,
-        isNewSession: allItems.length <= 1,
-      })
       if (canSend) {
         const questionToSend = shouldSendQuestion
-        console.log('[Chat] 可以立即发送，准备发送问题:', questionToSend)
         lastSentQuestionRef.current = questionToSend
         pendingQuestionRef.current = null
         // 立即清除shouldSendQuestion，防止重复发送
@@ -894,7 +819,6 @@ export const Chat: React.FC = () => {
         }, 100)
       }
       else {
-        console.log('[Chat] 历史记录还在加载中，保存待发送问题到 pendingQuestionRef:', shouldSendQuestion)
         // 如果历史记录还在加载中，保存待发送的问题，等待历史记录加载完成后再发送
         pendingQuestionRef.current = shouldSendQuestion
       }
@@ -1035,17 +959,8 @@ export const Chat: React.FC = () => {
   useEffect(() => {
     const handleAutoSubmitQuestion = (event: CustomEvent) => {
       const { conversationId, question, toolId, recordType, busiType } = event.detail
-      console.log('[Chat] 收到 autoSubmitQuestion 事件', {
-        eventConversationId: conversationId,
-        currentIdRef: currentIdRef.current,
-        match: conversationId === currentIdRef.current,
-        toolId,
-        recordType,
-        busiType,
-      })
       // 确保当前会话ID匹配
       if (conversationId === currentIdRef.current) {
-        console.log('[Chat] conversationId 匹配，调用 handleSubmitQuestion')
         handleSubmitQuestion(question, undefined, toolId, { recordType, busiType })
       }
       else {