三个角色的分工：

整个 tools_handler.py 很短（tools_handler.py:15）：

# tools_handler.py:15
class ToolsHandler(BaseModel):
    cache: CacheHandler | None = Field(default=None)
    last_used_tool: ToolCalling | InstructorToolCalling | None = Field(default=None)

    def on_tool_use(self, calling, output, should_cache=True) -> None:
        self.last_used_tool = calling                 # ① 记下"最后用的工具"
        if self.cache and should_cache and calling.tool_name != CacheTools().name:
            input_str = ""
            if calling.arguments:
                if isinstance(calling.arguments, dict):
                    input_str = json.dumps(calling.arguments)    # 参数序列化成字符串
                else:
                    input_str = str(calling.arguments)
            self.cache.add(                            # ② 写缓存
                tool=calling.tool_name, input=input_str, output=output)

真正的存储 CacheHandler（cache_handler.py）——本质是个字典 + 读写锁：

# cache_handler.py
class CacheHandler(BaseModel):
    _cache: dict[str, Any] = PrivateAttr(default_factory=dict)
    _lock: RWLock = PrivateAttr(default_factory=RWLock)      # 读写锁

    def add(self, tool: str, input: str, output: Any) -> None:
        with self._lock.w_locked():                          # ★写锁：独占
            self._cache[f"{tool}-{input}"] = output          # key = "工具名-参数串"

    def read(self, tool: str, input: str) -> Any | None:
        with self._lock.r_locked():                          # ★读锁：可并发
            return self._cache.get(f"{tool}-{input}")

_use 一开始就尝试读缓存（tool_usage.py:516）：

# tool_usage.py:516
from_cache = False
result = None
try:
    if self.tools_handler and self.tools_handler.cache:
        input_str = ""
        if calling.arguments:
            if isinstance(calling.arguments, dict):
                input_str = json.dumps(calling.arguments)
            else:
                input_str = str(calling.arguments)
        result = self.tools_handler.cache.read(          # ★先读缓存
            tool=sanitize_tool_name(calling.tool_name), input=input_str)
        from_cache = result is not None                 # 命中标记
    ...
    elif result is None:                                 # ★没命中才真执行
        # ... 真正 tool.invoke(...) ...

执行完后要不要写缓存，由每个工具的 cache_function 决定（tool_usage.py:591）：

# tool_usage.py:591
if self.tools_handler:
    should_cache = True
    # 从原工具（to_structured_tool 转来的）上找 cache_function
    original_tool = getattr(available_tool, "_original_tool", None)
    cache_func = None
    if original_tool and hasattr(original_tool, "cache_function"):
        cache_func = original_tool.cache_function
    elif hasattr(available_tool, "cache_function"):
        cache_func = available_tool.cache_function

    if cache_func:
        should_cache = cache_func(calling.arguments, result)  # ★传入参数和结果，返回布尔
    self.tools_handler.on_tool_use(
        calling=calling, output=result, should_cache=should_cache)  # 把决定传给中枢

默认的 cache_function（Day 27 见过，base_tool.py:81）永远返回 True：

# base_tool.py:81
def _default_cache_function(_args=None, _result=None) -> bool:
    """Default cache function that always allows caching."""
    return True

from crewai.tools import tool

@tool
def stock_price(symbol: str) -> str:
    """查询实时股价"""
    return fetch_price(symbol)

# 实时数据缓存了就过期 → 让 cache_function 永远返回 False
stock_price.cache_function = lambda args, result: False

缓存解决"重复调用还得走一遍流程"，而 _check_tool_repeated_usage（tool_usage.py:728）直接拦住"紧接着又调完全一样的一次"：

# tool_usage.py:728
def _check_tool_repeated_usage(self, calling) -> bool:
    if not self.tools_handler:
        return False
    if last_tool_usage := self.tools_handler.last_used_tool:   # 拿"上一次用的工具"
        return (
            sanitize_tool_name(calling.tool_name)
            == sanitize_tool_name(last_tool_usage.tool_name)   # 工具名相同
        ) and (calling.arguments == last_tool_usage.arguments) # 且参数完全相同
    return False

命中时 _use 会直接返回一句提示（tool_usage.py:476）：

# tool_usage.py:476
if self._check_tool_repeated_usage(calling=calling):
    result = I18N_DEFAULT.errors("task_repeated_usage").format(tool_names=self.tools_names)
    self.last_raw_result = result
    self._telemetry.tool_repeated_usage(...)
    return self._format_result(result=result)   # 直接回"你重复了"，不执行

执行前还会查用量上限（tool_usage.py:546，配合 Day 27 的 max_usage_count）：

# tool_usage.py:546
usage_limit_error = self._check_usage_limit(available_tool, sanitize_tool_name(tool.name))
if usage_limit_error:
    result = usage_limit_error
    self.last_raw_result = result
    self._telemetry.tool_usage_error(llm=self.function_calling_llm)
    result = self._format_result(result=result)     # 超限 → 返回提示，不执行
elif result is None:
    ...  # 未超限且未命中缓存 → 真执行

执行成功后，若工具设了 result_as_answer，会标记"这就是最终答案"（tool_usage.py:623）：

# tool_usage.py:623
if (hasattr(available_tool, "result_as_answer")
        and available_tool.result_as_answer):
    result_as_answer = available_tool.result_as_answer
    data["result_as_answer"] = result_as_answer       # 传给执行循环 → 直接收尾