# LangGraph Supervisor模式核心代码（2026最新API）
from langgraph_supervisor import create_supervisor
from langchain_openai import ChatOpenAI

model = ChatOpenAI(model="gpt-4.1")

# 定义专业Worker Agent
research_agent = Agent(
    name="researcher",
    instructions="你负责信息检索和事实核查",
    tools=[search_tool, web_scraper]
)
writer_agent = Agent(
    name="writer", 
    instructions="你负责基于研究结果撰写文章",
    tools=[write_tool]
)
qa_agent = Agent(
    name="qa_reviewer",
    instructions="你负责质量审核和事实校验",
    tools=[fact_check_tool]
)

# Supervisor自动编排三个Worker
supervisor = create_supervisor(
    agents=[research_agent, writer_agent, qa_agent],
    model=model,
    prompt="你是主编，协调研究→写作→审核流程"
).compile()

# LangGraph 分层Supervisor（两层示例）
from langgraph_supervisor import create_supervisor

# 第一层：技术VP
tech_lead = create_supervisor(
    agents=[backend_agent, frontend_agent, devops_agent],
    model=model,
    prompt="你是技术总监，分配开发任务"
).compile()

# 第一层：内容VP  
content_lead = create_supervisor(
    agents=[research_agent, writer_agent, designer_agent],
    model=model,
    prompt="你是内容总监，管理内容生产"
).compile()

# 第二层：CEO
ceo = create_supervisor(
    agents=[tech_lead, content_lead],
    model=model,
    prompt="你是CEO，协调技术和内容两条业务线"
).compile()

# OpenAI Agents SDK Handoff模式
from agents import Agent, Runner, handoff

triage_agent = Agent(
    name="triage",
    instructions="""你是客服分诊Agent。根据用户问题类型，
    交接给对应的专业Agent。""",
    handoffs=[
        handoff(billing_agent, 
                condition="用户询问账单或付费问题"),
        handoff(tech_support_agent,
                condition="用户报告技术故障"),
        handoff(escalation_agent,
                condition="用户情绪激动或要求投诉"),
    ]
)

result = await Runner.run(triage_agent, "我的账单多扣了50块")
# triage → billing_agent → (解决后返回triage)

# Router模式实现
class AgentRouter:
    def __init__(self):
        self.registry = {
            "code": code_agent,      # 代码生成
            "data": data_agent,       # 数据分析
            "doc": doc_agent,         # 文档处理
            "chat": general_agent,    # 通用对话
        }

    async def route(self, query: str):
        intent = await classify_intent(query)
        agent = self.registry.get(intent.category, general_agent)
        return await agent.run(query)

router = AgentRouter()
result = await router.route("帮我分析这份销售数据的趋势")

# OpenAI Agents SDK Swarm风格编排
from agents import Agent, Runner

analyst = Agent(
    name="data_analyst",
    instructions="分析数据并生成洞察。需要可视化时交接给designer。",
    tools=[sql_query, statistical_analysis],
    handoffs=[handoff(designer)]
)

designer = Agent(
    name="visual_designer", 
    instructions="根据分析结果创建图表。需要更多数据时交接回analyst。",
    tools=[create_chart, generate_report],
    handoffs=[handoff(analyst)]
)

# 无中心调度，Agent之间自由交接
result = await Runner.run(
    starting_agent=analyst,
    input="分析Q1销售数据并制作可视化报告"
)
# 可能的路径: analyst → designer → analyst → designer → done

# Blackboard模式实现
from dataclasses import dataclass, field

@dataclass
class Blackboard:
    """共享知识空间"""
    facts: dict = field(default_factory=dict)
    hypotheses: list = field(default_factory=list)
    evidence: list = field(default_factory=list)
    confidence: float = 0.0
    solved: bool = False

class BlackboardController:
    def __init__(self, agents, blackboard):
        self.agents = agents
        self.bb = blackboard

    async def run(self, problem):
        self.bb.facts["problem"] = problem
        max_rounds = 10

        for round in range(max_rounds):
            if self.bb.solved:
                break
            for agent in self.agents:
                contribution = await agent.contribute(self.bb)
                self._merge(contribution)
                if self.bb.confidence >= 0.85:
                    self.bb.solved = True
                    break
        return self.bb

// A2A Agent Card（v1.0规范）
{
  "schemaVersion": "1.0",
  "name": "FinancialAnalysisAgent",
  "description": "企业财务分析专家，支持财报解读和风险评估",
  "url": "https://agents.corp.example.com/finance",
  "capabilities": {
    "financial_report_analysis": {},
    "risk_assessment": {},
    "market_prediction": {}
  },
  "authentication": {
    "schemes": ["bearer_token"]
  },
  "defaultInputModes": ["text", "file"],
  "defaultOutputModes": ["text", "file"]
}

# A2A协议下的Mesh通信
from a2a.client import A2AClient

# Agent发现：查询能做财务分析的Agent
client = A2AClient()
agents = await client.discover(
    capability="financial_report_analysis"
)

# 直接与远程Agent建立任务
task = await client.send_task(
    agent_url=agents[0].url,
    message="分析苹果公司2025年Q4财报",
    context_id="session-12345"
)

# 轮询任务状态（A2A v1.0支持5种任务状态）
# submitted → working → completed / failed / cancelled
while task.status.state == "working":
    task = await client.get_task(task.id)

sequenceDiagram
    participant Client as Client Agent
    participant Remote as Remote Agent

    Client->>Remote: 1. 读取Agent Card (GET /.well-known/agent.json)
    Remote-->>Client: Agent Card (能力描述)

    Client->>Remote: 2. 发送任务 (tasks/send)
    Remote-->>Client: Task (status: working)

    alt 长时间任务
        Remote-->>Client: 3. Push Notification (进度更新)
    else 多轮交互
        Client->>Remote: 4. 继续任务 (tasks/send + context_id)
        Remote-->>Client: Task (status: working)
    end

    Remote-->>Client: 5. 任务完成 (status: completed)
    Note over Client,Remote: Task.artifacts 包含最终产出

# 多Agent辩论系统
class MultiAgentDebate:
    def __init__(self, agents, rounds=3):
        self.agents = agents
        self.rounds = rounds

    async def debate(self, question):
        positions = {}

        for round in range(self.rounds):
            for agent in self.agents:
                # 每个Agent看到其他Agent的论点后更新自己的立场
                context = f"问题: {question}\n"
                context += f"其他Agent的观点: {positions}\n"
                context += "请给出你的分析和论点。"

                response = await agent.run(context)
                positions[agent.name] = response

        # 最终裁决
        verdict = await judge_agent.run(
            f"基于以上辩论:\n{positions}\n给出最终结论。"
        )
        return verdict

flowchart TD
    A[需求分析] --> B{Agent数量?}
    B -->|2-4个| C{需要中心控制?}
    B -->|5-10个| D{跨组织?}
    B -->|10+个| E{Mesh + A2A}

    C -->|是| F{流程固定?}
    C -->|否| G[Swarm模式]

    F -->|是| H[Supervisor模式]
    F -->|否| I[Handoff模式]

    D -->|否| J{需要共享推理?}
    D -->|是| E

    J -->|是| K[Blackboard模式]
    J -->|否| L{需要多层级?}

    L -->|是| M[Hierarchical模式]
    L -->|否| N[Router模式]

    style E fill:#e1f5fe
    style G fill:#fff3e0
    style H fill:#e8f5e9
    style K fill:#fce4ec