core/model_manager.py 里有三个关键类，各管一摊：

还有一个跨文件的搭档 ProviderManager（provider_manager.py:557）——它是"配置中心"，ModelManager 靠它拿到"某供应商在某租户下的完整配置"。

入口是 ModelManager.get_model_instance（api/core/model_manager.py:475）：

# api/core/model_manager.py:475
def get_model_instance(self, tenant_id, provider, model_type, model) -> ModelInstance:
    if not provider:
        return self.get_default_model_instance(tenant_id, model_type)   # 没指定就用默认模型
    provider_model_bundle = self._provider_manager.get_provider_model_bundle(  # ★向配置中心要"包"
        tenant_id=tenant_id, provider=provider, model_type=model_type
    )
    return ModelInstance(provider_model_bundle, model)                  # ★用这个包造实例

造实例时，ModelInstance.__init__（api/core/model_manager.py:40）做了几件关键准备：

# api/core/model_manager.py:40
def __init__(self, provider_model_bundle, model, credentials=None):
    self.provider_model_bundle = provider_model_bundle
    self.model_name = model
    self.provider = provider_model_bundle.configuration.provider.provider
    if credentials is None:
        credentials = self._fetch_credentials_from_bundle(provider_model_bundle, model)  # ① 取凭据
    self.credentials = credentials
    self.model_type_instance = self.provider_model_bundle.model_type_instance            # ② 拿到"模型类型实例"
    self.load_balancing_manager = self._get_load_balancing_manager(                      # ③ 若配了多 key，建轮询器
        configuration=provider_model_bundle.configuration,
        model_type=provider_model_bundle.model_type_instance.model_type,
        model=model, credentials=self.credentials,
    )

拿到 ModelInstance 后，业务层调 invoke_llm（api/core/model_manager.py:154）：

# api/core/model_manager.py:154
def invoke_llm(self, prompt_messages, model_parameters=None, tools=None,
               stop=None, stream=True, callbacks=None, request_metadata=None):
    if not isinstance(self.model_type_instance, LargeLanguageModel):
        raise Exception("Model type instance is not LargeLanguageModel")     # 类型防呆
    return cast(Union[LLMResult, Generator], self._round_robin_invoke(       # ★统一走轮询包装
        self.model_type_instance.invoke,                                     #    真正要调的函数
        model=self.model_name, credentials=self.credentials,
        prompt_messages=list(prompt_messages), model_parameters=model_parameters,
        tools=list(tools) if tools else None, stop=list(stop) if stop else None,
        stream=stream, callbacks=callbacks, request_metadata=request_metadata,
    ))

包装函数 _round_robin_invoke（api/core/model_manager.py:378）的骨架——注意"没配负载均衡就直调"这个快路径：

# api/core/model_manager.py:378
def _round_robin_invoke(self, function, *args, **kwargs):
    if not self.load_balancing_manager:
        return function(*args, **kwargs)          # ★单 key：直接调，零开销
    while True:
        lb_config = self.load_balancing_manager.fetch_next()   # ① 轮询取下一个凭据
        if not lb_config:
            raise last_exception or ProviderTokenNotInitError(...)  # 全冷却了 → 报错
        try:
            kwargs["credentials"] = lb_config.credentials       # ② 换上这把凭据
            return function(*args, **kwargs)                    # ③ 调！成功就返回
        except InvokeRateLimitError as e:
            self.load_balancing_manager.cooldown(lb_config, expire=60)  # 限流 → 冷却 60s
            last_exception = e; continue                        # 换下一把重试
        except (InvokeAuthorizationError, InvokeConnectionError) as e:
            self.load_balancing_manager.cooldown(lb_config, expire=10)  # 认证/连接错 → 冷却 10s
            last_exception = e; continue

L03 那个"配置束"由 ProviderManager.get_provider_model_bundle（api/core/provider_manager.py:814）产出：

# api/core/provider_manager.py:814
def get_provider_model_bundle(self, tenant_id, provider, model_type) -> ProviderModelBundle:
    provider_configurations = self.get_configurations(tenant_id)         # ① 取该租户所有供应商配置
    provider_configuration = provider_configurations.get(provider)       # ② 挑出目标供应商
    if not provider_configuration:
        raise ValueError(f"Provider {provider} does not exist.")
    model_type_instance = provider_configuration.get_model_type_instance(model_type)  # ③ 取该类型实例
    return ProviderModelBundle(
        configuration=provider_configuration,
        model_type_instance=model_type_instance,
    )

L04 里 fetch_next() 是怎么"叫号"的？看 LBModelManager.fetch_next（api/core/model_manager.py:599）：

# api/core/model_manager.py:599
def fetch_next(self):
    """Strategy: Round Robin"""
    cache_key = "model_lb_index:{}:{}:{}:{}".format(              # ① 每个"租户+供应商+类型+模型"一个计数器
        self._tenant_id, self._provider, self._model_type.value, self._model)
    max_index = len(self._load_balancing_configs)
    while True:
        current_index = redis_client.incr(cache_key)             # ② ★Redis 自增：拿一个全局递增号
        current_index = cast(int, current_index)
        if current_index >= 10000000:                            #    防止无限增大，到顶归 1
            current_index = 1; redis_client.set(cache_key, current_index)
        redis_client.expire(cache_key, 3600)
        if current_index > max_index:
            current_index = current_index % max_index            # ③ ★对配置数取模 → 轮询
        real_index = current_index - 1
        config = self._load_balancing_configs[real_index]        # ④ 选中这把凭据
        if self.in_cooldown(config):                             # ⑤ 若正在冷却 → 跳过换下一个
            ...
            continue
        return config                                            # ⑥ 返回可用凭据