类的骨架（crew_agent_executor.py:98），它继承 BaseAgentExecutor：

# crew_agent_executor.py:98
class CrewAgentExecutor(BaseAgentExecutor):
    ...
    def invoke(self, inputs): ...              # :208 对外入口
    def _invoke_loop(self): ...                # :309 分流：原生 or 文本
    def _invoke_loop_react(self): ...          # :330 文本 ReAct 循环
    def _invoke_loop_native_tools(self): ...   # :484 原生函数调用循环
    def _handle_agent_action(self, ...): ...   # :1456 执行工具后把结果写回

对外入口 invoke（crew_agent_executor.py:208）：

# crew_agent_executor.py:208
def invoke(self, inputs: dict[str, Any]) -> dict[str, Any]:
    if self._resuming:
        self._resuming = False
    else:
        self.messages = []          # ① 清空消息历史
        self.iterations = 0         # ② 迭代计数归零
        self._setup_messages(inputs)        # ③ 组装系统提示 + 任务提示
        self._inject_multimodal_files(inputs)

    self._show_start_logs()
    self.ask_for_human_input = bool(inputs.get("ask_for_human_input", False))

    with _llm_stop_words_applied(self.llm, self):
        try:
            formatted_answer = self._invoke_loop()   # ④ 进入循环，直到拿到答案
        except AssertionError:
            ...
            raise
    if self.ask_for_human_input:
        formatted_answer = self._handle_human_feedback(formatted_answer)
    self._save_to_memory(formatted_answer)
    return {"output": formatted_answer.output}

进循环第一件事是分流（crew_agent_executor.py:309）：

# crew_agent_executor.py:309
def _invoke_loop(self) -> AgentFinish:
    use_native_tools = (
        hasattr(self.llm, "supports_function_calling")
        and callable(getattr(self.llm, "supports_function_calling", None))
        and self.llm.supports_function_calling()   # 模型支持"原生函数调用"吗？
        and self.original_tools                     # 且确实配了工具？
    )
    if use_native_tools:
        return self._invoke_loop_native_tools()    # 现代模型：结构化 tool_calls
    return self._invoke_loop_react()               # 老模型 / 无原生支持：文本解析

核心循环 _invoke_loop_react（crew_agent_executor.py:330），骨架是"没拿到 AgentFinish 就一直转"：

# crew_agent_executor.py:330
def _invoke_loop_react(self) -> AgentFinish:
    formatted_answer = None
    while not isinstance(formatted_answer, AgentFinish):   # ★核心条件
        try:
            if has_reached_max_iterations(self.iterations, self.max_iter):
                formatted_answer = handle_max_iterations_exceeded(...)   # 到上限强制收尾
                break
            enforce_rpm_limit(self.request_within_rpm_limit)   # 限流
            answer = get_llm_response(llm=..., messages=self.messages, ...)  # 问一次 LLM
            answer_str = str(answer) if not isinstance(answer, str) else answer
            formatted_answer = process_llm_response(answer_str, self.use_stop_words)  # 解析
            if isinstance(formatted_answer, AgentAction):     # 解析出"要调工具"
                tool_result = execute_tool_and_check_finality(...)   # 执行工具
                formatted_answer = self._handle_agent_action(formatted_answer, tool_result)
            self._invoke_step_callback(formatted_answer)
            self._append_message(formatted_answer.text)       # 结果进对话历史
        except OutputParserError as e:
            formatted_answer = handle_output_parser_exception(...)   # 解析失败→自愈
        except Exception as e:
            ...
        finally:
            self.iterations += 1        # ★每圈计数 +1（放 finally 保证一定执行）
    ...
    return formatted_answer

当这圈解析出 AgentAction，循环做的关键动作（crew_agent_executor.py:402）：

# crew_agent_executor.py:402
if isinstance(formatted_answer, AgentAction):
    fingerprint_context = {}
    if self.agent and hasattr(self.agent, "security_config") ...:
        fingerprint_context = {"agent_fingerprint": str(self.agent.security_config.fingerprint)}

    tool_result = execute_tool_and_check_finality(   # ★真正执行工具
        agent_action=formatted_answer,
        tools=self.tools,
        tools_handler=self.tools_handler,   # 缓存中枢（D11）
        task=self.task, agent=self.agent, crew=self.crew, ...)
    formatted_answer = self._handle_agent_action(formatted_answer, tool_result)  # 把结果写回

而 _handle_agent_action（crew_agent_executor.py:1456）里对"贴图片工具"有特殊处理，其余交给通用核心函数：

# crew_agent_executor.py:1456
def _handle_agent_action(self, formatted_answer, tool_result):
    add_image_tool = I18N_DEFAULT.tools("add_image")
    if isinstance(add_image_tool, dict) and formatted_answer.tool.casefold().strip() == ...:
        self.messages.append({"role": "assistant", "content": tool_result.result})
        return formatted_answer     # 图片：直接作为一条消息塞进去
    return handle_agent_action_core(       # 普通工具：走通用逻辑
        formatted_answer=formatted_answer, tool_result=tool_result,
        messages=self.messages, step_callback=self.step_callback, show_logs=self._show_logs)

另一条路 _invoke_loop_native_tools（crew_agent_executor.py:484），先把工具转成 OpenAI schema，再进 while True：

# crew_agent_executor.py:484
def _invoke_loop_native_tools(self) -> AgentFinish:
    if not self.original_tools:
        return self._invoke_loop_native_no_tools()   # 没工具→只问一次就结束
    openai_tools, available_functions, self._tool_name_mapping = (
        convert_tools_to_openai_schema(self.original_tools))
    while True:
        ...
        answer = get_llm_response(llm=..., tools=openai_tools, ...)  # LLM 直接返回结构化
        if isinstance(answer, list) and answer and self._is_tool_call_list(answer):
            tool_finish = self._handle_native_tool_calls(answer, available_functions)
            if tool_finish is not None:
                return tool_finish
            continue                       # 没结束→喂回结果，继续 while
        if isinstance(answer, str):        # 返回纯文本→就是最终答案
            formatted_answer = AgentFinish(thought="", output=answer, text=answer)
            ...
            return formatted_answer

关键在 _handle_native_tool_calls（crew_agent_executor.py:667）的策略——默认只执行第一个：

# crew_agent_executor.py:667（docstring + 精简）
"""Executes only the FIRST tool call and appends the result to message history.
This enables sequential tool execution with reflection after each tool ..."""
if len(parsed_calls) > 1:
    has_result_as_answer_in_batch = any(... "result_as_answer" ...)
    has_max_usage_count_in_batch  = any(... "max_usage_count" ...)
    if has_result_as_answer_in_batch or has_max_usage_count_in_batch:
        logger.debug("Skipping parallel native execution ...")   # 有特殊工具→不并行
    else:
        # :746 用线程池并行执行多个独立工具
        max_workers = min(8, len(execution_plan))
        with ThreadPoolExecutor(max_workers=max_workers) as pool:
            futures = {pool.submit(contextvars.copy_context().run,
                       self._execute_single_native_tool_call, ...): idx for ...}
            for future in as_completed(futures):
                ordered_results[futures[future]] = future.result()
        ...
        return None
# :786 常规情况：只取第一个执行
call_id, func_name, func_args = parsed_calls[0]
...

循环对各种"模型会犯的错"有细致处理（crew_agent_executor.py:434）：

# crew_agent_executor.py:434
except OutputParserError as e:
    formatted_answer = handle_output_parser_exception(   # ① 解析失败→把纠错提示喂回，重来
        e=e, messages=self.messages, iterations=self.iterations, ...)
except Exception as e:
    if e.__class__.__module__.startswith("litellm"):
        raise e                          # ② litellm 的错(如鉴权/网络)→原样抛出，不吞
    if is_context_length_exceeded(e):
        handle_context_length(           # ③ 上下文超长→自动摘要压缩历史
            respect_context_window=self.respect_context_window, messages=self.messages, ...)
        continue                         # 压缩后继续 while
    handle_unknown_error(PRINTER, e, verbose=self.agent.verbose)
    raise e
finally:
    self.iterations += 1

原生模式里还有一处降级（crew_agent_executor.py:577）：

# crew_agent_executor.py:577
if is_native_tool_calling_unsupported_error(e):
    self._append_text_tool_calling_fallback_message()
    return self._invoke_loop_react()     # ④ 模型其实不支持原生→当场切回文本 ReAct