Files
2026-11-02 22:54:14 +08:00

285 lines
9.2 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""
model_routing.py - Resolve OpenAI-style model ids to route-domain targets.
"""
from __future__ import annotations
from typing import Any, Dict, List, Optional
from app.utils.site_rules import derive_site_card_id
from app.utils.site_url import build_route_domain_aliases, get_preferred_route_domain
_GENERIC_MODEL_IDS = {
"",
"any",
"auto",
"default",
"web-browser",
"未知",
"unknown",
"gpt-3.5-turbo",
"gpt-4",
"gpt-4o",
"gpt-4.1",
"gpt-4.1-mini",
"gpt-4o-mini",
}
_MODEL_ALIAS_DELIMITERS = ("-", "_", "/", ":", ".")
def _normalize_model_id(value: Any) -> str:
return str(value or "").strip().lower()
def _clean_model_id(value: Any) -> str:
return str(value or "").strip()
def _build_model_id_candidates(route_domain: str) -> List[str]:
"""
Build user-facing model ids for a routed site.
Examples:
- chat.deepseek.com -> chat.deepseek.com, deepseek
- gemini.google.com -> gemini.google.com, gemini.com, gemini
"""
normalized_route = _normalize_model_id(route_domain)
if not normalized_route:
return []
result: List[str] = []
seen = set()
def _add(value: Any):
candidate = _normalize_model_id(value)
if candidate and candidate not in seen:
seen.add(candidate)
result.append(candidate)
route_aliases = build_route_domain_aliases(normalized_route)
_add(normalized_route)
for alias in route_aliases:
_add(alias)
for alias in [normalized_route, *route_aliases]:
_add(derive_site_card_id(alias))
return result
def _matches_model_alias(model_id: str, alias_id: str) -> bool:
if model_id == alias_id:
return True
if not alias_id or len(model_id) <= len(alias_id):
return False
if not model_id.startswith(alias_id):
return False
return model_id[len(alias_id)] in _MODEL_ALIAS_DELIMITERS
def _resolve_route_domain(tab: Dict[str, Any]) -> str:
return str(
tab.get("route_domain")
or get_preferred_route_domain(tab.get("current_domain") or "")
or ""
).strip().lower()
def _default_model_id_for_tab(tab: Dict[str, Any]) -> str:
return (
_clean_model_id(tab.get("route_domain"))
or _clean_model_id(get_preferred_route_domain(tab.get("current_domain") or ""))
or _clean_model_id(tab.get("current_domain"))
)
def _is_model_name_overridden(tab: Dict[str, Any]) -> bool:
return bool(_clean_model_id(tab.get("model_name_override_source")))
def _get_exposed_model_id(tab: Dict[str, Any]) -> str:
return _clean_model_id(tab.get("exposed_model_name")) or _default_model_id_for_tab(tab)
def collect_route_domain_models(tabs: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
"""
Build a deduplicated model list from active tabs.
The exported model id is the tab's exposed model name. Tabs without a
custom name keep the historical route-domain id and aliases.
"""
model_map: Dict[str, Dict[str, Any]] = {}
alias_map: Dict[str, str] = {}
ambiguous_aliases = set()
def _ensure_model(
model_id: str,
route_domain: str = "",
*,
allow_prefix: bool = True,
is_route_alias: bool = False,
) -> None:
normalized_model = _normalize_model_id(model_id)
if not normalized_model:
return
if normalized_model not in model_map:
model_map[normalized_model] = {
"id": _clean_model_id(model_id),
"display_name": _clean_model_id(model_id),
"model_name": _clean_model_id(model_id),
"route_type": "model_name",
"route_domains": set(),
"allow_prefix": bool(allow_prefix),
"is_route_alias": bool(is_route_alias),
}
if route_domain:
model_map[normalized_model]["route_domains"].add(route_domain)
if not allow_prefix:
model_map[normalized_model]["allow_prefix"] = False
if not is_route_alias:
model_map[normalized_model]["is_route_alias"] = False
for tab in tabs or []:
route_domain = _resolve_route_domain(tab)
exposed_model_id = _get_exposed_model_id(tab)
if not exposed_model_id:
continue
overridden = _is_model_name_overridden(tab)
_ensure_model(
exposed_model_id,
route_domain,
allow_prefix=not overridden,
is_route_alias=not overridden,
)
if overridden or not route_domain:
continue
exposed_key = _normalize_model_id(exposed_model_id)
for alias_id in _build_model_id_candidates(route_domain):
alias_key = _normalize_model_id(alias_id)
if not alias_key or alias_key == exposed_key:
continue
existing = alias_map.get(alias_key)
if existing and existing != exposed_key:
ambiguous_aliases.add(alias_key)
continue
alias_map[alias_key] = exposed_key
for alias_key in sorted(alias_map):
if alias_key in ambiguous_aliases or alias_key in model_map:
continue
target_key = alias_map[alias_key]
target = model_map.get(target_key)
if not target:
continue
model_map[alias_key] = {
"id": alias_key,
"display_name": alias_key,
"model_name": target["model_name"],
"route_type": "model_name",
"route_domains": set(target.get("route_domains") or set()),
"allow_prefix": True,
"is_route_alias": True,
}
result: List[Dict[str, Any]] = []
for model_key in sorted(model_map):
item = model_map[model_key]
route_domains = sorted(item.get("route_domains") or [])
result.append({
"id": item["id"],
"display_name": item.get("display_name") or item["id"],
"model_name": item.get("model_name") or item["id"],
"route_type": item.get("route_type") or "model_name",
"route_domain": route_domains[0] if len(route_domains) == 1 else "",
"route_domains": route_domains,
"allow_prefix": bool(item.get("allow_prefix", True)),
"is_route_alias": bool(item.get("is_route_alias", False)),
})
return result
def inspect_model_route(
model: Any,
tabs: List[Dict[str, Any]],
*,
allow_prefix: bool = True,
allow_generic: bool = True,
models: Optional[List[Dict[str, Any]]] = None,
) -> Dict[str, Any]:
"""
Return detailed model-route resolution information for logging/debugging.
"""
normalized_model = _normalize_model_id(model)
if models is None:
models = collect_route_domain_models(tabs)
available_model_ids = [str(item.get("id") or "") for item in models]
info: Dict[str, Any] = {
"normalized_model": normalized_model,
"route_domain": "",
"route_type": "",
"model_name": "",
"matched_id": "",
"match_type": "none",
"available_model_ids": available_model_ids,
}
# 优先级 1:先做标签页完全精确匹配并直接返回,避免暴露名恰为通用 id(如 gpt-4o)的
# 标签页被 generic 判定抢先、永远无法被精确路由
for item in models:
if normalized_model == _normalize_model_id(item["id"]):
info["route_domain"] = str(item.get("route_domain") or "")
info["route_type"] = str(item.get("route_type") or "model_name")
info["model_name"] = str(item.get("model_name") or item.get("id") or "")
info["matched_id"] = str(item.get("id") or "")
info["match_type"] = "exact"
return info
# 优先级 2:通用模型 id 落回 generic 默认分配流程(若启用 allow_generic)
if allow_generic and normalized_model in _GENERIC_MODEL_IDS:
info["match_type"] = "generic"
return info
if not allow_prefix:
return info
# 优先级 3:标签页前缀模糊匹配(按最长前缀优先匹配,避免短前缀遮蔽更具体的长前缀别名)
prefix_matches = [
item
for item in models
if item.get("allow_prefix") and _matches_model_alias(normalized_model, _normalize_model_id(item["id"]))
]
if prefix_matches:
best_match = max(prefix_matches, key=lambda x: len(str(x.get("id") or "")))
info["route_domain"] = str(best_match.get("route_domain") or "")
info["route_type"] = str(best_match.get("route_type") or "model_name")
info["model_name"] = str(best_match.get("model_name") or best_match.get("id") or "")
info["matched_id"] = str(best_match.get("id") or "")
info["match_type"] = "prefix"
return info
return info
def resolve_model_route_domain(model: Any, tabs: List[Dict[str, Any]]) -> str:
"""
Resolve a client-supplied `model` to a route-domain target.
Returns an empty string when the model should continue using the default
generic tab allocation flow.
"""
return str(inspect_model_route(model, tabs).get("route_domain") or "")
__all__ = [
"collect_route_domain_models",
"inspect_model_route",
"resolve_model_route_domain",
]