| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262 |
- """Per-provider model name normalization."""
- from __future__ import annotations
- import logging
- import re
- from typing import Optional
- # First hyphen-delimited token of a bare model name → vendor slug used by aggregator APIs
- # ("claude-sonnet-4.6" → "anthropic/claude-sonnet-4.6").
- _VENDOR_PREFIXES: dict[str, str] = {
- "claude": "anthropic",
- "gpt": "openai",
- "o1": "openai",
- "o3": "openai",
- "o4": "openai",
- "gemini": "google",
- "gemma": "google",
- "deepseek": "deepseek",
- "glm": "z-ai",
- "kimi": "moonshotai",
- "minimax": "minimax",
- "grok": "x-ai",
- "qwen": "qwen",
- "mimo": "xiaomi",
- "trinity": "arcee-ai",
- "nemotron": "nvidia",
- "llama": "meta-llama",
- "step": "stepfun"}
- # Providers whose APIs consume vendor/model slugs.
- _AGGREGATOR_PROVIDERS: frozenset[str] = frozenset({
- "openrouter", "nous", "ai-gateway", "kilocode"})
- # Providers that want bare names with dots replaced by hyphens.
- _DOT_TO_HYPHEN_PROVIDERS: frozenset[str] = frozenset({
- "anthropic"})
- # Providers that want bare names with dots preserved.
- _STRIP_VENDOR_ONLY_PROVIDERS: frozenset[str] = frozenset({
- "openai-codex"})
- # Providers whose native naming is authoritative -- pass through unchanged.
- _AUTHORITATIVE_NATIVE_PROVIDERS: frozenset[str] = frozenset({
- "huggingface"})
- # Direct providers that accept bare native names but should repair a matching
- # provider/ prefix when users copy the aggregator form into config.yaml.
- _MATCHING_PREFIX_STRIP_PROVIDERS: frozenset[str] = frozenset({
- "zai",
- "kimi-coding",
- # Providers whose endpoint does not accept image input, even though the provider's broader ecosystem has
- # vision models available elsewhere. When `auxiliary.vision.provider: auto` sees one of these as the
- # main provider, it must skip straight to the aggregator chain instead of returning a client that will
- # 404 on every vision request. kimi-coding / kimi-coding-cn: the Kimi Coding Plan routes through
- # api.kimi.com/coding (Anthropic Messages wire) which Kimi's own docs describe as having no image_in
- # capability. Vision lives on the separate Kimi Platform (api.moonshot.ai, OpenAI-wire, pay-as-you-go).
- # See #17076.
- "kimi-coding-cn",
- "minimax",
- "minimax-oauth",
- "minimax-cn",
- "alibaba",
- "qwen-oauth",
- "xiaomi",
- "arcee",
- "ollama-cloud",
- "nebius-token-factory",
- "custom",
- "gemini",
- "xai"})
- # Providers whose API serves ``vendor/model`` ids but whose endpoint can also
- # front arbitrary self-hosted models, so a bare name cannot be prefixed
- # blindly. A bare id is repaired only when the curated catalogue for that
- # provider holds exactly one entry ending in ``/<name>`` — a lookup, not a
- # guess. NVIDIA NIM is the case in hand: build.nvidia.com serves
- # ``nvidia/nemotron-…`` (and third-party ``z-ai/glm-…``), while the same
- # provider id also points at local NIM containers with their own naming.
- # Without this repair a bare ``nemotron-3-ultra-550b-a55b`` reaches the API
- # and returns a bare ``404 page not found`` that never names the model (#78796).
- _CATALOGUE_PREFIX_REPAIR_PROVIDERS: frozenset[str] = frozenset({
- "nvidia"})
- # Providers whose APIs require lowercase model IDs (Xiaomi rejects ``MiMo-V2.5-Pro`` copied from
- # marketing docs; only ``mimo-v2.5-pro`` works). Applied after matching-prefix stripping.
- _LOWERCASE_MODEL_PROVIDERS: frozenset[str] = frozenset({
- "xiaomi"})
- # DeepSeek retired ``deepseek-chat`` / ``deepseek-reasoner`` on 2026-07-24 (HTTP 400 since); saved
- # configs still carry them, so they fold onto the current Flash id (thinking mode is controlled by
- # extra_body.thinking on the profile). Every other id is the user's call and goes to the wire as typed:
- # a shape-based allow-list swallowed the vendor's own ``deepseek-flash`` the day it shipped (#107206),
- # and any new id without a ``v<N>`` marker would have met the same fate.
- _DEEPSEEK_RETIRED_ALIASES: dict[str, str] = {
- "deepseek-chat": "deepseek-flash", "deepseek-reasoner": "deepseek-flash"}
- def _normalize_for_deepseek(model_name: str) -> str:
- """Fold retired DeepSeek aliases onto their replacement; pass everything else through."""
- bare = _strip_vendor_prefix(model_name).lower()
- return _DEEPSEEK_RETIRED_ALIASES.get(bare, bare)
- def _strip_vendor_prefix(model_name: str) -> str:
- """Remove a ``vendor/`` prefix if present."""
- return model_name.split("/", 1)[1] if "/" in model_name else model_name
- def _dots_to_hyphens(model_name: str) -> str:
- return model_name.replace(".", "-")
- def _normalize_provider_alias(provider_name: str) -> str:
- """Resolve provider aliases to Hermes' canonical ids."""
- raw = (provider_name or "").strip().lower()
- if not raw:
- return raw
- try:
- from hermes_cli.models import normalize_provider
- return normalize_provider(raw)
- except Exception:
- return raw
- def _strip_matching_provider_prefix(model_name: str, target_provider: str) -> str:
- """Strip ``provider/`` or ``provider:`` only when the prefix matches the target provider, so
- arbitrary slash-bearing ids aren't mangled while ``zai/glm-5.1`` is repaired for ``zai``. The colon
- form is Hermes's own ``provider:model`` switch syntax (``-m openai-codex:gpt-5.6-sol``); left intact
- it reaches the wire and the Codex backend rejects it with HTTP 400 (#64787). Only the FIRST separator
- counts, so an Ollama-style ``qwen3:8b`` tag is never split on a later colon. ``custom`` is a bucket,
- not a vendor: an alias resolving to it (``ollama``) may be a real LiteLLM-style routing prefix, so
- only a literal ``custom/`` / ``custom:`` prefix is redundant there."""
- cut = min((i for i in (model_name.find("/"), model_name.find(":")) if i >= 0), default=-1)
- if cut < 0:
- return model_name
- prefix, remainder = model_name[:cut], model_name[cut + 1:]
- if not prefix.strip() or not remainder.strip():
- return model_name
- normalized_target = _normalize_provider_alias(target_provider)
- if normalized_target == "custom":
- return remainder.strip() if prefix.strip().lower() == "custom" else model_name
- normalized_prefix = _normalize_provider_alias(prefix)
- return remainder.strip() if normalized_prefix and normalized_prefix == normalized_target else model_name
- def detect_vendor(model_name: str) -> Optional[str]:
- """Vendor slug from a bare model name: an existing ``vendor/`` prefix, the first hyphen token,
- or a ``_VENDOR_PREFIXES`` key the name starts with (``qwen3.5-plus`` → ``qwen``)."""
- name = model_name.strip()
- if not name:
- return None
- if "/" in name:
- return name.split("/", 1)[0].lower() or None
- name_lower = name.lower()
- first_token = name_lower.split("-")[0]
- if first_token in _VENDOR_PREFIXES:
- return _VENDOR_PREFIXES[first_token]
- return next((vendor for prefix, vendor in _VENDOR_PREFIXES.items() if name_lower.startswith(prefix)), None)
- def _prepend_vendor(model_name: str) -> str:
- """Prepend the detected ``vendor/`` for aggregators; names with ``/`` or no detectable vendor
- pass through (the aggregator may still accept them)."""
- if "/" in model_name:
- return model_name
- vendor = detect_vendor(model_name)
- return f"{vendor}/{model_name}" if vendor else model_name
- def _repair_prefix_from_catalogue(model_name: str, provider: str) -> str:
- """Restore a dropped ``vendor/`` prefix only when the bare id matches **exactly one** curated
- entry for this provider modulo the prefix — a lookup, never a guess from name shape."""
- if "/" in model_name:
- return model_name
- try:
- from hermes_cli.models import _PROVIDER_MODELS
- except Exception:
- return model_name
- # Compare against the catalogue's own suffix, tag included: a bare ``…:free`` id must resolve to
- # the ``:free`` entry, not its paid sibling.
- needle = model_name.strip().lower()
- catalogue = _PROVIDER_MODELS.get(provider) or []
- matches = {e for e in catalogue if "/" in e and e.split("/", 1)[1].strip().lower() == needle}
- return matches.pop() if len(matches) == 1 else model_name
- def suggest_prefixed_model_id(provider: str, model_name: str) -> Optional[str]:
- """Prefixed catalogue id for a bare *model_name* if unambiguous, else ``None`` — the diagnostic
- counterpart to :func:`_repair_prefix_from_catalogue` for explaining a content-free 404."""
- name = (model_name or "").strip()
- if not name or "/" in name:
- return None
- try:
- canonical = _normalize_provider_alias(provider)
- except Exception:
- return None
- repaired = _repair_prefix_from_catalogue(name, canonical)
- return repaired if repaired != name else None
- def normalize_model_for_provider(model_input: str, target_provider: str) -> str:
- """Translate a model name (bare, vendor-prefixed or native) into what the target provider's API
- expects. ``target_provider`` should already be canonical. Never raises."""
- name = (model_input or "").strip()
- if not name:
- return name
- provider = _normalize_provider_alias(target_provider)
- if provider in _AGGREGATOR_PROVIDERS:
- return _prepend_vendor(name)
- # OpenCode Zen / Go are flat-namespace resellers: /v1/models returns bare IDs and inference 401s
- # vendor-prefixed names, so strip ANY leading ``vendor/`` (commonly copied from aggregator slugs).
- from hermes_cli.models import opencode_provider_family
- _oc_family = opencode_provider_family(provider)
- if _oc_family is not None:
- if "/" in name:
- name = name.split("/", 1)[1].strip() or name
- if _oc_family == "opencode-zen" and name.lower().startswith("claude-"):
- return _dots_to_hyphens(name)
- return name
- if provider in _DOT_TO_HYPHEN_PROVIDERS:
- bare = _strip_matching_provider_prefix(name, provider)
- return bare if "/" in bare else _dots_to_hyphens(bare)
- # A profile that owns its id space (alias table, dash-to-dot repair) answers first; a wrong
- # notation otherwise hits HTTP 400 model_not_supported. See issue #6879.
- from providers import get_provider_profile
- profile = get_provider_profile(provider)
- try:
- normalized = profile.normalize_model_id(name) if profile is not None else None
- except Exception: # a plugin hook failing must not break normalization: generic rules take over
- logging.getLogger(__name__).debug("normalize_model_id(%s) failed", provider, exc_info=True)
- normalized = None
- if normalized:
- return normalized
- if provider in _STRIP_VENDOR_ONLY_PROVIDERS:
- stripped = _strip_matching_provider_prefix(name, provider)
- if stripped == name and name.startswith(("openai/", "openai:")):
- return name[len("openai/"):] # openai-codex maps openai/gpt-5.4 and openai:gpt-5.4 -> gpt-5.4
- return stripped
- if provider == "deepseek":
- bare = _strip_matching_provider_prefix(name, provider)
- return bare if "/" in bare else _normalize_for_deepseek(bare)
- if provider in _MATCHING_PREFIX_STRIP_PROVIDERS:
- result = _strip_matching_provider_prefix(name, provider)
- return result.lower() if provider in _LOWERCASE_MODEL_PROVIDERS else result
- # Unknown names (a local NIM container, a proxied model) pass through untouched.
- if provider in _CATALOGUE_PREFIX_REPAIR_PROVIDERS:
- return _repair_prefix_from_catalogue(name, provider)
- # Authoritative native providers, custom and all others: pass through as-is.
- return name
|