"""Public-name catalogs for shared metrics: the only non-enum names a package may carry. Every set here is something Nous itself publishes (slash-command registry, bundled and optional skills, optional-mcps/ and plugin-catalog/ entries, built-in auxiliary tasks, shipped locales). A name outside its set is reported as ``custom`` so user-defined identities never leave the machine. Loaders are cached: the catalogs only change with the installed Hermes version. """ from __future__ import annotations import functools import logging import re from pathlib import Path logger = logging.getLogger(__name__) _REPO_ROOT = Path(__file__).resolve().parents[2] CUSTOM = "custom" def _skill_dir_names(root: Path) -> frozenset[str]: try: return frozenset(p.parent.name.lower() for p in root.rglob("SKILL.md")) except OSError: return frozenset() def _yaml_stems(root: Path) -> frozenset[str]: try: return frozenset(p.stem.lower() for p in root.glob("*.yaml")) except OSError: return frozenset() @functools.cache def slash_command_names() -> frozenset[str]: from hermes_cli.commands import COMMAND_REGISTRY return frozenset(command.name for command in COMMAND_REGISTRY) @functools.cache def bundled_skill_names() -> frozenset[str]: from hermes_constants import get_bundled_skills_dir, get_optional_skills_dir return _skill_dir_names(get_bundled_skills_dir(_REPO_ROOT / "skills")) | _skill_dir_names( get_optional_skills_dir(_REPO_ROOT / "optional-skills") ) @functools.cache def mcp_catalog_names() -> frozenset[str]: from hermes_constants import get_optional_mcps_dir root = get_optional_mcps_dir(_REPO_ROOT / "optional-mcps") try: return frozenset(p.name.lower() for p in root.iterdir() if p.is_dir()) except OSError: return frozenset() @functools.cache def plugin_catalog_names() -> frozenset[str]: return _yaml_stems(_REPO_ROOT / "plugin-catalog") @functools.cache def aux_task_names() -> frozenset[str]: from hermes_cli.main_provider_setup import _AUX_TASKS return frozenset(key for key, _name, _desc in _AUX_TASKS) @functools.cache def display_languages() -> frozenset[str]: return _yaml_stems(_REPO_ROOT / "locales") @functools.cache def provider_names() -> frozenset[str]: """Provider ids Hermes itself ships: built-in auth rows, overlays, alias tables and the in-tree ``plugins/model-providers`` profiles. Never the live registries (``PROVIDER_REGISTRY``, picker labels): ``$HERMES_HOME`` and pip provider plugins add their user-chosen names there.""" import providers from hermes_cli.auth import _PROVIDER_ALIASES, BUILTIN_PROVIDER_IDS from hermes_cli.models_catalog_static import _PROVIDER_ALIASES as _CATALOG_ALIASES from hermes_cli.providers import ALIASES, HERMES_OVERLAYS providers.list_providers() # runs discovery; bundled profiles land in the process-wide layer bundled = { alias for name, profile in providers._REGISTRY.items() if providers._SOURCES.get(name) == "bundled" for alias in (name, *profile.aliases) } return BUILTIN_PROVIDER_IDS.union( HERMES_OVERLAYS, ALIASES, _PROVIDER_ALIASES, _CATALOG_ALIASES, bundled, ("openrouter", CUSTOM) ) @functools.cache def user_named_model_providers() -> frozenset[str]: """Providers whose model ids the user names: custom endpoints and loopback servers.""" from urllib.parse import urlparse from hermes_cli import auth, models, providers from hermes_cli.auth import PROVIDER_REGISTRY hosts = {"localhost", "127.0.0.1", "::1", "0.0.0.0"} loopback = { name for name, config in PROVIDER_REGISTRY.items() if urlparse(str(getattr(config, "inference_base_url", "") or "")).hostname in hosts } # Alias spellings (``lm-studio``) pass provider_metric_name as shipped names, so they must collapse too. tables = (providers.ALIASES, getattr(auth, "_PROVIDER_ALIASES", {}), getattr(models, "_PROVIDER_ALIASES", {})) aliases = {alias for table in tables for alias, canon in table.items() if canon in loopback} return frozenset(loopback | aliases | {CUSTOM}) @functools.cache def custom_provider_aliases() -> frozenset[str]: """Provider ids Hermes routes through the generic ``custom`` provider (``ollama``, ``vllm``, ``llamacpp``...): shipped names, but the server and its model ids are the user's own.""" from hermes_cli import auth, models, providers tables = (providers.ALIASES, getattr(auth, "_PROVIDER_ALIASES", {}), getattr(models, "_PROVIDER_ALIASES", {})) return frozenset(alias for table in tables for alias, canon in table.items() if canon == CUSTOM) # ---- v4 gateway ---- @functools.cache def bundled_platform_names() -> frozenset[str]: """Messaging platforms Hermes ships as ``plugins/platforms/`` (the dir is the registered name).""" root = _REPO_ROOT / "plugins" / "platforms" try: return frozenset(p.name.lower() for p in root.iterdir() if (p / "plugin.yaml").is_file()) except OSError: return frozenset() @functools.cache def catalog_platform_names() -> frozenset[str]: """``plugin-catalog/`` entries whose category is ``platform`` (in-tree only: never a network fetch).""" from hermes_cli.plugin_catalog import CATALOG_TIERS, load_catalog return frozenset(e.name for e in load_catalog() if e.category == "platform" and e.tier in CATALOG_TIERS) def platform_metric_name(raw: object, core: frozenset[str]) -> str: """A messaging platform's public name: a core or bundled platform's own name, the catalog entry name of the installed catalog plugin that registered it, else ``plugin``. ``core`` is the contract's static platform vocabulary.""" name = _norm(getattr(raw, "value", raw)) if name in core or name in _safe(bundled_platform_names): return name if not name: return "plugin" from hermes_constants import get_hermes_home return _catalog_platform_owner(str(get_hermes_home()), name) or "plugin" @functools.lru_cache(maxsize=64) def _catalog_platform_owner(home: str, platform: str) -> str | None: """The catalog entry that installed the plugin registering ``platform`` in this profile. The plugin is located from where its adapter factory's code lives (not a name it could claim), and the catalog install is proven only by the installer-owned ``.install-metadata.json`` record, never by anything inside the plugin tree, so a URL install cannot claim a catalog name.""" try: import inspect from gateway.platform_registry import platform_registry from hermes_cli.plugins_provenance import read_sidecar_rows entry = platform_registry.get(platform) if entry is None or getattr(entry, "source", "") != "plugin": return None plugins_dir = (Path(home) / "plugins").resolve() code_path = Path(inspect.getfile(entry.adapter_factory)).resolve() if not code_path.is_relative_to(plugins_dir) or code_path.parent == plugins_dir: return None row = read_sidecar_rows(plugins_dir).get(code_path.relative_to(plugins_dir).parts[0]) row = row if isinstance(row, dict) else {} block = row.get("catalog") name = _norm(block.get("name") if isinstance(block, dict) else row.get("catalog_name")) return name if name in _safe(catalog_platform_names) else None except Exception: logger.debug("Shared-metrics platform provenance unavailable", exc_info=True) return None def _norm(value: object) -> str: return value.strip().lower() if isinstance(value, str) else "" def _safe(loader) -> frozenset[str]: try: return loader() except Exception: logger.debug("Shared-metrics catalog %s unavailable", loader.__name__, exc_info=True) return frozenset() def slash_command_metric_name(raw: object) -> str: """Canonical registry name for a command or alias; skill and plugin commands stay anonymous.""" name = _norm(raw).lstrip("/").split(" ", 1)[0] if not name: return "unknown" try: from hermes_cli.commands import resolve_command command = resolve_command(name) except Exception: command = None if command is not None and command.name in _safe(slash_command_names): return command.name try: from agent.skill_commands import resolve_skill_command_key if resolve_skill_command_key(name): return "skill" from hermes_cli.plugins import get_plugin_command_handler if get_plugin_command_handler(name) is not None: return "plugin" except Exception: pass return "unknown" def skill_metric_name(raw: object) -> str: name = _norm(raw) return name if name in _safe(bundled_skill_names) else CUSTOM _EXTENSION_CATALOGS = { "skill": bundled_skill_names, "mcp_server": mcp_catalog_names, "plugin": plugin_catalog_names, } def extension_metric_name(kind: str, raw: object) -> str: """A catalog entry's public name, else ``custom`` (URL/local installs of anything).""" loader = _EXTENSION_CATALOGS.get(kind) name = _norm(raw).rsplit("/", 1)[-1] return name if loader is not None and name in _safe(loader) else CUSTOM def aux_task_metric_name(raw: object) -> str: name = _norm(raw) if not name: return "none" return name if name in _safe(aux_task_names) else "other" def provider_metric_name(raw: object) -> str: """A shipped provider id; user-named providers (``custom:``, unknown ids) and the local server aliases of ``custom`` read ``custom``.""" from .shared_metrics_contract import PROVIDER_IDENTIFIER_MAX_LENGTH, _metric_identifier name = _metric_identifier(raw, max_length=PROVIDER_IDENTIFIER_MAX_LENGTH) if name == "unknown": return name if name.startswith(CUSTOM) or name in _safe(custom_provider_aliases): return CUSTOM return name if name in _safe(provider_names) or _models_dev_provider(name) else CUSTOM @functools.lru_cache(maxsize=256) def _models_dev_provider(name: str) -> bool: """A public models.dev provider id, from the local cache only (never a network call).""" try: from agent.models_dev import get_provider_info return get_provider_info(name, allow_network=False) is not None except Exception: return False def model_metric_name(raw: object, provider: str, *, max_length: int) -> str: """The model id for a shipped remote provider; ``custom`` when the user names it (custom endpoint, loopback server), the provider is unknown (nothing proves the id is public), or it looks like a filesystem path or URL.""" from .shared_metrics_contract import _metric_identifier if provider in _safe(user_named_model_providers): return CUSTOM model = _metric_identifier(raw, max_length=max_length) if model == "unknown": return model if provider == "unknown" or _LOCATION_MODEL.match(model): return CUSTOM # Azure calls a deployment by the name its owner chose (``acme-legal-prod``): only a public model id passes. if provider.startswith("azure") and model not in _safe(public_model_ids): return CUSTOM return model @functools.cache def public_model_ids() -> frozenset[str]: """Model ids Hermes ships in its static catalogs plus every id in the local models.dev cache (never a network call), with and without a ``vendor/`` prefix.""" from agent.models_dev import fetch_models_dev from hermes_cli.models_catalog_static import _PROVIDER_MODELS ids = {model for models in _PROVIDER_MODELS.values() for model in models} for entry in fetch_models_dev(allow_network=False).values(): if isinstance(entry, dict) and isinstance(entry.get("models"), dict): ids.update(entry["models"]) return frozenset(form.lower() for model in ids if isinstance(model, str) for form in (model, model.rsplit("/", 1)[-1])) # The user's own server or account, never a public model id: a URL or path (``:/``), a weight file, # a loopback or IPv4 host, ``host:port`` (a 2-5 digit port, so Bedrock's ``...-v1:0`` stays readable), # or an AWS ARN (it carries the account id). _LOCATION_MODEL = re.compile( r"arn:|.*:/|.*\.(?:gguf|bin|safetensors)$|(?:localhost|\d{1,3}(?:\.\d{1,3}){3})(?:[:/]|$)|[^/:]+:\d{2,5}(?:/|$)" ) def display_language_metric_name(raw: object) -> str: name = _norm(raw) or "en" return name if name in _safe(display_languages) else "other"