| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122 |
- """Config, env var and provider custom-endpoint dashboard routes.
- Extracted from ``hermes_cli.web_server``; helpers/state that tests monkeypatch on
- ``web_server`` stay there and are late-bound (cycle-safe).
- """
- import contextlib
- import logging
- import re
- import asyncio
- import time
- import urllib.parse
- from fastapi import APIRouter
- from hermes_cli.web_routers._common import (
- REDACTED_CREDENTIAL_WRITE_DETAIL, config_scoped_to_thread, http_failure,
- is_redacted_credential_preview, redacted_credential_preview, scoped_to_thread,
- )
- from hermes_cli.config_backend import refusing_locked_omissions
- from hermes_cli.web_deps import LateState, late
- from hermes_cli.web_server_config import (
- _apply_main_model_assignment, _denormalize_config_from_web, drop_model_key, _normalize_config_for_web, _schema_with_dynamic_provider_options,
- _validated_main_model_selection,
- )
- from hermes_cli.web_server_profiles import (
- _approval_mode_of, _broadcast_gateway_session_info, _is_other_profile, _parse_model_entries,
- )
- from fastapi import HTTPException, Request
- from hermes_cli.config import DEFAULT_CONFIG, OPTIONAL_ENV_VARS, read_raw_config, require_readable_config_before_write, custom_endpoint_key_env, coerce_provider_id, find_provider_entry, get_compatible_custom_providers, _ENV_REF_RE, _deep_merge
- from hermes_cli.config_providers import _canonical_api_mode, _custom_provider_entry_to_provider_config
- from hermes_cli.web_models import ConfigUpdate, EnvVarUpdate, EnvVarDelete, EnvVarReveal, CustomEndpointUpdate
- from typing import Any, Dict, List, Optional, Tuple
- _log = logging.getLogger("hermes_cli.web_server")
- config_router = APIRouter()
- router = APIRouter()
- # Late-bound so a test's monkeypatch on the owning module wins at call time.
- _channel_managed_env_keys = late("_channel_managed_env_keys", "hermes_cli.web_server_messaging")
- _config_profile_scope = late("_config_profile_scope", "hermes_cli.web_server_profiles")
- _profile_scope = late("_profile_scope", "hermes_cli.web_server_profiles")
- _require_token = late("_require_token")
- load_config = late("load_config", "hermes_cli.config")
- load_env = late("load_env", "hermes_cli.config")
- remove_env_value = late("remove_env_value", "hermes_cli.config")
- save_config = late("save_config", "hermes_cli.config")
- save_env_value = late("save_env_value", "hermes_cli.config")
- _CONFIG_MUTATION_LOCK = LateState("_CONFIG_MUTATION_LOCK")
- # Simple rate limiter for the reveal endpoint
- _reveal_timestamps: list[float] = []
- _REVEAL_MAX_PER_WINDOW = 5
- _REVEAL_WINDOW_SECONDS = 30
- # Display order for tabs — unlisted categories sort alphabetically after these.
- _CATEGORY_ORDER = [
- "general", "agent", "terminal", "display", "delegation",
- "memory", "compression", "security", "browser", "voice",
- "tts", "stt", "logging", "discord", "auxiliary",
- ]
- @contextlib.contextmanager
- def _env_write_errors(log_msg: str):
- """``ValueError`` -> 400 with its message (save/remove_env_value reject
- invalid names and denylisted keys — LD_PRELOAD, PATH, PYTHONPATH, …, the
- credential lifecycle rejects keys a managed install or administrator pins,
- and the SPA needs the reason, not an opaque 500); ``HTTPException`` (the
- profile scope's 404 for an unknown ``?profile=``) passes through; anything
- else is logged and becomes 500 "Internal server error"."""
- try:
- yield
- except HTTPException:
- raise
- except ValueError as exc:
- raise HTTPException(status_code=400, detail=str(exc)) from exc
- except Exception:
- _log.exception(log_msg)
- raise HTTPException(status_code=500, detail="Internal server error")
- @config_router.get("/api/config")
- async def get_config(profile: Optional[str] = None, include_defaults: bool = True):
- # _profile_scope blocks on the process-wide _SKILLS_PROFILE_LOCK and
- # load_config() reads from disk; a slow lock-holder on the event loop froze
- # the whole gateway for >1s. asyncio.to_thread copies the contextvar
- # context, so the profile override stays scoped to the worker thread.
- # Opt in to saved values so clients can distinguish user choices from defaults.
- config = await scoped_to_thread(
- profile, lambda: _normalize_config_for_web(load_config() if include_defaults else read_raw_config())
- )
- # Strip internal keys that the frontend shouldn't see or send back
- return {k: v for k, v in config.items() if not k.startswith("_")}
- @config_router.get("/api/config/defaults")
- async def get_defaults():
- return DEFAULT_CONFIG
- @config_router.get("/api/config/schema")
- async def get_schema(profile: Optional[str] = None):
- # Discovery-driven provider options (voice command providers + memory
- # provider plugins) are merged per-request so providers added after server
- # start still show up, scoped to the requested profile's config. That merge
- # walks the schema and scans plugin dirs on disk, so it runs on a worker
- # thread: on the event loop it froze every other request — including
- # /api/ws — for as long as the scan took. asyncio.to_thread copies the
- # contextvar context, so the profile override stays scoped to the worker.
- fields = await config_scoped_to_thread(profile, _schema_with_dynamic_provider_options)
- return {"fields": fields, "category_order": _CATEGORY_ORDER}
- @config_router.get("/api/egress/status")
- async def get_egress_status(profile: Optional[str] = None):
- """Dashboard/Desktop-readable egress proxy status and remediation text."""
- from hermes_cli.proxy_cli import format_status_text
- # Reads the profile's ``proxy:`` config block from disk; on the event loop
- # that read stalled every other dashboard request for its duration.
- return {"text": await config_scoped_to_thread(profile, format_status_text)}
- @router.put("/api/config")
- async def update_config(
- body: ConfigUpdate, profile: Optional[str] = None, preserve_language: bool = False
- ):
- def _run():
- approvals_mode_changed = False
- with _profile_scope(body.profile or profile):
- # The dashboard form is schema-driven; root keys absent from the
- # schema (``custom_providers``, ``agent.personalities``, ...) are not
- # in the PUT body, so deep-merge incoming over disk rather than
- # full-replace — the frontend can only overwrite what it sends.
- with _CONFIG_MUTATION_LOCK:
- # Strict read: the merge below builds a new dict, so a swallowed read error here
- # would save the PUT body alone over the whole file.
- existing = require_readable_config_before_write()
- incoming = _denormalize_config_from_web(body.config)
- merged = _deep_merge(existing, incoming)
- # Compare normalized approvals.mode across the in-memory
- # documents, not config blocks and not cache re-reads: the page
- # PUTs the defaulted GET record while disk holds sparse YAML (a
- # block compare is always-unequal), and a post-save reload can
- # serve the pre-save cache on an (mtime_ns, size) collision.
- # Only approvals.mode feeds session.info, so it is the trigger.
- approvals_mode_changed = _approval_mode_of(merged) != _approval_mode_of(existing)
- # Explicit English must survive default stripping: an absent
- # language lets the desktop follow the OS on its next launch.
- # Ordinary settings saves include merged defaults, not a choice.
- save_config(
- merged, preserve_keys={("display", "language")} if preserve_language else None
- )
- # REST saves bypass the config.set RPC (which re-emits itself), so
- # refresh live sessions' cached approval/YOLO indicators after a mode
- # change. Own-profile saves only: a profile-scoped save targets a
- # different HERMES_HOME than this process's gateway sessions.
- if approvals_mode_changed and not _is_other_profile(body.profile or profile):
- _broadcast_gateway_session_info()
- return {"ok": True}
- with http_failure("PUT /api/config failed", 500, detail="Internal server error"):
- return await asyncio.to_thread(_run)
- def _provider_card(d, description: str, url, *, is_password: bool, advanced: bool) -> dict:
- return {
- "provider": d.slug, "provider_label": d.label, "description": description, "url": url,
- "is_password": is_password, "advanced": advanced, "category": "provider",
- }
- _AUTH_TYPE_ENV_VARS = {
- "aws_sdk": (
- ("AWS_REGION", lambda d, var: f"{d.label} ({var})"),
- ("AWS_PROFILE", lambda d, var: f"{d.label} ({var})"),
- ),
- "vertex": (("VERTEX_CREDENTIALS_PATH", lambda d, var: f"{d.label} — service account JSON path (or use ADC)"),),
- }
- def _catalog_provider_env_metadata() -> dict:
- """Map provider env vars -> desktop card metadata, derived from the catalog.
- Returns ``{env_var: {provider, provider_label, description, url, is_password,
- advanced}}`` for every API-key provider in the unified ``provider_catalog()``
- (the ``hermes model`` universe). When multiple providers intentionally share
- one env var, ``provider_profiles`` preserves every provider identity while
- the legacy singular fields keep describing the first provider. Hand
- ``OPTIONAL_ENV_VARS`` prose is layered on top in the endpoint; this only
- supplies membership + grouping + fallbacks.
- """
- try:
- from hermes_cli.provider_catalog import provider_catalog
- except Exception:
- return {}
- # Env vars declared with a NON-provider category (e.g. the shared
- # GITHUB_TOKEN, a Skills-Hub "tool" credential) must not be promoted into a
- # provider card even when a provider lists them as auth aliases.
- _non_provider_keys = {
- k for k, v in OPTIONAL_ENV_VARS.items()
- if (v or {}).get("category") and (v or {}).get("category") != "provider"
- }
- meta: dict = {}
- def _profile(entry: dict) -> dict:
- """Return the provider-specific part of a shared credential row."""
- return {
- "provider": entry["provider"],
- "provider_label": entry["provider_label"],
- "description": entry["description"],
- "url": entry["url"],
- "primary": bool(entry.get("provider_primary")),
- }
- def _add_provider_env(env_var: str, entry: dict) -> None:
- """Add one provider without discarding peers that share ``env_var``."""
- existing = meta.get(env_var)
- if existing is None:
- meta[env_var] = entry
- return
- if existing.get("provider") == entry.get("provider"):
- return
- profiles = existing.setdefault("provider_profiles", [_profile(existing)])
- if not any(profile.get("provider") == entry.get("provider") for profile in profiles):
- profiles.append(_profile(entry))
- for d in provider_catalog():
- if d.tab != "keys":
- continue
- # API-key vars: the first is the primary (password) field; aliases are
- # kept as additional password fields so users can clear them too.
- for index, env_var in enumerate(d.api_key_env_vars):
- if env_var in _non_provider_keys:
- continue # don't hijack a shared tool/messaging credential
- entry = _provider_card(
- d, d.description, d.signup_url or None, is_password=True, advanced=False,
- )
- entry["provider_primary"] = index == 0
- _add_provider_env(
- env_var,
- entry,
- )
- # Base-URL override is an advanced, non-secret field for the same card.
- if d.base_url_env_var:
- meta.setdefault(
- d.base_url_env_var,
- _provider_card(d, f"{d.label} base URL override", None, is_password=False, advanced=True),
- )
- # Providers without api_key_env_vars would otherwise be invisible on
- # the Keys tab: AWS-SDK providers (Bedrock) authenticate via the AWS
- # credential chain, Vertex via OAuth2 (service-account JSON path or
- # ADC — a path, not a secret). Tag their env vars to the card.
- for var, describe in _AUTH_TYPE_ENV_VARS.get(d.auth_type, ()):
- existing = meta.get(var, {})
- meta[var] = _provider_card(
- d, existing.get("description") or describe(d, var), existing.get("url"),
- is_password=False, advanced=existing.get("advanced", True),
- )
- return meta
- @router.get("/api/env")
- async def get_env_vars(profile: Optional[str] = None):
- # _profile_scope takes _SKILLS_PROFILE_LOCK and load_env()/catalog
- # discovery read from disk — keep the whole build off the event loop.
- return await asyncio.to_thread(_get_env_vars_sync, profile)
- def _get_env_vars_sync(profile: Optional[str] = None):
- with _profile_scope(profile):
- env_on_disk = load_env()
- channel_keys = _channel_managed_env_keys()
- catalog_meta = _catalog_provider_env_metadata()
- def _row(var_name: str, info: dict, *, custom: bool = False) -> dict:
- value = env_on_disk.get(var_name)
- cat_meta = catalog_meta.get(var_name) or {}
- # Hand OPTIONAL_ENV_VARS prose wins where present; the catalog fills any
- # gaps (description/url) and always supplies provider grouping hints.
- return {
- "is_set": bool(value),
- "redacted_value": redacted_credential_preview(value),
- "description": info.get("description") or cat_meta.get("description", ""),
- "url": info.get("url") if info.get("url") is not None else cat_meta.get("url"),
- "category": info.get("category") or cat_meta.get("category", ""),
- "is_password": info.get("password", cat_meta.get("is_password", False)),
- "tools": info.get("tools", []),
- "advanced": info.get("advanced", cat_meta.get("advanced", False)),
- # Messaging-platform credential owned by a Channels page card; the
- # Keys/Env page hides it rather than duplicate the richer UI.
- "channel_managed": var_name in channel_keys,
- # Provider grouping from the unified catalog, so the desktop groups
- # by the SAME provider identity the CLI `hermes model` picker uses.
- "provider": cat_meta.get("provider", ""),
- "provider_label": cat_meta.get("provider_label", ""),
- # One credential can intentionally serve multiple built-in routes.
- # Preserve those identities so Desktop can render distinct cards
- # that edit the same underlying env var.
- "provider_profiles": cat_meta.get("provider_profiles", []),
- # The provider's own index-0 credential flag. Desktop picks a card's
- # main "Paste key" field from this FIRST, so a shared alias that a
- # peer profile contributes (DASHSCOPE_API_KEY for the CN Coding /
- # Token Plan cards) can never re-point the card's primary field.
- "provider_primary": bool(cat_meta.get("provider_primary", False)),
- # True for a .env key in no catalog at all — an arbitrary/custom var
- # the user added directly, listed so the Keys page can manage it.
- "custom": custom,
- }
- result = {}
- for var_name, info in OPTIONAL_ENV_VARS.items():
- result[var_name] = _row(var_name, info)
- # Catalog provider env vars with no hand entry in OPTIONAL_ENV_VARS.
- for var_name in catalog_meta:
- if var_name not in result:
- result[var_name] = _row(var_name, {})
- # Custom keys from .env: always "set" (on disk), treated as secrets by
- # default (is_password=True -> redacted, reveal-gated) since an
- # unrecognised key could hold anything. Channel-managed credentials belong
- # to the Channels page. A key added via "add a custom key" round-trips here.
- for var_name in env_on_disk:
- if var_name in result or var_name in channel_keys:
- continue
- row = _row(var_name, {}, custom=True)
- row["category"] = "custom"
- row["is_password"] = True
- result[var_name] = row
- return result
- @router.put("/api/env")
- async def set_env_var(body: EnvVarUpdate, profile: Optional[str] = None):
- # Unified credential lifecycle: writes .env AND reconciles any config.yaml
- # mirror still holding the previous value of this var (model.api_key /
- # auxiliary.*.api_key / custom_providers[*]), so a rotation can't leave a
- # stale higher-precedence copy that keeps authenticating with the old key.
- # Display-only previews (sentinel or legacy mask) must never gain write authority.
- if is_redacted_credential_preview(body.value):
- raise HTTPException(status_code=400, detail=REDACTED_CREDENTIAL_WRITE_DETAIL)
- with _env_write_errors("PUT /api/env failed"):
- return await scoped_to_thread(body.profile or profile, lambda: _save_env_credential(body.key, body.value, body.provider_setup))
- def _save_env_credential(key: str, value: str, provider_setup: bool = False) -> Any:
- """Save under the request's profile scope; a new provider API key also counts as a provider setup."""
- from hermes_cli.config import load_env
- from hermes_cli.credential_lifecycle import save_provider_env_credential
- from hermes_cli.observability.shared_metrics_setup import record_api_key_saved, web_setup_surface
- previous = load_env().get(key)
- result = save_provider_env_credential(key, value)
- record_api_key_saved(key, value, previous, web_setup_surface(), connecting=provider_setup)
- return result
- # Live credential probes keyed by env var: (url, auth) where auth is "bearer"
- # (Authorization header) or "query" (?key=). A cheap read-only call that 401s
- # on a bad token — enough to catch a mistyped key before it's persisted.
- # Providers absent here (or local endpoints) are not network-validated; the
- # client treats those as "unknown".
- _CREDENTIAL_PROBES: dict[str, tuple[str, str]] = {
- "OPENROUTER_API_KEY": ("https://openrouter.ai/api/v1/key", "bearer"),
- "OPENAI_API_KEY": ("https://api.openai.com/v1/models", "bearer"),
- "XAI_API_KEY": ("https://api.x.ai/v1/models", "bearer"),
- "GEMINI_API_KEY": ("https://generativelanguage.googleapis.com/v1beta/models", "query"),
- }
- def _custom_endpoint_id(raw: str, fallback: str = "custom") -> str:
- slug = re.sub(r"[^A-Za-z0-9_-]+", "-", coerce_provider_id(raw)).strip("-_").lower()
- return slug or fallback
- def _resolve_custom_endpoint_entry(providers: Any, endpoint_id: str) -> tuple[Any, Optional[dict[str, Any]]]:
- """Resolve a custom endpoint id using the stored key first, then its legacy slug.
- The list route hands Desktop the literal ``providers.<key>`` (a v11→v12
- migration keeps dots/colons from the display name: ``local-127.0.0.1:8283``;
- hand-written keys keep their case), so that spelling must round-trip
- unchanged. Slugging is only the compatibility path for callers that still
- send an unslugged display name.
- """
- stored_key, entry = find_provider_entry(providers, endpoint_id)
- if entry is not None:
- return stored_key, entry
- normalized_key = _custom_endpoint_id(endpoint_id)
- if normalized_key == endpoint_id:
- return None, None
- return find_provider_entry(providers, normalized_key)
- def _models_from_custom_endpoint_entry(entry: dict[str, Any]) -> list[str]:
- models: list[str] = []
- raw_models = entry.get("models")
- if isinstance(raw_models, (dict, list)):
- models.extend(str(model).strip() for model in raw_models)
- default_model = str(entry.get("model") or entry.get("default_model") or "").strip()
- if default_model:
- models.insert(0, default_model)
- seen: set[str] = set()
- return [model for model in models if model and not (model in seen or seen.add(model))]
- def _api_key_display(entry: dict[str, Any]) -> tuple[bool, Optional[str]]:
- """Return ``(has_api_key, preview)`` for a provider or model config block.
- Keys live in ``.env`` behind ``key_env``; only older entries still carry a
- plaintext ``api_key``. Checking both keeps the panel honest either way.
- See #69449.
- """
- plaintext = str(entry.get("api_key") or "").strip()
- if plaintext:
- return True, redacted_credential_preview(plaintext)
- key_env = str(entry.get("key_env") or "").strip()
- if key_env:
- return True, f"${{{key_env}}}"
- return False, None
- def _raw_provider_api_key(endpoint_id: str) -> Any:
- """The on-disk (un-expanded) ``api_key`` of a providers entry, or ``None``."""
- _stored, entry = find_provider_entry(read_raw_config().get("providers"), endpoint_id)
- return entry.get("api_key") if isinstance(entry, dict) else None
- def _config_api_key_is_env_ref(endpoint_id: str) -> bool:
- """True when this endpoint's on-disk ``api_key`` is a ``${VAR}`` template.
- ``load_config()`` expands env refs, so a hand-written ``api_key: ${MY_KEY}``
- is indistinguishable from a literal secret by the time it reaches us. Such
- an entry already keeps its secret out of config.yaml, so migrating it would
- only copy that secret into a second env var the user didn't ask for.
- """
- raw_key = _raw_provider_api_key(endpoint_id)
- return bool(isinstance(raw_key, str) and re.search(r"\$\{[^}]+\}", raw_key))
- _DESKTOP_API_MODES = {"chat_completions", "codex_responses", "anthropic_messages"}
- def _endpoint_api_mode(entry: dict[str, Any]) -> str:
- """The transport a providers entry pins (``api_mode``, or the v12 migration's ``transport``
- spelling), canonicalized; ``""`` = runtime auto-detect. Mirrors the read order of
- ``runtime_provider_custom._get_named_custom_provider``."""
- raw = str(entry.get("api_mode") or entry.get("transport") or "")
- mode = _canonical_api_mode(raw).lower()
- return mode if mode in _DESKTOP_API_MODES else ""
- def _endpoint_row(
- endpoint_id: str, name: str, base_url: str, model: str, models: list[str], context_length,
- discover_models: bool, key_entry: dict[str, Any], is_current: bool, source: str,
- ) -> dict[str, Any]:
- has_api_key, api_key_preview = _api_key_display(key_entry)
- return {
- "id": endpoint_id, "name": name, "base_url": base_url, "model": model, "models": models,
- "api_mode": _endpoint_api_mode(key_entry),
- "context_length": context_length, "discover_models": discover_models,
- "has_api_key": has_api_key, "api_key_preview": api_key_preview,
- "is_current": is_current, "source": source,
- }
- def _model_names_provider(model_cfg: dict[str, Any], provider_key: str, entry: Optional[dict[str, Any]]) -> bool:
- """True when ``model.provider`` points at this ``providers`` entry.
- ``switch_model`` spells the active provider either as the stored key or as
- ``custom:<lowercased name>``; the list's ``is_current`` and delete's mirror
- detach must accept both, or a mixed-case key activates but never shows as
- active.
- """
- names = {coerce_provider_id(provider_key).lower()}
- if isinstance(entry, dict) and coerce_provider_id(entry.get("name")):
- names.add(coerce_provider_id(entry.get("name")).lower())
- current = str(model_cfg.get("provider") or "").strip().lower()
- return current.removeprefix("custom:") in names
- def _custom_endpoint_response(cfg: dict[str, Any]) -> dict[str, Any]:
- model_cfg = cfg.get("model", {}) if isinstance(cfg.get("model"), dict) else {}
- current_provider = str(model_cfg.get("provider", "") or "")
- current_model = str(model_cfg.get("default", model_cfg.get("name", "")) or "")
- current_base_url = str(model_cfg.get("base_url", "") or "")
- endpoints: list[dict[str, Any]] = []
- providers = cfg.get("providers")
- if isinstance(providers, dict):
- for provider_id, raw_entry in providers.items():
- if not isinstance(raw_entry, dict):
- continue
- base_url = str(raw_entry.get("base_url") or raw_entry.get("url") or raw_entry.get("api") or "").strip()
- if not base_url:
- continue
- endpoint_id = str(provider_id)
- models = _models_from_custom_endpoint_entry(raw_entry)
- endpoints.append(_endpoint_row(
- endpoint_id, str(raw_entry.get("name") or endpoint_id), base_url,
- str(raw_entry.get("model") or raw_entry.get("default_model") or (models[0] if models else "")),
- models, raw_entry.get("context_length"), bool(raw_entry.get("discover_models", True)),
- raw_entry, _model_names_provider(model_cfg, endpoint_id, raw_entry), "providers",
- ))
- # Legacy ``custom_providers:`` list entries the migration left behind are
- # still routed at runtime (get_compatible_custom_providers), so they need a
- # row too, or the panel hides an endpoint the agent can pick. Entries from
- # ``providers:`` carry ``provider_key``; the legacy ones do not. A bare
- # ``provider: custom`` main slot is "current" for the legacy row whose
- # base_url it points at.
- is_bare_custom = current_provider.lower() == "custom" and bool(current_base_url)
- seen_ids = {e["id"] for e in endpoints}
- for entry in get_compatible_custom_providers(cfg):
- if entry.get("provider_key"):
- continue
- endpoint_id = _custom_endpoint_id(entry["name"])
- if endpoint_id in seen_ids:
- continue
- seen_ids.add(endpoint_id)
- models = _models_from_custom_endpoint_entry(entry)
- is_current = is_bare_custom and entry["base_url"].rstrip("/") == current_base_url.rstrip("/")
- endpoints.append(_endpoint_row(
- endpoint_id, entry["name"], entry["base_url"],
- str(entry.get("model") or (models[0] if models else "")), models,
- entry.get("context_length"), bool(entry.get("discover_models", True)),
- entry, is_current, "custom_providers",
- ))
- if is_bare_custom and not any(e["id"] == "custom" or e["is_current"] for e in endpoints):
- endpoints.insert(0, _endpoint_row(
- "custom", "Custom", current_base_url, current_model, [current_model] if current_model else [],
- model_cfg.get("context_length"), True, model_cfg, True, "direct-config",
- ))
- return {
- "endpoints": endpoints,
- "current": {
- "provider": current_provider, "model": current_model, "base_url": current_base_url,
- },
- }
- def _pop_legacy_custom_provider(cfg: dict[str, Any], provider_key: str) -> Optional[dict[str, Any]]:
- """Remove and return the legacy ``custom_providers:`` list entry whose name slugs to *provider_key*."""
- legacy = cfg.get("custom_providers")
- if not isinstance(legacy, list):
- return None
- for index, entry in enumerate(legacy):
- if isinstance(entry, dict) and _custom_endpoint_id(str(entry.get("name") or "")) == provider_key:
- return legacy.pop(index)
- return None
- def _detach_main_model_from_provider(cfg: dict[str, Any], provider_key: str, entry: Optional[dict[str, Any]] = None) -> None:
- """Drop the main-slot mirror of a provider that no longer exists.
- ``activate_custom_endpoint`` copies the endpoint's ``base_url`` and
- ``api_key`` onto ``model``; that mirror outranks the environment at client
- construction, so deleting the endpoint without clearing it leaves the agent
- authenticating to the deleted host with the deleted key (and the key in
- config.yaml). Only touches ``model`` when it names the deleted provider —
- ``switch_model`` spells that either as the stored key or as
- ``custom:<lowercased name>``, so both spellings count.
- See #62269.
- """
- model_cfg = cfg.get("model")
- if not isinstance(model_cfg, dict) or not _model_names_provider(model_cfg, provider_key, entry):
- return
- for field in ("provider", "base_url", "api_key", "key_env"):
- model_cfg.pop(field, None)
- cfg["model"] = model_cfg
- def _write_custom_endpoint(cfg: dict[str, Any], body: CustomEndpointUpdate) -> tuple[str, dict[str, Any]]:
- name = (body.name or "").strip()
- base_url = (body.base_url or "").strip().rstrip("/")
- model = (body.model or "").strip()
- if not name:
- raise HTTPException(status_code=400, detail="name required")
- if not base_url:
- raise HTTPException(status_code=400, detail="base_url required")
- try:
- parsed = urllib.parse.urlparse(base_url)
- except ValueError as exc:
- raise HTTPException(status_code=400, detail="base_url must include scheme and host") from exc
- if not parsed.scheme or not parsed.netloc:
- raise HTTPException(status_code=400, detail="base_url must include scheme and host")
- if not model:
- raise HTTPException(status_code=400, detail="model required")
- # Deliver the bearer token through a named provider entry. A bare ``provider: custom`` cannot carry a
- # credential for this host: OPENAI_API_KEY is deliberately gated to openai.com (#28660), so the token
- # was dropped and requests went out as "no-key-required".
- providers = cfg.get("providers")
- if not isinstance(providers, dict):
- providers = {}
- # An edit payload carries the stored key verbatim; slugging it first would
- # miss the entry and fork a slugged twin next to the original.
- stored_key, existing = _resolve_custom_endpoint_entry(providers, body.id or body.name)
- endpoint_id = coerce_provider_id(stored_key) if existing is not None else _custom_endpoint_id(body.id or body.name)
- if existing is None:
- # Settings saves the row the list rendered. A legacy custom_providers
- # entry is not in providers, so resolving only there forked a keyless
- # twin and left the list row (and its key_env) behind.
- from hermes_cli.config_providers import _custom_provider_entry_to_provider_config
- legacy = _pop_legacy_custom_provider(cfg, endpoint_id)
- converted = (
- _custom_provider_entry_to_provider_config(legacy, provider_key=endpoint_id)
- if legacy is not None else None
- )
- if isinstance(converted, dict):
- existing = converted
- elif legacy is not None:
- restored = cfg.get("custom_providers")
- if isinstance(restored, list):
- restored.append(legacy)
- if existing is None:
- existing = {}
- # Merge onto the existing entry rather than replacing it: a providers.<name>
- # block can carry hand-written keys the dashboard has no field for
- # (``key_env``/``api_key_env``, ``extra_headers`` — possibly with
- # credentials — ``request_overrides``); rebuilding from scratch silently
- # dropped them on an unrelated edit.
- entry: dict[str, Any] = dict(existing)
- entry.update({
- "name": name, "base_url": base_url, "model": model,
- "discover_models": bool(body.discover_models),
- })
- # A Responses-only or Anthropic-compatible host 404s on the runtime's
- # Chat Completions default, so the panel pins the transport the same way
- # ``hermes model`` does (``api_mode``; the runtime also reads the v12
- # ``transport`` spelling, so drop it rather than let the two disagree).
- # ``None`` = older UI payload: keep whatever is hand-written. See #93622.
- if body.api_mode is not None:
- entry.pop("transport", None)
- if body.api_mode:
- entry["api_mode"] = body.api_mode
- else:
- entry.pop("api_mode", None)
- # Same for the model map, so existing models keep their context lengths.
- # ``body.models`` is the catalogue the panel's Test button discovered;
- # without it only the hand-typed model survived Save. A payload with no
- # ``models`` (older UI) still ensures the named default is present.
- # See #69988.
- details = {d.id.strip(): d for d in (body.model_details or ()) if d.id.strip()}
- existing_models = entry.get("models")
- models_map: dict[str, Any] = dict(existing_models) if isinstance(existing_models, dict) else {}
- for candidate in (*(body.models or ()), *details, model):
- model_id = str(candidate).strip()
- if not model_id:
- continue
- current = models_map.get(model_id)
- row = dict(current) if isinstance(current, dict) else {}
- detail = details.get(model_id)
- if detail is not None:
- # Keep the alias metadata ``/v1/models`` advertised so the catalogue
- # still says what ``gpt-5.6-sol-high`` stands for after Save.
- row.update({k: v.strip() for k, v in (("canonical_model", detail.canonical_model),
- ("reasoning_effort", detail.reasoning_effort)) if v and v.strip()})
- models_map[model_id] = row
- entry["models"] = models_map
- # A reasoning alias is not a model the inference route accepts literally:
- # persist the canonical model and pin its effort through the one runtime
- # chokepoint (``agent.reasoning_overrides`` → ``resolve_reasoning_config``).
- alias = details.get(model)
- canonical = (alias.canonical_model or "").strip() if alias is not None else ""
- if canonical and canonical != model:
- from hermes_constants import parse_reasoning_effort
- effort = (alias.reasoning_effort or "").strip().lower()
- if parse_reasoning_effort(effort) is not None:
- agent_cfg = cfg.get("agent") if isinstance(cfg.get("agent"), dict) else {}
- overrides = agent_cfg.get("reasoning_overrides")
- overrides = dict(overrides) if isinstance(overrides, dict) else {}
- overrides[canonical] = effort
- agent_cfg["reasoning_overrides"] = overrides
- cfg["agent"] = agent_cfg
- model = canonical
- entry["model"] = model
- models_map.setdefault(model, {})
- if body.context_length and body.context_length > 0:
- entry["context_length"] = int(body.context_length)
- entry["models"][model]["context_length"] = int(body.context_length)
- # API keys never belong in config.yaml: write to .env and reference it via
- # ``key_env`` — the indirection built-in providers use and that
- # runtime_provider.py resolves at load time.
- # See #69449.
- env_var = custom_endpoint_key_env(endpoint_id)
- submitted_key = body.api_key.strip() if body.api_key is not None else None
- if submitted_key:
- # ``${KEY_ENV}`` is the GET display for key_env entries; the helper covers the
- # sentinel and legacy masks. Either one is display-only, current or stale.
- if _ENV_REF_RE.fullmatch(submitted_key) or is_redacted_credential_preview(submitted_key):
- raise HTTPException(status_code=400, detail=REDACTED_CREDENTIAL_WRITE_DETAIL)
- save_env_value(env_var, submitted_key)
- entry["key_env"] = env_var
- entry.pop("api_key", None)
- elif submitted_key is not None:
- # Blank field means "clear the key", not "leave it alone".
- remove_env_value(env_var)
- entry.pop("key_env", None)
- entry.pop("api_key", None)
- elif str(entry.get("api_key") or "").strip() and not _config_api_key_is_env_ref(endpoint_id):
- # Migrate a plaintext key an earlier release wrote, on the next save,
- # without the user having to re-enter it.
- save_env_value(env_var, entry["api_key"].strip())
- entry["key_env"] = env_var
- entry.pop("api_key", None)
- if stored_key is not None and stored_key != endpoint_id:
- providers.pop(stored_key, None)
- providers[endpoint_id] = entry
- cfg["providers"] = providers
- if body.make_default:
- result = _validated_main_model_selection(cfg, endpoint_id, model, base_url)
- cfg["model"] = _apply_main_model_assignment(cfg.get("model", {}), result)
- if entry.get("key_env") and isinstance(cfg["model"], dict):
- cfg["model"]["key_env"] = entry["key_env"]
- drop_model_key(cfg["model"], "api_key")
- return endpoint_id, entry
- # Sections a custom-endpoint default assignment writes together: the route and its provider entry.
- _ROUTE_SECTIONS = ("model", "providers", "custom_providers")
- @router.get("/api/providers/custom-endpoints")
- def list_custom_endpoints(profile: Optional[str] = None):
- """Return configured OpenAI-compatible custom endpoints for Desktop.
- Scoped to the requested profile's config.yaml: the desktop settings UI
- targets the active profile, so read/write must resolve that profile's home
- rather than the process-level HERMES_HOME (mirrors ``/api/config``).
- """
- with http_failure("GET /api/providers/custom-endpoints failed", 500, detail="Failed to list custom endpoints"):
- with _config_profile_scope(profile):
- return _custom_endpoint_response(load_config())
- @router.post("/api/providers/custom-endpoints")
- def upsert_custom_endpoint(body: CustomEndpointUpdate, profile: Optional[str] = None):
- """Create or update a v12+ ``providers`` custom endpoint entry."""
- with http_failure("POST /api/providers/custom-endpoints failed", 500, detail="Failed to save custom endpoint"):
- # Sync-def endpoints run on worker threads: the load→mutate→save span
- # holds _CONFIG_MUTATION_LOCK so a concurrent config autosave cannot
- # drop this write (or vice versa).
- with _config_profile_scope(profile), _CONFIG_MUTATION_LOCK:
- cfg = load_config()
- providers = cfg.get("providers")
- created = _resolve_custom_endpoint_entry(
- providers if isinstance(providers, dict) else {}, body.id or body.name)[1] is None
- endpoint_id, _entry = _write_custom_endpoint(cfg, body)
- # make_default: the model route and the provider definition it names are one change,
- # so a lock on either refuses both (never a model.provider naming an omitted entry).
- with refusing_locked_omissions(*_ROUTE_SECTIONS) if body.make_default else contextlib.nullcontext():
- save_config(cfg)
- response = _custom_endpoint_response(cfg)
- from hermes_constants import get_hermes_home
- home = get_hermes_home()
- if created: # editing an endpoint that exists sets nothing new up
- _record_custom_endpoint_setup(home)
- response["ok"] = True
- response["id"] = endpoint_id
- return response
- def _record_custom_endpoint_setup(home: Any) -> None:
- """Counted after the config lock is released (a cold metrics runtime must not stall writers)."""
- from hermes_cli.observability.shared_metrics_setup import record_provider_setup_done, web_setup_surface
- record_provider_setup_done(web_setup_surface(), "custom", hermes_home=home, background=True)
- @router.post("/api/providers/custom-endpoints/{endpoint_id}/activate")
- def activate_custom_endpoint(endpoint_id: str, profile: Optional[str] = None):
- """Set a configured custom endpoint as the default model provider."""
- with http_failure(
- f"POST /api/providers/custom-endpoints/{endpoint_id}/activate failed", 500,
- detail="Failed to activate custom endpoint",
- ):
- with _config_profile_scope(profile), _CONFIG_MUTATION_LOCK: # RMW span
- cfg = load_config()
- stored_key, entry = _resolve_custom_endpoint_entry(cfg.get("providers"), endpoint_id)
- if entry is None:
- # A legacy ``custom_providers:`` row: the main slot names providers by
- # key, so promote the entry to ``providers.<key>`` (the v12 shape the
- # migration would have written) before activating it.
- provider_key = _custom_endpoint_id(endpoint_id)
- legacy = _pop_legacy_custom_provider(cfg, provider_key)
- entry = _custom_provider_entry_to_provider_config(legacy, provider_key=provider_key) if legacy else None
- if entry is None:
- raise HTTPException(status_code=404, detail="custom endpoint not found")
- providers = cfg.get("providers") if isinstance(cfg.get("providers"), dict) else {}
- providers[provider_key] = entry
- cfg["providers"] = providers
- else:
- provider_key = coerce_provider_id(stored_key)
- models = _models_from_custom_endpoint_entry(entry)
- model = str(entry.get("model") or entry.get("default_model") or (models[0] if models else "")).strip()
- base_url = str(entry.get("base_url") or entry.get("api") or "").strip()
- if not model or not base_url:
- raise HTTPException(status_code=400, detail="custom endpoint is incomplete")
- model_cfg = _apply_main_model_assignment(
- cfg.get("model", {}), _validated_main_model_selection(cfg, provider_key, model, base_url))
- if entry.get("key_env"):
- model_cfg["key_env"] = entry["key_env"]
- drop_model_key(model_cfg, "api_key")
- elif entry.get("api_key"):
- # `cfg` is env-expanded, so a raw `${VAR}` api_key would land as
- # plaintext; copy the raw template when that's what's on disk.
- try:
- _raw_key = str(_raw_provider_api_key(provider_key) or "").strip()
- except Exception:
- _raw_key = ""
- if _raw_key.startswith("${") and _raw_key.endswith("}"):
- model_cfg["api_key"] = _raw_key
- else:
- model_cfg["api_key"] = entry["api_key"]
- cfg["model"] = model_cfg
- with refusing_locked_omissions(*_ROUTE_SECTIONS):
- save_config(cfg)
- return {"ok": True, "provider": provider_key, "model": model}
- @router.delete("/api/providers/custom-endpoints/{endpoint_id}")
- def delete_custom_endpoint(endpoint_id: str, profile: Optional[str] = None):
- """Remove a configured custom endpoint from ``providers``."""
- with http_failure(
- f"DELETE /api/providers/custom-endpoints/{endpoint_id} failed", 500,
- detail="Failed to delete custom endpoint",
- ):
- with _config_profile_scope(profile), _CONFIG_MUTATION_LOCK: # RMW span
- cfg = load_config()
- providers = cfg.get("providers")
- stored_key, entry = _resolve_custom_endpoint_entry(providers, endpoint_id)
- if entry is not None and isinstance(providers, dict):
- provider_key = coerce_provider_id(stored_key)
- providers.pop(stored_key, None)
- cfg["providers"] = providers
- else:
- # A legacy ``custom_providers:`` row is addressed by its slug.
- provider_key = _custom_endpoint_id(endpoint_id)
- if _pop_legacy_custom_provider(cfg, provider_key) is None:
- raise HTTPException(status_code=404, detail="custom endpoint not found")
- _detach_main_model_from_provider(cfg, provider_key, entry)
- remove_env_value(custom_endpoint_key_env(provider_key))
- save_config(cfg)
- response = _custom_endpoint_response(cfg)
- response["ok"] = True
- return response
- @router.post("/api/providers/custom-endpoints/validate")
- async def validate_custom_endpoint(body: CustomEndpointUpdate):
- """Probe a custom endpoint by calling its OpenAI-compatible /models URL."""
- base_url = (body.base_url or "").strip().rstrip("/")
- if not base_url:
- return {"ok": False, "reachable": True, "message": "Enter an endpoint URL first.", "models": []}
- headers = {"Accept": "application/json"}
- if body.api_key and body.api_key.strip():
- headers["Authorization"] = f"Bearer {body.api_key.strip()}"
- resolved, resp = await _probe_openai_compatible_models(base_url, headers)
- if resp is None:
- return {"ok": False, "reachable": False, "message": f"Could not reach {base_url}/models.", "models": []}
- if resp.status_code in (401, 403):
- return {"ok": False, "reachable": True, "message": "The endpoint rejected the API key.", "models": []}
- if not resp.is_success:
- return {"ok": False, "reachable": True, "message": f"Endpoint returned HTTP {resp.status_code}.", "models": []}
- # ``models`` stays the bare id list older clients read; ``model_details`` keeps the
- # alias metadata (``canonical_model`` / ``reasoning_effort``) the id list flattens.
- entries = _parse_model_entries(resp)
- ids = [e["id"] for e in entries]
- if not ids:
- # A 200 that parses to zero models is the SPA-catch-all signature (#83128): a real
- # OpenAI-compatible /models answers JSON with a usable list. ``_parse_model_entries``
- # is lenient by design, so classify the empty result here instead of reporting
- # success. ok:false + reachable:true is a warning in the UI — Save stays possible
- # for endpoints that legitimately expose no model list.
- return {"ok": False, "reachable": True, "message": _no_models_probe_message(resp, resolved),
- "models": [], "model_details": [], "resolved_base_url": resolved}
- # /models answering proves nothing about the transport the runtime will POST to:
- # a Responses-only host lists models fine and 404s every /chat/completions (#93622).
- # Probe the route the saved mode (or the runtime's URL auto-detect) actually uses, on the
- # base that actually served /models (#65488) — that is the URL the runtime will persist.
- mode = _canonical_api_mode(body.api_mode or "").lower() or _auto_api_mode(resolved)
- probe_model = (body.model or "").strip() or (ids[0] if ids else "")
- try:
- async with _endpoint_probe_client(resolved, 8.0) as client:
- missing = await _probe_transport_route(client, resolved, mode, probe_model, headers)
- except Exception:
- missing = "" # inconclusive (see _probe_transport_route): never block on a transport error
- result = {"ok": True, "reachable": True, "message": "", "models": ids, "model_details": entries,
- "transport_checked": mode, "resolved_base_url": resolved}
- if missing:
- result.update(ok=False, message=missing)
- return result
- def _no_models_probe_message(resp: Any, base_url: str) -> str:
- """Why a 200 ``/models`` probe yielded no usable models (#83128).
- Distinguishes the three ways that happens — a non-JSON body (an SPA catch-all serves
- HTML for every route, so 200 proves nothing), a JSON body without a model list, and a
- genuinely empty list — mirroring the onboarding store's wording for the last case.
- """
- url = base_url + "/models"
- content_type = (resp.headers.get("content-type") or "").split(";")[0].strip()
- try:
- payload = resp.json()
- except ValueError: # json.JSONDecodeError — a non-JSON body (HTML, plain text) is the case being named
- payload = None
- if not isinstance(payload, (dict, list)):
- kind = content_type or "a non-JSON body"
- return (f"Connected to {url}, but it returned {kind} instead of a JSON model list — "
- "the URL may be an SPA catch-all or a wrong base URL, not an OpenAI-compatible API.")
- data = payload.get("data") if isinstance(payload, dict) else payload
- if not isinstance(data, list):
- return f"Connected to {url}, but its response is not an OpenAI-compatible model list."
- return (f"Connected to {url}, but it advertised no models. "
- "Start a model on that endpoint and try again.")
- async def _probe_openai_compatible_models(base_url: str, headers: Optional[dict]) -> tuple[str, Any]:
- """GET ``{base}/models``, then ``{base}/v1/models`` (or the ``/v1``-stripped variant) when the
- first answers a non-success. Returns ``(resolved_base_url, response)`` — the base that served the
- model list is what the caller must PERSIST: the runtime appends ``/chat/completions`` to the saved
- URL verbatim, so a bare host root that only "detected" via ``/v1/models`` would 404 every chat
- (#65488). ``response`` is None when no candidate could be reached at all."""
- base = base_url.rstrip("/")
- alternate = base[:-3].rstrip("/") if base.lower().endswith("/v1") else base + "/v1"
- resolved, resp = base, None
- async with _endpoint_probe_client(base, 8.0) as client:
- for candidate in (base, alternate):
- try:
- candidate_resp = await client.get(candidate + "/models", headers=headers)
- except Exception:
- continue
- # Keep the most telling failure: a 401/403 from the /v1 alternate says "server is
- # there, key rejected", which beats the typed root's 404 (wrong path).
- if resp is None or candidate_resp.is_success or resp.status_code == 404:
- resolved, resp = candidate, candidate_resp
- if candidate_resp.is_success:
- break
- return resolved, resp
- _TRANSPORT_ROUTES = {"chat_completions": "/chat/completions", "codex_responses": "/responses",
- "anthropic_messages": "/messages"}
- _TRANSPORT_LABELS = {"chat_completions": "Chat Completions", "codex_responses": "Responses API",
- "anthropic_messages": "Anthropic Messages"}
- def _auto_api_mode(base_url: str) -> str:
- """The transport the runtime falls back to for an endpoint without a pinned ``api_mode``
- (same resolver as ``runtime_provider_custom._custom_runtime``)."""
- from hermes_cli.runtime_provider import _detect_api_mode_for_url
- return _detect_api_mode_for_url(base_url) or "chat_completions"
- async def _probe_transport_route(client, base_url: str, mode: str, model: str, headers: dict[str, str]) -> str:
- """POST a 1-token request to ``mode``'s route; return a failure message when the host does
- not serve it (404/405/501), ``""`` otherwise. Any other status — 200, 400 (bad body), 401,
- 422, 429 — means the route exists, which is all the check needs to know; a network error or
- timeout (a local server still loading the model) is inconclusive and does not block."""
- route = _TRANSPORT_ROUTES.get(mode)
- if route is None:
- return ""
- if mode == "anthropic_messages":
- payload = {"model": model, "max_tokens": 1, "messages": [{"role": "user", "content": "hi"}]}
- token = headers.get("Authorization", "").removeprefix("Bearer ")
- headers = {**headers, "anthropic-version": "2023-06-01", **({"x-api-key": token} if token else {})}
- elif mode == "codex_responses":
- payload = {"model": model, "input": "hi", "max_output_tokens": 16}
- else:
- payload = {"model": model, "max_tokens": 1, "messages": [{"role": "user", "content": "hi"}]}
- try:
- resp = await client.post(base_url + route, json=payload, headers=headers)
- except Exception:
- return ""
- if resp.status_code not in (404, 405, 501):
- return ""
- return (f"{base_url}/models answered, but POST {route} returned HTTP {resp.status_code}: this host "
- f"does not serve the {_TRANSPORT_LABELS[mode]} API. Pick the API mode it does serve.")
- def _endpoint_probe_client(url: str, timeout: float):
- """httpx client for a user-entered endpoint probe. Local endpoints (loopback, LAN, Tailscale)
- ignore ``HTTP(S)_PROXY``: httpx honours the env/system proxy but not its bypass list, so a
- system proxy (Clash on Windows, corporate) answered the ``127.0.0.1`` probe with its own error
- page and the GUI reported "advertised no models" while the CLI saw the model (#63472)."""
- import httpx
- from agent.model_metadata import is_local_endpoint
- return httpx.AsyncClient(timeout=httpx.Timeout(timeout), trust_env=not is_local_endpoint(url))
- @router.post("/api/providers/validate")
- async def validate_provider_credential(body: EnvVarUpdate, request: Request):
- """Live-probe a provider credential before it's saved.
- Returns {ok, reachable, message}. ok=True means the provider accepted the
- key; ok=False + reachable=True means the key is bad (caller should block);
- reachable=False means the network probe couldn't run (caller may save with
- a warning rather than hard-blocking offline users).
- """
- _require_token(request)
- import httpx
- key = (body.key or "").strip()
- value = (body.value or "").strip()
- if not value:
- return {"ok": False, "reachable": True, "message": "Enter a value first."}
- # Local / custom endpoint: validate connectivity, not auth — any HTTP
- # response (even 401) proves the endpoint is up. Also surface the model ids
- # it advertises (OpenAI ``/v1/models`` shape) so the GUI can auto-pick a
- # default. The optional API key is sent so servers that require auth on
- # ``/v1/models`` still enumerate instead of returning an empty list.
- if key == "OPENAI_BASE_URL":
- api_key = (body.api_key or "").strip()
- headers = {"Authorization": f"Bearer {api_key}"} if api_key else None
- resolved, resp = await _probe_openai_compatible_models(value, headers)
- url = resolved + "/models"
- if resp is None:
- return {"ok": False, "reachable": False, "message": f"Could not reach {url}."}
- entries = _parse_model_entries(resp)
- models = [e["id"] for e in entries]
- if not models and not resp.is_success:
- # A proxy/gateway error page parses as "no models"; name the status instead so the
- # GUI does not tell the user to "start a model" on a server that answered.
- return {"ok": False, "reachable": True, "message": f"{url} answered HTTP {resp.status_code}.", "models": []}
- return {"ok": True, "reachable": True, "message": "", "models": models, "model_details": entries,
- "resolved_base_url": resolved}
- probe = _CREDENTIAL_PROBES.get(key)
- if not probe:
- # No probe for this provider — can't validate, don't block.
- return {"ok": True, "reachable": False, "message": ""}
- url, auth = probe
- if key == "GEMINI_API_KEY":
- from agent.gemini_native_adapter import normalize_gemini_base_url
- # Normalize guarantees the version segment; the key itself never decides the surface —
- # AQ. keys exist for both AI Studio and Vertex express mode (#115306).
- url = normalize_gemini_base_url(url.rsplit("/models", 1)[0]) + "/models"
- headers = {"Accept": "application/json"}
- params = {}
- if auth == "bearer":
- headers["Authorization"] = f"Bearer {value}"
- else:
- params["key"] = value
- try:
- async with httpx.AsyncClient(timeout=httpx.Timeout(10.0)) as client:
- resp = await client.get(url, headers=headers, params=params)
- except Exception:
- return {"ok": False, "reachable": False, "message": "Could not reach the provider to verify the key."}
- if resp.status_code in (401, 403):
- return {"ok": False, "reachable": True, "message": "That API key was rejected. Double-check it and try again."}
- if resp.status_code == 429 or resp.is_success:
- # 429 = key is valid but rate-limited; success = valid.
- return {"ok": True, "reachable": True, "message": ""}
- return {"ok": False, "reachable": True, "message": f"Provider returned HTTP {resp.status_code} for this key."}
- @router.delete("/api/env")
- async def remove_env_var(body: EnvVarDelete, profile: Optional[str] = None):
- # Unified credential lifecycle: clears the .env entry AND every mirror of
- # the credential — env-seeded credential_pool entries in auth.json (stale
- # ones kept providers alive in the model picker), the affected providers'
- # model-cache rows, and value-matched config.yaml api_key mirrors.
- # OAuth/device-code/manual pool entries for the same provider are preserved.
- with _env_write_errors("DELETE /api/env failed"):
- from hermes_cli.credential_lifecycle import remove_provider_env_credential
- result = await scoped_to_thread(
- body.profile or profile, lambda: remove_provider_env_credential(body.key)
- )
- if not result.get("found"):
- raise HTTPException(status_code=404, detail=f"{body.key} not found in .env")
- return result
- @router.post("/api/env/reveal")
- async def reveal_env_var(
- body: EnvVarReveal, request: Request, profile: Optional[str] = None
- ):
- """Return the real (unredacted) value of a single env var.
- Protected by the ephemeral session token (per server start, injected into
- the SPA), rate limiting (max 5 reveals per 30s window) and audit logging.
- """
- _require_token(request)
- now = time.time()
- cutoff = now - _REVEAL_WINDOW_SECONDS
- _reveal_timestamps[:] = [t for t in _reveal_timestamps if t > cutoff]
- if len(_reveal_timestamps) >= _REVEAL_MAX_PER_WINDOW:
- raise HTTPException(status_code=429, detail="Too many reveal requests. Try again shortly.")
- _reveal_timestamps.append(now)
- env_on_disk = await scoped_to_thread(body.profile or profile, load_env)
- value = env_on_disk.get(body.key)
- if value is None:
- raise HTTPException(status_code=404, detail=f"{body.key} not found in .env")
- _log.info("env/reveal: %s", body.key)
- return {"key": body.key, "value": value}
|