test-chat-sdk 0.0.0

package/src/components/ChatItem/index.tsx

@@ -0,0 +1,843 @@
+import {
+  ChatContextType,
+  DateInfoType,
+  EntityInfoType,
+  FilterItemType,
+  MsgDataType,
+  ParseStateEnum,
+  ParseTimeCostType,
+  RangeValue,
+  SimilarQuestionType,
+} from '../../common/type';
+import { createContext, useEffect, useRef, useState } from 'react';
+import { chatExecute, chatParse, queryData, deleteQuery, switchEntity } from '../../service';
+import { PARSE_ERROR_TIP, PREFIX_CLS, SEARCH_EXCEPTION_TIP } from '../../common/constants';
+import { message, Spin } from 'antd';
+import IconFont from '../IconFont';
+import ExpandParseTip from './ExpandParseTip';
+import ParseTip from './ParseTip';
+import ExecuteItem from './ExecuteItem';
+import { isMobile } from '../../utils/utils';
+import classNames from 'classnames';
+import Tools from '../Tools';
+import SqlItem from './SqlItem';
+import SimilarQuestionItem from './SimilarQuestionItem';
+import { AgentType } from '../../Chat/type';
+import dayjs, { Dayjs } from 'dayjs';
+import { exportCsvFile } from '../../utils/utils';
+import { useMethodRegister } from '../../hooks';
+
+type Props = {
+  msg: string;
+  conversationId?: number;
+  questionId?: number;
+  modelId?: number;
+  agentId?: number;
+  score?: number;
+  filter?: any[];
+  parseInfos?: ChatContextType[];
+  parseTimeCostValue?: ParseTimeCostType;
+  msgData?: MsgDataType;
+  triggerResize?: boolean;
+  isDeveloper?: boolean;
+  integrateSystem?: string;
+  executeItemNode?: React.ReactNode;
+  renderCustomExecuteNode?: boolean;
+  isSimpleMode?: boolean;
+  isDebugMode?: boolean;
+  currentAgent?: AgentType;
+  isLastMessage?: boolean;
+  onMsgDataLoaded?: (data: MsgDataType, valid: boolean, isRefresh?: boolean) => void;
+  onUpdateMessageScroll?: () => void;
+  onSendMsg?: (msg: string) => void;
+};
+
+export const ChartItemContext = createContext({
+  register: (...args: any[]) => {},
+  call: (...args: any[]) => {},
+});
+
+const ChatItem: React.FC<Props> = ({
+  msg,
+  conversationId,
+  questionId,
+  modelId,
+  agentId,
+  score,
+  filter,
+  triggerResize,
+  parseInfos,
+  parseTimeCostValue,
+  msgData,
+  isDeveloper,
+  integrateSystem,
+  executeItemNode,
+  renderCustomExecuteNode,
+  isSimpleMode,
+  currentAgent,
+  isDebugMode,
+  isLastMessage,
+  onMsgDataLoaded,
+  onUpdateMessageScroll,
+  onSendMsg,
+}) => {
+  const [parseLoading, setParseLoading] = useState(false);
+  const [parseTimeCost, setParseTimeCost] = useState<ParseTimeCostType>();
+  const [parseInfo, setParseInfo] = useState<ChatContextType>();
+  const [parseInfoOptions, setParseInfoOptions] = useState<ChatContextType[]>([]);
+  const [preParseInfoOptions, setPreParseInfoOptions] = useState<ChatContextType[]>([]);
+  const [parseTip, setParseTip] = useState('');
+  const [executeMode, setExecuteMode] = useState(false);
+  const [preParseMode, setPreParseMode] = useState(false);
+  const [showExpandParseTip, setShowExpandParseTip] = useState(false);
+  const [executeLoading, setExecuteLoading] = useState(false);
+  const [executeTip, setExecuteTip] = useState('');
+  const [executeErrorMsg, setExecuteErrorMsg] = useState('');
+  const [data, setData] = useState<MsgDataType>();
+  const [entitySwitchLoading, setEntitySwitchLoading] = useState(false);
+  const [dimensionFilters, setDimensionFilters] = useState<FilterItemType[]>([]);
+  const [dateInfo, setDateInfo] = useState<DateInfoType>({} as DateInfoType);
+  const [entityInfo, setEntityInfo] = useState<EntityInfoType>({} as EntityInfoType);
+  const [dataCache, setDataCache] = useState<Record<number, { tip: string; data?: MsgDataType }>>(
+    {}
+  );
+  const [isParserError, setIsParseError] = useState<boolean>(false);
+  const [selectedDataSetIds, setSelectedDataSetIds] = useState<number[]>([]);
+  const [streamingSummary, setStreamingSummary] = useState<string>('');
+  const resetState = () => {
+    setParseLoading(false);
+    setParseTimeCost(undefined);
+    setParseInfo(undefined);
+    setParseInfoOptions([]);
+    setPreParseMode(false);
+    setShowExpandParseTip(false);
+    setPreParseInfoOptions([]);
+    setParseTip('');
+    setExecuteMode(false);
+    setDimensionFilters([]);
+    setData(undefined);
+    setExecuteErrorMsg('');
+    setDateInfo({} as DateInfoType);
+    setEntityInfo({} as EntityInfoType);
+    setDataCache({});
+    setIsParseError(false);
+    setSelectedDataSetIds([]);
+    setStreamingSummary('');
+  };
+
+  const prefixCls = `${PREFIX_CLS}-item`;
+
+  // 生成包含数据集ID的缓存键，确保数据集切换后使用不同的缓存
+  const generateCacheKey = (chatContext: any): string => {
+    if (!chatContext) return '';
+    
+    // 使用解析ID和数据集ID组合作为缓存键
+    const parseId = chatContext.id || '';
+    const dataSetIds = chatContext.dataSetIds || [];
+    
+    // 关键修复：如果chatContext中有dataSet对象，使用其ID作为缓存键的一部分
+    // 这样可以确保数据集对象本身变化时也能触发缓存更新
+    const dataSetId = chatContext.dataSet?.id || '';
+    
+    // 处理空数组的情况，确保缓存键的唯一性
+    if (dataSetIds.length === 0 && !dataSetId) {
+      return `${parseId}_no_dataset`;
+    }
+    
+    // 将数据集ID数组转换为字符串，确保顺序一致
+    const dataSetIdStr = dataSetIds.sort().join('_');
+    
+    // 如果有dataSet对象ID，将其加入缓存键
+    const dataSetObjId = dataSetId ? `_${dataSetId}` : '';
+    
+    return `${parseId}_${dataSetIdStr}${dataSetObjId}`;
+  };
+
+  const updateData = (res: Result<MsgDataType>) => {
+    let tip: string = '';
+    let data: MsgDataType | undefined = undefined;
+    const { queryColumns, queryResults, queryState, queryMode, response, chatContext, errorMsg } =
+      res.data || {};
+    setExecuteErrorMsg(errorMsg);
+    if (res.code === 400 || res.code === 401 || res.code === 412) {
+      tip = res.msg;
+    } else if (res.code !== 200) {
+      tip = SEARCH_EXCEPTION_TIP;
+    } else if (queryState !== 'SUCCESS') {
+      tip = response && typeof response === 'string' ? response : SEARCH_EXCEPTION_TIP;
+    } else if (
+      (queryColumns && queryColumns.length > 0 && queryResults) ||
+      queryMode === 'WEB_PAGE' ||
+      queryMode === 'WEB_SERVICE' ||
+      queryMode === 'PLAIN_TEXT'
+    ) {
+      data = res.data;
+      tip = '';
+    }
+    if (chatContext) {
+      // 生成包含数据集ID的缓存键，确保数据集切换后使用不同的缓存
+      const cacheKey = generateCacheKey(chatContext);
+      setDataCache({ ...dataCache, [cacheKey]: { tip, data } });
+    }
+    if (data) {
+      setData(data);
+      setExecuteTip('');
+      return true;
+    }
+    setExecuteTip(tip || SEARCH_EXCEPTION_TIP);
+    return false;
+  };
+
+  const onExecute = async (
+    parseInfoValue: ChatContextType,
+    parseInfos?: ChatContextType[],
+    isSwitchParseInfo?: boolean,
+    isRefresh = false
+  ) => {
+    setExecuteMode(true);
+    if (isSwitchParseInfo) {
+      setEntitySwitchLoading(true);
+    } else {
+      setExecuteLoading(true);
+    }
+    try {
+      // 确保使用最新的数据集ID - 优先使用组件状态中的selectedDataSetIds
+      const effectiveDataSetIds = selectedDataSetIds.length > 0 ? selectedDataSetIds : 
+        (parseInfoValue.dataSetIds || (parseInfoValue.dataSet?.id ? [parseInfoValue.dataSet.id] : undefined));
+      
+      // 检查是否切换了数据集 - 使用JSON.stringify进行精确比较
+      const currentDataSetIds = parseInfo?.dataSetIds || [];
+      const newDataSetIds = effectiveDataSetIds || [];
+      const isDataSetSwitched = JSON.stringify(currentDataSetIds.sort()) !== JSON.stringify(newDataSetIds.sort());
+      
+      // 如果切换了数据集，强制清除当前数据状态，确保显示新的查询结果
+      if (isDataSetSwitched) {
+        setData(undefined);
+        setExecuteTip('');
+      }
+      
+      // 创建包含正确数据集ID的parseInfo对象
+      const parseInfoWithCorrectDataSetIds = {
+        ...parseInfoValue,
+        dataSetIds: effectiveDataSetIds
+      };
+      
+      const res: any = await chatExecute(msg, conversationId!, parseInfoWithCorrectDataSetIds, agentId);
+      const valid = updateData(res);
+      // 更新parseInfo状态，确保SqlItem组件能获取到最新的SQL信息
+      setParseInfo(parseInfoWithCorrectDataSetIds);
+      onMsgDataLoaded?.(
+        {
+          ...res.data,
+          parseInfos,
+          queryId: parseInfoValue.queryId,
+        },
+        valid,
+        isRefresh
+      );
+    } catch (e) {
+      const tip = SEARCH_EXCEPTION_TIP;
+      setExecuteTip(SEARCH_EXCEPTION_TIP);
+      // 使用新的缓存键生成方式
+      const cacheKey = generateCacheKey(parseInfoValue);
+      setDataCache({ ...dataCache, [cacheKey]: { tip } });
+    }
+    if (isSwitchParseInfo) {
+      setEntitySwitchLoading(false);
+    } else {
+      setExecuteLoading(false);
+    }
+  };
+
+  const updateDimensionFitlers = (filters: FilterItemType[]) => {
+    setDimensionFilters(
+      filters.sort((a, b) => {
+        if (a.name < b.name) {
+          return -1;
+        }
+        if (a.name > b.name) {
+          return 1;
+        }
+        return 0;
+      })
+    );
+  };
+
+  const sendMsg = async () => {
+    setParseLoading(true);
+    const parseData: any = await chatParse({
+      queryText: msg,
+      chatId: conversationId,
+      modelId,
+      agentId,
+      filters: filter,
+      dataSetIds: selectedDataSetIds.length > 0 ? selectedDataSetIds : undefined,
+    });
+    setParseLoading(false);
+    const { code, data } = parseData || {};
+    const { state, selectedParses, candidateParses, queryId, parseTimeCost, errorMsg } = data || {};
+    const parses = selectedParses?.concat(candidateParses || []) || [];
+    if (
+      code !== 200 ||
+      state === ParseStateEnum.FAILED ||
+      !parses.length ||
+      (!parses[0]?.properties?.type && !parses[0]?.queryMode)
+    ) {
+      setParseTip(state === ParseStateEnum.FAILED && errorMsg ? errorMsg : PARSE_ERROR_TIP);
+
+      setParseInfo({ queryId } as any);
+      return;
+    }
+    onUpdateMessageScroll?.();
+    const parseInfos = parses.slice(0, 5).map((item: any) => ({
+      ...item,
+      queryId,
+    }));
+    if (parseInfos.length > 1) {
+      setPreParseInfoOptions(parseInfos);
+      setShowExpandParseTip(true);
+      setPreParseMode(true);
+    }
+    setParseInfoOptions(parseInfos || []);
+    const parseInfoValue = parseInfos[0];
+    if (!(currentAgent?.enableFeedback === 1 && parseInfos.length > 1)) {
+      setParseInfo(parseInfoValue);
+    }
+    setParseTimeCost(parseTimeCost);
+    setEntityInfo(parseInfoValue.entityInfo || {});
+    updateDimensionFitlers(parseInfoValue?.dimensionFilters || []);
+    setDateInfo(parseInfoValue?.dateInfo);
+    if (parseInfos.length === 1) {
+      onExecute(parseInfoValue, parseInfos);
+    }
+  };
+
+  const initChatItem = (msg, msgData) => {
+    if (msgData) {
+      const parseInfoOptionsValue =
+        parseInfos && parseInfos.length > 0
+          ? parseInfos.map(item => ({ ...item, queryId: msgData.queryId }))
+          : [{ ...msgData.chatContext, queryId: msgData.queryId }];
+      const parseInfoValue = parseInfoOptionsValue[0];
+      setParseInfoOptions(parseInfoOptionsValue);
+      setParseInfo(parseInfoValue);
+      setParseTimeCost(parseTimeCostValue);
+      updateDimensionFitlers(parseInfoValue.dimensionFilters || []);
+      setDateInfo(parseInfoValue.dateInfo);
+      setExecuteMode(true);
+      updateData({ code: 200, data: msgData, msg: 'success' });
+    } else if (msg) {
+      sendMsg();
+    }
+  };
+
+  useEffect(() => {
+    if (data !== undefined || executeTip !== '' || parseLoading) {
+      return;
+    }
+    initChatItem(msg, msgData);
+  }, [msg, msgData]);
+
+  const onSwitchEntity = async (entityId: string) => {
+    setEntitySwitchLoading(true);
+    const res = await switchEntity(entityId, data?.chatContext?.modelId, conversationId || 0);
+    setEntitySwitchLoading(false);
+    setData(res.data);
+    const { chatContext, entityInfo } = res.data || {};
+    const chatContextValue = { ...(chatContext || {}), queryId: parseInfo?.queryId };
+    setParseInfo(chatContextValue);
+    setEntityInfo(entityInfo);
+    updateDimensionFitlers(chatContextValue?.dimensionFilters || []);
+    setDateInfo(chatContextValue?.dateInfo);
+    // 使用新的缓存键生成方式
+    const cacheKey = generateCacheKey(chatContextValue);
+    setDataCache({ ...dataCache, [cacheKey]: { tip: '', data: res.data } });
+  };
+
+  const onFiltersChange = (dimensionFilters: FilterItemType[]) => {
+    setDimensionFilters(dimensionFilters);
+  };
+
+  const onDateInfoChange = (dates: [Dayjs | null, Dayjs | null] | null) => {
+    if (dates && dates[0] && dates[1]) {
+      const [start, end] = dates;
+      setDateInfo({
+        ...(dateInfo || {}),
+        startDate: dayjs(start).format('YYYY-MM-DD'),
+        endDate: dayjs(end).format('YYYY-MM-DD'),
+        dateMode: 'BETWEEN',
+        unit: 0,
+      });
+    }
+  };
+
+  const handlePresetClick = (range: RangeValue) => {
+    setDateInfo({
+      ...(dateInfo || {}),
+      startDate: dayjs(range[0]).format('YYYY-MM-DD'),
+      endDate: dayjs(range[1]).format('YYYY-MM-DD'),
+      dateMode: 'BETWEEN',
+      unit: 0,
+    });
+  };
+
+  const onRefresh = async (parseInfoValue?: ChatContextType) => {
+    setEntitySwitchLoading(true);
+    const { dimensions, metrics, id, queryId, dataSetIds, dataSet } = parseInfoValue || parseInfo || {};
+    // 优先使用传递的dataSetIds参数，其次是parseInfo中的dataSetIds，最后是selectedDataSetIds状态
+    const effectiveDataSetIds = dataSetIds || (parseInfoValue?.dataSetIds || parseInfo?.dataSetIds) || (selectedDataSetIds.length > 0 ? selectedDataSetIds : undefined);
+    
+    // 检查是否切换了数据集 - 使用JSON.stringify进行精确比较
+    const isDataSetSwitched = effectiveDataSetIds && 
+      parseInfo?.dataSetIds && 
+      JSON.stringify(effectiveDataSetIds.sort()) !== JSON.stringify((parseInfo.dataSetIds || []).sort());
+    
+    // 不再使用regenerateSQL标志，仅根据数据集切换情况决定是否需要重新解析
+    if (isDataSetSwitched || (parseInfoValue !== undefined && parseInfoValue !== parseInfo)) {
+      // 数据集切换时，清除所有相关缓存
+      const newDataCache = { ...dataCache };
+      Object.keys(newDataCache).forEach(key => {
+        newDataCache[key] = { tip: '', data: undefined };
+      });
+      setDataCache(newDataCache);
+      
+      // 强制清除当前数据状态，确保重新执行查询
+      setData(undefined);
+      setExecuteTip('');
+      
+      // 数据集切换时，重新调用chatParse获取新的解析结果
+      const { code, data }: any = await chatParse({
+        queryText: msg,
+        chatId: conversationId,
+        modelId,
+        agentId,
+        filters: filter,
+        parseId: id,
+        queryId,
+        parseInfo: parseInfoValue || parseInfo,
+        dataSetIds: effectiveDataSetIds
+      });
+      setEntitySwitchLoading(false);
+      if (code === 200) {
+        setParseTimeCost(data.parseTimeCost);
+        const newParseInfo = data.selectedParses[0];
+        newParseInfo.queryId = data.queryId;
+        // 确保新的解析结果包含正确的数据集ID
+        newParseInfo.dataSetIds = effectiveDataSetIds;
+        
+        // 重要修复：确保newParseInfo有正确的dataSet信息
+        // 如果API没有返回dataSet信息，但知道数据集ID，需要构建dataSet对象
+        if (!newParseInfo.dataSet && effectiveDataSetIds && effectiveDataSetIds.length > 0) {
+          // 尝试从当前parseInfo中获取数据集名称，或者使用ID作为名称
+          const currentDataSetName = parseInfo?.dataSet?.name || 
+            (parseInfoOptions.find(opt => {
+              const optDataSetId = opt.dataSet?.id || (opt.dataSetIds && opt.dataSetIds[0]);
+              return optDataSetId && effectiveDataSetIds.includes(optDataSetId);
+            })?.dataSet?.name) || 
+            `数据集${effectiveDataSetIds[0]}`;
+            
+          newParseInfo.dataSet = {
+            id: effectiveDataSetIds[0],
+            name: currentDataSetName
+          };
+        }
+        
+        // 重要修复：基于数据集ID来匹配和更新解析选项，而不是基于解析选项的id
+        // 这样可以确保数据集切换后正确替换对应数据集的解析信息
+        const updatedParseInfoOptions = parseInfoOptions.map(option => {
+          // 检查当前选项的数据集ID是否与新的解析结果的数据集ID匹配
+          const optionDataSetId = option.dataSet?.id || (option.dataSetIds && option.dataSetIds[0]);
+          const newParseInfoDataSetId = newParseInfo.dataSet?.id || (newParseInfo.dataSetIds && newParseInfo.dataSetIds[0]);
+          
+          if (optionDataSetId && newParseInfoDataSetId && optionDataSetId === newParseInfoDataSetId) {
+            return newParseInfo;
+          }
+          return option;
+        });
+        
+        // 如果新的解析信息的数据集不在原有选项中，则添加它
+        const newParseInfoDataSetId = newParseInfo.dataSet?.id || (newParseInfo.dataSetIds && newParseInfo.dataSetIds[0]);
+        const existingDataSetOption = updatedParseInfoOptions.find(option => {
+          const optionDataSetId = option.dataSet?.id || (option.dataSetIds && option.dataSetIds[0]);
+          return optionDataSetId && newParseInfoDataSetId && optionDataSetId === newParseInfoDataSetId;
+        });
+        
+        if (!existingDataSetOption) {
+          updatedParseInfoOptions.push(newParseInfo);
+        }
+        
+        setParseInfoOptions(updatedParseInfoOptions);
+        setParseInfo(newParseInfo);
+        updateDimensionFitlers(newParseInfo.dimensionFilters || []);
+        setDateInfo(newParseInfo.dateInfo);
+        if (newParseInfo.entityInfo) {
+          setEntityInfo(newParseInfo.entityInfo);
+        }
+        // 清除旧缓存，确保使用新的查询结果
+        const cacheKey = generateCacheKey(newParseInfo);
+        setDataCache({ ...dataCache, [cacheKey]: { tip: '', data: undefined } });
+        // 确保传递正确的数据集ID给onExecute
+        const parseInfoWithDataSetIds = {
+          ...newParseInfo,
+          dataSetIds: effectiveDataSetIds
+        };
+        onExecute(parseInfoWithDataSetIds, updatedParseInfoOptions, true, true);
+      }
+    } else {
+      // 非数据集切换时，调用queryData查询数据
+      const chatContextValue = {
+        dimensions,
+        metrics,
+        dateInfo,
+        dimensionFilters,
+        parseId: id,
+        queryId,
+        dataSetIds: effectiveDataSetIds,
+        // 确保传递正确的数据集信息 - 使用parseInfo中的dataSet或保持undefined
+        dataSet: parseInfoValue?.dataSet || parseInfo?.dataSet
+      };
+      const res: any = await queryData(chatContextValue);
+      setEntitySwitchLoading(false);
+      if (res.code === 200) {
+        const resChatContext = res.data?.chatContext;
+        // 保留原始的properties.CONTEXT信息，确保SqlItem组件能正确显示Schema映射
+        const contextValue = { 
+          ...(resChatContext || chatContextValue), 
+          queryId,
+          properties: {
+            ...(parseInfoValue?.properties || parseInfo?.properties || {}),
+            // 确保CONTEXT属性被正确保留
+            CONTEXT: parseInfoValue?.properties?.CONTEXT || parseInfo?.properties?.CONTEXT
+          }
+        };
+        const dataValue = {
+          ...res.data,
+          chatContext: contextValue,
+          parseInfos: parseInfoOptions,
+          queryId,
+        };
+        onMsgDataLoaded?.(dataValue, true, true);
+        setData(dataValue);
+        setParseInfo(contextValue);
+        // 使用新的缓存键生成方式
+        const cacheKey = generateCacheKey(contextValue);
+        setDataCache({ ...dataCache, [cacheKey]: { tip: '', data: dataValue } });
+      }
+    }
+  };
+
+  const deleteQueryInfo = async (queryId: number) => {
+    const { code }: any = await deleteQuery(queryId);
+    if (code === 200) {
+      resetState();
+      initChatItem(msg, undefined);
+    }
+  };
+
+  const onSelectParseInfo = async (parseInfoValue: ChatContextType) => {
+    setParseInfo(parseInfoValue);
+    updateDimensionFitlers(parseInfoValue.dimensionFilters || []);
+    setDateInfo(parseInfoValue.dateInfo);
+    if (parseInfoValue.entityInfo) {
+      setEntityInfo(parseInfoValue.entityInfo);
+    }
+    // 设置选择的数据集ID
+    const effectiveDataSetIds = parseInfoValue.dataSet?.id ? 
+      [parseInfoValue.dataSet.id] : 
+      (parseInfoValue.dataSetIds || selectedDataSetIds);
+      
+    if (effectiveDataSetIds && effectiveDataSetIds.length > 0) {
+      setSelectedDataSetIds(effectiveDataSetIds);
+    }
+    
+    // 检查是否切换了数据集 - 使用JSON.stringify进行精确比较
+    const currentDataSetIds = parseInfo?.dataSetIds || [];
+    const newDataSetIds = effectiveDataSetIds || [];
+    const isDataSetSwitched = JSON.stringify(currentDataSetIds.sort()) !== JSON.stringify(newDataSetIds.sort());
+    
+    // 如果切换了数据集，清除所有相关缓存
+    if (isDataSetSwitched) {
+      const newDataCache = { ...dataCache };
+      Object.keys(newDataCache).forEach(key => {
+        newDataCache[key] = { tip: '', data: undefined };
+      });
+      setDataCache(newDataCache);
+      // 强制清除当前数据状态，确保重新执行查询
+      setData(undefined);
+      setExecuteTip('');
+    }
+    
+    // 使用新的缓存键生成方式
+    const cacheKey = generateCacheKey(parseInfoValue);
+    if (dataCache[cacheKey] && !isDataSetSwitched) {
+      const { tip, data } = dataCache[cacheKey];
+      setExecuteTip(tip);
+      setData(data);
+    } else {
+      // 如果没有缓存数据或者切换了数据集，强制重新执行查询
+      const parseInfoWithDataSetIds = {
+        ...parseInfoValue,
+        dataSetIds: effectiveDataSetIds
+      };
+      // 重要修复：无论是否切换数据集，都传递所有的解析选项，确保下拉列表显示所有可用选项
+      const executeParseOptions = parseInfoOptions;
+      onExecute(parseInfoWithDataSetIds, executeParseOptions, true);
+    }
+  };
+
+  const onExpandSelectParseInfo = async (parseInfoValue: ChatContextType) => {
+    setParseInfo(parseInfoValue);
+    setPreParseMode(false);
+    // 设置选择的数据集ID
+    const effectiveDataSetIds = parseInfoValue.dataSet?.id ? 
+      [parseInfoValue.dataSet.id] : 
+      (parseInfoValue.dataSetIds || selectedDataSetIds);
+      
+    if (effectiveDataSetIds && effectiveDataSetIds.length > 0) {
+      setSelectedDataSetIds(effectiveDataSetIds);
+    }
+    
+    const { id: parseId, queryId } = parseInfoValue;
+    setParseLoading(true);
+    const { code, data }: any = await chatParse({
+      queryText: msg,
+      chatId: conversationId,
+      modelId,
+      agentId,
+      filters: filter,
+      parseId,
+      queryId,
+      parseInfo: parseInfoValue,
+      dataSetIds: effectiveDataSetIds,
+    });
+    setParseLoading(false);
+      if (code === 200) {
+        setParseTimeCost(data.parseTimeCost);
+        const parseInfo = data.selectedParses[0];
+        parseInfo.queryId = data.queryId;
+        // 确保新的解析结果包含正确的数据集ID
+        parseInfo.dataSetIds = effectiveDataSetIds;
+        
+        // 重要修复：确保parseInfo有正确的dataSet信息
+        // 如果API没有返回dataSet信息，但知道数据集ID，需要构建dataSet对象
+        if (!parseInfo.dataSet && effectiveDataSetIds && effectiveDataSetIds.length > 0) {
+          // 尝试从当前parseInfo中获取数据集名称，或者使用ID作为名称
+          const currentDataSetName = parseInfo?.dataSet?.name || 
+            (parseInfoOptions.find(opt => {
+              const optDataSetId = opt.dataSet?.id || (opt.dataSetIds && opt.dataSetIds[0]);
+              return optDataSetId && effectiveDataSetIds.includes(optDataSetId);
+            })?.dataSet?.name) || 
+            `数据集${effectiveDataSetIds[0]}`;
+            
+          parseInfo.dataSet = {
+            id: effectiveDataSetIds[0],
+            name: currentDataSetName
+          };
+        }
+        
+        // 重要修复：基于数据集ID来匹配和更新解析选项，而不是基于解析选项的id
+        // 这样可以确保数据集切换后正确替换对应数据集的解析信息
+        const updatedParseInfoOptions = parseInfoOptions.map(option => {
+          // 检查当前选项的数据集ID是否与新的解析结果的数据集ID匹配
+          const optionDataSetId = option.dataSet?.id || (option.dataSetIds && option.dataSetIds[0]);
+          const newParseInfoDataSetId = parseInfo.dataSet?.id || (parseInfo.dataSetIds && parseInfo.dataSetIds[0]);
+          
+          if (optionDataSetId && newParseInfoDataSetId && optionDataSetId === newParseInfoDataSetId) {
+            return parseInfo;
+          }
+          return option;
+        });
+        
+        // 如果新的解析信息的数据集不在原有选项中，则添加它
+        const newParseInfoDataSetId = parseInfo.dataSet?.id || (parseInfo.dataSetIds && parseInfo.dataSetIds[0]);
+        const existingDataSetOption = updatedParseInfoOptions.find(option => {
+          const optionDataSetId = option.dataSet?.id || (option.dataSetIds && option.dataSetIds[0]);
+          return optionDataSetId && newParseInfoDataSetId && optionDataSetId === newParseInfoDataSetId;
+        });
+        
+        if (!existingDataSetOption) {
+          updatedParseInfoOptions.push(parseInfo);
+        }
+        
+        setParseInfoOptions(updatedParseInfoOptions);
+        setParseInfo(parseInfo);
+        updateDimensionFitlers(parseInfo.dimensionFilters || []);
+        setDateInfo(parseInfo.dateInfo);
+        if (parseInfo.entityInfo) {
+          setEntityInfo(parseInfo.entityInfo);
+        }
+        // 确保传递正确的数据集ID给onExecute
+        const parseInfoWithDataSetIds = {
+          ...parseInfo,
+          dataSetIds: effectiveDataSetIds
+        };
+        onExecute(parseInfoWithDataSetIds, updatedParseInfoOptions, true, true);
+      }
+  };
+
+  const onExportData = () => {
+    const { queryColumns, queryResults } = data || {};
+    if (!!queryResults && !!queryColumns) {
+      const exportData = queryResults.map(item => {
+        return queryColumns.reduce((result, column) => {
+          result[column.name || column.nameEn] = item[column.nameEn];
+          return result;
+        }, {});
+      });
+      exportCsvFile(exportData);
+    }
+  };
+
+  const onSelectQuestion = (question: SimilarQuestionType) => {
+    onSendMsg?.(question.queryText);
+  };
+
+  const contentClass = classNames(`${prefixCls}-content`, {
+    [`${prefixCls}-content-mobile`]: isMobile,
+  });
+
+  const { llmReq, llmResp } = parseInfo?.properties?.CONTEXT || {};
+
+  const { register, call } = useMethodRegister(() => message.error('该条消息暂不支持该操作'));
+
+  let actualQueryText=parseInfo?.properties?.CONTEXT?.queryText //  2025-05-27 增加判空，防止出现上下文没有 queryText 的情况
+  actualQueryText=actualQueryText==null?msg:actualQueryText
+  return (
+    <ChartItemContext.Provider value={{ register, call }}>
+      <div className={prefixCls}>
+        {!isMobile && <IconFont type="icon-zhinengsuanfa" className={`${prefixCls}-avatar`} />}
+        <div className={isMobile ? `${prefixCls}-mobile-msg-card` : ''}>
+          <div className={`${prefixCls}-time`}>
+            {parseTimeCost?.parseStartTime
+              ? dayjs(parseTimeCost.parseStartTime).format('M月D日 HH:mm')
+              : ''}
+          </div>
+          <div className={contentClass}>
+            <>
+              {currentAgent?.enableFeedback === 1 && !questionId && showExpandParseTip && (
+                <div style={{ marginBottom: 10 }}>
+                  <ExpandParseTip
+                    isSimpleMode={isSimpleMode}
+                    parseInfoOptions={preParseInfoOptions}
+                    agentId={agentId}
+                    integrateSystem={integrateSystem}
+                    parseTimeCost={parseTimeCost?.parseTime}
+                    isDeveloper={isDeveloper}
+                    onSelectParseInfo={onExpandSelectParseInfo}
+                    onSwitchEntity={onSwitchEntity}
+                    onFiltersChange={onFiltersChange}
+                    onDateInfoChange={onDateInfoChange}
+                    onRefresh={onRefresh}
+                    handlePresetClick={handlePresetClick}
+                    setSelectedDataSetIds={setSelectedDataSetIds}
+                  />
+                </div>
+              )}
+
+              {!preParseMode && (
+                <ParseTip
+                  isSimpleMode={isSimpleMode}
+                  parseLoading={parseLoading}
+                  parseInfoOptions={parseInfoOptions}
+                  parseTip={parseTip}
+                  currentParseInfo={parseInfo}
+                  agentId={agentId}
+                  dimensionFilters={dimensionFilters}
+                  dateInfo={dateInfo}
+                  entityInfo={entityInfo}
+                  integrateSystem={integrateSystem}
+                  parseTimeCost={parseTimeCost?.parseTime}
+                  isDeveloper={isDeveloper}
+                  onSelectParseInfo={onSelectParseInfo}
+                  onSwitchEntity={onSwitchEntity}
+                  onFiltersChange={onFiltersChange}
+                  onDateInfoChange={onDateInfoChange}
+                  onRefresh={(parseInfo) => {
+                    onRefresh(parseInfo);
+                  }}
+                  handlePresetClick={handlePresetClick}
+                  setSelectedDataSetIds={setSelectedDataSetIds}
+                />
+              )}
+            </>
+
+            {executeMode && (
+              <Spin spinning={entitySwitchLoading}>
+                <div style={{ minHeight: 50 }}>
+                  {!isMobile &&
+                    parseInfo?.sqlInfo &&
+                    isDeveloper &&
+                    isDebugMode &&
+                    !isSimpleMode && (
+                      <SqlItem
+                        agentId={agentId}
+                        queryId={parseInfo.queryId}
+                        question={actualQueryText}
+                        llmReq={llmReq}
+                        llmResp={llmResp}
+                        integrateSystem={integrateSystem}
+                        queryMode={parseInfo.queryMode}
+                        sqlInfo={parseInfo.sqlInfo}
+                        sqlTimeCost={parseTimeCost?.sqlTime}
+                        executeErrorMsg={executeErrorMsg}
+                        dataSetIds={parseInfo.dataSetIds} // 添加dataSetIds属性
+                      />
+                    )}
+                  <ExecuteItem
+                    isSimpleMode={isSimpleMode}
+                    queryId={parseInfo?.queryId}
+                    parseId={parseInfo?.id}
+                    question={actualQueryText}
+                    queryMode={parseInfo?.queryMode}
+                    executeLoading={executeLoading}
+                    executeTip={executeTip}
+                    executeErrorMsg={executeErrorMsg}
+                    chartIndex={0}
+                    data={data}
+                    triggerResize={triggerResize}
+                    executeItemNode={executeItemNode}
+                    isDeveloper={isDeveloper}
+                    renderCustomExecuteNode={renderCustomExecuteNode}
+                    enableStreamingSummary={!data?.textSummary}
+                    onStreamingSummaryUpdate={setStreamingSummary}
+                    agentId={agentId}
+                    dataSetIds={parseInfo?.dataSetIds}
+                  />
+                </div>
+              </Spin>
+            )}
+            {executeMode &&
+              !executeLoading &&
+              !isSimpleMode &&
+              parseInfo?.queryMode !== 'PLAIN_TEXT' && (
+                <SimilarQuestionItem
+                  queryId={parseInfo?.queryId}
+                  defaultExpanded={parseTip !== '' || executeTip !== ''}
+                  similarQueries={data?.similarQueries}
+                  onSelectQuestion={onSelectQuestion}
+                />
+              )}
+          </div>
+          {(parseTip !== '' || (executeMode && !executeLoading)) &&
+            parseInfo?.queryMode !== 'PLAIN_TEXT' && (
+              <Tools
+                isLastMessage={isLastMessage}
+                queryId={parseInfo?.queryId || 0}
+                scoreValue={score}
+                isParserError={isParserError}
+                onExportData={() => {
+                  onExportData();
+                }}
+                isSimpleMode={isSimpleMode}
+                onReExecute={queryId => {
+                  deleteQueryInfo(queryId);
+                }}
+              />
+            )}
+        </div>
+      </div>
+    </ChartItemContext.Provider>
+  );
+};
+
+export default ChatItem;