Multi-Agent Debate

from dataclasses import dataclass, field
from openai import OpenAI

client = OpenAI()

DEBATE_SYSTEM = """Ты — участник дебатов. Решаешь задачу и обсуждаешь с другими агентами.

Правила:
1. Дай свой ответ с подробным рассуждением
2. Если видишь ответы других — проанализируй их аргументы
3. Если находишь ошибку в чужом рассуждении — укажи конкретно
4. Если твой ответ был неверен — признай и исправь
5. Не соглашайся просто потому, что большинство так считает — нужны аргументы"""


@dataclass
class DebateAgent:
    """Один агент в дебатах."""
    id: int
    model: str = "gpt-4o"
    temperature: float = 0.7
    history: list[str] = field(default_factory=list)

    def respond(self, task: str, other_responses: list[str] | None = None) -> str:
        """Сгенерировать ответ (первый раунд или пересмотр)."""
        if other_responses:
            others_text = "\n\n".join(
                f"Агент {i+1}: {r}" for i, r in enumerate(other_responses)
            )
            prompt = (
                f"Задача: {task}\n\n"
                f"Ответы других агентов:\n{others_text}\n\n"
                f"Твой предыдущий ответ: {self.history[-1]}\n\n"
                f"Пересмотри свой ответ с учётом аргументов других. "
                f"Если считаешь, что прав — аргументируй."
            )
        else:
            prompt = f"Задача: {task}"

        resp = client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": DEBATE_SYSTEM},
                {"role": "user", "content": prompt}
            ],
            temperature=self.temperature
        )
        answer = resp.choices[0].message.content.strip()
        self.history.append(answer)
        return answer


def extract_final_answer(response: str) -> str:
    """Извлечь финальный ответ из рассуждения."""
    for marker in ["Ответ:", "Final answer:", "Итого:", "**Ответ"]:
        if marker.lower() in response.lower():
            idx = response.lower().index(marker.lower())
            return response[idx:].split("\n")[0].strip()
    # Последнее предложение
    return response.strip().split("\n")[-1].strip()


def check_consensus(responses: list[str]) -> bool:
    """Проверить, совпадают ли финальные ответы."""
    answers = [extract_final_answer(r) for r in responses]
    return len(set(answers)) == 1


def multi_agent_debate(
    task: str,
    n_agents: int = 3,
    max_rounds: int = 4,
    models: list[str] | None = None
) -> dict:
    """Полный цикл мультиагентных дебатов."""
    if models is None:
        models = ["gpt-4o"] * n_agents

    agents = [
        DebateAgent(id=i, model=models[i], temperature=0.5 + i * 0.2)
        for i in range(n_agents)
    ]

    # Раунд 1: независимые ответы
    responses = [agent.respond(task) for agent in agents]

    if check_consensus(responses):
        return {
            "answer": extract_final_answer(responses[0]),
            "rounds": 1,
            "consensus": True,
            "debate_log": [responses]
        }

    # Раунды дебатов
    debate_log = [responses]
    for round_num in range(2, max_rounds + 1):
        new_responses = []
        for i, agent in enumerate(agents):
            other = [r for j, r in enumerate(responses) if j != i]
            new_responses.append(agent.respond(task, other))

        responses = new_responses
        debate_log.append(responses)

        if check_consensus(responses):
            return {
                "answer": extract_final_answer(responses[0]),
                "rounds": round_num,
                "consensus": True,
                "debate_log": debate_log
            }

    # Fallback: мажоритарное голосование
    from collections import Counter
    answers = [extract_final_answer(r) for r in responses]
    most_common = Counter(answers).most_common(1)[0][0]
    return {
        "answer": most_common,
        "rounds": max_rounds,
        "consensus": False,
        "debate_log": debate_log
    }


# Пример использования
result = multi_agent_debate(
    task="Если поезд проехал 180 км за 2.5 часа, а затем "
         "ещё 120 км за 1.5 часа, какова средняя скорость?",
    n_agents=3,
    max_rounds=3
)

print(f"Ответ: {result['answer']}")
print(f"Раундов: {result['rounds']}")
print(f"Консенсус: {result['consensus']}")

def cross_model_debate(task: str) -> dict:
    """Дебаты между разными моделями — борьба с groupthink."""
    return multi_agent_debate(
        task=task,
        n_agents=3,
        max_rounds=3,
        models=["gpt-4o", "claude-sonnet-4-20250514", "gemini-1.5-pro"]
    )