Initial commit

This commit is contained in:
Alex committed 2026-11-02 22:54:14 +08:00
commit 57fc3525eb
7311 files changed
+1291398

No files matched your search

+425
View File
@@ -0,0 +1,425 @@
"""
app/services/catalog_routing.py - 通用动态模型目录与路由派发器
职责:
- 统一管理各站点的动态模型目录提供者(CatalogProvider)
- 抽象统一的 CatalogRouter,支持动态目录模型匹配、Tab 挑选及模型列表发现
- 彻底解耦 API 层(chat.py)与具体业务模型目录(如 Arena Direct)的实现细节
"""
from __future__ import annotations
import random
import sys
from typing import Any, Callable, Dict, List, Optional, Protocol, Sequence, Set, Tuple
from app.core.config import get_logger
from app.utils.site_url import route_domain_matches
logger = get_logger("SERVICES.CATALOG_ROUTING")
def _get_chat_or_service_attr(name: str, fallback_module: Optional[Any] = None) -> Any:
chat_mod = sys.modules.get("app.api.chat")
if chat_mod and hasattr(chat_mod, name):
return getattr(chat_mod, name)
if fallback_module and hasattr(fallback_module, name):
return getattr(fallback_module, name)
return None
def select_catalog_tab(
browser: Any,
candidates: List[Dict[str, Any]],
preset_name: Any = None,
cursor_prefix: str = "arena_catalog",
) -> Optional[Dict[str, Any]]:
"""Select a tab from candidates respecting the tab pool's allocation policy."""
if not candidates:
return None
idle_candidates = [
item
for item in candidates
if str(item.get("status") or "").strip().lower() == "idle"
]
pool = idle_candidates or candidates
try:
allocation_mode = str(
getattr(browser.tab_pool, "allocation_mode", "") or ""
).strip().lower()
except Exception:
allocation_mode = ""
if allocation_mode not in {"first_idle", "round_robin", "random"}:
allocation_mode = "first_idle"
if allocation_mode == "round_robin":
from app.api import tab_routes as tab_routes_api
cursor_key = f"{cursor_prefix}::{str(preset_name or '').strip().casefold()}"
return tab_routes_api._select_round_robin_tab(pool, cursor_key)
if allocation_mode == "random":
return random.choice(pool)
return min(pool, key=lambda item: int(item.get("persistent_index") or 0))
class CatalogProvider(Protocol):
"""Protocol defining a dynamic catalog provider for model discovery and routing."""
@property
def name(self) -> str: ...
@property
def route_domain(self) -> str: ...
def match_tab_model(
self,
browser: Any,
config_engine: Any,
tab: Dict[str, Any],
requested_model: Any,
) -> Optional[Dict[str, Any]]: ...
def collect_catalog_configs(
self,
config_engine: Any,
tabs: List[Dict[str, Any]],
) -> List[Dict[str, Any]]: ...
def is_alias_suppressed(
self,
item: Dict[str, Any],
catalog_configs: List[Dict[str, Any]],
) -> bool: ...
def list_catalog_model_entries(
self,
browser: Any,
catalog_configs: List[Dict[str, Any]],
created: int,
) -> List[Dict[str, Any]]: ...
class ArenaCatalogProvider:
"""Dynamic catalog provider for Arena Direct models."""
@property
def name(self) -> str:
return "arena_direct"
@property
def route_domain(self) -> str:
return "arena.ai"
def match_tab_model(
self,
browser: Any,
config_engine: Any,
tab: Dict[str, Any],
requested_model: Any,
) -> Optional[Dict[str, Any]]:
import app.services.arena_direct_models as adm
get_catalog_fn = _get_chat_or_service_attr("get_arena_direct_catalog_for_tab", adm)
list_models_fn = _get_chat_or_service_attr("list_arena_direct_models", adm)
match_model_fn = _get_chat_or_service_attr("match_arena_direct_model", adm)
get_public_id_fn = _get_chat_or_service_attr("get_arena_direct_model_public_id", adm)
catalog_info = get_catalog_fn(config_engine, tab) if callable(get_catalog_fn) else None
catalog = catalog_info.get("catalog") if catalog_info else None
if not isinstance(catalog, dict) or not catalog.get("enabled"):
return None
try:
models = list_models_fn(browser, catalog_config=catalog, tab=tab)
except TypeError:
models = list_models_fn(browser, catalog_config=catalog)
model = match_model_fn(models, requested_model)
if not model:
return None
preset_name = str(catalog_info.get("preset_name") or "")
public_model_id = get_public_id_fn(model) if callable(get_public_id_fn) else ""
return {
"tab": tab,
"model": model,
"preset_name": preset_name,
"public_model_id": public_model_id,
"route_domain": self.route_domain,
}
def collect_catalog_configs(
self,
config_engine: Any,
tabs: List[Dict[str, Any]],
) -> List[Dict[str, Any]]:
import app.services.arena_direct_models as adm
get_catalog_fn = _get_chat_or_service_attr("get_arena_direct_catalog_for_tab", adm)
normalize_config_fn = _get_chat_or_service_attr("normalize_model_catalog_config", adm)
catalog_presets: List[Dict[str, Any]] = []
seen_catalog_keys: Set[Tuple[Any, ...]] = set()
for tab in tabs or []:
candidate = get_catalog_fn(config_engine, tab) if callable(get_catalog_fn) else None
cat_obj = candidate.get("catalog") if isinstance(candidate, dict) else None
if isinstance(cat_obj, dict) and cat_obj.get("enabled"):
cat = cat_obj
else:
cat = None
if route_domain_matches(self.route_domain, tab.get("route_domain") or tab.get("current_domain") or ""):
effective_preset_name = str(
tab.get("preset_name") or config_engine.get_default_preset(self.route_domain) or ""
).strip()
try:
preset = config_engine._get_site_data_readonly(self.route_domain, effective_preset_name or None)
if isinstance(preset, dict) and callable(normalize_config_fn):
cat_candidate = normalize_config_fn(preset.get("model_catalog"))
if cat_candidate.get("enabled") and cat_candidate.get("source") == "arena_direct":
cat = cat_candidate
except Exception:
pass
if cat and cat.get("enabled"):
cat_key = (
cat.get("source", ""),
cat.get("modality", ""),
tuple(cat.get("include_keywords") or []),
tuple(cat.get("exclude_keywords") or []),
bool(cat.get("enable_dark_pool", False)),
str(cat.get("dark_pool_since") or "").strip(),
tuple(cat.get("dark_pool_whitelist_keywords") or []),
tuple(cat.get("dark_pool_blacklist_keywords") or []),
)
if cat_key not in seen_catalog_keys:
seen_catalog_keys.add(cat_key)
catalog_presets.append(cat)
return catalog_presets
def is_alias_suppressed(
self,
item: Dict[str, Any],
catalog_configs: List[Dict[str, Any]],
) -> bool:
if not catalog_configs or not item.get("is_route_alias"):
return False
item_route_domains = list(item.get("route_domains") or [])
if item.get("route_domain"):
item_route_domains.append(item.get("route_domain"))
return any(route_domain_matches(self.route_domain, domain) for domain in item_route_domains)
def list_catalog_model_entries(
self,
browser: Any,
catalog_configs: List[Dict[str, Any]],
created: int,
) -> List[Dict[str, Any]]:
import app.services.arena_direct_models as adm
list_models_fn = _get_chat_or_service_attr("list_arena_direct_models", adm)
build_entries_fn = _get_chat_or_service_attr("build_openai_model_entries", adm)
entries: List[Dict[str, Any]] = []
for cat in catalog_configs:
cat_models = list_models_fn(browser, catalog_config=cat) if callable(list_models_fn) else []
model_entries = build_entries_fn(cat_models, created=created) if callable(build_entries_fn) else []
for item in model_entries:
entries.append({
"id": item.get("id"),
"owned_by": item.get("owned_by") or self.route_domain,
"display_name": item.get("display_name") or item.get("id"),
})
return entries
class CatalogRouter:
"""Universal dispatcher for dynamic catalog matching and model enumeration."""
def __init__(self, providers: Optional[Sequence[CatalogProvider]] = None):
self._providers: List[CatalogProvider] = list(providers or [ArenaCatalogProvider()])
def register_provider(self, provider: CatalogProvider) -> None:
self._providers.append(provider)
def match_route(
self,
browser: Any,
config_engine: Any,
tabs: List[Dict[str, Any]],
requested_model: Any,
preset_name: Any = None,
) -> Optional[Dict[str, Any]]:
"""Match a requested model against all registered catalog providers across open tabs."""
if not browser or not tabs:
return None
# Check if chat API has monkeypatched match/select function
chat_match_fn = _get_chat_or_service_attr("_match_arena_catalog_tab")
if callable(chat_match_fn) and not getattr(chat_match_fn, "_is_default_wrapper", False):
matched_tab_info = chat_match_fn(browser, config_engine, tabs, requested_model)
if matched_tab_info:
matched_tab = matched_tab_info.get("tab") or {}
matched_model = matched_tab_info.get("model") or {}
matched_preset = matched_tab_info.get("preset_name") or preset_name
import app.services.arena_direct_models as adm
get_public_id_fn = _get_chat_or_service_attr("get_arena_direct_model_public_id", adm)
public_model_id = get_public_id_fn(matched_model) if callable(get_public_id_fn) else str(requested_model or "")
catalog_tab_index = int(matched_tab.get("persistent_index") or 0) or None
return {
"route_domain": "arena.ai",
"route_type": "model_catalog",
"model_name": public_model_id or str(requested_model or ""),
"matched_id": public_model_id or str(requested_model or ""),
"match_type": "catalog",
"preset_name": matched_preset,
"available_model_ids": [public_model_id] if public_model_id else [],
"catalog_tab": matched_tab,
"catalog_tab_index": catalog_tab_index,
"matched_model": matched_model,
}
return None
is_url_excluded = getattr(getattr(browser, "tab_pool", None), "is_url_excluded", None)
for provider in self._providers:
matches: List[Dict[str, Any]] = []
for tab in tabs:
tab_url = str(tab.get("current_url") or tab.get("url") or "").strip()
if callable(is_url_excluded) and is_url_excluded(tab_url):
continue
matched = provider.match_tab_model(browser, config_engine, tab, requested_model)
if matched:
matches.append(matched)
if not matches:
continue
select_tab_fn = _get_chat_or_service_attr("_select_arena_catalog_tab")
if callable(select_tab_fn) and select_tab_fn is not select_catalog_tab:
selected_tab = select_tab_fn(
browser,
[entry["tab"] for entry in matches],
preset_name=preset_name,
)
else:
selected_tab = select_catalog_tab(
browser,
[entry["tab"] for entry in matches],
preset_name=preset_name,
)
if not selected_tab:
continue
selected_index = int(selected_tab.get("persistent_index") or 0)
selected_tab_id = str(selected_tab.get("id") or selected_tab.get("tab_id") or "").strip()
target_entry = next(
(
entry
for entry in matches
if entry["tab"] is selected_tab
or (selected_tab_id and str(entry["tab"].get("id") or entry["tab"].get("tab_id") or "").strip() == selected_tab_id)
or int(entry["tab"].get("persistent_index") or 0) == selected_index
),
None,
)
if not target_entry:
continue
catalog_tab = target_entry["tab"]
catalog_match = target_entry["model"]
matched_preset_name = target_entry["preset_name"]
public_model_id = target_entry.get("public_model_id") or ""
catalog_tab_index = int(catalog_tab.get("persistent_index") or 0) or None
matched_uuid = str(
catalog_match.get("id")
or catalog_match.get("uuid")
or catalog_match.get("arena_model_id")
or ""
)
matched_public_name = str(
catalog_match.get("public_name") or catalog_match.get("publicName") or ""
)
matched_display_name = str(
catalog_match.get("display_name")
or catalog_match.get("displayName")
or catalog_match.get("name")
or ""
)
logger.info(
f"[CATALOG_ROUTER:MATCH] 成功匹配动态目录模型: provider={provider.name}, "
f"requested_model={requested_model!r}, preset={matched_preset_name!r}, "
f"uuid={matched_uuid!r}, public_name={matched_public_name!r}, "
f"display_name={matched_display_name!r}, public_model_id={public_model_id!r}, "
f"target_tab_index={catalog_tab_index}, "
f"target_tab_url={catalog_tab.get('current_url') or catalog_tab.get('url')}"
)
return {
"route_domain": provider.route_domain,
"route_type": "model_catalog",
"model_name": public_model_id or str(requested_model or ""),
"matched_id": public_model_id or str(requested_model or ""),
"match_type": "catalog",
"preset_name": matched_preset_name,
"available_model_ids": [public_model_id] if public_model_id else [],
"catalog_tab": catalog_tab,
"catalog_tab_index": catalog_tab_index,
"matched_model": catalog_match,
}
return None
def collect_models_for_catalog(
self,
browser: Any,
config_engine: Any,
tabs: List[Dict[str, Any]],
append_entry: Callable[[str, Optional[str], Optional[str]], None],
created: int,
) -> None:
"""Collect models across tabs and catalog providers for the /v1/models endpoint."""
from app.utils.model_routing import collect_route_domain_models
# 1. 收集所有 Provider 的 Catalog 预设配置
provider_configs: Dict[str, List[Dict[str, Any]]] = {}
for provider in self._providers:
configs = provider.collect_catalog_configs(config_engine, tabs)
provider_configs[provider.name] = configs
# 2. 输出通用 Route Domain 模型,对被 Catalog 接管的 alias 模型进行抑制
for item in collect_route_domain_models(tabs):
suppressed = any(
provider.is_alias_suppressed(item, provider_configs.get(provider.name, []))
for provider in self._providers
)
if suppressed:
continue
append_entry(
item.get("id"),
item.get("route_domain") or "universal-web-api",
item.get("display_name") or item.get("id"),
)
# 3. 输出各 Catalog Provider 发现的动态模型列表
for provider in self._providers:
configs = provider_configs.get(provider.name, [])
if not configs:
continue
for model_entry in provider.list_catalog_model_entries(browser, configs, created):
append_entry(
model_entry.get("id"),
model_entry.get("owned_by") or provider.route_domain,
model_entry.get("display_name") or model_entry.get("id"),
)
catalog_router = CatalogRouter()