The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
"""One resolved-route identity for launch-route gates.
Two launch routes are the same route when the runtime resolver would send them to the same
endpoint: compare what it resolves (canonical provider, configured named entry, effective
URL), never raw spellings. ``ollama``/``vllm`` resolve to ``custom``, ``deep-infra`` to
``deepinfra``, and a configured ``providers:``/``custom_providers`` name (or its
``custom:<name>`` spelling) to that entry.
"""
# Every ``model:`` key that belongs to one endpoint; a route change drops them all, so none of the
# replaced endpoint's values is paired with the new one:
# - route itself (provider, base_url): which endpoint the turn goes to;
# - wire protocol (api_mode): how that endpoint speaks; another host may speak another protocol;
# - window (context_length): the replaced model's context size, wrong for the new one;
# - credentials (api_key, api, api_key_from, key_env, api_key_env): a key authenticates only the
# endpoint that issued it, and sending it anywhere else leaks it.
ROUTE_BOUND_KEYS = ('provider', 'base_url', 'api_mode', 'context_length',
'api_key', 'api', 'api_key_from', 'key_env', 'api_key_env')
def _named_entry(name: str, config: dict) -> dict | None:
from hermes_cli.runtime_provider_custom import _get_named_custom_provider
return _get_named_custom_provider(name, config=config, resolve_credentials=False)
def _canonical(name: str) -> str:
from hermes_cli.models import normalize_provider
canonical = normalize_provider(name)
from hermes_cli.auth import AuthError, resolve_provider
try:
return resolve_provider(canonical)
except AuthError: # not a registry provider: its canonical spelling is its identity
return canonical
def configured_entry_key(identity: str, config: dict) -> str:
"""The bare config key of the configured entry behind a ``custom:<key>`` identity, else ``''``.
Raw provider resolution defers a bare name that is a canonical built-in to the built-in, so a
``providers:`` entry keyed ``deepseek`` is reachable only through its ``custom:`` spelling. Only
that key names a keyed entry: its display name may be a real built-in's slug (``name: OpenRouter``
on ``providers.work``), and a pick of that built-in is not this endpoint (#140107). A legacy
``custom_providers:`` entry has no key, so its normalized display name is its identity and its
key here (``custom_provider_slug``): ``name: OpenRouter`` there answers ``openrouter``, as
Desktop's ``customDefaultSupersedesPick`` does.
"""
identity = str(identity or '').strip().lower()
if not identity.startswith('custom:') or not _named_entry(identity, config):
return ''
return identity.split(':', 1)[1].strip()
def profile_route_identity(config: dict) -> str:
"""The identity the profile's own ``model`` block resolves to — ``custom`` for an endpoint with
no provider named (or ``auto``), which already routes to ``custom`` at that URL."""
held = dict(config.get('model') or {}) if isinstance(config.get('model'), dict) else {}
if str(held.get('provider') or '').strip().lower() in ('', 'auto') and str(held.get('base_url') or '').strip():
held['provider'] = 'custom'
return resolved_route(held, config)[0]
def resolved_route(model_cfg: dict, config: dict) -> tuple[str, str]:
"""``(provider_identity, effective_base_url)`` the runtime resolves ``model_cfg`` to."""
model_cfg = model_cfg if isinstance(model_cfg, dict) else {}
config = config if isinstance(config, dict) else {}
name = str(model_cfg.get('provider') or '').strip().lower()
if name in ('', 'auto'):
return 'auto', ''
base_url = str(model_cfg.get('base_url') or '').strip()
entry = _named_entry(name, config)
if entry:
from hermes_cli.providers import custom_provider_slug
identity = custom_provider_slug(str(entry.get('name') or ''), str(entry.get('provider_key') or ''))
base_url = base_url or str(entry.get('base_url') or '').strip()
else:
identity = _canonical(name)
return identity, base_url.rstrip('/')
def same_route(a_cfg: dict, b_cfg: dict, config: dict) -> bool:
"""True when both configs resolve to one endpoint; ``auto`` on either side keeps the route."""
a_id, a_url = resolved_route(a_cfg, config)
b_id, b_url = resolved_route(b_cfg, config)
if 'auto' in (a_id, b_id):
return True
if a_url or b_url:
from hermes_cli.route_identity import normalize_route_base_url
return normalize_route_base_url(a_url) == normalize_route_base_url(b_url)
return a_id == b_id