主循环形态

for iteration in range(start_iteration, self._config.max_iterations):
    logger.info(f"ReAct iteration {iteration + 1}/{self._config.max_iterations}")

    # Honor force_finish requests set at iteration boundary
    # (e.g. by rails on AFTER_REACT_ITERATION). This lets a
    # graceful abort take effect at the top of the next
    # iteration, after the previous one fully completes.
    boundary_finish = ctx.consume_force_finish()
    if boundary_finish:
        await self.context_engine.save_contexts(session)
        invoke_inputs.result = boundary_finish.result
        break

    # Inject the steering messages the rails let through
    # before the next model call.
    steering = await self._drain_steering_batch(ctx)

let mut next_step_context = Some(first_step_context);
loop {
    // Note that pending_input would be something like a message the user
    // submitted through the UI while the model was running. Though the UI
    // may support this, the model might not.
    let pending_input = if can_drain_pending_input {
        sess.input_queue
            .get_pending_input(&sess.active_turn)
            .await
            .0
    } else {
        Vec::new()
    };

private async kick(): Promise<void> {
  try {
    while (await this.turn()) {}
  } catch (_error) {
    // Reported failures and cancellation are contained at the driver boundary.
  } finally {
    if (this.phase.kind === 'running') {
      const { turn, wakeRequested } = this.phase
      this.setPhase({ kind: 'idle', lastTurn: turn })
      if (wakeRequested && this.inbox.hasPending) this.wakeDriver()
    }
  }
}

// Check for steering messages at start (user may have typed while waiting)
let pendingMessages: AgentMessage[] = (await config.getSteeringMessages?.()) || [];

// Outer loop: continues when queued follow-up messages arrive after agent would stop
while (true) {
    let hasMoreToolCalls = true;

    // Inner loop: process tool calls and steering messages
    while (hasMoreToolCalls || pendingMessages.length > 0) {