目录布局一眼看清有哪些原生 provider（llms/providers/）：

llms/providers/
├── openai/completion.py             # OpenAICompletion
├── anthropic/completion.py          # AnthropicCompletion（今天主角）
├── azure/completion.py              # AzureCompletion
├── gemini/completion.py             # GeminiCompletion
├── bedrock/completion.py            # BedrockCompletion
├── snowflake/completion.py          # SnowflakeCompletion
├── openai_compatible/completion.py  # 一批"类 OpenAI"服务共用
└── utils/common.py                  # 共享工具（safe_tool_conversion 等）

它同样继承 BaseLLM，但字段是 Anthropic 专属的（anthropic/completion.py:148）：

# anthropic/completion.py:148
class AnthropicCompletion(BaseLLM):
    """Anthropic native completion implementation. ...native tool use,
    streaming support, and proper message formatting."""
    llm_type: Literal["anthropic"] = "anthropic"
    model: str = "claude-3-5-sonnet-20241022"
    max_retries: int = 2
    max_tokens: int = 4096                        # ★Anthropic 要求 max_tokens 必填
    stream: bool = False
    client_params: dict[str, Any] | None = None
    interceptor: BaseInterceptor[...] | None = None
    thinking: AnthropicThinkingConfig | None = None       # 思考模式配置
    response_format: JsonResponseFormat | type[BaseModel] | None = None
    tool_search: AnthropicToolSearchConfig | None = None
    is_claude_3: bool = False
    supports_tools: bool = True
    _client: Any = PrivateAttr(default=None)              # SDK 同步客户端（私有）
    _async_client: Any = PrivateAttr(default=None)        # SDK 异步客户端

初始化前还有一步字段归一化（anthropic/completion.py:176）：

# anthropic/completion.py:176
@model_validator(mode="before")
def _normalize_anthropic_fields(cls, data):
    popped = data.pop("stop_sequences", None)
    seqs = popped if popped is not None else (data.get("stop") or [])
    if isinstance(seqs, str): seqs = [seqs]
    data["stop"] = seqs                                   # 统一成 list
    data["is_claude_3"] = "claude-3" in data.get("model", "").lower()  # 顺手判代际
    ts = data.get("tool_search")
    if ts is True: data["tool_search"] = AnthropicToolSearchConfig()   # True→默认配置对象
    return data

构建 SDK 客户端这一步做得很谨慎（anthropic/completion.py:195）：

# anthropic/completion.py:195
@model_validator(mode="after")
def _init_clients(self) -> AnthropicCompletion:
    """Eagerly build clients when the API key is available, otherwise
    defer so LLM(model="anthropic/...") can be constructed at module
    import time even before deployment env vars are set."""
    try:
        self._client = self._build_sync_client()
        self._async_client = self._build_async_client()
    except ValueError:
        pass                             # ★没 key → 静默跳过，不报错
    return self

def _get_sync_client(self) -> Any:       # :222
    if self._client is None:             # 用的时候若还没建，补建
        self._client = self._build_sync_client()
    return self._client

最能体现"翻译官"价值的方法（anthropic/completion.py:653），docstring 列出了 Anthropic 的硬性要求：

# anthropic/completion.py:653
def _format_messages_for_anthropic(self, messages):
    """Anthropic has specific requirements:
    - System messages are separate from conversation messages   # ① system 单拎出来
    - Messages must alternate between user and assistant          # ② 必须交替
    - First message must be from user                             # ③ 首条必是 user
    - Tool results must be in user messages with tool_result blocks  # ④ 工具结果进 user
    - When thinking is enabled, assistant messages must start with thinking blocks
    Returns: Tuple of (formatted_messages, system_message)."""
    base_formatted = super()._format_messages(messages)   # 先做通用格式化
    formatted_messages: list[LLMMessage] = []
    system_message: str | None = None
    pending_tool_results: list[dict[str, Any]] = []
    for message in base_formatted:
        ...                                                # 逐条按四条铁律重排

对比 Day 49 的 LiteLLM 版 call，Anthropic 版走自己的流程（anthropic/completion.py:277）：

# anthropic/completion.py:277
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():
        try:
            self._emit_call_started_event(...)                     # ① 同样广播开始事件
            formatted_messages, system_message = \
                self._format_messages_for_anthropic(messages)      # ② 翻译成 Anthropic 格式
            if not self._invoke_before_llm_call_hooks(formatted_messages, from_agent):
                raise ValueError("LLM call blocked by before_llm_call hook")   # ③ 同样过钩子
            completion_params = self._prepare_completion_params(
                formatted_messages, system_message, tools, available_functions)  # ④ 组参数
            effective_response_model = response_model or self.response_format
            if self._effective_stream():
                return self._handle_streaming_completion(completion_params, ...)  # 流式
            return self._handle_completion(completion_params, ...)                # 一次性
        except Exception as e:
            self._emit_call_failed_event(error=f"Anthropic API call failed: {e!s}", ...)
            raise                                                  # ⑤ 失败也广播事件再抛

最省心的复用——一批"长得像 OpenAI"的服务共用一个类（openai_compatible/completion.py:113）：

# openai_compatible/completion.py:113
class OpenAICompatibleCompletion(OpenAICompletion):   # ★直接继承 OpenAICompletion
    """Supported providers:
        - openrouter / deepseek / ollama / ollama_chat
        - hosted_vllm / cerebras / dashscope
    Example:
        llm = LLM(model="deepseek/deepseek-chat")
        llm = LLM(model="llama3", provider="ollama")"""

    @model_validator(mode="before")
    def _resolve_provider_config(cls, data):
        provider = data.get("provider", "")
        config = OPENAI_COMPATIBLE_PROVIDERS.get(provider)
        if config is None:
            supported = ", ".join(sorted(OPENAI_COMPATIBLE_PROVIDERS.keys()))
            raise ValueError(f"Unknown OpenAI-compatible provider: {provider}. "
                             f"Supported providers: {supported}")   # ★未知 provider 明确报错
        data["api_key"]  = cls._resolve_api_key(data.get("api_key"), config, provider)
        data["base_url"] = cls._resolve_base_url(data.get("base_url"), config, provider)
        data["default_headers"] = cls._resolve_headers(data.get("default_headers"), config)
        return data

Day 49 说"原生 provider 会覆盖能力探测方法"，这就是例子（anthropic/completion.py:1846）：

# anthropic/completion.py:1846
def get_context_window_size(self) -> int:
    from crewai.llm import CONTEXT_WINDOW_USAGE_RATIO
    context_windows = {
        "claude-3-5-sonnet": 200000, "claude-3-5-haiku": 200000,
        "claude-3-opus": 200000,     "claude-3-7-sonnet": 200000,
        "claude-2.1": 200000,        "claude-2": 100000,
        "claude-instant": 100000,
    }
    for model_prefix, size in context_windows.items():
        if self.model.startswith(model_prefix):
            return int(size * CONTEXT_WINDOW_USAGE_RATIO)   # 命中→按前缀返回
    return int(200000 * CONTEXT_WINDOW_USAGE_RATIO)         # 默认 200k

def supports_function_calling(self) -> bool:  # :1838
    return True                                # Anthropic 都支持，直接 True