| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126 |
- """Fail-closed URL identity normalization for model/provider routes."""
- from __future__ import annotations
- from typing import Any, Optional
- from urllib.parse import urlsplit, urlunsplit
- def normalize_route_base_url(base_url: Any) -> str:
- """Canonicalize only proven-equivalent endpoint URL components."""
- raw = str(base_url or "")
- if not raw:
- return ""
- if any(ord(char) <= 0x20 for char in raw):
- return raw
- had_query_delimiter = "?" in raw.split("#", 1)[0]
- try:
- parsed = urlsplit(raw)
- hostname = parsed.hostname
- if not parsed.scheme or not hostname:
- return raw
- scheme = parsed.scheme.lower()
- if "%" in hostname:
- address, zone = hostname.split("%", 1)
- host = f"{address.lower()}%{zone}"
- else:
- host = hostname.lower()
- port = parsed.port
- except (TypeError, ValueError):
- return raw
- route_host = parsed.netloc.rsplit("@", 1)[-1]
- if route_host.startswith("[") or ":" in host:
- host = f"[{host}]"
- if port is not None and (scheme, port) not in {("http", 80), ("https", 443)}:
- host = f"{host}:{port}"
- if "@" in parsed.netloc:
- host = f"{parsed.netloc.rsplit('@', 1)[0]}@{host}"
- path = parsed.path
- if path.endswith("/") and not had_query_delimiter:
- path = path[:-1]
- normalized = urlunsplit((scheme, host, path, parsed.query, ""))
- if had_query_delimiter and not parsed.query:
- normalized += "?"
- return normalized
- def provider_owns_route(provider: Any, base_url: Any, config: Any = None) -> Optional[bool]:
- """Whether ``model.base_url`` is *provider*'s own endpoint.
- ``True``: the host is the provider's registry/plugin endpoint or the endpoint of a
- ``providers:``/``custom_providers:`` entry that resolves to *provider*, or *provider* is bare
- ``custom``/``local`` (the URL *is* the route). ``False``: the host is another known provider's
- stock endpoint, or *provider* names a user entry with a different endpoint. ``None``: unknown
- host (a proxy, a LAN server) — nothing here can say whose it is. Offline: the registry lookup
- never fetches the models.dev catalog.
- """
- from hermes_cli.providers import get_provider, normalize_provider, resolve_custom_provider, resolve_user_provider
- from utils import base_url_hostname
- host = base_url_hostname(str(base_url or ""))
- if not host:
- return None
- raw = str(provider or "").strip().lower()
- canonical = normalize_provider(raw)
- if canonical in ("custom", "local"):
- # Bare custom / local-server aliases are configured BY model.base_url (#14676, #27132);
- # resolve_custom_provider would also self-heal bare "custom" to the first entry (#17478).
- return True
- cfg = config if isinstance(config, dict) else {}
- user_pdef = resolve_user_provider(raw, cfg.get("providers") or {}) or resolve_custom_provider(
- raw, cfg.get("custom_providers"))
- if user_pdef is not None and user_pdef.base_url:
- return base_url_hostname(user_pdef.base_url) == host
- pdef = get_provider(canonical, allow_network=False)
- if pdef is not None and pdef.base_url and base_url_hostname(pdef.base_url) == host:
- return True
- if pdef is None and user_pdef is None:
- return True
- from agent.model_metadata import _infer_provider_from_url
- inferred = _infer_provider_from_url(str(base_url))
- if inferred is None:
- return None
- return normalize_provider(inferred) == canonical
- def drop_stale_model_route(model_cfg: Any, provider: Any, config: Any = None) -> tuple[dict[str, Any], bool]:
- """Pop the route keys (``base_url``, ``api_mode``) a previous provider left in ``model:``
- when the block is re-pointed at *provider* without a fresh route (``hermes config set
- model.provider``). Mirrors what a persisted ``/model`` switch writes: the route is synced to
- the target, never carried over. Returns ``(popped {key: old value}, unverified)`` where
- ``unverified`` is True when a base_url of unknown ownership was kept — the caller should say so.
- A base_url that belongs to *provider* is kept together with its api_mode; with no base_url the
- api_mode alone is wire state of the old route and goes."""
- if not isinstance(model_cfg, dict):
- return {}, False
- base_url = str(model_cfg.get("base_url") or "").strip()
- owned = provider_owns_route(provider, base_url, config) if base_url else False
- if owned:
- return {}, False
- if owned is None:
- return {}, True
- popped = {k: model_cfg.pop(k) for k in ("base_url", "api_mode") if model_cfg.get(k) not in (None, "")}
- return popped, False
- def should_clear_context_pin(configured_model: Any, active_model: Any, configured_base_url: Any, active_base_url: Any,
- configured_provider: Any, active_provider: Any) -> bool:
- """True when a configured ``model.context_length`` pin no longer matches its runtime route.
- Fail-closed: any error during route comparison returns ``True`` (drop the pin) so a stale window
- never silently inflates the compression threshold."""
- configured_model = str(configured_model or "").strip()
- if configured_model and configured_model != str(active_model or "").strip():
- return True
- try:
- from agent.agent_init import _context_route_mismatch
- return _context_route_mismatch(configured_base_url, active_base_url, configured_provider, active_provider)
- except Exception:
- return True
- async def should_clear_context_pin_async(*args: Any) -> bool:
- """``should_clear_context_pin`` on a worker thread so async gateway handlers never run it on the
- event loop — the resolution chain is cache-only (``allow_network=False``) but can still do
- cold-start disk I/O."""
- import asyncio
- return await asyncio.to_thread(should_clear_context_pin, *args)
|