User Request
       ↓
  Orchestrator
  (Task Planning & Routing)
       ↓
   ┌───┼───┐
   ↓   ↓   ↓
Worker1 Worker2 Worker3
 (Search) (Write) (Review)
   ↓   ↓   ↓
   └───┴───┘
       ↓
  Orchestrator
  (Result Aggregation)
       ↓
  Final Response

from dataclasses import dataclass
from typing import List, Optional
import json

@dataclass
class Task:
    task_id: str
    task_type: str  # "search" | "write" | "review"
    input_data: dict
    priority: int = 0

class OrchestratorAgent:
    """编排器：负责任务规划和结果汇总"""

    def __init__(self, workers: dict):
        self.workers = workers  # {"search": SearchAgent(), "write": WriteAgent(), ...}

    def decompose(self, user_request: str) -> List[Task]:
        """将用户请求分解为子任务"""
        # 实际上这里可以调用 LLM 来做任务分解
        # 这里用简化的硬编码示例
        if "研究" in user_request or "分析" in user_request:
            return [
                Task(task_id="t1", task_type="research", 
                     input_data={"query": user_request}),
                Task(task_id="t2", task_type="summarize", 
                     input_data={"research_output": "<placeholder>"}),
            ]
        return [Task(task_id="t1", task_type="write", 
                     input_data={"topic": user_request})]

    def aggregate(self, results: List[dict]) -> str:
        """汇总 Worker 的输出"""
        # 简化版：直接拼接
        return "\n\n".join(r.get("output", "") for r in results)

    def run(self, user_request: str) -> str:
        tasks = self.decompose(user_request)

        # 并行执行所有 Worker
        results = []
        for task in tasks:
            worker = self.workers.get(task.task_type)
            if worker is None:
                results.append({"task_id": task.task_id, "error": f"Unknown task type: {task.task_type}"})
                continue
            result = worker.execute(task)
            results.append({"task_id": task.task_id, "output": result})

        return self.aggregate(results)


class ResearchAgent:
    """研究 Agent：负责信息检索"""

    def execute(self, task: Task) -> str:
        # 实际实现中，这里会调用搜索 API 或读取文档
        return f"Research completed for: {task.input_data['query']}"


class WriteAgent:
    """写作 Agent：负责内容生成"""

    def execute(self, task: Task) -> str:
        return f"Article draft on: {task.input_data['topic']}"

import random

class SupervisorAgent:
    """监督者：不做执行，只做判断"""

    def __init__(self, subagents: dict):
        self.subagents = subagents

    def decide_next_action(self, state: dict) -> str:
        """根据当前状态决定下一步"""
        context = state.get("context", "")
        history = state.get("history", [])

        # 简化版决策逻辑
        if len(history) == 0:
            return "classify_intent"
        elif len(history) == 1:
            return "gather_info"
        elif len(history) == 2:
            return "generate_response"
        else:
            return "finalize"

    def run(self, user_input: str, max_steps: int = 5) -> str:
        state = {"context": user_input, "history": [], "current_output": ""}

        for step in range(max_steps):
            action = self.decide_next_action(state)
            subagent = self.subagents.get(action)

            if subagent is None:
                break

            result = subagent.execute(state)
            state["history"].append(action)
            state["current_output"] = result

            # 监督者判断是否应该停止
            if action == "finalize":
                break

        return state["current_output"]


class ClassifyIntentAgent:
    def execute(self, state: dict) -> str:
        return f"Intent classified for: {state['context'][:50]}"


class GatherInfoAgent:
    def execute(self, state: dict) -> str:
        return "Relevant information gathered"


class GenerateResponseAgent:
    def execute(self, state: dict) -> str:
        return "Response draft generated"


class FinalizeAgent:
    def execute(self, state: dict) -> str:
        return "Final response ready to deliver"

Agent A ←──→ Agent B
   ↓            ↓
   → Agent C ←──

# ❌ 错误设计：一个 Agent 处理所有事
class BadBlogAssistant:
    def run(self, topic: str):
        # 同时做搜索、大纲、写作、编辑
        info = self.search(topic)
        outline = self.make_outline(info)
        draft = self.write(outline)
        final = self.edit(draft)
        return final

# ✅ 正确设计：各司其职的 Agent 团队
from dataclasses import dataclass
from typing import List

@dataclass
class ArticleRequest:
    topic: str
    target_audience: str = "developers"
    style: str = "technical"

@dataclass
class ResearchOutput:
    key_points: List[str]
    sources: List[str]
    quality_score: float  # 0-1

@dataclass
class OutlineOutput:
    sections: List[dict]  # [{"title": "...", "key_points": [...]}]
    reading_time_minutes: int

@dataclass
class DraftOutput:
    content: str
    word_count: int
    tone_assessment: str

@dataclass
class ReviewOutput:
    issues: List[str]
    suggestions: List[str]
    overall_score: float


class MaterialCollectorAgent:
    """资料收集 Agent"""

    def __init__(self):
        self.name = "material_collector"

    def research(self, topic: str) -> ResearchOutput:
        # 实际实现中，调用搜索 API、阅读文档
        return ResearchOutput(
            key_points=[f"核心概念A关于{topic}", f"核心概念B关于{topic}"],
            sources=["source1", "source2"],
            quality_score=0.85
        )


class OutlinerAgent:
    """大纲生成 Agent"""

    def __init__(self):
        self.name = "outliner"

    def create_outline(self, research: ResearchOutput, 
                       audience: str) -> OutlineOutput:
        sections = [
            {"title": "背景与问题", "key_points": research.key_points[:2]},
            {"title": "核心原理", "key_points": ["原理1", "原理2"]},
            {"title": "实战案例", "key_points": ["案例展示"]},
            {"title": "总结与建议", "key_points": ["关键结论"]}
        ]
        return OutlineOutput(
            sections=sections,
            reading_time_minutes=15
        )


class WriterAgent:
    """写作 Agent"""

    def __init__(self):
        self.name = "writer"

    def write(self, outline: OutlineOutput, 
              style: str) -> DraftOutput:
        content_lines = [f"## {s['title']}" for s in outline.sections]
        content = "\n\n".join(content_lines)
        return DraftOutput(
            content=content,
            word_count=3000,
            tone_assessment=style
        )


class ReviewerAgent:
    """审稿 Agent"""

    def __init__(self):
        self.name = "reviewer"

    def review(self, draft: DraftOutput, 
               outline: OutlineOutput) -> ReviewOutput:
        issues = []
        suggestions = ["建议增加代码示例", "第二部分可以更深入"]

        # 大纲覆盖率检查
        outline_titles = {s["title"] for s in outline.sections}
        return ReviewOutput(
            issues=issues,
            suggestions=suggestions,
            overall_score=0.78
        )


class TeamLeadAgent:
    """团队负责人：协调整个工作流"""

    def __init__(self):
        self.material_collector = MaterialCollectorAgent()
        self.outliner = OutlinerAgent()
        self.writer = WriterAgent()
        self.reviewer = ReviewerAgent()

    def run(self, request: ArticleRequest) -> dict:
        # Step 1: 资料收集
        research = self.material_collector.research(request.topic)

        # Step 2: 生成大纲（可并行验证资料质量）
        outline = self.outliner.create_outline(research, request.target_audience)

        # Step 3: 写作初稿
        draft = self.writer.write(outline, request.style)

        # Step 4: 审稿
        review = self.reviewer.review(draft, outline)

        # Step 5: 如果审稿分数不够，返回修改建议
        if review.overall_score < 0.8:
            # 这里可以增加回退到步骤3重新写作的逻辑
            pass

        return {
            "draft": draft.content,
            "outline": outline.sections,
            "review": review,
            "reading_time": outline.reading_time_minutes
        }

def run_with_quality_gates(self, request: ArticleRequest) -> dict:
    # 资料质量检查
    research = self.material_collector.research(request.topic)
    if research.quality_score < 0.7:
        return {"error": "资料不足，需要人工介入"}

    # 大纲质量检查
    outline = self.outliner.create_outline(research, request.target_audience)
    if len(outline.sections) < 3:
        return {"error": "大纲生成异常"}

    # ...后续步骤