关键方法一览（tool_usage.py:76 的 ToolUsage 类）：

# tool_usage.py
class ToolUsage:
    def use(self, calling, tool_string): ...            # :132 总入口
    def parse_tool_calling(self, tool_string): ...      # :121 解析入口
    def _tool_calling(self, tool_string): ...           # :861 三级降级解析
    def _validate_tool_input(self, tool_input): ...     # :884 四招修 JSON
    def _select_tool(self, tool_name): ...              # :759 模糊匹配工具
    def _use(self, tool_string, tool, calling): ...     # :469 真正执行

整个 tool_calling.py 只有两个小模型（tool_calling.py:11）：

# tool_calling.py:11
class ToolCalling(BaseModel):
    tool_name: str = Field(..., description="The name of the tool to be called.")
    arguments: dict[str, Any] | None = Field(
        ..., description="A dictionary of arguments to be passed to the tool.")

class InstructorToolCalling(PydanticBaseModel):
    tool_name: str = PydanticField(..., description="The name of the tool to be called.")
    arguments: dict[str, Any] | None = PydanticField(
        ..., description="A dictionary of arguments to be passed to the tool.")

解析核心 _tool_calling（tool_usage.py:861）是一个"try 里套 try、失败就递归重试"的结构：

# tool_usage.py:861
def _tool_calling(self, tool_string):
    try:
        try:
            return self._original_tool_calling(tool_string, raise_error=True)  # ① 首选：直接解析
        except Exception:
            if self.function_calling_llm:
                return self._function_calling(tool_string)   # ② 退而求其次：让 LLM 帮忙解析
            return self._original_tool_calling(tool_string)  # 无备用 LLM → 再试一次不抛错版
    except Exception as e:
        self._run_attempts += 1
        if self._run_attempts > self._max_parsing_attempts:  # ③ 试够上限 → 放弃，返回错误提示
            self._telemetry.tool_usage_error(llm=self.function_calling_llm)
            if self.task:
                self.task.increment_tools_errors()
            return ToolUsageError(
                f"{I18N_DEFAULT.errors('tool_usage_error').format(error=e)}\n"
                f"Moving on then. {I18N_DEFAULT.slice('format').format(tool_names=self.tools_names)}")
        return self._tool_calling(tool_string)               # ★递归重试

参数往往是破损的。_validate_tool_input（tool_usage.py:884）依次用四种手段尝试：

# tool_usage.py:884
def _validate_tool_input(self, tool_input: str | None) -> dict:
    if tool_input is None:
        return {}
    if not isinstance(tool_input, str) or not tool_input.strip():
        raise Exception("Tool input must be a valid dictionary in JSON or Python literal format")

    try:                                    # 招式1：标准 JSON
        arguments = json.loads(tool_input)
        if isinstance(arguments, dict):
            return arguments
    except (JSONDecodeError, TypeError):
        pass

    try:                                    # 招式2：Python 字面量（单引号、True/None 等）
        arguments = ast.literal_eval(tool_input)
        if isinstance(arguments, dict):
            return arguments
    except (ValueError, SyntaxError):
        repaired_input = repair_json(tool_input)

    try:                                    # 招式3：JSON5（宽松 JSON，允许尾逗号/注释）
        arguments = json5.loads(tool_input)
        if isinstance(arguments, dict):
            return arguments
    except (JSONDecodeError, ValueError, TypeError):
        pass

    try:                                    # 招式4：repair_json 强力修复（补括号/引号）
        repaired_input = str(repair_json(tool_input, skip_json_loads=True))
        if self.agent and self.agent.verbose:
            PRINTER.print(content=f"Repaired JSON: {repaired_input}", color="blue")
        arguments = json.loads(repaired_input)
        if isinstance(arguments, dict):
            return arguments
    except Exception as e:
        ...
    error_message = "Tool input must be a valid dictionary in JSON or Python literal format"
    self._emit_validate_input_error(error_message)      # 四招全败 → 发事件 + 抛错
    raise Exception(error_message)

模型给的工具名未必精确，_select_tool（tool_usage.py:759）用字符串相似度匹配：

# tool_usage.py:759
def _select_tool(self, tool_name: str) -> Any:
    sanitized_input = sanitize_tool_name(tool_name)
    order_tools = sorted(                           # ★按相似度从高到低排序
        self.tools,
        key=lambda tool: SequenceMatcher(
            None, sanitize_tool_name(tool.name), sanitized_input).ratio(),
        reverse=True)
    for tool in order_tools:
        sanitized_tool = sanitize_tool_name(tool.name)
        if (sanitized_tool == sanitized_input       # 完全相等 → 直接命中
                or SequenceMatcher(None, sanitized_tool, sanitized_input).ratio() > 0.85):
            return tool                             # 相似度 > 0.85 → 认为是它
    if self.task:
        self.task.increment_tools_errors()
    if tool_name and tool_name != "":
        error = f"Action '{tool_name}' don't exist, these are the only available Actions:\n{self.tools_description}"
        crewai_event_bus.emit(self, ToolSelectionErrorEvent(...))
        raise Exception(error)
    error = f"I forgot the Action name, these are the only available Actions: {self.tools_description}"
    ...
    raise Exception(error)

对外总入口 use（tool_usage.py:132）把前面几块串起来：

# tool_usage.py:132
def use(self, calling, tool_string) -> str:
    if isinstance(calling, ToolUsageError):          # 解析阶段就失败了
        error = calling.message
        if self.agent and self.agent.verbose:
            PRINTER.print(content=f"\n\n{error}\n", color="red")
        if self.task:
            self.task.increment_tools_errors()
        return error                                 # 把错误当结果返回（喂回给 LLM）

    try:
        tool = self._select_tool(calling.tool_name)  # ★选工具（L05）
    except Exception as e:
        error = getattr(e, "message", str(e))
        if self.task:
            self.task.increment_tools_errors()
        if self.agent and self.agent.verbose:
            PRINTER.print(content=f"\n\n{error}\n", color="red")
        return error                                 # 选不到 → 返回错误提示
    ...
    # 之后走 _use(...) 真正执行（L07 / D30）

_use 真正调用工具前，会把参数按 schema 过滤一遍（tool_usage.py:570）：

# tool_usage.py:570
if calling.arguments:
    try:
        acceptable_args = tool.args_schema.model_json_schema()["properties"].keys()
        arguments = {                      # ★只保留 schema 里声明的字段
            k: v for k, v in calling.arguments.items() if k in acceptable_args}
        result = tool.invoke(input=arguments, config=fingerprint_config)
    except Exception:
        arguments = calling.arguments      # 过滤失败 → 用原始参数兜底
        result = tool.invoke(input=arguments, config=fingerprint_config)
else:
    result = tool.invoke(input={}, config=fingerprint_config)  # 无参数工具