mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-16 02:46:38 +03:00
55b0b2611f
Cloning a profile that has no model of its own inherited the launch profile's model through the explicit-selection validator: an authenticated /models request to the inherited endpoint, and a key probe that left an auth.json in the new profile. Inheritance now copies the source selection and its selected endpoint without validating it. Selection identity (name, provider_key, enabled) is captured in the source profile's scope and matched against the destination's entries in its own scope; URL and key references stay raw and bind the new profile's environment. The endpoint seed is located with the runtime's own config-path lookup. The inherited assignment sits next to the explicit one in model_assignment and applies the same route cleanup, Remote Config masks and lock guard. It keeps the source's provider and applies only the model-name repair, never copies the source's endpoint-bound model keys (inline key, key pointer, context pin; the validated path never did), and compares routes as the new profile resolves them: the destination's own keys survive a differently spelled URL for the same endpoint, and are cleared when either side has no URL to compare. The endpoint-bound key groups are named once in route_identity and shared with the route-change clearing. On Remote Config a locked change under model, providers or custom_providers refuses the save. Explicit model picks still validate.
236 lines
13 KiB
Python
236 lines
13 KiB
Python
"""Main-slot model assignment: normalize a (provider, model) pick, validate it through
|
|
``switch_model``, and apply it to a ``model:`` config block.
|
|
|
|
Shared by the dashboard (``POST /api/model/set``, the Config page, custom endpoints) and profile
|
|
provisioning, so nothing here knows about HTTP: a rejected pick raises
|
|
:class:`ModelAssignmentRejected` and each surface maps it (the dashboard to a 400).
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import logging
|
|
from dataclasses import replace
|
|
from typing import Any, Optional
|
|
|
|
from hermes_cli.model_switch import ModelSwitchResult
|
|
|
|
# The dashboard's logger, as before the move: hermes_logging routes it to gui.log.
|
|
logger = logging.getLogger("hermes_cli.web_server")
|
|
|
|
|
|
class ModelAssignmentRejected(ValueError):
|
|
"""``switch_model`` refused the pick; the message says why."""
|
|
|
|
|
|
def normalize_main_model_assignment(provider: str, model: str) -> tuple[str, str]:
|
|
"""Normalize a main-slot (provider, model) pair before persisting.
|
|
|
|
The per-card "Use as → Main model" menu can send the model's VENDOR prefix as the
|
|
provider (analytics rows with no ``billing_provider``), producing e.g.
|
|
``provider: anthropic`` + ``default: anthropic/claude-opus-4.6`` — an aggregator slug on
|
|
the native provider, which 400s. Two repairs at this single chokepoint:
|
|
|
|
1. Vendor-name → Hermes-provider: when the provider is not a known provider/alias but the
|
|
model is a vendor-prefixed slug, keep the user's CURRENT aggregator if on one, else
|
|
openrouter. User-declared ``providers:``/``custom_providers:`` entries resolve first,
|
|
and durable named-custom slugs (``custom`` / ``custom:<name>``) are excluded —
|
|
``_KNOWN_PROVIDER_NAMES`` lists only the bare ``custom`` bucket, so without this a
|
|
LiteLLM proxy serving ``ollama/glm-5.2`` would be silently reassigned to openrouter.
|
|
Matching only that syntax (not ``startswith("custom")``) avoids swallowing
|
|
unconfigured vendors like ``customproxy``.
|
|
2. Model-format normalization for the resolved provider via
|
|
``normalize_model_for_provider`` (custom/user providers keep the model verbatim).
|
|
"""
|
|
from hermes_cli.config import get_compatible_custom_providers, load_config
|
|
from hermes_cli.models import _AGGREGATOR_PROVIDERS, _KNOWN_PROVIDER_NAMES, normalize_provider
|
|
from hermes_cli.model_normalize import normalize_model_for_provider
|
|
from hermes_cli.providers import resolve_custom_provider, resolve_user_provider
|
|
|
|
prov_in = (provider or "").strip()
|
|
model_in = (model or "").strip()
|
|
canonical = normalize_provider(prov_in)
|
|
|
|
try:
|
|
cfg = load_config()
|
|
except Exception: # an unreadable config normalizes against no declared providers
|
|
logger.debug("config unreadable while normalizing %s/%s", prov_in, model_in, exc_info=True)
|
|
cfg = {}
|
|
if not isinstance(cfg, dict):
|
|
cfg = {}
|
|
user_providers = cfg.get("providers")
|
|
declared = resolve_user_provider(
|
|
prov_in, user_providers if isinstance(user_providers, dict) else {}
|
|
) or resolve_custom_provider(prov_in, get_compatible_custom_providers(cfg))
|
|
if declared is not None:
|
|
return declared.id, model_in
|
|
|
|
is_custom_provider_slug = canonical == "custom" or canonical.startswith("custom:")
|
|
if canonical not in _KNOWN_PROVIDER_NAMES and not is_custom_provider_slug and "/" in model_in:
|
|
cur_cfg = cfg.get("model", {})
|
|
cur_provider = str(cur_cfg.get("provider", "") or "").strip().lower() if isinstance(cur_cfg, dict) else ""
|
|
if cur_provider and normalize_provider(cur_provider) in _AGGREGATOR_PROVIDERS:
|
|
canonical = normalize_provider(cur_provider)
|
|
prov_in = cur_provider
|
|
else:
|
|
from hermes_cli.models_detect import provider_has_credentials
|
|
|
|
# Only guess OpenRouter when the user actually holds a key for it; otherwise keep the
|
|
# pair as sent rather than persisting a provider they never selected.
|
|
if provider_has_credentials("openrouter"):
|
|
canonical = prov_in = "openrouter"
|
|
|
|
if canonical in _KNOWN_PROVIDER_NAMES and not canonical.startswith("custom"):
|
|
try:
|
|
model_in = normalize_model_for_provider(model_in, canonical) or model_in
|
|
except Exception:
|
|
logger.debug("model normalization failed for %s/%s", prov_in, model_in, exc_info=True)
|
|
|
|
return prov_in, model_in
|
|
|
|
|
|
BARE_CUSTOM_SELECTORS = frozenset({"custom", "local"})
|
|
|
|
|
|
def _same_endpoint(a: Any, b: Any) -> bool:
|
|
"""Trailing-slash and case insensitive URL equality (``_save_custom_provider`` dedups the same way)."""
|
|
return str(a or "").strip().rstrip("/").lower() == str(b or "").strip().rstrip("/").lower()
|
|
|
|
|
|
def entry_points_elsewhere(entry: Any, base_url: str) -> bool:
|
|
"""A configured provider block that names a DIFFERENT host than the submitted endpoint. Its
|
|
credentials belong to that host; a block for the same host (e.g. its ``key_env``) still applies."""
|
|
return isinstance(entry, dict) and not _same_endpoint(entry.get("base_url"), base_url)
|
|
|
|
|
|
def is_explicit_custom_endpoint(provider: str, base_url: str) -> bool:
|
|
"""A bare ``custom`` / ``local`` pick that carries its own endpoint URL defines a route; it is
|
|
never a reference to an already-configured provider."""
|
|
return provider.strip().lower() in BARE_CUSTOM_SELECTORS and bool((base_url or "").strip())
|
|
|
|
|
|
def validated_main_model_selection(
|
|
cfg: dict, provider: str, model: str, base_url: str = "", api_key: str = "",
|
|
explicit_endpoint: Optional[bool] = None,
|
|
) -> ModelSwitchResult:
|
|
"""Route a main-slot pick through ``switch_model`` (catalog/alias/credential
|
|
validation) seeded with the configured route, exactly like a ``/model <model> --provider
|
|
<provider> --global``. A bare ``custom`` target carries the submitted endpoint as the current
|
|
one, which is how ``switch_model`` binds a custom base_url/key. A rejection raises
|
|
:class:`ModelAssignmentRejected`."""
|
|
from hermes_cli.config import get_compatible_custom_providers
|
|
from hermes_cli.model_switch import switch_model
|
|
|
|
model_cfg = cfg.get("model") if isinstance(cfg.get("model"), dict) else {}
|
|
is_bare_custom = provider.strip().lower() in BARE_CUSTOM_SELECTORS
|
|
# An explicit endpoint must not resolve through the configured providers: the legacy
|
|
# bare-``custom`` recovery in ``resolve_custom_provider`` would bind the FIRST named entry, and
|
|
# a ``providers.custom`` / ``providers.local`` block (same key as the bare selector) would win
|
|
# the credential step and validate ITS host with ITS key. The dashboard's ``_prepare_main_assignment``
|
|
# passes whether the URL was SUBMITTED; a URL it filled from that block is a selection, not a route.
|
|
if explicit_endpoint is None:
|
|
explicit_endpoint = is_explicit_custom_endpoint(provider, base_url)
|
|
user_providers = cfg.get("providers") if isinstance(cfg.get("providers"), dict) else {}
|
|
if explicit_endpoint:
|
|
user_providers = {k: v for k, v in user_providers.items()
|
|
if not (str(k).strip().lower() in BARE_CUSTOM_SELECTORS
|
|
and entry_points_elsewhere(v, base_url))}
|
|
# The submitted endpoint is seeded as a current bare-``custom`` route so the credential step
|
|
# keeps it: arriving from another provider it re-resolves ``custom`` from config and would
|
|
# validate the saved ``model.base_url`` (and its key) instead of the endpoint being saved.
|
|
result = switch_model(
|
|
raw_input=model, explicit_provider=provider, is_global=True,
|
|
current_provider="custom" if explicit_endpoint else str(model_cfg.get("provider") or ""),
|
|
current_model=str(model_cfg.get("default") or ""),
|
|
current_base_url=base_url if is_bare_custom else str(model_cfg.get("base_url") or ""),
|
|
current_api_key=api_key if is_bare_custom else "",
|
|
user_providers=user_providers,
|
|
custom_providers=[] if explicit_endpoint else get_compatible_custom_providers(cfg))
|
|
if not result.success:
|
|
raise ModelAssignmentRejected(result.error_message or "model switch rejected")
|
|
if is_bare_custom and base_url.strip():
|
|
# The submitted endpoint IS the route this pick asked for; the credential step may have
|
|
# re-resolved the bare target onto an env/config endpoint (CUSTOM_BASE_URL, a stale
|
|
# model.base_url, the OPENROUTER_BASE_URL mirror). Restore the submitted endpoint AND the
|
|
# wire protocol it mandates: ``model.base_url`` and ``model.api_mode`` are persisted
|
|
# together, so a mode derived from the displaced host would route the submitted endpoint
|
|
# over the wrong wire.
|
|
from hermes_cli.providers import determine_api_mode
|
|
url = base_url.strip()
|
|
result = replace(result, base_url=url,
|
|
api_mode=determine_api_mode(result.target_provider, url))
|
|
return result
|
|
|
|
|
|
def apply_main_model_assignment(model_cfg: Any, result: ModelSwitchResult, api_key: str = "") -> dict:
|
|
"""Apply a main-slot selection to a ``model`` config dict via the canonical /model shape
|
|
(``hermes_cli.model_switch.apply_model_selection``). An explicit key for a custom endpoint is
|
|
the one inline credential the runtime reads (``model.api_key``); the legacy ``api`` alias is
|
|
dropped so a stale secret cannot shadow it.
|
|
|
|
Returns a new dict."""
|
|
from hermes_cli.config_backend import supports_file_tooling
|
|
from hermes_cli.model_switch import apply_model_selection, remote_model_selection_guard
|
|
|
|
before = model_cfg
|
|
# Remote Config: the caller saves the effective block as a whole document, so a cleared
|
|
# inherited key must be masked (null), and a locked route key refuses the whole assignment.
|
|
model_cfg = apply_model_selection(model_cfg, result, mask_cleared=not supports_file_tooling())
|
|
if api_key.strip():
|
|
model_cfg["api_key"] = api_key.strip()
|
|
drop_model_key(model_cfg, "api")
|
|
remote_model_selection_guard(before, model_cfg)
|
|
return model_cfg
|
|
|
|
|
|
def apply_inherited_model_assignment(model_cfg: Any, inherited: dict) -> dict:
|
|
"""Pin another profile's raw ``model`` block over *model_cfg* without revalidating it: the same
|
|
cleanup, Remote Config masks and lock guard as :func:`apply_main_model_assignment`. The source's
|
|
endpoint-bound keys (inline credential, credential pointer, context pin) stay behind: the new
|
|
profile's own environment can route the same references to a different endpoint, and the
|
|
validated assignment never carried them either. Call it in the new profile's config scope: routes
|
|
are compared as this profile resolves them, so two spellings of one endpoint keep its own keys.
|
|
|
|
Returns a new dict."""
|
|
from hermes_cli.config import _expand_env_vars
|
|
from hermes_cli.config_backend import supports_file_tooling
|
|
from hermes_cli.model_switch import apply_model_selection, remote_model_selection_guard
|
|
from hermes_cli.route_identity import ENDPOINT_CREDENTIAL_KEYS, ENDPOINT_KEY_POINTER_KEYS
|
|
|
|
current = dict(model_cfg) if isinstance(model_cfg, dict) else {}
|
|
here = str(_expand_env_vars(current.get("base_url") or ""))
|
|
there = str(_expand_env_vars(inherited.get("base_url") or ""))
|
|
result = ModelSwitchResult(
|
|
success=True, target_provider=inherited["provider"], new_model=inherited["default"],
|
|
base_url=there, api_mode=inherited.get("api_mode") or "")
|
|
mask = not supports_file_tooling()
|
|
compared = {**current, "base_url": here} if "base_url" in current else current
|
|
selected = apply_model_selection(compared, result, mask_cleared=mask)
|
|
bound = {*ENDPOINT_CREDENTIAL_KEYS, *ENDPOINT_KEY_POINTER_KEYS, "context_length"}
|
|
if not (here and there):
|
|
# Without both URLs the endpoint may come from a replaced endpoint entry or the
|
|
# environment, so the destination's own endpoint-bound keys cannot be shown to apply.
|
|
for key in bound & current.keys():
|
|
if mask:
|
|
selected[key] = None
|
|
else:
|
|
selected.pop(key, None)
|
|
carried = {k: v for k, v in inherited.items() if k not in bound}
|
|
assigned = {**selected, **carried}
|
|
remote_model_selection_guard(model_cfg, assigned)
|
|
return assigned
|
|
|
|
|
|
def drop_model_key(model_cfg: dict, key: str) -> None:
|
|
"""Remove *key* from a ``model`` block an assignment is building. Under Remote Config the block
|
|
is the EFFECTIVE one, so a key it holds may be inherited from an upper level that a profile
|
|
removal cannot reach (contract §5.4); store null ("no value") instead, the same mask
|
|
:func:`hermes_cli.model_switch.apply_model_selection` applies. A key the block lacks stays
|
|
absent. File backend: a plain removal."""
|
|
from hermes_cli.config_backend import supports_file_tooling
|
|
if key not in model_cfg:
|
|
return
|
|
if supports_file_tooling():
|
|
model_cfg.pop(key, None)
|
|
else:
|
|
model_cfg[key] = None
|