class AgentRegistry:
    def load(self, prompts_dir):
        for md_file in sorted(prompts_dir.glob("*_agent.md")):
            name = md_file.stem.replace("_agent", "")  # "product_agent" → "product"
            prompt = md_file.read_text()
            agent_params = params.get(name, {})
            self._agents[name] = AgentDef(
                name=name,
                system_prompt=prompt,
                max_turns=agent_params.get("max_turns", 30),
                allowed_tools=agent_params.get("allowed_tools", "..."),
            )

@dataclass
class HandoffContext:
    original_task: str                    # 用户原始任务
    pipeline_stages: list[str]            # 流水线阶段列表
    previous_outputs: dict[str, str]      # {阶段名: 输出文本}
    working_dir: str
    task_id: str

    def build_prompt(self, current_stage: str) -> str:
        parts = [f"## Original Task\n\n{self.original_task}"]

        if self.previous_outputs:
            parts.append("\n## Previous Stage Outputs\n")
            for stage, output in self.previous_outputs.items():
                truncated = output[:8000] if len(output) > 8000 else output
                parts.append(f"### {stage}\n\n{truncated}\n")

        parts.append(
            f"\n## Your Role\n\n"
            f"You are the **{current_stage}** agent. "
            f"Complete your responsibilities for the task above. "
            f"Working directory: `{self.working_dir}`"
        )
        return "\n".join(parts)

    def record_output(self, stage: str, output: str) -> None:
        self.previous_outputs[stage] = output

async def execute(self, task_session: TaskSession) -> None:
    handoff = HandoffContext(
        original_task=task_session.description,
        pipeline_stages=task_session.pipeline,
        working_dir=working_dir,
    )

    while True:
        stage_name = task_session.advance_stage()
        if stage_name is None:
            break  # 所有阶段完成

        agent_def = self._registry.get(stage_name)
        prompt = handoff.build_prompt(stage_name)

        # 每个 Agent 是独立的 Claude Code 进程
        cp = await self._runner.run(
            prompt=prompt,
            system_prompt=agent_def.system_prompt,
            max_turns=agent_def.max_turns,
            allowed_tools=agent_def.allowed_tools,
        )

        # 流式读取输出
        collected_text = []
        async for chunk in cp.read_stream():
            if chunk.chunk_type == ChunkType.TEXT_DELTA:
                collected_text.append(chunk.text)
            # 同时推送到 Admin UI
            await bus.publish(Event(type=EventType.AGENT_OUTPUT, ...))

        output = "".join(collected_text)
        handoff.record_output(stage_name, output)  # 记录输出供后续 Agent 使用

# Orchestrator 获得的系统提示
system_prompt = """
# Team Orchestrator

You are a Team Orchestrator. Coordinate specialized agents to complete the task.

## Available Agents
### product
- Description: Analyzes requirements and creates product specifications
### development
- Description: Implements code changes based on technical design
...

## Instructions
1. Analyze the user's task and decide which agents to involve.
2. Use the Task tool to spawn sub-agents.
3. You may run agents in parallel when their work is independent.
4. Coordinate handoffs between agents.
"""

# 检测 Task 工具调用，识别被 spawn 的 Agent
if chunk.chunk_type == ChunkType.TOOL_USE_START:
    if chunk.tool_name == "Task":
        _in_task_tool = True

if chunk.chunk_type == ChunkType.TOOL_USE_INPUT and _in_task_tool:
    _task_input_parts.append(chunk.text)
    # 解析 JSON，模糊匹配 Agent 名称
    agent_name = self._try_extract_subagent(tool_input)

# mcp_server.py
@mcp.tool()
async def dispatch_agent(agent_name: str, task: str) -> str:
    """Dispatch a task to a specialized agent."""
    url = f"{OPENTEAM_URL}/api/internal/dispatch"
    payload = {"task_id": OPENTEAM_TASK_ID, "agent_name": agent_name, "task": task}

    async with httpx.AsyncClient(timeout=600.0) as client:
        resp = await client.post(url, json=payload)
        result = resp.json()

    return f"{result['output']}\n\n[Agent {agent_name} completed · cost=${cost:.4f}]"

def _write_mcp_config(self, working_dir: str, task_id: str) -> Path:
    mcp_config = {
        "mcpServers": {
            "openteam": {
                "command": sys.executable,
                "args": [mcp_server_path],
                "env": {
                    "OPENTEAM_URL": f"http://127.0.0.1:{port}",
                    "OPENTEAM_TASK_ID": task_id,
                },
            }
        }
    }
    mcp_path = Path(working_dir) / ".mcp.json"
    mcp_path.write_text(json.dumps(mcp_config, indent=2))
    return mcp_path

class ChunkType(str, Enum):
    TEXT_DELTA = "text_delta"         # Agent 的文本输出
    TOOL_USE_START = "tool_use_start" # 工具调用开始（含工具名）
    TOOL_USE_INPUT = "tool_use_input" # 工具调用参数（流式 JSON 片段）
    TOOL_RESULT = "tool_result"       # 工具执行结果
    RESULT = "result"                 # 最终结果（含总成本、耗时）
    SYSTEM = "system"                 # 系统消息（session_id 等）
    ERROR = "error"                   # 解析错误
    UNKNOWN = "unknown"               # 未识别的消息类型

def parse_line(line: str) -> StreamChunk | None:
    data = json.loads(line)
    msg_type = data.get("type", "")

    if msg_type == "assistant":
        # 提取文本内容
        content = data["message"]["content"]
        text = "".join(b["text"] for b in content if b["type"] == "text")
        return StreamChunk(chunk_type=ChunkType.TEXT_DELTA, text=text)

    if msg_type == "content_block_start":
        block = data["content_block"]
        if block["type"] == "tool_use":
            return StreamChunk(
                chunk_type=ChunkType.TOOL_USE_START,
                tool_name=block["name"],
            )

    if msg_type == "result":
        return StreamChunk(
            chunk_type=ChunkType.RESULT,
            cost_usd=data.get("cost_usd", 0.0),
            duration_ms=data.get("duration_ms", 0),
        )

class EventBus:
    def __init__(self):
        self._handlers: dict[EventType, list[EventHandler]] = {}
        self._queue: asyncio.Queue[Event] = asyncio.Queue()

    async def publish(self, event: Event) -> None:
        await self._queue.put(event)

    async def start(self) -> None:
        while self._running:
            event = await asyncio.wait_for(self._queue.get(), timeout=1.0)
            for handler in self._handlers.get(event.type, []):
                await handler(event)

# websocket.py
async def _broadcast_event(self, event: Event):
    message = json.dumps({"type": event.type.value, "data": event.data})
    for connection in self._connections:
        await connection.send_text(message)

# 支持的命令格式
@openteam <message>             # 普通对话（默认）
@openteam --pipeline <task>     # 全流水线
@openteam dev <task>            # 单阶段（Pipeline 模式）
@openteam dev+test <task>       # 多阶段组合（Pipeline 模式）
@openteam --team <task>         # Team 模式
@openteam --auto <task>         # Auto 模式
@openteam --dir ~/repo <task>   # 指定工作目录
@openteam status                # 查看状态
@openteam stop task-0001        # 停止任务

# 阶段别名
product → prod, p
architecture → arch, a
development → dev, d
testing → test, t
review → rev, r

# 每 5 秒轮询一次
imsg history --chat-id 67 --limit 20 --json

class AppConfig(BaseModel):
    server: ServerConfig = ServerConfig()
    openclaw: OpenClawConfig = OpenClawConfig()
    claude: ClaudeConfig = ClaudeConfig()
    agents: AgentsConfig = AgentsConfig()
    notifications: NotificationsConfig = NotificationsConfig()
    admin: AdminConfig = AdminConfig()