# 七种协议的核心伪代码对比
protocols = {
    # 投票类 - 独立表态后统计
    "majority_vote": lambda agents: mode([a.decide() for a in agents]),
    "plurality_vote": lambda agents: max(set([a.decide() for a in agents]), 
                                          key=[a.decide() for a in agents].count),
    "unanimous_vote": lambda agents: a[0].decide() if len(
        set([a.decide() for a in agents])) == 1 else "NO_CONSENSUS",

    # 共识类 - 多轮协商
    "consensus_proposal": lambda agents: deliberation_rounds(
        agents, rounds=3, mode="proposal"),
    "consensus_rotating": lambda agents: deliberation_rounds(
        agents, rounds=3, mode="rotating_chair"),
    "consensus_merge": lambda agents: deliberation_rounds(
        agents, rounds=3, mode="incremental_merge"),
    "consensus_debate": lambda agents: deliberation_rounds(
        agents, rounds=3, mode="structured_debate"),
}

┌─────────────────────────────────────┐
│          AgentShield 架构            │
├─────────────────────────────────────┤
│  Layer 3: 共识验证层                │
│  ├─ 加权拜占庭容错 (WBFT)           │
│  ├─ 可信度评分 < 0.6 的Agent降权    │
│  └─ 最终共识需 2f+1/f 确认          │
├─────────────────────────────────────┤
│  Layer 2: 异常检测层                │
│  ├─ 输出一致性校验                  │
│  ├─ 语义偏差检测 (embedding距离)     │
│  └─ 时序行为异常检测                │
├─────────────────────────────────────┤
│  Layer 1: 输入净化层                │
│  ├─ Prompt注入检测                  │
│  ├─ 上下文完整性验证                │
│  └─ 工具调用参数校验                │
└─────────────────────────────────────┘

class WBFTConsensus:
    """加权拜占庭容错共识引擎"""
    def __init__(self, agents, fault_tolerance=1):
        self.agents = agents
        self.f = fault_tolerance  # 可容忍的叛徒数
        self.credibility = {a.id: 1.0 for a in agents}

    def reach_consensus(self, question):
        responses = {}
        for agent in self.agents:
            responses[agent.id] = agent.query(question)

        # Step 1: 语义聚类，找出主流意见
        clusters = semantic_cluster(responses)

        # Step 2: 按可信度加权投票
        weighted_votes = {}
        for cluster_id, members in clusters.items():
            weight = sum(self.credibility[a.id] for a in members)
            weighted_votes[cluster_id] = weight

        # Step 3: 需要 2f+1 总权重的确认
        total_weight = sum(self.credibility.values())
        winner = max(weighted_votes, key=weighted_votes.get)

        if weighted_votes[winner] >= (2 * self.f + 1) / (len(self.agents) + self.f) * total_weight:
            # 更新可信度：与共识一致的Agent加分
            for agent in self.agents:
                if agent.id in clusters[winner]:
                    self.credibility[agent.id] = min(1.0, 
                        self.credibility[agent.id] + 0.05)
                else:
                    self.credibility[agent.id] = max(0.1, 
                        self.credibility[agent.id] - 0.15)
            return clusters[winner][0].response

        return "NO_CONSENSUS"  # 无法达成共识

class RoMaCredibilityGraph:
    """RoMa可信度图谱"""
    def __init__(self):
        self.trust_graph = nx.DiGraph()
        self.domain_expertise = {}  # {agent_id: {domain: score}}

    def evaluate_response(self, agent_id, response, domain):
        """综合评估Agent响应的可信度"""
        scores = []

        # 维度1: 领域专业度
        domain_score = self.domain_expertise.get(agent_id, {}).get(domain, 0.5)
        scores.append(domain_score * 0.3)

        # 维度2: 历史准确率（滑动窗口）
        history = self.get_recent_accuracy(agent_id, window=20)
        scores.append(history * 0.3)

        # 维度3: 群体一致性（与其他Agent的语义相似度）
        consistency = self.compute_peer_consistency(agent_id, response)
        scores.append(consistency * 0.2)

        # 维度4: 自评置信度的校准度
        calibration = self.compute_calibration(agent_id)
        scores.append(calibration * 0.2)

        return sum(scores)  # 0-1的综合可信度

flowchart TD
    A[提出议题] --> B[第一轮: 自由发言]
    B --> C{所有Agent意见一致?}
    C -->|是| D[全员共识达成]
    C -->|否| E[第二轮: 分级审议]
    E --> F[每个Agent对其他方案评级<br/>grade: 0/1/2]
    F --> G{存在grade≥2的方案?}
    G -->|是| H[选择最高评级方案]
    G -->|否| I[第三轮: 主持人裁决]
    I --> J[轮值主持人提出折中方案]
    J --> K{全员接受?}
    K -->|是| D
    K -->|否| L[标记为无法共识<br/>触发人工介入]
    H --> M[进入确定性验证]
    M --> D

class SymphonyBeacon:
    """Symphony信标机制 - 去中心化任务发现"""
    def __init__(self, agent_id, capabilities):
        self.agent_id = agent_id
        self.capabilities = capabilities
        self.beacon_interval = 5  # 秒

    def broadcast_beacon(self):
        """广播能力信标"""
        beacon = {
            "agent_id": self.agent_id,
            "capabilities": self.capabilities,
            "current_load": self.get_current_load(),
            "timestamp": time.time(),
            "ttl": 30  # 信标存活时间
        }
        # 基于Gossip协议扩散
        self.gossip_broadcast(beacon)

    def on_task_announced(self, task):
        """任务发布时的自组织响应"""
        my_score = self.compute_fitness(task)
        if my_score > self.score_threshold:
            self.bid_for_task(task, my_score)

    def compute_fitness(self, task):
        """计算自身对任务的适配度"""
        cap_match = len(set(self.capabilities) & set(task.required_caps))
        load_factor = 1.0 - (self.current_load / self.max_load)
        return cap_match * load_factor

class MAGMAMemory:
    """MAGMA多图记忆系统"""
    def __init__(self, neo4j_uri):
        self.driver = GraphDatabase.driver(neo4j_uri)
        # 四层图结构
        self.graphs = {
            "episodic": EpisodicGraph(),    # 事件经历图
            "semantic": SemanticGraph(),     # 语义知识图  
            "procedural": ProceduralGraph(), # 过程技能图
            "social": SocialGraph()          # 社交关系图
        }

    def write_memory(self, agent_id, memory_type, content):
        """Agent写入记忆"""
        graph = self.graphs[memory_type]
        # 跨图链接：自动建立 episodic <-> semantic <-> procedural 映射
        graph.add_node(agent_id=agent_id, content=content)
        self.cross_link_memories(agent_id, content)

    def read_for_consensus(self, topic):
        """为共识准备共享上下文"""
        shared_context = {}
        for gtype, graph in self.graphs.items():
            shared_context[gtype] = graph.query(topic)
        return shared_context

    def cross_link_memories(self, agent_id, content):
        """跨图链接 - MAGMA的核心创新"""
        # 将新事件与已有语义知识关联
        related_semantics = self.graphs["semantic"].find_related(content)
        for sem in related_semantics:
            self.create_edge("episodic", content, "sem", sem)

        # 更新社交图谱 - 记录Agent之间的知识交互
        collaborating_agents = self.find_collaborators(content)
        for other_agent in collaborating_agents:
            self.graphs["social"].strengthen_tie(agent_id, other_agent)

from mahilo import MultiAgentFramework, Agent, HumanAgent

# 创建多Agent系统
framework = MultiAgentFramework()

# 创建专业Agent
research_agent = Agent(
    name="Researcher",
    description="数据研究和分析专家",
    tools=[web_search, data_analyzer]
)
legal_agent = Agent(
    name="LegalAdvisor", 
    description="法律合规审查专家",
    tools=[contract_reviewer, regulation_search]
)
finance_agent = Agent(
    name="FinancialAnalyst",
    description="财务风险评估专家",
    tools=[risk_calculator, market_analyzer]
)

# 创建人类Agent - 与AI Agent平等参与
human = HumanAgent(
    name="DecisionMaker",
    role="最终决策者",
    can_override=True,  # 可以推翻Agent共识
    notification_channel="slack"  # 实时接收Agent讨论
)

# 注册所有Agent
framework.register([research_agent, legal_agent, finance_agent, human])

# 设置共识规则：高风险决策必须人类确认
framework.set_consensus_rule(
    rule="HIGH_RISK",
    mechanism="consensus_with_human_veto",
    threshold=0.8,  # Agent共识度需达80%
    human_veto_power="absolute"  # 人类拥有一票否决权
)

# 执行任务
result = framework.execute(
    task="评估收购公司X的风险和收益",
    consensus_rule="HIGH_RISK"
)

{
  "agent_card": {
    "name": "FinancialRiskAnalyzer",
    "description": "评估投资组合风险暴露",
    "capabilities": ["risk_analysis", "portfolio_optimization"],
    "endpoint": "https://api.example.com/a2a/financial-risk",
    "authentication": {"type": "oauth2", "scope": "risk:read"},
    "protocols": ["a2a/v1.0"],
    "input_schema": {
      "type": "object",
      "properties": {
        "portfolio": {"type": "array"},
        "timeframe": {"type": "string"}
      }
    },
    "output_schema": {
      "type": "object", 
      "properties": {
        "risk_score": {"type": "number"},
        "recommendations": {"type": "array"}
      }
    }
  }
}

flowchart TD
    A[多Agent决策需求] --> B{Agent数量?}
    B -->|3-7个| C{需要容错吗?}
    B -->|10+个| D{有中心编排器吗?}
    B -->|3-5个高风险| E{需要人类介入吗?}

    C -->|是| F[AgentShield WBFT]
    C -->|否| G{任务类型?}
    G -->|推理型| H[多数投票协议]
    G -->|创意型| I[共识融合协议]

    D -->|是| J[传统编排+共识]
    D -->|否| K[Symphony去中心化]

    E -->|是| L[mahilo人在环中]
    E -->|否| M[全员共识协议]

    F --> N{需要共享记忆吗?}
    H --> N
    I --> N
    N -->|是| O[+ MAGMA多图记忆]
    N -->|否| P[独立记忆基线]

    K --> Q{需要跨框架互操作?}
    Q -->|是| R[+ A2A协议]
    Q -->|否| S[封闭系统]