"""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:`` 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:`` 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