Human:
  @architect @security @tester 请一起评审这个 API 设计，
  重点看边界、鉴权、异常处理和测试策略。

Architect Agent:
  我先看资源模型和调用链……

Security Agent:
  我补充鉴权和敏感数据暴露风险……

Tester Agent:
  我基于你们的结论列验收测试……

Human:
  @architect 请根据 security 的意见改一下方案。

User -> Conversation -> Agent -> Model -> Response

Room
  ├── Human
  ├── Architect Agent
  ├── Security Agent
  ├── Tester Agent
  └── Bot / Tool / Workflow

{
  "message_id": "msg_123",
  "room_id": "room_api_review",
  "sender": {
    "id": "human_walter",
    "type": "human"
  },
  "mentions": ["agent_architect", "agent_security", "agent_tester"],
  "reply_to": null,
  "content": "请一起评审这个 API 设计，重点看鉴权、异常处理和测试策略。",
  "attachments": [
    {
      "type": "markdown",
      "name": "api_design.md",
      "uri": "artifact://api_design"
    }
  ],
  "visibility": "room",
  "created_at": "2026-04-30T22:10:00+08:00"
}

def route_message(room, message):
    if message.sender.type == "agent" and not room.policy.allow_agent_to_agent:
        return []

    if message.mentions:
        return [
            p for p in room.participants
            if p.id in message.mentions and p.type == "agent"
        ]

    if message.reply_to:
        parent = load_message(message.reply_to)
        if parent.sender.type == "agent":
            return [find_participant(room, parent.sender.id)]

    if message.content.startswith("@all-agents"):
        return [p for p in room.participants if p.type == "agent"]

    return []

id: agent_security
display_name: Security Agent
role_prompt: |
  You are a security reviewer.
  Focus on authentication, authorization, data exposure,
  abuse prevention, logging safety, and threat modeling.
tools:
  - read_artifact
  - search_code
  - run_static_check
memory_scope: room
permission_level: reviewer
can_initiate_message: false

Security Agent:
  @architect 当前设计里 tenant_id 是从 token claims 里取，
  还是从 request body 里取？如果两者都有，以哪个为准？

Architect Agent:
  应该只信任 token claims，request body 里的 tenant_id 只能作为过滤条件，
  不能作为授权依据。我会把这一点写进设计约束。

Agent Context =
  System Prompt
  + Agent Role
  + Room Objective
  + Relevant Messages
  + Mention Thread
  + Selected Artifacts
  + Tool Results
  + Constraints / Policies

def build_context(room, agent, message):
    thread = load_thread(message)
    relevant = retrieve_relevant_messages(
        room_id=room.id,
        query=message.content,
        filters={"roles": agent.interested_roles}
    )
    artifacts = select_artifacts(room, agent, message)

    return [
        system_prompt(agent),
        room_objective(room),
        policy_block(room.policy, agent),
        summarize_room_state(room),
        *thread,
        *relevant,
        *artifacts,
    ]

            ┌────────────────────┐
            │  Chat UI / Channel │
            └─────────┬──────────┘
                      │
                      v
            ┌────────────────────┐
            │  Message Service   │
            └─────────┬──────────┘
                      │ append event
                      v
            ┌────────────────────┐
            │ Conversation Store │
            └─────────┬──────────┘
                      │
                      v
            ┌────────────────────┐
            │ Conversation Router│
            └─────────┬──────────┘
                      │ dispatch
        ┌─────────────┼─────────────┐
        v             v             v
 ┌────────────┐ ┌────────────┐ ┌────────────┐
 │ Architect  │ │ Security   │ │ Tester     │
 │ Agent      │ │ Agent      │ │ Agent      │
 └─────┬──────┘ └─────┬──────┘ └─────┬──────┘
       │              │              │
       v              v              v
 ┌──────────────────────────────────────────┐
 │ Context Builder + Policy + Tool Gateway  │
 └──────────────────────────────────────────┘

sequenceDiagram
    participant H as Human
    participant MS as Message Service
    participant R as Router
    participant A as Architect Agent
    participant S as Security Agent
    participant T as Tester Agent
    participant G as Tool Gateway

    H->>MS: @architect @security @tester review API design
    MS->>R: message_created
    R->>A: dispatch with scoped context
    R->>S: dispatch with scoped context
    R->>T: dispatch with scoped context
    A->>MS: architecture review message
    S->>G: read artifact / check policy
    G-->>S: tool result
    S->>MS: security findings
    T->>MS: test strategy
    H->>MS: approve decisions / ask follow-up

create table rooms (
  id text primary key,
  title text not null,
  created_by text not null,
  policy_json text not null,
  created_at timestamp not null
);

create table participants (
  room_id text not null,
  participant_id text not null,
  participant_type text not null, -- human | agent
  role text not null,
  config_json text not null,
  primary key (room_id, participant_id)
);

create table messages (
  id text primary key,
  room_id text not null,
  sender_id text not null,
  sender_type text not null,
  content text not null,
  mentions_json text not null,
  reply_to text,
  turn_index integer not null,
  created_at timestamp not null
);

MAX_AGENT_TURNS = 6

def handle_message(room_id, message):
    save_message(message)

    if count_agent_turns(room_id, root_message_id(message)) >= MAX_AGENT_TURNS:
        save_system_message(room_id, "Agent turn limit reached. Waiting for human input.")
        return

    agents = route_message(load_room(room_id), message)

    for agent in agents:
        context = build_context(room_id, agent, message)
        response = run_agent(agent, context)
        save_message(response)

You are {agent_name}, a participant in a group chat.

Your role:
- {role_description}

Group chat rules:
- Respond only when you are mentioned, replied to, or explicitly asked by the moderator.
- Keep your response focused on your role.
- If another agent made a useful point, build on it instead of repeating it.
- If you disagree, explain the concrete reason and propose a fix.
- Do not call tools unless the current room policy allows it.
- Do not ask another agent to perform actions outside its role or permission.
- When a human decision is required, mark it clearly as "Needs human decision".

Output format:
- Findings
- Questions
- Recommendations
- Risks