Repository navigation
Expand file tree
/
Copy pathmodel_routing.py
More file actions
104 lines (81 loc) · 3.46 KB
/
Copy pathmodel_routing.py
File metadata and controls
104 lines (81 loc) · 3.46 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
"""LCM model override routing helpers."""
from __future__ import annotations
import logging
from collections.abc import Callable
from dataclasses import dataclass
logger = logging.getLogger(__name__)
@dataclass(frozen=True)
class ModelRoute:
provider: str | None
model: str
ProviderResolver = Callable[[str], bool]
# Conservative allowlist for built-in provider registry fallbacks. Non-canonical
# named custom providers from the Hermes config are safe to split; registry-only
# providers still need an allowlist because many provider IDs are also valid
# OpenRouter model namespaces, for example ``anthropic/...``, ``google/...``
# and ``x-ai/...``. ``custom:<name>/...`` is accepted for non-canonical named
# custom providers because Hermes auxiliary routing normalizes ``provider`` the
# same way, but canonical built-ins such as ``custom:openai-codex/...`` remain
# model-only to avoid accidentally selecting the built-in provider.
_PROVIDER_PREFIXES = frozenset({"cerebras"})
def _provider_route_is_resolvable(provider: str) -> bool:
"""Return whether Hermes can route an explicit auxiliary provider."""
provider = (provider or "").strip().lower()
if not provider:
return False
if provider.startswith("custom:"):
provider = provider.split(":", 1)[1].strip()
if not provider:
return False
try:
from hermes_cli.auth import PROVIDER_REGISTRY
if provider in PROVIDER_REGISTRY:
return provider in _PROVIDER_PREFIXES
except Exception:
pass
try:
from hermes_cli.runtime_provider import _get_named_custom_provider
if _get_named_custom_provider(provider):
return True
except Exception:
pass
return False
def parse_lcm_model_override(
value: str | None,
*,
provider_resolver: ProviderResolver | None = None,
) -> ModelRoute:
"""Parse an LCM model override into explicit provider/model routing.
Values whose first path segment is resolvable by the Hermes host are split
into ``provider=<prefix>`` and ``model=<rest>``. The default resolver only
treats non-canonical named custom providers (plus conservative registry
allowlist entries) as resolvable so OpenRouter-style model slugs and
canonical built-in provider names remain model-only overrides.
"""
model = (value or "").strip()
if not model:
return ModelRoute(provider=None, model="")
provider, sep, rest = model.partition("/")
provider = provider.strip().lower()
rest = rest.strip()
route_provider = provider
if provider.startswith("custom:"):
route_provider = provider.split(":", 1)[1].strip()
can_resolve_provider = provider_resolver or _provider_route_is_resolvable
if sep and rest and route_provider and can_resolve_provider(route_provider):
return ModelRoute(provider=route_provider, model=rest)
return ModelRoute(provider=None, model=model)
def apply_lcm_model_route(call_kwargs: dict, model: str | None) -> None:
"""Apply parsed LCM provider/model overrides to Hermes auxiliary kwargs."""
route = parse_lcm_model_override(model)
if route.provider:
call_kwargs["provider"] = route.provider
if route.model:
call_kwargs["model"] = route.model
if model and route.model:
logger.debug(
"LCM auxiliary model override routed: raw=%r provider=%s model=%s",
model,
route.provider or "(task default)",
route.model,
)