| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325 |
- """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/<name>`` (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:<name>``, 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"
|