524 lines
21 KiB
Python
524 lines
21 KiB
Python
"""BoardOrchestrator - 私董会讨论引擎
|
||
|
||
驱动 BoardTeam 执行多轮群聊式讨论：
|
||
|
||
1. 主持人开场介绍议题和讨论规则
|
||
2. 循环 max_rounds 轮：
|
||
- 所有非主持人专家并行生成发言（基于共享讨论历史 + 角色 prompt）
|
||
- 主持人小结本轮要点
|
||
- 检查用户干预和停止命令
|
||
3. 主持人最终总结（决策建议、共识点、分歧点）
|
||
|
||
终止条件：
|
||
- 正常终止：达到最大轮次
|
||
- 用户终止：用户发送 /stop
|
||
- 异常终止：LLM 不可用或所有专家发言失败
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import asyncio
|
||
import logging
|
||
from typing import Any
|
||
|
||
from .expert import Expert
|
||
from .board import BoardTeam, BoardStatus
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
|
||
class BoardOrchestrator:
|
||
"""Board meeting orchestration engine.
|
||
|
||
The moderator (lead expert) facilitates the discussion:
|
||
- Opens with topic introduction
|
||
- Summarizes each round
|
||
- Gives final decision advice
|
||
|
||
Member experts give speeches each round based on shared history.
|
||
"""
|
||
|
||
STOP_COMMANDS = frozenset({"/stop", "停止讨论", "stop", "结束讨论"})
|
||
|
||
def __init__(self, team: BoardTeam) -> None:
|
||
self._team = team
|
||
|
||
async def execute(self, topic: str) -> dict[str, Any]:
|
||
"""Execute a board meeting discussion.
|
||
|
||
Flow:
|
||
1. Broadcast board_started event
|
||
2. Moderator opens the discussion
|
||
3. Loop max_rounds times:
|
||
- Parallel generate member speeches
|
||
- Moderator summarizes the round
|
||
- Check for user intervention / stop
|
||
4. Moderator gives final conclusion
|
||
5. Broadcast board_concluded event
|
||
|
||
Returns:
|
||
Dict with status, summary, decision_advice, total_rounds,
|
||
consensus_points, dissent_points
|
||
"""
|
||
moderator = self._team.moderator
|
||
if not moderator or not moderator.is_active:
|
||
active = self._team.active_experts
|
||
if not active:
|
||
return {
|
||
"status": "failed",
|
||
"summary": "",
|
||
"decision_advice": "",
|
||
"total_rounds": 0,
|
||
"consensus_points": [],
|
||
"dissent_points": [],
|
||
"error": "No active expert available",
|
||
}
|
||
# Promote first active expert to moderator
|
||
self._team._moderator_name = active[0].config.name
|
||
moderator = active[0]
|
||
logger.warning(
|
||
f"Moderator not available, falling back to '{moderator.config.name}'"
|
||
)
|
||
|
||
self._team.set_status(BoardStatus.DISCUSSING)
|
||
|
||
# 1. Broadcast board_started event
|
||
await self._broadcast_event(
|
||
"board_started",
|
||
{
|
||
"team_id": self._team.team_id,
|
||
"topic": topic,
|
||
"experts": [
|
||
{
|
||
"name": e.config.name,
|
||
"avatar": e.config.avatar,
|
||
"color": e.config.color,
|
||
"is_moderator": e.config.name == self._team._moderator_name,
|
||
"persona": e.config.persona[:100],
|
||
}
|
||
for e in self._team.active_experts
|
||
],
|
||
"max_rounds": self._team.max_rounds,
|
||
},
|
||
)
|
||
|
||
try:
|
||
# 2. Moderator opens the discussion
|
||
opening = await self._generate_moderator_opening(moderator, topic)
|
||
if opening:
|
||
await self._team.add_to_history(0, moderator.config.name, opening, "moderator")
|
||
await self._broadcast_event(
|
||
"expert_speech",
|
||
{
|
||
"expert_name": moderator.config.name,
|
||
"expert_avatar": moderator.config.avatar,
|
||
"expert_color": moderator.config.color,
|
||
"content": opening,
|
||
"round": 0,
|
||
"role": "moderator",
|
||
},
|
||
)
|
||
|
||
# 3. Discussion rounds
|
||
for round_num in range(1, self._team.max_rounds + 1):
|
||
self._team.increment_round()
|
||
|
||
# Check for stop command before starting the round
|
||
interventions = self._team.consume_user_interventions()
|
||
if self._has_stop_command(interventions):
|
||
logger.info(f"Discussion stopped by user at round {round_num}")
|
||
break
|
||
|
||
# Generate member speeches in parallel
|
||
members = self._team.member_experts
|
||
if members:
|
||
speech_results = await asyncio.gather(
|
||
*[self._generate_expert_speech(e, round_num) for e in members],
|
||
return_exceptions=True,
|
||
)
|
||
|
||
# Broadcast speeches in order (not parallel broadcast)
|
||
for expert, result in zip(members, speech_results):
|
||
if isinstance(result, Exception):
|
||
logger.warning(
|
||
f"Expert '{expert.config.name}' speech failed: {result}"
|
||
)
|
||
continue
|
||
|
||
await self._team.add_to_history(
|
||
round_num, expert.config.name, result, "expert"
|
||
)
|
||
await self._broadcast_event(
|
||
"expert_speech",
|
||
{
|
||
"expert_name": expert.config.name,
|
||
"expert_avatar": expert.config.avatar,
|
||
"expert_color": expert.config.color,
|
||
"content": result,
|
||
"round": round_num,
|
||
"role": "expert",
|
||
},
|
||
)
|
||
|
||
# Moderator summarizes the round
|
||
summary = await self._generate_moderator_summary(moderator, round_num)
|
||
if summary:
|
||
await self._team.add_to_history(
|
||
round_num, moderator.config.name, summary, "moderator"
|
||
)
|
||
await self._broadcast_event(
|
||
"round_summary",
|
||
{
|
||
"moderator_name": moderator.config.name,
|
||
"content": summary,
|
||
"round": round_num,
|
||
"continue": round_num < self._team.max_rounds,
|
||
},
|
||
)
|
||
|
||
# Check history length and compress if needed
|
||
gateway = self._get_llm_gateway(moderator)
|
||
if gateway and len(self._team.history) > 20:
|
||
await self._team.compress_history(moderator, gateway)
|
||
|
||
# 4. Final conclusion
|
||
self._team.set_status(BoardStatus.CONCLUDING)
|
||
conclusion = await self._generate_final_conclusion(moderator, topic)
|
||
|
||
self._team.set_status(BoardStatus.COMPLETED)
|
||
|
||
# 5. Broadcast board_concluded event
|
||
await self._broadcast_event(
|
||
"board_concluded",
|
||
{
|
||
"summary": conclusion.get("summary", ""),
|
||
"decision_advice": conclusion.get("decision_advice", ""),
|
||
"total_rounds": self._team.current_round,
|
||
"consensus_points": conclusion.get("consensus_points", []),
|
||
"dissent_points": conclusion.get("dissent_points", []),
|
||
},
|
||
)
|
||
|
||
return {
|
||
"status": "completed",
|
||
"summary": conclusion.get("summary", ""),
|
||
"decision_advice": conclusion.get("decision_advice", ""),
|
||
"total_rounds": self._team.current_round,
|
||
"consensus_points": conclusion.get("consensus_points", []),
|
||
"dissent_points": conclusion.get("dissent_points", []),
|
||
}
|
||
|
||
except Exception as e:
|
||
logger.error(f"Board meeting execution failed: {e}")
|
||
self._team.set_status(BoardStatus.DISSOLVED)
|
||
|
||
# Try to give a fallback conclusion
|
||
fallback = await self._generate_fallback_conclusion(moderator, topic)
|
||
|
||
await self._broadcast_event(
|
||
"board_concluded",
|
||
{
|
||
"summary": fallback.get("summary", ""),
|
||
"decision_advice": fallback.get("decision_advice", ""),
|
||
"total_rounds": self._team.current_round,
|
||
"consensus_points": [],
|
||
"dissent_points": [],
|
||
"error": str(e),
|
||
},
|
||
)
|
||
|
||
return {
|
||
"status": "failed",
|
||
"summary": fallback.get("summary", ""),
|
||
"decision_advice": fallback.get("decision_advice", ""),
|
||
"total_rounds": self._team.current_round,
|
||
"consensus_points": [],
|
||
"dissent_points": [],
|
||
"error": str(e),
|
||
}
|
||
|
||
async def _generate_moderator_opening(self, moderator: Expert, topic: str) -> str:
|
||
"""Generate moderator's opening speech.
|
||
|
||
The moderator introduces the topic and sets the stage for discussion.
|
||
"""
|
||
gateway = self._get_llm_gateway(moderator)
|
||
if not gateway:
|
||
return f"欢迎来到私董会。今天的讨论主题是：{topic}。请各位专家发表看法。"
|
||
|
||
prompt = (
|
||
f"你是私董会主持人 {moderator.config.name}。\n"
|
||
f"你的角色：{moderator.config.persona}\n"
|
||
f"你的表达风格：{moderator.config.speaking_style}\n\n"
|
||
f"讨论主题：{topic}\n\n"
|
||
"请作为主持人开场，介绍议题并邀请各位专家发表看法。"
|
||
"开场应该简洁有力，2-3 段话，点明讨论的核心问题。"
|
||
)
|
||
|
||
try:
|
||
response = await gateway.chat(
|
||
messages=[{"role": "user", "content": prompt}],
|
||
model="default",
|
||
)
|
||
return response.content.strip()
|
||
except Exception as e:
|
||
logger.warning(f"Moderator opening generation failed: {e}")
|
||
return f"欢迎来到私董会。今天的讨论主题是：{topic}。请各位专家发表看法。"
|
||
|
||
async def _generate_expert_speech(self, expert: Expert, round: int) -> str:
|
||
"""Generate an expert's speech for the current round.
|
||
|
||
The speech is based on:
|
||
- Expert's persona, thinking_style, speaking_style, decision_framework
|
||
- Full discussion history
|
||
- Current round / max rounds
|
||
"""
|
||
gateway = self._get_llm_gateway(expert)
|
||
if not gateway:
|
||
return f"[{expert.config.name} 因 LLM 不可用无法发言]"
|
||
|
||
history_text = self._team.get_history_text()
|
||
|
||
prompt = (
|
||
f"你是 {expert.config.name}，正在参加私董会讨论。\n\n"
|
||
f"你的角色：{expert.config.persona}\n"
|
||
f"你的思维风格：{expert.config.thinking_style}\n"
|
||
f"你的表达风格：{expert.config.speaking_style}\n"
|
||
f"你的决策框架：{expert.config.decision_framework}\n\n"
|
||
f"讨论主题：{self._team.topic}\n"
|
||
f"当前轮次：第 {round} 轮 / 共 {self._team.max_rounds} 轮\n\n"
|
||
)
|
||
|
||
if history_text:
|
||
prompt += f"之前的讨论历史：\n{history_text}\n\n"
|
||
|
||
prompt += (
|
||
"请基于你的角色和决策框架，就当前讨论主题发表你的看法。"
|
||
"要求：\n"
|
||
"- 保持角色一致性，用你的思维方式和表达风格发言\n"
|
||
"- 2-4 段话，简洁但有洞察力\n"
|
||
"- 可以引用或反驳之前发言者的观点\n"
|
||
"- 给出明确的立场或建议\n"
|
||
)
|
||
|
||
response = await gateway.chat(
|
||
messages=[{"role": "user", "content": prompt}],
|
||
model="default",
|
||
)
|
||
return response.content.strip()
|
||
|
||
async def _generate_moderator_summary(self, moderator: Expert, round: int) -> str:
|
||
"""Generate moderator's round summary.
|
||
|
||
The moderator summarizes the key points of the current round.
|
||
"""
|
||
gateway = self._get_llm_gateway(moderator)
|
||
if not gateway:
|
||
return f"[第 {round} 轮小结因 LLM 不可用无法生成]"
|
||
|
||
# Get only current round's speeches
|
||
round_history = [
|
||
h for h in self._team.history if h["round"] == round
|
||
]
|
||
if not round_history:
|
||
return ""
|
||
|
||
round_text = "\n\n".join(
|
||
f"[{h['expert_name']}]: {h['content']}" for h in round_history
|
||
)
|
||
|
||
prompt = (
|
||
f"你是私董会主持人 {moderator.config.name}。\n"
|
||
f"你的角色：{moderator.config.persona}\n"
|
||
f"你的表达风格：{moderator.config.speaking_style}\n\n"
|
||
f"讨论主题：{self._team.topic}\n"
|
||
f"当前轮次：第 {round} 轮 / 共 {self._team.max_rounds} 轮\n\n"
|
||
f"本轮发言：\n{round_text}\n\n"
|
||
"请作为主持人小结本轮讨论：\n"
|
||
"- 归纳各方核心观点（2-3 句话）\n"
|
||
"- 指出共识点和分歧点\n"
|
||
"- 提示下一轮可以深入的方向\n"
|
||
"- 保持简洁，3-5 句话\n"
|
||
)
|
||
|
||
try:
|
||
response = await gateway.chat(
|
||
messages=[{"role": "user", "content": prompt}],
|
||
model="default",
|
||
)
|
||
return response.content.strip()
|
||
except Exception as e:
|
||
logger.warning(f"Moderator summary generation failed: {e}")
|
||
return f"[第 {round} 轮讨论完成，主持人小结生成失败]"
|
||
|
||
async def _generate_final_conclusion(self, moderator: Expert, topic: str) -> dict[str, Any]:
|
||
"""Generate moderator's final conclusion.
|
||
|
||
The moderator gives:
|
||
- Overall summary of the discussion
|
||
- Decision advice
|
||
- Consensus points
|
||
- Dissent points
|
||
"""
|
||
gateway = self._get_llm_gateway(moderator)
|
||
if not gateway:
|
||
return {
|
||
"summary": "讨论已完成，但 LLM 不可用无法生成总结。",
|
||
"decision_advice": "建议参考讨论历史自行判断。",
|
||
"consensus_points": [],
|
||
"dissent_points": [],
|
||
}
|
||
|
||
history_text = self._team.get_history_text()
|
||
|
||
prompt = (
|
||
f"你是私董会主持人 {moderator.config.name}。\n"
|
||
f"你的角色：{moderator.config.persona}\n"
|
||
f"你的表达风格：{moderator.config.speaking_style}\n"
|
||
f"你的决策框架：{moderator.config.decision_framework}\n\n"
|
||
f"讨论主题：{topic}\n"
|
||
f"总轮次：{self._team.current_round}\n\n"
|
||
f"完整讨论历史：\n{history_text}\n\n"
|
||
"请作为主持人给出最终总结。输出 JSON 格式：\n"
|
||
"```json\n"
|
||
"{\n"
|
||
' "summary": "整体讨论总结，3-5句话",\n'
|
||
' "decision_advice": "基于讨论的决策建议，明确给出你的推荐",\n'
|
||
' "consensus_points": ["共识点1", "共识点2"],\n'
|
||
' "dissent_points": ["分歧点1", "分歧点2"]\n'
|
||
"}\n"
|
||
"```\n"
|
||
"只输出 JSON，不要其他文字。"
|
||
)
|
||
|
||
try:
|
||
import json
|
||
import re
|
||
|
||
response = await gateway.chat(
|
||
messages=[{"role": "user", "content": prompt}],
|
||
model="default",
|
||
)
|
||
content = response.content.strip()
|
||
|
||
# Extract JSON from response
|
||
json_match = re.search(r"\{.*\}", content, re.DOTALL)
|
||
if json_match:
|
||
result = json.loads(json_match.group(0))
|
||
return {
|
||
"summary": result.get("summary", ""),
|
||
"decision_advice": result.get("decision_advice", ""),
|
||
"consensus_points": result.get("consensus_points", []),
|
||
"dissent_points": result.get("dissent_points", []),
|
||
}
|
||
|
||
# If JSON parsing fails, return raw content as summary
|
||
return {
|
||
"summary": content,
|
||
"decision_advice": "",
|
||
"consensus_points": [],
|
||
"dissent_points": [],
|
||
}
|
||
except Exception as e:
|
||
logger.warning(f"Final conclusion generation failed: {e}")
|
||
return {
|
||
"summary": f"讨论已完成（{self._team.current_round}轮），总结生成失败。",
|
||
"decision_advice": "建议参考讨论历史自行判断。",
|
||
"consensus_points": [],
|
||
"dissent_points": [],
|
||
}
|
||
|
||
async def _generate_fallback_conclusion(self, moderator: Expert, topic: str) -> dict[str, Any]:
|
||
"""Generate a fallback conclusion when execution fails.
|
||
|
||
Uses existing discussion history to provide a basic summary.
|
||
"""
|
||
history_text = self._team.get_history_text()
|
||
if not history_text:
|
||
return {
|
||
"summary": "讨论未能正常完成，无历史记录。",
|
||
"decision_advice": "",
|
||
}
|
||
|
||
gateway = self._get_llm_gateway(moderator)
|
||
if not gateway:
|
||
# Return truncated history as summary
|
||
return {
|
||
"summary": f"讨论异常终止。已有历史（{len(self._team.history)}条）：\n"
|
||
+ history_text[:500],
|
||
"decision_advice": "建议参考讨论历史自行判断。",
|
||
}
|
||
|
||
prompt = (
|
||
f"你是私董会主持人 {moderator.config.name}。\n"
|
||
f"讨论主题：{topic}\n"
|
||
f"讨论因异常终止，已完成 {self._team.current_round} 轮。\n\n"
|
||
f"已有讨论历史：\n{history_text}\n\n"
|
||
"请基于已有历史给出总结和决策建议。输出 JSON：\n"
|
||
"```json\n"
|
||
'{"summary": "...", "decision_advice": "..."}\n'
|
||
"```\n"
|
||
)
|
||
|
||
try:
|
||
import json
|
||
import re
|
||
|
||
response = await gateway.chat(
|
||
messages=[{"role": "user", "content": prompt}],
|
||
model="default",
|
||
)
|
||
content = response.content.strip()
|
||
json_match = re.search(r"\{.*\}", content, re.DOTALL)
|
||
if json_match:
|
||
result = json.loads(json_match.group(0))
|
||
return {
|
||
"summary": result.get("summary", content),
|
||
"decision_advice": result.get("decision_advice", ""),
|
||
}
|
||
return {"summary": content, "decision_advice": ""}
|
||
except Exception:
|
||
return {
|
||
"summary": f"讨论异常终止，已完成 {self._team.current_round} 轮。",
|
||
"decision_advice": "",
|
||
}
|
||
|
||
def _has_stop_command(self, interventions: list[str]) -> bool:
|
||
"""Check if any user intervention contains a stop command."""
|
||
for msg in interventions:
|
||
msg_lower = msg.strip().lower()
|
||
if msg_lower in self.STOP_COMMANDS:
|
||
return True
|
||
return False
|
||
|
||
def _get_llm_gateway(self, expert: Expert | None = None) -> Any:
|
||
"""Get LLM gateway from the given expert or the moderator's agent.
|
||
|
||
Falls back to other active experts if the primary target has no gateway.
|
||
"""
|
||
target = expert or self._team.moderator
|
||
if target and hasattr(target, "agent") and hasattr(target.agent, "_llm_gateway"):
|
||
gateway = target.agent._llm_gateway
|
||
if gateway is not None:
|
||
return gateway
|
||
# Fallback: try first active expert with a gateway
|
||
for exp in self._team.active_experts:
|
||
if hasattr(exp, "agent") and hasattr(exp.agent, "_llm_gateway"):
|
||
gateway = exp.agent._llm_gateway
|
||
if gateway is not None:
|
||
return gateway
|
||
return None
|
||
|
||
async def _broadcast_event(self, event_type: str, data: dict[str, Any]) -> None:
|
||
"""Broadcast a board event to the team channel.
|
||
|
||
Events are emitted via handoff_transport for WebSocket relay.
|
||
"""
|
||
if self._team.handoff_transport:
|
||
try:
|
||
await self._team.handoff_transport.send(
|
||
self._team.team_channel, {"type": event_type, **data}
|
||
)
|
||
except Exception as e:
|
||
logger.warning(f"Failed to broadcast event '{event_type}': {e}")
|