from langgraph.graph import StateGraph, MessagesState, START, END
from langgraph.types import Command

def supervisor(state: MessagesState) -> Command:
    """主管路由：分析最后一条消息，决定分发给谁"""
    last_msg = state["messages"][-1].content
    if "代码" in last_msg or "bug" in last_msg:
        return Command(goto="coder")
    elif "分析" in last_msg or "数据" in last_msg:
        return Command(goto="analyst")
    else:
        return Command(goto="responder")

builder = StateGraph(MessagesState)
builder.add_node("supervisor", supervisor)
builder.add_node("coder", coder_agent)
builder.add_node("analyst", analyst_agent)
builder.add_node("responder", responder_agent)
builder.add_edge(START, "supervisor")
builder.add_edge("coder", "supervisor")
builder.add_edge("analyst", "supervisor")
builder.add_edge("responder", END)
graph = builder.compile()

from crewai import Agent, Task, Crew, Process

researcher = Agent(role="Researcher", goal="Gather information",
                   backstory="Expert researcher", llm="gpt-4.1")
writer = Agent(role="Writer", goal="Write article",
               backstory="Professional writer", llm="gpt-4.1")
editor = Agent(role="Editor", goal="Review and polish",
               backstory="Senior editor", llm="claude-sonnet-4-6")

research_task = Task(description="Research {topic}", agent=researcher,
                     expected_output="Research notes with sources")
write_task = Task(description="Write article from research",
                  agent=writer, expected_output="Draft article")
edit_task = Task(description="Edit and finalize", agent=editor,
                 expected_output="Final article")

crew = Crew(agents=[researcher, writer, editor],
            tasks=[research_task, write_task, edit_task],
            process=Process.sequential)
result = crew.kickoff(inputs={"topic": "Multi-Agent Architecture 2026"})

# 1. 黑板：结构化共享状态空间
class Blackboard:
    def __init__(self):
        self.state = {}           # 全局状态字典
        self.history = []         # 版本历史，支持回滚
        self.lock = asyncio.Lock() # 并发写入锁

    async def write(self, agent_id: str, key: str, value: Any):
        async with self.lock:
            version = len(self.history)
            self.history.append({
                "version": version, "agent": agent_id,
                "key": key, "old_value": self.state.get(key),
                "new_value": value, "timestamp": time.time()
            })
            self.state[key] = value

# 2. 控制器：调度策略
class Controller:
    def __init__(self, agents, blackboard):
        self.agents = agents
        self.bb = blackboard

    async def run(self, max_iterations=20):
        for _ in range(max_iterations):
            # 评估每个Agent的贡献意愿
            contributions = []
            for agent in self.agents:
                score = await agent.evaluate(self.bb.state)
                contributions.append((score, agent))
            contributions.sort(reverse=True)

            if contributions[0][0] < THRESHOLD:
                break  # 没有Agent愿意贡献，结束

            best_agent = contributions[0][1]
            await best_agent.execute(self.bb)  # 执行并更新黑板

# 3. 专家Agent
class ExpertAgent:
    def __init__(self, specialty, llm):
        self.specialty = specialty
        self.llm = llm

    async def evaluate(self, state):
        """评估自己能否对当前状态做出有价值的贡献"""
        prompt = f"Given current state: {json.dumps(state)}, 
                  can you contribute as {self.specialty}? Score 0-1."
        return float(await self.llm.invoke(prompt))

# workflow.yaml - Conductor声明式DAG定义
name: code-review-pipeline
steps:
  - id: security-scan
    agent: security-reviewer
    prompt: "Review for security vulnerabilities: {code}"

  - id: style-check
    agent: style-reviewer
    prompt: "Check coding style: {code}"

  - id: perf-analysis
    agent: perf-reviewer
    prompt: "Analyze performance implications: {code}"

  - id: synthesize
    agent: lead-reviewer
    depends_on: [security-scan, style-check, perf-analysis]
    prompt: |
      Combine these reviews into actionable feedback:
      Security: {security-scan.output}
      Style: {style-check.output}
      Performance: {perf-analysis.output}

graph TB
    subgraph "多Agent编排六拓扑"
        SW["Supervisor-Worker<br/>中心路由分发"]
        HI["Hierarchical<br/>多级层级委派"]
        PL["Pipeline<br/>线性/分支流水线"]
        BB["Blackboard<br/>共享状态空间"]
        SC["Swarm Consensus<br/>去中心化投票/辩论"]
        DA["DAG Workflow<br/>声明式依赖图"]
    end

    subgraph "跨Agent通信协议"
        A2A["A2A Protocol v1.0<br/>Agent间互操作"]
        MCP["MCP<br/>Agent到工具/数据"]
    end

    subgraph "持久化与执行引擎"
        LG["LangGraph<br/>图状态机"]
        TM["Temporal<br/>持久工作流"]
        IN["Inngest<br/>事件驱动"]
        CD["Conductor<br/>确定性DAG CLI"]
    end

    subgraph "状态管理"
        OPT["乐观锁<br/>版本号并发控制"]
        CHK["检查点<br/>DAG节点级快照"]
        EMB["嵌入向量<br/>语义状态检索"]
    end

    SW --> A2A
    HI --> A2A
    BB --> MCP
    SC --> A2A
    DA --> CD
    DA --> TM

    SW --> OPT
    BB --> OPT
    DA --> CHK

    A2A -.->|"互补"| MCP
    LG --> CHK
    TM --> CHK

graph TD
    START[多Agent编排选型] --> Q1{任务是否需要<br/>迭代/反馈？}
    Q1 -->|否| Q2{步骤间是否有<br/>明确依赖关系？}
    Q1 -->|是| Q3{反馈需要几个<br/>Agent参与？}

    Q2 -->|线性顺序| PL[Pipeline<br/>CrewAI Sequential<br/>确定性最高]
    Q2 -->|有依赖图| DA[DAG Workflow<br/>LangGraph / Conductor<br/>并行执行无依赖节点]
    Q2 -->|需要路由| SW[Supervisor-Worker<br/>LangGraph / OpenAI Agents<br/>最成熟的生产模式]

    Q3 -->|1对1反馈| PL2[Pipeline+反馈环<br/>最大重试3次]
    Q3 -->|多Agent协作<br/>构建同一产物| BB[Blackboard<br/>自建 / agent-blackboard<br/>并行写入+版本控制]
    Q3 -->|需要达成<br/>共识决策| SC[Swarm Consensus<br/>AutoGen / 自建<br/>Token消耗最高]

    Q3 -->|需要多级<br/>任务分解| HI[Hierarchical<br/>AutoGen NestedChat<br/>3层以上适用]