mirror of
https://github.com/NousResearch/hermes-agent.git
synced 2026-11-16 02:46:38 +03:00
104 lines
5.9 KiB
Python
104 lines
5.9 KiB
Python
"""The ``model:`` section's load/save canon: root-level legacy keys, the ``api_base`` alias, a
|
|
dict-valued model id, and the model-id key itself. ``hermes_cli.config`` re-exports it and runs it
|
|
on every load and on what every save writes."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Any
|
|
|
|
from hermes_cli.config_providers import _warn_once_per_provider, coerce_provider_id
|
|
|
|
|
|
def _normalize_root_model_keys(config: dict[str, Any]) -> dict[str, Any]:
|
|
"""Canonicalize the ``model`` section at the single load/save chokepoint.
|
|
Root-level ``provider``/``base_url``/``context_length`` (older layouts) are moved under
|
|
``model`` only when the corresponding ``model.*`` key is empty — never overriding. ``api_base``
|
|
(the OpenAI-SDK/LiteLLM name users reach for) is an alias for ``base_url``; the runtime reads
|
|
only ``model.base_url``. A dict-valued ``default``/``model``/``name`` is flattened so no reader
|
|
sees a nested dict, and the id is canonicalized to ``default``.
|
|
|
|
Also aliases ``api_base`` → ``base_url`` (issue #8919). ``api_base`` is the intuitive name OpenAI-SDK /
|
|
LiteLLM users reach for, and ``hermes config set`` blindly accepts any dotted key — so
|
|
``model.api_base`` got written, confirmed, and then silently ignored by the runtime resolver (which
|
|
reads only ``model.base_url``), causing requests to fall back to OpenRouter. We migrate the alias to the
|
|
canonical key (fallback-only — never override an explicit ``base_url``) and drop the alias so it can't
|
|
confuse later loads.
|
|
Finally, canonicalizes the model-id key to ``model.default`` (issue #34500). The runtime resolver and
|
|
~14 other readers select the chat model via ``model.default``; ``model.model`` was already aliased
|
|
inline at some sites but ``model.name`` was not, so a custom-provider config like ``model: {name: <id>,
|
|
provider: <custom>}`` resolved to an empty model and the API request went out with ``model=`` (HTTP 400
|
|
from OpenAI-compatible backends) — while display paths (``hermes status``/``dump``) read ``name`` and
|
|
*showed* the model, making the failure silent. Normalizing here (the single load/save chokepoint) means
|
|
every reader, present and future, sees a populated ``default`` and the stale alias is migrated out of
|
|
config.yaml on the next save. Precedence: ``default`` > ``model`` > ``name`` (never overrides an
|
|
explicit ``default``, so existing configs are unaffected).
|
|
"""
|
|
model_in = config.get("model")
|
|
model_provider = model_in.get("provider") if isinstance(model_in, dict) else None
|
|
needs_model_work = (model_provider is not None and not isinstance(model_provider, str)) or (
|
|
isinstance(model_in, dict) and (
|
|
model_in.get("api_base")
|
|
or model_in.get("model") or model_in.get("name")
|
|
or any(isinstance(model_in.get(k), dict) for k in ("default", "model", "name"))))
|
|
has_root = any(config.get(k) for k in ("provider", "base_url", "context_length", "api_base"))
|
|
if not has_root and not needs_model_work:
|
|
return config
|
|
|
|
config = dict(config)
|
|
model = config.get("model")
|
|
model = dict(model) if isinstance(model, dict) else {"default": model} if model else {}
|
|
config["model"] = model
|
|
|
|
# Flatten ``{provider: <p>, model: <m>}``. The nested provider wins over the merged default
|
|
# ``"auto"`` (which runtime resolution treats as authoritative) but never over a configured one.
|
|
# Extra nested keys were never runtime settings. Warn by path before dropping them (#153296),
|
|
# without promoting them into live routing or exposing potentially secret values.
|
|
for _key in ("default", "model", "name"):
|
|
_val = model.get(_key)
|
|
if isinstance(_val, dict):
|
|
_nested_model = _val.get("model") or _val.get("default")
|
|
_nested_provider = str(_val.get("provider") or "").strip()
|
|
model[_key] = str(_nested_model or "").strip()
|
|
if _nested_provider:
|
|
_outer_provider = str(model.get("provider") or "").strip()
|
|
if not _outer_provider or _outer_provider == "auto":
|
|
model["provider"] = _nested_provider
|
|
for _extra in _val:
|
|
if _extra in ("model", "default", "provider"):
|
|
continue
|
|
_warn_once_per_provider(
|
|
"model-section", f"discarded:{_key}.{_extra}",
|
|
"config.yaml: unsupported model.%s.%s is discarded when normalizing "
|
|
"the model ID; move it to model.%s if intended", _key, _extra, _extra)
|
|
|
|
for key in ("provider", "base_url", "context_length"):
|
|
root_val = config.get(key)
|
|
if root_val and not model.get(key):
|
|
model[key] = root_val
|
|
config.pop(key, None)
|
|
|
|
# Provider identity is a string (#117345): an unquoted YAML scalar (``provider: 2``)
|
|
# loads as int, and downstream readers call ``(provider or "").strip()`` — a gateway
|
|
# turn dies before the agent runs. Normalize at the load/save chokepoint so every
|
|
# reader (and the next save, which rewrites config.yaml) heals the persisted value.
|
|
# Guard on presence: coerce_provider_id(None) is "" — injecting an empty key into
|
|
# provider-less configs would add churn to config.yaml on the next save.
|
|
if model.get("provider") is not None:
|
|
model["provider"] = coerce_provider_id(model.get("provider"))
|
|
|
|
for alias_val in (config.get("api_base"), model.get("api_base")):
|
|
if alias_val and not model.get("base_url"):
|
|
model["base_url"] = alias_val
|
|
config.pop("api_base", None)
|
|
model.pop("api_base", None)
|
|
|
|
# ``model``/``name`` are last-resort aliases (in that order), then dropped.
|
|
alias = model.get("model") or model.get("name")
|
|
if not model.get("default") and alias:
|
|
model["default"] = alias
|
|
if model.get("default"):
|
|
model.pop("model", None)
|
|
model.pop("name", None)
|
|
|
|
return config
|