Context窗口与状态管理优化策略

// 当前实现：直接传递所有历史消息
const sendMessages = buildRequestMessages(sessionMessages.concat(userMsg));

// 优化方案：实现滑动窗口截断
const MAX_CONTEXT_MESSAGES = 20;        // 保留最近20条消息
const MAX_CONTEXT_TOKENS = 4000;        // 最大Token限制

function truncateMessages(messages: Message[]): Message[] {
  // 保留系统消息
  const systemMessages = messages.filter(m => m.role === 'system');
  
  // 获取非系统消息
  const chatMessages = messages.filter(m => m.role !== 'system');
  
  // 滑动窗口：只保留最近N条
  const recentMessages = chatMessages.slice(-MAX_CONTEXT_MESSAGES);
  
  return [...systemMessages, ...recentMessages];
}

// 当历史消息过长时，生成摘要
interface MessageSummary {
  originalLength: number;
  summary: string;
  keyPoints: string[];
}

function summarizeOldMessages(messages: Message[]): Message[] {
  const SUMMARY_THRESHOLD = 10;  // 超过10条开始摘要
  
  if (messages.length <= SUMMARY_THRESHOLD) {
    return messages;
  }
  
  // 保留最近对话
  const recentMessages = messages.slice(-5);
  
  // 将早期对话转为摘要
  const oldMessages = messages.slice(0, -5);
  const summary = generateSummary(oldMessages);
  
  return [
    { role: 'system', content: `历史对话摘要：${summary}` },
    ...recentMessages
  ];
}

// 处理大量消息时的渲染优化
import { useVirtualizer } from '@tanstack/react-virtual';

function useMessageVirtualizer(messages: Message[]) {
  const parentRef = useRef<HTMLDivElement>(null);
  
  const virtualizer = useVirtualizer({
    count: messages.length,
    getScrollElement: () => parentRef.current,
    estimateSize: () => 80,  // 预估每条消息高度
    overscan: 5,             // 预渲染5条
  });
  
  return { parentRef, virtualizer };
}

// 避免单次更新大量数据
interface MessageChunk {
  id: string;
  messages: Message[];
  timestamp: number;
}

function useChunkedMessages() {
  const [chunks, setChunks] = useState<MessageChunk[]>([]);
  
  // 分片存储，每片最多100条消息
  const addMessage = (message: Message) => {
    const latestChunk = chunks[chunks.length - 1];
    
    if (!latestChunk || latestChunk.messages.length >= 100) {
      // 创建新分片
      setChunks([...chunks, {
        id: uid(),
        messages: [message],
        timestamp: Date.now()
      }]);
    } else {
      // 追加到现有分片
      latestChunk.messages.push(message);
      setChunks([...chunks]);
    }
  };
  
  // 合并所有消息（按需）
  const getAllMessages = () => {
    return chunks.flatMap(chunk => chunk.messages);
  };
  
  return { chunks, addMessage, getAllMessages };
}

// 对历史消息进行压缩存储
function compressMessageContent(content: string): string {
  // 使用LZ-string等压缩算法
  if (content.length > 1000) {
    return LZString.compressToUTF16(content);
  }
  return content;
}

function decompressMessageContent(content: string): string {
  try {
    return LZString.decompressFromUTF16(content) || content;
  } catch {
    return content;
  }
}

// 优化前：全量更新
setMessages([...messages, newMessage]);  // O(n) 复杂度

// 优化后：增量更新
const addMessage = (newMessage: Message) => {
  // 使用不可变数据结构的优化
  setMessages(prev => {
    // 如果数组很大，使用Object.freeze防止意外修改
    if (prev.length > 100) {
      Object.freeze(prev);
    }
    return [...prev, newMessage];
  });
};

// useOptimizedChat.ts
interface OptimizedChatConfig {
  maxContextMessages?: number;
  maxContextTokens?: number;
  enableSummarization?: boolean;
  enableVirtualization?: boolean;
}

export function useOptimizedChat(
  sessionMessages: Message[],
  updateCurrentSession: (messages: Message[]) => void,
  config: OptimizedChatConfig = {}
) {
  const {
    maxContextMessages = 20,
    maxContextTokens = 4000,
    enableSummarization = true,
    enableVirtualization = true
  } = config;

  // 1. 上下文截断
  const truncatedMessages = useMemo(() => {
    if (sessionMessages.length <= maxContextMessages) {
      return sessionMessages;
    }
    
    const systemMsgs = sessionMessages.filter(m => m.role === 'system');
    const chatMsgs = sessionMessages.filter(m => m.role !== 'system');
    const recentMsgs = chatMsgs.slice(-maxContextMessages);
    
    return [...systemMsgs, ...recentMsgs];
  }, [sessionMessages, maxContextMessages]);

  // 2. 智能摘要（当消息过多时）
  const summarizedMessages = useMemo(() => {
    if (!enableSummarization || sessionMessages.length <= 10) {
      return truncatedMessages;
    }
    
    return generateSmartSummary(truncatedMessages);
  }, [truncatedMessages, enableSummarization]);

  // 3. 发送消息（使用优化后的上下文）
  const handleSend = async (text: string) => {
    const userMsg: Message = {
      id: uid(),
      role: 'user',
      content: text,
      timestamp: Date.now()
    };

    // 乐观更新UI
    const optimisticMessages = [...sessionMessages, userMsg];
    updateCurrentSession(optimisticMessages);

    try {
      // 使用截断后的消息发送API
      const response = await fetch('/api/chat', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({
          messages: buildRequestMessages(summarizedMessages.concat(userMsg)),
          stream: true
        })
      });

      // 流式处理响应...
      await handleStreamResponse(response, optimisticMessages);
      
    } catch (error) {
      console.error('发送失败:', error);
      // 回滚乐观更新
      updateCurrentSession(sessionMessages);
    }
  };

  return {
    messages: enableVirtualization 
      ? useVirtualizedMessages(sessionMessages) 
      : sessionMessages,
    truncatedMessages: summarizedMessages,
    handleSend,
    messageCount: sessionMessages.length,
    isContextTruncated: sessionMessages.length > maxContextMessages
  };
}

// 实时监控Context窗口状态
function useContextMonitor(messages: Message[]) {
  const [metrics, setMetrics] = useState({
    messageCount: 0,
    estimatedTokens: 0,
    memoryUsage: 0
  });

  useEffect(() => {
    // 估算Token数量（粗略估计：1个汉字≈2个token）
    const estimatedTokens = messages.reduce((sum, msg) => {
      return sum + Math.ceil(msg.content.length * 2);
    }, 0);

    // 计算内存使用（粗略估计）
    const memoryUsage = new Blob([JSON.stringify(messages)]).size;

    setMetrics({
      messageCount: messages.length,
      estimatedTokens,
      memoryUsage
    });

    // 预警机制
    if (estimatedTokens > 8000) {
      console.warn('⚠️ Context窗口接近上限，建议开启摘要模式');
    }
    
    if (memoryUsage > 1024 * 1024) {  // 超过1MB
      console.warn('⚠️ 消息内存占用过高，建议清理历史');
    }
  }, [messages]);

  return metrics;
}