停止条件

def should_continue(self) -> bool:
    """Return True if the loop may proceed.

    Evaluates all evaluators with OR semantics — the first
    evaluator that returns True from ``should_stop()``
    terminates the loop and records the stop reason.
    """
    if self._aborted:
        self._stop_reason = "Aborted"
        return False

    ctx = self._build_eval_context()
    for ev in self._evaluators:
        try:
            if ev.should_stop(ctx):
                self._stop_reason = ev.name
                logger.info(
                    "Stop condition met: %s",
                    ev.name,
                )
                return False
        except Exception:
            logger.warning(
                "Evaluator %s raised an error",
                ev.name,
                exc_info=True,
            )
    return True

let needs_follow_up = model_needs_follow_up || has_pending_input;
let token_limit_reached = token_status.token_limit_reached;
// ...（425-499 行：上下文快满时先压缩再继续）
if !needs_follow_up {
    last_agent_message = sampling_request_last_agent_message;
    let stop_outcome = run_turn_stop_hooks(
        &sess,
        &step_context,
        stop_hook_active,
        last_agent_message.clone(),
    )
    .await;
    if stop_outcome.should_block {
        if let Some(hook_prompt_message) =
            build_hook_prompt_message(&stop_outcome.continuation_fragments)
        {
            sess.record_response_item_and_emit_turn_item(
                &turn_context,
                hook_prompt_message,
            )
            .await;
            sess.input_queue
                .accept_mailbox_delivery_for_current_turn(
                    &sess.active_turn,
                    &turn_context.sub_id,
                )
                .await;
            stop_hook_active = true;
            continue;
        } else {
            sess.send_event(
                &turn_context,
                EventMsg::Warning(WarningEvent {
                    message: "Stop hook requested continuation without a prompt; ignoring the block.".to_string(),
                }),
            )
            .await;
        }
    }
    if stop_outcome.should_stop {
        break;
    }

let turnEnds: TurnEndReason | null = null
let target: InboxTarget = 'next-turn'
try {
  while (true) {
    signal.throwIfAborted()
    const step = phase.step + 1
    const decision = await this.preStep(target, { turn, step })
    if (decision.kind === 'reject') {
      turnEnds = { kind: 'blocked' }
      return false
    }
    if (turnEnds && decision.messages.length === 0) break
    // A removed waking message or an enter decision rewritten to empty
    // still owns the initial turn boundary, but it spends no model call.
    if (phase.step === 0 && decision.messages.length === 0) {
      turnEnds = { kind: 'completed' }
      return false
    }
    signal.throwIfAborted()
    this.session.append('step/start', { turn, step })
    phase.step = step
    try {
      for (const message of decision.messages) {
        this.session.append('user/message', message, { surfaceOp: 'append' })
      }
      // max-tokens is sticky: once any step hits the ceiling, later steps
      // that complete normally must not downgrade the turn outcome.
      const stepEnd = await this.step(decision.assembly)
      // max-tokens stays sticky: a later completed step must not
      // downgrade the turn outcome.
      if (turnEnds === null || turnEnds.kind !== 'max-tokens') turnEnds = stepEnd
    } finally {
      this.session.append('step/end', { turn, step })
    }
    signal.throwIfAborted()
    if (turnEnds && this.inbox.nextStep.length === 0) {
      await this.dispatch.serial('agent/turn-stopping', { turn, signal })
      signal.throwIfAborted()
    }
    if (turnEnds && this.inbox.nextStep.length === 0) break
    target = 'next-step'
  }
// ...（302-315 行：异常分支：中止记为 aborted，其余错误结构化后记为 error）
} finally {
  try {
    // oxlint-disable-next-line typescript/no-non-null-assertion -- every exit assigns a turn ending
    this.session.append('turn/end', { turn, reason: turnEnds! })
  } catch (error: unknown) {
    this.throwError(error)
  }
}
if (!this.inbox.hasPending) return false
phase.abort = new AbortController()
// A fresh controller makes a latch set on the old one stale: the live driver claims the queue itself.
phase.wakeRequested = false
phase.step = 0
return true

	if (message.stopReason === "error" || message.stopReason === "aborted") {
		await emit({ type: "turn_end", message, toolResults: [] });
		await emit({ type: "agent_end", messages: newMessages });
		return;
	}

	// Check for tool calls
	const toolCalls = message.content.filter((c) => c.type === "toolCall");

	const toolResults: ToolResultMessage[] = [];
	hasMoreToolCalls = false;
	if (toolCalls.length > 0) {
		// A "length" stop means the output was cut off by the token limit, so
		// every tool call in the message may carry truncated arguments. Fail
		// them all instead of executing potentially borked calls.
		const executedToolBatch =
			message.stopReason === "length"
				? await failToolCallsFromTruncatedMessage(toolCalls, emit)
				: await executeToolCalls(currentContext, message, config, signal, emit);
		toolResults.push(...executedToolBatch.messages);
		hasMoreToolCalls = !executedToolBatch.terminate;
 // ...（217-246 行：发出 turn_end，允许钩子替换下一轮的上下文、模型与思考强度）
	if (
		await config.shouldStopAfterTurn?.({
			message,
			toolResults,
			context: currentContext,
			newMessages,
		})
	) {
		await emit({ type: "agent_end", messages: newMessages });
		return;
	}

	pendingMessages = (await config.getSteeringMessages?.()) || [];
}

// Agent would stop here. Check for follow-up messages.
const followUpMessages = (await config.getFollowUpMessages?.()) || [];
if (followUpMessages.length > 0) {
	// Set as pending so inner loop processes them
	pendingMessages = followUpMessages;
	continue;
}

// No more messages, exit
break;