先看 llm.py 的整体骨架（llm.py，2714 行的核心文件）：

# llm.py:368
class LLM(BaseLLM):                              # 继承统一接口
    llm_type: Literal["litellm"] = "litellm"
    def __new__(cls, model, is_litellm=False, **kwargs): ...   # :393 工厂路由
    def _get_native_provider(cls, provider): ...              # :665 provider 映射表
    def call(self, messages, tools=None, ...): ...            # :1820 高层调用入口
    def supports_function_calling(self): ...                  # :2402 会不会原生工具调用
    def get_context_window_size(self): ...                    # :2443 上下文窗口多大
    def _prepare_completion_params(self, messages, tools): ...# :748 组装请求参数

抽象基类定义了"一个 LLM 至少要有哪些字段和方法"（llms/base_llm.py:150）：

# llms/base_llm.py:150
class BaseLLM(BaseModel, ABC):               # 既是 Pydantic 模型，又是抽象基类
    model_config = ConfigDict(arbitrary_types_allowed=True, populate_by_name=True)
    llm_type: str = "base"
    model: str                               # ★唯一必填：模型名
    temperature: float | None = None
    max_tokens: int | float | None = None
    stream: bool | None = None
    api_key: str | None = None
    base_url: str | None = None
    provider: str = Field(default="openai")
    stop: list[str] = Field(default_factory=list,
        validation_alias=AliasChoices("stop", "stop_sequences"))   # 两种名字都认
    additional_params: dict[str, Any] = Field(default_factory=dict)

以及那个所有子类都必须实现的抽象方法 call（llms/base_llm.py:312）：

# llms/base_llm.py:312
def call(
    self,
    messages: str | list[LLMMessage],
    tools: list[dict[str, BaseTool]] | None = None,
    callbacks: list[Any] | None = None,
    available_functions: dict[str, Any] | None = None,
    from_task: Task | None = None,
    from_agent: BaseAgent | None = None,
    response_model: type[BaseModel] | None = None,
) -> str | Any:
    """Call the LLM with the given messages. ...
    Returns: Either a text response (str) or the result of a tool call (Any)."""

LLM 在 BaseLLM 基础上又加了一大堆"LiteLLM 支持的高级参数"（llm.py:368）：

# llm.py:368
class LLM(BaseLLM):
    llm_type: Literal["litellm"] = "litellm"
    completion_cost: float | None = None       # 本次调用花了多少钱
    timeout: float | int | None = None
    top_p: float | None = None
    max_completion_tokens: int | None = None
    presence_penalty: float | None = None
    frequency_penalty: float | None = None
    response_format: JsonResponseFormat | type[BaseModel] | None = None  # 结构化输出（D51）
    seed: int | None = None
    reasoning_effort: Literal["none","low","medium","high"] | None = None # o 系列推理力度
    stream: bool = False
    thinking: Any = None                        # 思考/reasoning 配置
    context_window_size: int = 0                # 上下文窗口（D52 惰性算）
    is_anthropic: bool = False

最精妙的地方——LLM(...) 这行代码执行时，先进的不是 __init__ 而是 __new__（llm.py:393）。它是个"路由器"，注释里写死了 4 条优先级：

# llm.py:393
def __new__(cls, model: str, is_litellm: bool = False, **kwargs: Any) -> LLM:
    """Routing priority:
        1. custom_openai=True → 强制原生 OpenAI（需自定义 endpoint）
        2. provider 显式给了 → 用那个 provider
        3. 模型名带 "/" → 拆前缀，是原生大厂且模型在常量表里 → 原生；否则 LiteLLM
        4. 都不满足 → 从模型名推断 provider"""
    if not model or not isinstance(model, str):
        raise ValueError("Model must be a non-empty string")   # ★边界：空模型名直接拦
    custom_openai = bool(kwargs.pop("custom_openai", False))
    explicit_provider = kwargs.get("provider")
    if custom_openai:
        provider = "openai"; use_native = True                 # 路①
    elif explicit_provider:
        provider = explicit_provider; use_native = True         # 路②
    elif "/" in model:                                          # 路③
        prefix, _, model_part = model.partition("/")
        provider_mapping = {"openai":"openai","anthropic":"anthropic","claude":"anthropic",
            "azure":"azure","google":"gemini","gemini":"gemini","bedrock":"bedrock",
            "aws":"bedrock","ollama":"ollama", ...}
        canonical_provider = provider_mapping.get(prefix.lower())
        valid_native_model = bool(canonical_provider
            and cls._validate_model_in_constants(model_part, canonical_provider))
        if canonical_provider and valid_native_model:
            provider = canonical_provider; use_native = True
        # 否则落到 LiteLLM

路由算出 provider 字符串后，靠这张"查表"拿到真正的实现类（llm.py:665）：

# llm.py:665
def _get_native_provider(cls, provider: str) -> type | None:
    if provider == "openai":
        from crewai.llms.providers.openai.completion import OpenAICompletion
        return OpenAICompletion
    if provider == "anthropic" or provider == "claude":
        from crewai.llms.providers.anthropic.completion import AnthropicCompletion
        return AnthropicCompletion
    if provider == "azure" or provider == "azure_openai":
        from crewai.llms.providers.azure.completion import AzureCompletion
        return AzureCompletion
    if provider == "google" or provider == "gemini":
        from crewai.llms.providers.gemini.completion import GeminiCompletion
        return GeminiCompletion
    if provider == "bedrock":
        from crewai.llms.providers.bedrock.completion import BedrockCompletion
        return BedrockCompletion
    if provider == "snowflake":
        from crewai.llms.providers.snowflake.completion import SnowflakeCompletion
        return SnowflakeCompletion
    openai_compatible_providers = {"openrouter","deepseek","ollama","ollama_chat",
        "hosted_vllm","cerebras","dashscope"}
    if provider in openai_compatible_providers:
        from crewai.llms.providers.openai_compatible.completion import OpenAICompatibleCompletion
        return OpenAICompatibleCompletion
    return None                              # 没有原生实现 → 上层退回 LiteLLM

无论走哪条实现，执行器调的都是 call。看 LiteLLM 版的 call（llm.py:1820）：

# llm.py:1820
def call(self, messages, tools=None, callbacks=None, available_functions=None,
         from_task=None, from_agent=None, response_model=None) -> str | Any:
    with llm_call_context():                         # 生成本次调用的唯一 call_id
        self._emit_call_started_event(...)           # ① 广播"LLM 调用开始"事件（D26 事件系统）
        self._validate_call_params()                 # ② 校验参数合法
        if isinstance(messages, str):
            messages = [{"role": "user", "content": messages}]   # ③ 字符串→标准消息列表
        if "o1" in self.model.lower():
            for message in messages:
                if message.get("role") == "system":
                    message["role"] = "assistant"    # ④ o1 不支持 system，降级为 assistant
        if not self._invoke_before_llm_call_hooks(messages, from_agent):
            raise ValueError("LLM call blocked by before_llm_call hook")  # ⑤ 钩子可拦截
        with suppress_warnings():
            params = self._prepare_completion_params(messages, tools)     # ⑥ 组装请求参数
            if self._effective_stream():
                result = self._handle_streaming_response(params=params, ...)  # 流式
            else:
                result = self._handle_non_streaming_response(params=params, ...)  # 一次性
            if isinstance(result, str):
                result = self._invoke_after_llm_call_hooks(messages, result, ...) # 后置钩子

还记得 Day 08 那句 self.llm.supports_function_calling() 吗？它就在这（llm.py:2402）：

# llm.py:2402
def supports_function_calling(self) -> bool:
    """Note: 只用于 litellm 兜底路径。原生 provider 会各自覆盖此方法。"""
    if not _ensure_litellm():
        return True                          # litellm 没装 → 假设现代模型都支持
    try:
        provider = self._get_custom_llm_provider()
        return litellm.utils.supports_function_calling(self.model, custom_llm_provider=provider)
    except Exception as e:
        logging.error(f"Failed to check function calling support: {e!s}")
        return True                          # 查不到 → 默认 True

def supports_stop_words(self) -> bool:       # :2422
    model_lower = self.model.lower() if self.model else ""
    if "gpt-5" in model_lower:
        return False                         # ★硬编码：gpt-5 不支持 stop words
    ...