类的骨架（base_tool.py:103），它同时继承 Pydantic 的 BaseModel 和 ABC（抽象基类）：

# base_tool.py:103
class BaseTool(BaseModel, ABC):
    model_config = ConfigDict(arbitrary_types_allowed=True)

    name: str          # 工具的唯一名字
    description: str   # 告诉模型"何时/为何用它"
    args_schema: type[PydanticBaseModel]      # 参数的 schema
    result_schema: type[PydanticBaseModel] | None
    cache_function: SerializableCallable      # 决定要不要缓存
    result_as_answer: bool = False            # 结果直接当最终答案？
    max_usage_count: int | None = None        # 最多用几次

    @abstractmethod
    def _run(self, *args, **kwargs) -> Any: ...   # ★子类必须实现的"真正干活"
    def run(self, *args, **kwargs) -> Any: ...     # :314 统一入口
    def to_structured_tool(self) -> CrewStructuredTool: ...  # :393 转执行态

核心字段的完整声明（base_tool.py:139 起）：

# base_tool.py:139
name: str = Field(description="The unique name of the tool ...")
description: str = Field(description="Used to tell the model how/when/why to use the tool.")
env_vars: list[EnvVar] = Field(default_factory=list, ...)   # 依赖哪些环境变量
args_schema: type[PydanticBaseModel] = Field(
    default=_ArgsSchemaPlaceholder, validate_default=True, ...)  # 参数 schema
result_schema: type[PydanticBaseModel] | None = Field(default=None, ...)  # 输出 schema
# base_tool.py:176
cache_function: SerializableCallable = Field(default=_default_cache_function, ...)
result_as_answer: bool = Field(default=False, ...)   # 工具结果=最终答案
max_usage_count: int | None = Field(default=None, ...)  # 用量上限
current_usage_count: int = Field(default=0, ...)        # 已用次数
_usage_lock: threading.Lock = PrivateAttr(default_factory=threading.Lock)  # 计数锁

所以 BaseTool 用一个 字段校验器 在创建时自动推断（base_tool.py:200）：

# base_tool.py:200
@field_validator("args_schema", mode="before")
@classmethod
def _default_args_schema(cls, v):
    if isinstance(v, dict):          # 从存档反序列化：dict → 模型类
        restored = _deserialize_schema(v)
        if restored is not None:
            return restored
    if v is None or v == cls._ArgsSchemaPlaceholder:
        pass                         # 没提供 → 往下走，从签名生成
    elif isinstance(v, type):
        return v                     # 已经给了一个模型类 → 直接用

    run_sig = signature(cls._run)    # ★读 _run 的函数签名
    fields: dict[str, Any] = {}
    for param_name, param in run_sig.parameters.items():
        if param_name in ("self", "return"):
            continue
        if param.kind in (Parameter.VAR_POSITIONAL, Parameter.VAR_KEYWORD):
            continue   # 跳过 *args / **kwargs
        annotation = param.annotation if param.annotation != param.empty else Any
        if param.default is param.empty:
            fields[param_name] = (annotation, ...)      # 无默认 → 必填
        else:
            fields[param_name] = (annotation, param.default)  # 有默认 → 可选
    if not fields:                   # _run 没参数？再看 _arun（异步版）
        arun_sig = signature(cls._arun)
        ...
    return create_model(f"{cls.__name__}Schema", **fields)   # 动态造一个模型类

统一入口 run（base_tool.py:314）——注意它不是直接调 _run，而是先过三关：

# base_tool.py:314
def run(self, *args, **kwargs) -> Any:
    if not args:
        kwargs = self._validate_kwargs(kwargs)   # ① 关卡一：校验参数

    limit_error = self._claim_usage()             # ② 关卡二：占用量名额
    if limit_error:
        return limit_error                        # 超限 → 直接返回错误字符串

    result = self._run(*args, **kwargs)           # ③ 真正干活

    if asyncio.iscoroutine(result):
        result = asyncio.run(result)              # _run 若返回协程 → 跑完它
    return result

关卡一 _validate_kwargs（base_tool.py:272）用 args_schema 做校验，失败时给出可读的提示：

# base_tool.py:272
def _validate_kwargs(self, kwargs):
    if self.args_schema is not None and self.args_schema.model_fields:
        try:
            validated = self.args_schema.model_validate(kwargs)
            return validated.model_dump()          # 校验通过 → 用清洗后的值
        except Exception as e:
            hint = build_schema_hint(self.args_schema)   # 拼出"期望哪些参数"
            raise ValueError(
                f"Tool '{self.name}' arguments validation failed: {e}{hint}")
    return kwargs

关卡二 _claim_usage（base_tool.py:295）——"检查上限 + 计数 +1"必须是一个原子动作：

# base_tool.py:295
def _claim_usage(self) -> str | None:
    with self._usage_lock:            # ★加锁：同一时刻只有一个线程能进来
        if (self.max_usage_count is not None
                and self.current_usage_count >= self.max_usage_count):
            return (f"Tool '{self.name}' has reached its usage limit of "
                    f"{self.max_usage_count} times and cannot be used anymore.")
        self.current_usage_count += 1   # 没超限 → 占一个名额
        return None                     # None = 允许执行

大多数人不会去继承 BaseTool，而是用 @tool 装饰器（base_tool.py:676）。它支持三种写法：

# base_tool.py:676（精简）
def tool(*args, result_schema=None, result_as_answer=False, max_usage_count=None):
    def _make_with_name(tool_name: str):
        def _make_tool(f):
            if f.__doc__ is None:
                raise ValueError("Function must have a docstring")   # ★强制写文档
            func_sig = signature(f)
            fields = {}
            for param_name, param in func_sig.parameters.items():
                ...   # 和 L03 一样：从签名抽字段
            class_name = "".join(tool_name.split()).title()
            args_schema = create_model(class_name, **fields)
            return Tool(name=tool_name, description=f.__doc__, func=f,   # ★描述=docstring
                        args_schema=args_schema, result_as_answer=result_as_answer,
                        max_usage_count=max_usage_count, ...)
        return _make_tool
    if len(args) == 1 and callable(args[0]):        # 用法1：@tool（裸用）
        return _make_with_name(args[0].__name__)(args[0])
    if len(args) == 1 and isinstance(args[0], str): # 用法2：@tool("自定义名")
        return _make_with_name(args[0])
    if len(args) == 0:                              # 用法3：@tool(result_as_answer=True)
        def decorator(f): return _make_with_name(f.__name__)(f)
        return decorator
    raise ValueError("Invalid arguments")

from crewai.tools import tool

@tool("天气查询")
def get_weather(city: str) -> str:
    """查询某城市当前天气，输入城市名，返回温度描述。"""
    return f"{city} 当前 18°C 晴"

# get_weather 现在是一个 Tool 实例
print(get_weather.run(city="上海"))   # → 上海 当前 18°C 晴

工具创建后有个 model_post_init 钩子会调 _generate_description（base_tool.py:482），把参数 schema拼进描述里：

# base_tool.py:482
def _generate_description(self) -> None:
    schema = generate_model_description(self.args_schema)
    args_json = json.dumps(schema["json_schema"]["schema"], indent=2)
    self.description = (
        f"Tool Name: {sanitize_tool_name(self.name)}\n"
        f"Tool Arguments: {args_json}\n"        # ★把参数 JSON schema 拼进来
        f"Tool Description: {self.description}")