# 简单多数投票实现
from collections import Counter

def majority_vote(responses: list[str]) -> str:
    """多Agent多数投票"""
    vote_counts = Counter(responses)
    winner, count = vote_counts.most_common(1)[0]
    confidence = count / len(responses)
    return winner, confidence

# 加权投票：根据Agent历史准确率赋权
def weighted_vote(responses: list[str], weights: list[float]) -> str:
    """加权投票"""
    score = {}
    for resp, w in zip(responses, weights):
        score[resp] = score.get(resp, 0) + w
    return max(score, key=score.get)

# MAD结构化辩论核心循环
class DebateRound:
    def __init__(self, agents, max_rounds=3):
        self.agents = agents
        self.max_rounds = max_rounds

    def run(self, question):
        arguments = {}
        for rnd in range(self.max_rounds):
            for agent in self.agents:
                # 每个Agent看到其他Agent的论点后重新推理
                context = self._build_context(arguments, exclude=agent.id)
                arguments[agent.id] = agent.deliberate(question, context)

            # 早期停止：如果达成共识则终止
            if self._consensus_reached(arguments):
                break
        return self._aggregate(arguments)

    def _consensus_reached(self, arguments):
        answers = [a.conclusion for a in arguments.values()]
        return max(Counter(answers).values()) > len(self.agents) * 0.6

# CONSENSAGENT早期停止 + 置信度聚合
class ConsensusProtocol:
    def __init__(self, agents, consensus_threshold=0.7):
        self.agents = agents
        self.threshold = consensus_threshold

    def deliberate(self, query):
        round_history = []
        for rnd in range(10):  # 最多10轮
            responses = [a.respond(query, round_history) for a in self.agents]

            # 计算共识度
            agreement = self._calc_agreement(responses)
            round_history.append(responses)

            if agreement >= self.threshold:
                return self._final_decision(responses), rnd + 1

        # 未达共识，取加权结果
        return self._final_decision(responses), 10

    def _calc_agreement(self, responses):
        """基于语义相似度的共识度量"""
        embeddings = [embed(r.answer) for r in responses]
        pairwise_sim = cosine_similarity(embeddings)
        return pairwise_sim.mean()

graph TB
    Q[用户查询] --> R1[GPT-4o<br/>推理者1]
    Q --> R2[Claude Opus<br/>推理者2]
    Q --> R3[Gemini Ultra<br/>推理者3]
    R1 --> CM[共识模型<br/>Consensus Model]
    R2 --> CM
    R3 --> CM
    CM --> C{共识达成?}
    C -->|是| F[最终答案<br/>置信度≥0.8]
    C -->|否| D[追加轮次<br/>定向质疑]
    D --> R1
    D --> R2
    D --> R3

# CP-WBFT 核心逻辑简化
class CP_WBFT:
    """置信度探针加权拜占庭容错共识"""

    def __init__(self, agents, f=None):
        self.agents = agents
        self.f = f or len(agents) // 3  # 容忍的拜占庭节点数

    def consensus(self, query):
        # Phase 1: 置信度探针
        probes = []
        for agent in self.agents:
            answer = agent.respond(query)
            confidence = agent.probe_confidence(query, answer)
            probes.append((answer, confidence))

        # Phase 2: 交叉验证
        cross_validations = {}
        for i, (ans_i, conf_i) in enumerate(probes):
            for j, (ans_j, conf_j) in enumerate(probes):
                if i != j:
                    agree = semantic_match(ans_i, ans_j)
                    cross_validations[(i,j)] = agree

        # Phase 3: 权重计算
        weights = self._compute_weights(probes, cross_validations)

        # Phase 4: 加权共识
        answer_scores = {}
        for i, (ans, conf) in enumerate(probes):
            answer_scores[ans] = answer_scores.get(ans, 0) + weights[i]

        return max(answer_scores, key=answer_scores.get)

    def _compute_weights(self, probes, cross_validations):
        """基于置信度和交叉验证计算权重"""
        weights = []
        for i in range(len(probes)):
            conf = probes[i][1]
            # 被其他Agent支持的程度
            support_rate = sum(
                1 for j in range(len(probes)) 
                if j != i and cross_validations.get((j,i), False)
            ) / (len(probes) - 1)
            weights.append(conf * 0.4 + support_rate * 0.6)
        return weights

# SwarmAgentic 启发式共识（简化）
class SwarmConsensus:
    """群体智能共识 - 无中央协调器"""

    def __init__(self, agents, pheromone_decay=0.85):
        self.agents = agents
        self.decay = pheromone_decay
        self.pheromones = {}  # answer -> strength

    def evolve(self, query, iterations=20):
        # 初始化：每个Agent独立回答
        positions = {a.id: a.respond(query) for a in self.agents}

        for t in range(iterations):
            new_positions = {}
            for agent in self.agents:
                # 获取邻居状态
                neighbors = self._get_neighbors(agent.id)
                neighbor_answers = [positions[n] for n in neighbors]

                # 信息素更新
                self._update_pheromones(neighbor_answers)

                # Agent根据信息素和自身判断调整立场
                best_attracted = max(
                    set(neighbor_answers + [positions[agent.id]]),
                    key=lambda a: self.pheromones.get(a, 0)
                )

                # 以概率切换到信息素最强的答案
                if random() < self._attraction_prob(agent, best_attracted):
                    new_positions[agent.id] = best_attracted
                else:
                    new_positions[agent.id] = positions[agent.id]

            positions = new_positions

            # 检查全局收敛
            if self._convergence(positions) > 0.9:
                break

        return self._extract_consensus(positions)

graph TD
    START[多Agent决策需求] --> Q1{Agent来源?}
    Q1 -->|同模型多实例| Q2{任务类型?}
    Q1 -->|多模型异构| Q4{有恶意Agent风险?}
    Q1 -->|大规模群体≥10| L6[L6 群体智能]

    Q2 -->|推理/数学| L2[L2 多轮辩论]
    Q2 -->|分类/选择| L1[L1 简单投票]
    Q2 -->|多步推理| L3[L3 共识协议]

    Q4 -->|是, 高风险场景| L5[L5 拜占庭容错]
    Q4 -->|否, 追求低幻觉| L4[L4 异构委员会]

    L1 --> E1[成本1-3x<br/>即开即用]
    L2 --> E2[成本5-15x<br/>2-3轮最优]
    L3 --> E3[成本3-8x<br/>早期停止]
    L4 --> E4[成本4.2x<br/>幻觉-36%]
    L5 --> E5[成本3-6x<br/>容忍f个拜占庭]
    L6 --> E6[成本变量<br/>自组织]