| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990 |
- """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
|