OpenClaw 核心流程第二部分：双重循环 — 路由、提示词与 Agent 状态机

type MsgContext = {
  Body?: string;           // 标准消息内容
  BodyForAgent?: string;   // 可能包含信封/历史/上下文
  Channel?: string;        // "whatsapp"、"telegram" 等
  From?: string;           // 发送者 ID
  ChatType?: string;       // "direct" | "group" | "channel"
  GroupId?: string;
  ReplyToId?: string;
  MediaPath?: string;
  CommandAuthorized?: boolean;  // 默认为 false（默认拒绝）
  // ... 70+ 个其他字段
};

const tiers = [
  { matchedBy: "binding.peer",          // 第 1 层：直接 peer 匹配
    predicate: (c) => c.match.peer.state === "valid" },
  { matchedBy: "binding.peer.parent",   // 第 2 层：父级 peer（线程 → 父级）
    predicate: (c) => c.match.peer.state === "valid" },
  { matchedBy: "binding.guild+roles",   // 第 3 层：Discord 服务器 + 身份组
    predicate: (c) => hasGuildConstraint(c.match) && hasRolesConstraint(c.match) },
  { matchedBy: "binding.guild",         // 第 4 层：无身份组的服务器
    predicate: (c) => hasGuildConstraint(c.match) && !hasRolesConstraint(c.match) },
  { matchedBy: "binding.team",          // 第 5 层：Slack 工作区
    predicate: (c) => hasTeamConstraint(c.match) },
  { matchedBy: "binding.account",       // 第 6 层：账号（非通配符）
    predicate: (c) => c.match.accountPattern !== "*" },
  { matchedBy: "binding.channel",       // 第 7 层：Channel 通配符
    predicate: (c) => c.match.accountPattern === "*" },
];
// 第 8 层：resolveDefaultAgentId(cfg) — 全局回退

const { builtInTools, customTools } = splitSdkTools({ tools, sandboxEnabled });

const { session } = await createAgentSession({
  cwd: resolvedWorkspace,
  model: params.model,
  thinkingLevel: mapThinkingLevel(params.thinkLevel),
  tools: builtInTools,
  customTools: [...customTools, ...clientToolDefs],
  sessionManager,
  settingsManager,
});

const { unsubscribe } = subscribeEmbeddedPiSession({
  session,
  onBlockReply: ({ text, mediaUrls }) => { /* 流式传输给用户 */ },
  onToolResult: ({ text }) => { /* 发出工具事件 */ },
  onReasoningStream: ({ text }) => { /* 流式传输思考过程 */ },
});

export class Agent {
  private _state: AgentState;
  private steeringQueue: AgentMessage[] = [];
  private followUpQueue: AgentMessage[] = [];
  private abortController?: AbortController;

  async prompt(input) {
    if (this._state.isStreaming) {
      throw new Error("Agent is already processing. Use steer() or followUp().");
    }
    await this._runLoop(messages);
  }

  steer(m: AgentMessage)   { this.steeringQueue.push(m); }
  followUp(m: AgentMessage) { this.followUpQueue.push(m); }
  abort() { this.abortController?.abort(); }
}

async function streamAssistantResponse(context, config, signal, stream) {
  // 1. 应用 transformContext（扩展修改上下文）
  let messages = config.transformContext
    ? await config.transformContext(context.messages, signal)
    : context.messages;

  // 2. 将 AgentMessage 转换为 LLM Message
  const llmMessages = await config.convertToLlm(messages);

  // 3. 从 LLM 流式获取响应
  const response = await streamFn(config.model, { systemPrompt, messages: llmMessages, tools }, { signal });

  // 4. 处理流式事件
  for await (const event of response) {
    switch (event.type) {
      case "start":      stream.push({ type: "message_start", message: event.partial }); break;
      case "text_delta": stream.push({ type: "message_update", ... }); break;
      case "done":       stream.push({ type: "message_end", message: finalMessage }); break;
    }
  }
}

async function executeToolCalls(tools, assistantMessage, signal, stream, getSteeringMessages) {
  for (let i = 0; i < toolCalls.length; i++) {
    const toolCall = toolCalls[i];
    stream.push({ type: "tool_execution_start", ... });

    try {
      const validatedArgs = validateToolArguments(tool, toolCall);
      result = await tool.execute(toolCall.id, validatedArgs, signal, (partial) => {
        stream.push({ type: "tool_execution_update", partialResult: partial });
      });
    } catch (e) {
      result = { content: [{ type: "text", text: e.message }] };
      isError = true;  // LLM 可见错误，可重试
    }

    stream.push({ type: "tool_execution_end", ... });

    // 工具调用之间的转向检查：
    const steering = await getSteeringMessages();
    if (steering.length > 0) {
      // 跳过剩余工具，注入转向消息
      for (const skipped of toolCalls.slice(i + 1)) {
        results.push(skipToolCall(skipped));
      }
      return { toolResults: results, steeringMessages: steering };
    }
  }
}