自我改善的智能体实践：政府公文写作系统

// lib/types.ts
export interface GovDocSEED {
  searchDepth: number;              // 搜索深度（5-20）
  sourceWhitelist: string[];        // 信源白名单
  focusDirective: string;           // 研判指令
  writingRequirements: string;      // 写作要求（完整提示词）
}

const v1Seed: GovDocSEED = {
  searchDepth: 2,
  sourceWhitelist: ['全网'],
  focusDirective: '通用概述',
  writingRequirements: `写作要求：
1. 结构清晰，逻辑严密
2. 字数控制在800-1200字

请直接输出公文内容，不要额外说明。`
}

// 示例：诊断发现"事实准确性"和"内容深度"不足
const v2Seed: GovDocSEED = {
  searchDepth: 15,                           // 增加搜索深度
  sourceWhitelist: ['政府官网', '统计局', '权威智库', '央媒'],  // 限制权威信源
  focusDirective: '数据驱动+深度问题剖析',     // 更明确的研判方向
  writingRequirements: `写作要求：
1. 必须引用具体数据，标注来源
2. 加强问题分析的深度和逻辑推导
3. 提出的建议需具体可操作，包含实施步骤
4. 字数控制在1000-1500字
5. 论证严谨，无跳跃推理

请直接输出公文内容，不要额外说明。`
}

// lib/agents.ts
export async function searchAgent(
  topic: string,
  seed: GovDocSEED
): Promise<SearchResult[]> {
  const tvly = tavily({ apiKey: process.env.TAVILY_API_KEY });

  // 根据信源白名单调整搜索策略
  let searchQuery = topic;
  if (seed.sourceWhitelist.includes('政府官网')) {
    searchQuery += ' site:.gov.cn OR site:stats.gov.cn';
  }

  const response = await tvly.search(searchQuery, {
    maxResults: seed.searchDepth,
    searchDepth: seed.searchDepth > 10 ? 'advanced' : 'basic',
  });

  // 根据白名单过滤结果
  return filterByWhitelist(response.results, seed.sourceWhitelist);
}

export async function insightAgent(
  topic: string,
  searchResults: SearchResult[],
  seed: GovDocSEED
): Promise<WritingGuidance> {
  const prompt = `你是一个专业的政策研判Agent。基于以下搜索结果，按照指定的研判方向进行深度分析：

主题：${topic}
研判指令：${seed.focusDirective}

搜索结果：
${searchResults.map((r, i) => `[${i + 1}] ${r.title}\n来源：${r.source}\n摘要：${r.snippet}`).join('\n\n')}

请生成结构化的写作指引（JSON格式），包含：
{
  "keyPoints": ["核心观点1", "核心观点2", ...],
  "dataReferences": ["数据引用1", "数据引用2", ...],
  "suggestedStructure": ["段落1主题", "段落2主题", ...],
  "focusAreas": ["重点关注领域1", "重点关注领域2", ...]
}

根据研判指令"${seed.focusDirective}"，确保分析深入、有数据支撑、有针对性。`;

  return await callDeepSeekStructured<WritingGuidance>(prompt);
}

export async function writerAgent(
  topic: string,
  searchResults: SearchResult[],
  guidance: WritingGuidance,
  seed: GovDocSEED
): Promise<string> {
  const prompt = `你是一个专业的公文写作Agent。请根据以下信息撰写一份政府公文：

主题：${topic}

核心观点：
${guidance.keyPoints.map((p, i) => `${i + 1}. ${p}`).join('\n')}

关键数据：
${guidance.dataReferences.map((d, i) => `${i + 1}. ${d}`).join('\n')}

建议结构：
${guidance.suggestedStructure.map((s, i) => `${i + 1}. ${s}`).join('\n')}

重点方向：
${guidance.focusAreas.join('、')}

参考资料：
${searchResults.map((r) => `【${r.source}】${r.snippet}`).join('\n')}

${seed.writingRequirements}`;

  return await callDeepSeek(prompt, 0.6, 2000);
}

// lib/evaluators.ts
export async function evaluationAgent(
  topic: string,
  content: string
): Promise<EvaluationScores> {
  const prompt = `你是一个专业的公文评审专家。请对以下公文进行5维度评估，每个维度给出0-1之间的分数，并详细说明打分理由。

主题：${topic}
公文内容：
${content}

评估维度：
1. 政治站位：是否符合政策方针？用词是否准确规范？
2. 事实准确：数据是否有依据？引用是否权威？
3. 逻辑严密：论证是否严谨？段落是否连贯？
4. 公文规范：是否符合公文格式？语言是否得体？
5. 内容深度：是否有深度？建议是否可操作？

返回JSON格式：
{
  "政治站位": {
    "score": 0.85,
    "reason": "用词规范，符合政策导向，但在体现创新发展理念上有所欠缺。"
  },
  "事实准确": { "score": 0.75, "reason": "..." },
  ...
}

请客观、严格评分，找出不足之处。`;

  return await callDeepSeekStructured<EvaluationScores>(prompt);
}

export async function diagnosticAgent(
  scores: EvaluationScores,
  currentSeed: GovDocSEED
): Promise<DiagnosisResult> {
  // 找出最低的两个维度
  const sortedScores = Object.entries(scores)
    .sort((a, b) => a[1].score - b[1].score)
    .slice(0, 2);

  const weaknesses = sortedScores.map(([dim, data]) => `${dim}(${data.score})`).join(' 与 ');

  const prompt = `你是一个AI系统诊断专家。当前系统生成的公文评分如下：

${Object.entries(scores).map(([k, v]) => `${k}: ${v.score} - ${v.reason}`).join('\n')}

当前SEED参数：
- 搜索深度：${currentSeed.searchDepth}
- 信源范围：${currentSeed.sourceWhitelist.join(', ')}
- 研判指令：${currentSeed.focusDirective}
- 写作要求：${currentSeed.writingRequirements.split('\n')[1]}

识别出的主要弱点：${weaknesses}

请分析：
1. 为什么这些维度得分较低？
2. 当前SEED参数的哪些设置导致了这些问题？
3. 应该如何调整SEED参数来改进？

返回JSON格式：
{
  "weakness": "简明描述弱点",
  "reason": "深层原因分析（150字内）",
  "mutation": [
    "搜索深度: 2 -> 15",
    "信源范围: 全网 -> 政府官网+统计局+权威智库",
    "研判指令: 通用概述 -> 数据驱动+深度问题剖析",
    "写作要求: 需要重新生成针对性提示词"
  ]
}`;

  return await callDeepSeekStructured<DiagnosisResult>(prompt);
}

export async function architectAgent(
  diagnosis: DiagnosisResult,
  currentSeed: GovDocSEED
): Promise<GovDocSEED> {
  const newSeed: GovDocSEED = { ...currentSeed };

  // 1. 解析mutation建议，应用到数值参数
  diagnosis.mutation.forEach(mutation => {
    if (mutation.includes('搜索深度')) {
      const match = mutation.match(/(\d+)/g);
      if (match && match.length >= 2) {
        newSeed.searchDepth = parseInt(match[1]);
      }
    }

    if (mutation.includes('信源')) {
      if (mutation.includes('权威') || mutation.includes('政府')) {
        newSeed.sourceWhitelist = ['政府官网', '统计局', '权威智库', '央媒'];
      }
    }

    if (mutation.includes('研判')) {
      if (mutation.includes('数据') || mutation.includes('深度')) {
        newSeed.focusDirective = '数据驱动+深度问题剖析';
      }
    }
  });

  // 2. 调用AI动态生成新的writingRequirements
  const prompt = `你是一位专业的公文写作指导专家。根据以下问题诊断，生成改进后的"写作要求"提示词。

当前发现的问题：
${diagnosis.weakness}

问题原因分析：
${diagnosis.reason}

改进建议：
${diagnosis.mutation.join('\n')}

请生成一份完整的、针对性的"写作要求"提示词。要求：
1. 针对上述问题进行有针对性的改进
2. 保持格式为标准的写作要求清单
3. 在提示词末尾添加"请直接输出公文内容，不要额外说明。"
4. 不要包含任何markdown代码块或额外的格式符号，直接输出纯文本`;

  newSeed.writingRequirements = await callDeepSeek(
    [
      { role: 'system', content: '你是一位经验丰富的公文写作提示词设计专家，能够根据问题诊断生成精准有效的写作要求。' },
      { role: 'user', content: prompt }
    ],
    0.6,
    1500
  );

  return newSeed;
}

// app/api/generate/route.ts
function createStreamResponse() {
  const encoder = new TextEncoder();
  const stream = new TransformStream();
  const writer = stream.writable.getWriter();

  const sendLog = async (msg: string, type: 'info' | 'success' | 'warning' | 'error' = 'info') => {
    await writer.write(encoder.encode(`data: ${JSON.stringify({
      type: 'log',
      data: { time: new Date().toLocaleTimeString(), msg, type }
    })}\n\n`));
  };

  const sendStatus = async (status: string) => {
    await writer.write(encoder.encode(`data: ${JSON.stringify({
      type: 'status',
      data: status
    })}\n\n`));
  };

  const sendScores = async (scores: EvaluationScores, version: string) => {
    await writer.write(encoder.encode(`data: ${JSON.stringify({
      type: 'scores',
      data: { scores, version }
    })}\n\n`));
  };

  // ... 其他发送函数

  return { stream: stream.readable, sendLog, sendStatus, sendScores, /* ... */ };
}

export async function POST(request: NextRequest) {
  const { topic } = await request.json();
  const { stream, sendLog, sendStatus, sendContent, sendScores, sendSeed, sendDiagnosis, sendSearchResults, close } = createStreamResponse();

  (async () => {
    // V1阶段
    await sendStatus('running_v1');
    await sendLog('System Init: Topic="${topic}"');

    const searchResults = await searchAgent(topic, v1Seed);
    await sendLog(`Agent [Search] returned ${searchResults.length} results`);
    await sendSearchResults(searchResults, 'v1');

    const guidance = await insightAgent(topic, searchResults, v1Seed);
    await sendLog('Agent [Insight] generated guidance');

    const v1Content = await writerAgent(topic, searchResults, guidance, v1Seed);
    await sendContent(v1Content, 'v1');

    // 评估阶段
    await sendStatus('evaluating_v1');
    const v1Scores = await evaluationAgent(topic, v1Content);
    await sendScores(v1Scores, 'v1');

    // 进化阶段
    await sendStatus('evolving');
    const diagnosis = await diagnosticAgent(v1Scores, v1Seed);
    await sendDiagnosis(diagnosis);

    const v2Seed = await architectAgent(diagnosis, v1Seed);
    await sendSeed(v2Seed, 'v2');

    // V2阶段
    await sendStatus('running_v2');
    // ... V2执行流程

    await sendStatus('done');
    await close();
  })();

  return new Response(stream, {
    headers: {
      'Content-Type': 'text/event-stream',
      'Cache-Control': 'no-cache',
      'Connection': 'keep-alive',
    },
  });
}

// app/page.tsx
const startSimulation = async () => {
  const response = await fetch('/api/generate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ topic })
  });

  const reader = response.body?.getReader();
  const decoder = new TextDecoder();
  let buffer = '';
  let currentPhase: 'v1' | 'v2' = 'v1';

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;

    buffer += decoder.decode(value, { stream: true });
    const lines = buffer.split('\n\n');
    buffer = lines.pop() || '';

    for (const line of lines) {
      if (!line.startsWith('data: ')) continue;

      const event = JSON.parse(line.replace('data: ', ''));

      switch (event.type) {
        case 'status':
          setStatus(event.data);
          if (event.data === 'running_v2') currentPhase = 'v2';
          break;

        case 'log':
          if (currentPhase === 'v1') {
            setV1Logs(prev => [...prev, event.data]);
          } else {
            setV2Logs(prev => [...prev, event.data]);
          }
          break;

        case 'content':
          if (event.data.version === 'v1') {
            setV1Content(event.data.content);
          } else {
            setV2Content(event.data.content);
          }
          break;

        case 'scores':
          if (event.data.version === 'v1') {
            setV1Scores(event.data.scores);
          } else {
            setV2Scores(event.data.scores);
          }
          break;

        case 'diagnosis':
          setDiagnosis(event.data);
          break;

        case 'searchResults':
          if (event.data.version === 'v1') {
            setV1SearchResults(event.data.results);
          } else {
            setV2SearchResults(event.data.results);
          }
          break;
      }
    }
  }
};

const RadarChart = ({ v1Scores, v2Scores, showComparison }: Props) => {
  const size = 280;
  const center = size / 2;
  const radius = 90;
  const keys = Object.keys(v1Scores);
  const total = keys.length;
  const angleSlice = (Math.PI * 2) / total;

  const getCoordinates = (value: number, index: number) => {
    const angle = index * angleSlice - Math.PI / 2;
    return {
      x: center + radius * value * Math.cos(angle),
      y: center + radius * value * Math.sin(angle)
    };
  };

  // 绘制网格线
  const gridLevels = [0.2, 0.4, 0.6, 0.8, 1.0];

  return (
    <svg width={size} height={size}>
      {/* 绘制同心多边形网格 */}
      {gridLevels.map((level, idx) => (
        <polygon
          key={idx}
          points={keys.map((_, i) => {
            const { x, y } = getCoordinates(level, i);
            return `${x},${y}`;
          }).join(' ')}
          fill="none"
          stroke="#e5e7eb"
          strokeWidth="1"
        />
      ))}

      {/* V1数据多边形 */}
      <polygon
        points={keys.map((key, i) => {
          const { x, y } = getCoordinates(v1Scores[key].score, i);
          return `${x},${y}`;
        }).join(' ')}
        fill="rgba(59, 130, 246, 0.2)"
        stroke="#3b82f6"
        strokeWidth="2"
      />

      {/* V2数据多边形（对比模式） */}
      {showComparison && v2Scores && (
        <polygon
          points={keys.map((key, i) => {
            const { x, y } = getCoordinates(v2Scores[key].score, i);
            return `${x},${y}`;
          }).join(' ')}
          fill="rgba(249, 115, 22, 0.25)"
          stroke="#f97316"
          strokeWidth="2"
        />
      )}

      {/* 维度标签 */}
      {keys.map((key, i) => {
        const { x, y } = getCoordinates(1.25, i);
        return (
          <text key={i} x={x} y={y} textAnchor="middle" className="text-[10px] fill-gray-500">
            {key}
          </text>
        );
      })}
    </svg>
  );
};

const AgentLog = ({ logs, title }: { logs: LogItem[]; title: string }) => {
  const scrollRef = useRef<HTMLDivElement>(null);

  useEffect(() => {
    if (scrollRef.current) {
      scrollRef.current.scrollTop = scrollRef.current.scrollHeight;
    }
  }, [logs]);

  return (
    <div className="bg-[#1e1e1e] rounded-xl overflow-hidden border border-gray-700">
      <div className="bg-[#2d2d2d] px-4 py-2 flex items-center gap-2">
        <div className="w-3 h-3 rounded-full bg-[#ff5f56]"></div>
        <div className="w-3 h-3 rounded-full bg-[#ffbd2e]"></div>
        <div className="w-3 h-3 rounded-full bg-[#27c93f]"></div>
        <span className="ml-auto text-gray-500 text-xs">{title}</span>
      </div>

      <div ref={scrollRef} className="p-4 h-56 overflow-y-auto font-mono text-xs">
        {logs.map((log, idx) => (
          <div key={idx} className="flex gap-3">
            <span className="text-gray-500">[{log.time}]</span>
            <span className={
              log.type === 'error' ? 'text-red-400' :
              log.type === 'success' ? 'text-emerald-400' :
              log.type === 'warning' ? 'text-yellow-400' :
              'text-blue-300'
            }>
              {log.msg}
            </span>
          </div>
        ))}
      </div>
    </div>
  );
};

// AI根据诊断结果，完整重写提示词
newSeed.writingRequirements = await callDeepSeek(`
根据以下问题诊断，生成改进后的写作要求：
问题：${diagnosis.weakness}
原因：${diagnosis.reason}
建议：${diagnosis.mutation}
...
`);

while (!converged && generation < MAX_GENERATIONS) {
  const newDoc = await generateWithSeed(currentSeed);
  const scores = await evaluate(newDoc);

  if (scores.average > 0.90) {
    converged = true; // 收敛条件
  }

  currentSeed = await evolve(scores, currentSeed);
  generation++;
}

interface ExtendedSEED {
  // 当前参数
  searchDepth: number;
  sourceWhitelist: string[];
  focusDirective: string;
  writingRequirements: string;

  // 新增参数
  thinkingChain: boolean;           // 是否启用思维链
  multiModelEnsemble: string[];     // 多模型集成
  exampleDocuments: string[];       // Few-shot示例
  constraintRules: Rule[];          // 硬约束规则
  creativityBudget: number;         // 创造性预算
}