| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312 |
- """ACP model picker: deduplicated ``provider:model`` rows from the Hermes inventory + named endpoints."""
- from __future__ import annotations
- import logging
- import os
- from dataclasses import dataclass, field
- from typing import Callable
- from acp.schema import ModelInfo, SessionModelState
- logger = logging.getLogger("acp_adapter.server")
- # Per-provider row cap (clients render all `availableModels` in one dropdown; mirrors the
- # MoA picker cap). Not a total cap; the current model is always kept via the fallback insert.
- ACP_MAX_MODELS_PER_PROVIDER = 200
- def _named_custom_provider_catalogs() -> list[tuple[str, str, list[tuple[str, str]]]]:
- """``(slug, label, [(model_id, description), ...])`` for named endpoints (v12 ``providers:``
- and legacy ``custom_providers:``), which canonical provider enumeration never lists.
- Models = the entry's declared models, refreshed from the live ``/models`` listing when a
- credential exists and ``discover_models`` isn't disabled; declared models survive a failed
- discovery (some endpoints have no ``/models`` route). Slugs use the ``custom:<name>`` shape
- ``parse_model_input``/``resolve_runtime_provider`` resolve, so choice ids round-trip."""
- try:
- from hermes_cli.config import (get_compatible_custom_providers, is_provider_enabled, load_config)
- from hermes_cli.model_switch import _declared_model_ids, _entry_models_discovered, _models_config_is_allowlist
- from hermes_cli.model_switch_providers import _NativePickerModelList, _fetch_picker_live_models
- from hermes_cli.model_switch_providers import _discover_flag
- from hermes_cli.models_local import should_use_ollama_native_catalog
- from hermes_cli.providers import custom_provider_slug
- except ImportError:
- return []
- try:
- cfg = load_config()
- entries = get_compatible_custom_providers(cfg)
- except Exception:
- logger.debug("Could not load named custom providers", exc_info=True)
- return []
- # ``get_compatible_custom_providers`` drops ``enabled``; read disabled keys from raw config.
- raw_providers = cfg.get("providers") if isinstance(cfg, dict) else None
- disabled_keys = {
- str(key).strip().lower()
- for key, raw in (raw_providers.items() if isinstance(raw_providers, dict) else ())
- if isinstance(raw, dict) and not is_provider_enabled(raw)
- }
- def _entry_catalog(entry: dict) -> tuple[str, str, list[tuple[str, str]]] | None:
- field = lambda key: str(entry.get(key) or "").strip()
- provider_key, name, base_url = field("provider_key"), field("name"), field("base_url")
- if provider_key.lower() in disabled_keys or not name or not base_url:
- return None
- slug = custom_provider_slug(name, provider_key)
- api_key = field("api_key")
- if not api_key:
- key_env = str(entry.get("key_env") or entry.get("api_key_env") or "").strip()
- api_key = os.environ.get(key_env, "").strip() if key_env else ""
- models_cfg = entry.get("models")
- declared = [m for m in dict.fromkeys([field("model"), *_declared_model_ids(models_cfg)]) if m]
- native_headers = entry.get("extra_headers") or None
- is_ollama_key = provider_key.lower() in {"ollama", "custom:ollama"}
- is_native_ollama = should_use_ollama_native_catalog(
- provider_key if is_ollama_key else "custom", base_url, headers=native_headers
- )
- if not api_key and not declared and not is_native_ollama:
- return None # nothing to discover with and nothing declared: not addressable
- model_ids = list(declared)
- live = None
- if _discover_flag(entry) and (api_key or is_native_ollama):
- try:
- live = _fetch_picker_live_models(
- api_key, base_url, provider_key if is_native_ollama and is_ollama_key else "custom",
- _models_config_is_allowlist(models_cfg, _entry_models_discovered(entry)),
- headers=native_headers, timeout=1.5, api_mode=entry.get("api_mode"),
- )
- except Exception:
- live = None
- if isinstance(live, _NativePickerModelList):
- model_ids = list(live)
- elif live is not None:
- model_ids = declared + [m for m in live if m not in declared]
- if not model_ids and not isinstance(live, _NativePickerModelList):
- return None
- return slug, name, [(mid, "") for mid in model_ids]
- catalogs = [_entry_catalog(entry) for entry in entries if isinstance(entry, dict)]
- return [c for c in catalogs if c is not None]
- def _semantic_provider(provider_id: str, normalize_provider: Callable[[str], str]) -> str:
- raw = str(provider_id or "").strip().lower()
- if raw in {"ollama", "custom:ollama"}:
- return "ollama"
- if raw.startswith("custom:"):
- return raw
- return normalize_provider(raw)
- def _empty_catalog_applies(
- provider_id: str, empty_authoritative: set[str], normalize_provider: Callable[[str], str]
- ) -> bool:
- """True when a named endpoint with an authoritative-empty catalog owns ``provider_id``."""
- raw = str(provider_id or "").strip().lower()
- normalized = normalize_provider(raw)
- if normalized == "custom":
- return any(
- candidate == raw
- or f"custom:{candidate}" == raw
- or (raw == "custom" and candidate == "custom")
- for candidate in empty_authoritative
- )
- return any(
- candidate == raw
- or candidate == f"custom:{normalized}"
- or candidate == f"custom:{raw}"
- or normalize_provider(candidate) == normalized
- for candidate in empty_authoritative
- )
- def _choice_provider(model_id: str) -> str:
- """Provider prefix of an encoded choice id; longest configured ``custom:`` slug wins."""
- parts = model_id.split(":")
- if parts[:1] == ["custom"] and len(parts) > 1:
- from hermes_cli.models import _configured_custom_provider_ids
- lowered = model_id.lower()
- for candidate in sorted(
- (p for p in _configured_custom_provider_ids() if p.startswith("custom:")), key=len, reverse=True,
- ):
- if lowered.startswith(candidate + ":"):
- return candidate
- return "custom"
- return parts[0]
- def encode_model_choice(provider: str | None, model: str | None) -> str:
- """``provider:model`` so ACP clients keep provider context."""
- raw_model = str(model or "").strip()
- if not raw_model:
- return ""
- raw_provider = str(provider or "").strip().lower()
- return f"{raw_provider}:{raw_model}" if raw_provider else raw_model
- @dataclass
- class _ModelCatalog:
- """Deduplicated ACP model rows from the inventory + named endpoints.
- Dedupes on the encoded choice id AND a semantic ``provider:model`` id (``ollama`` ==
- ``custom:ollama``). A bare/``custom`` current provider whose base_url matches an ollama
- inventory row is resolved to ``custom:ollama``."""
- normalize_provider: Callable[[str], str]
- current_model: str
- current_choice_provider: str
- current_base_url: str
- models: list[ModelInfo] = field(default_factory=list)
- seen_ids: set[str] = field(default_factory=set)
- seen_semantic_ids: set[str] = field(default_factory=set)
- empty_authoritative: set[str] = field(default_factory=set)
- def __post_init__(self) -> None:
- if self.current_choice_provider == "ollama":
- self.current_choice_provider = "custom:ollama"
- self._identity_resolved = self.current_choice_provider not in {"", "custom"}
- def semantic(self, provider_id: str) -> str:
- return _semantic_provider(provider_id, self.normalize_provider)
- def add(self, provider_id: str, model_id: str, name: str, description: str) -> None:
- choice_id = encode_model_choice(provider_id, model_id)
- semantic_id = f"{self.semantic(provider_id)}:{model_id}"
- if not choice_id or choice_id in self.seen_ids or semantic_id in self.seen_semantic_ids:
- return
- self.models.append(ModelInfo(model_id=choice_id, name=name, description=description))
- self.seen_ids.add(choice_id)
- self.seen_semantic_ids.add(semantic_id)
- def add_inventory_rows(self, rows: list, provider_label: Callable[[str], str]) -> None:
- for row in rows:
- raw_row_provider = str(row.get("slug") or "").strip().lower()
- row_provider = self.normalize_provider(raw_row_provider)
- row_base_url = str(row.get("api_url") or "").strip().rstrip("/").lower()
- if row.get("native_catalog_empty"):
- self.empty_authoritative.add(raw_row_provider)
- if not self._identity_resolved and raw_row_provider in {"ollama", "custom:ollama"} and (
- self.current_base_url and row_base_url == self.current_base_url
- ):
- self.current_choice_provider = "custom:ollama"
- self._identity_resolved = True
- row_models = row.get("models")
- if not row_provider or not isinstance(row_models, (list, tuple)):
- continue
- provider_name = str(row.get("name") or "").strip() or provider_label(row_provider)
- encoded_provider = (
- "custom:ollama" if raw_row_provider == "ollama"
- else raw_row_provider if raw_row_provider.startswith("custom:")
- else row_provider
- )
- for model_entry in row_models:
- if isinstance(model_entry, dict):
- model_entry = model_entry.get("id") or model_entry.get("model") or model_entry.get("name")
- rendered_model = str(model_entry or "").strip()
- if not rendered_model:
- continue
- is_current = rendered_model == self.current_model and (
- self.semantic(encoded_provider) == self.semantic(self.current_choice_provider)
- )
- self.add(
- encoded_provider, rendered_model, f"{provider_name} · {rendered_model}",
- f"Provider: {provider_name}" + (" • current" if is_current else ""),
- )
- def add_named_catalogs(self, catalogs: list, current_choice_provider: str) -> None:
- """Named user-defined endpoints (providers: / custom_providers:) are invisible
- to canonical enumeration — append them like the TUI /model picker. An empty
- catalog marks that slug authoritative-empty."""
- for named_slug, named_label, named_catalog in catalogs:
- if not named_catalog:
- self.empty_authoritative.add(str(named_slug).strip().lower())
- continue
- for named_model, named_desc in named_catalog:
- is_current = named_slug.lower() == current_choice_provider and named_model == self.current_model
- parts = [f"Provider: {named_label}", str(named_desc or "").strip(), "current" if is_current else ""]
- self.add(named_slug, named_model, named_model, " • ".join(part for part in parts if part))
- def build_model_state(model: str, provider: str, base_url: str) -> SessionModelState | None:
- """Picker state from the shared inventory + named endpoints; ``None`` when nothing is listable
- (caller falls back to a single current-model row). Raises on inventory failure."""
- from hermes_cli.inventory import build_models_payload, load_picker_context
- from hermes_cli.models import normalize_provider, provider_label
- normalized_provider = normalize_provider(provider)
- context = load_picker_context().with_overrides(
- current_provider=normalized_provider, current_model=model, current_base_url=base_url,
- )
- payload = build_models_payload(
- context, explicit_only=True, include_unconfigured=False, picker_hints=False,
- canonical_order=True, pricing=False, capabilities=False, refresh=False,
- probe_custom_providers=False, probe_current_custom_provider=False, max_models=ACP_MAX_MODELS_PER_PROVIDER,
- )
- named_catalogs = _named_custom_provider_catalogs()
- named_slugs = {str(slug).strip().lower() for slug, _label, _models in named_catalogs}
- current_choice_provider = str(provider or "").strip().lower()
- current_base = base_url.strip().rstrip("/").lower()
- # ``build_models_payload`` represents configured ``providers:`` entries by their raw
- # config key. ACP ids must instead use the durable ``custom:<key>`` identity so the
- # picker value round-trips through ``parse_model_input``. Only user-defined rows are
- # replaced by the named catalogs: a ``providers:`` key that shadows a canonical name
- # (``providers.openrouter:`` → proxy) must leave the canonical row — and a session that
- # runs on the canonical endpoint — alone, or picking "current" re-routes to the proxy.
- all_rows = payload.get("providers") or []
- canonical_current = any(
- str(r.get("slug") or "").strip().lower() == current_choice_provider and not r.get("is_user_defined")
- for r in all_rows
- )
- inventory_rows: list = []
- for row in all_rows:
- slug = str(row.get("slug") or "").strip().lower()
- if not row.get("is_user_defined") or not {slug, f"custom:{slug}"} & named_slugs:
- inventory_rows.append(row)
- continue
- row_base = str(row.get("api_url") or "").strip().rstrip("/").lower()
- if slug.removeprefix("custom:") == current_choice_provider and (current_base == row_base or not canonical_current):
- current_choice_provider = f"custom:{current_choice_provider}"
- cat = _ModelCatalog(
- normalize_provider=normalize_provider, current_model=model,
- current_choice_provider=current_choice_provider,
- current_base_url=current_base,
- )
- cat.add_inventory_rows(inventory_rows, provider_label)
- cat.add_named_catalogs(named_catalogs, current_choice_provider)
- available_models = cat.models
- def empty_applies(provider_id: str) -> bool:
- return _empty_catalog_applies(provider_id, cat.empty_authoritative, normalize_provider)
- if cat.empty_authoritative:
- available_models = [m for m in available_models if not empty_applies(_choice_provider(m.model_id))]
- current_is_empty = empty_applies(cat.current_choice_provider)
- if current_is_empty:
- available_models = [m for m in available_models if " • current" not in str(m.description or "")]
- current_model_id = "" if current_is_empty else encode_model_choice(cat.current_choice_provider, model)
- if current_model_id and current_model_id not in {item.model_id for item in available_models}:
- provider_name = provider_label(normalized_provider)
- available_models.insert(0, ModelInfo(
- model_id=current_model_id, name=f"{provider_name} · {model}",
- description=f"Provider: {provider_name} • current",
- ))
- if not available_models and current_is_empty:
- return SessionModelState(available_models=[], current_model_id="")
- if available_models:
- return SessionModelState(
- available_models=available_models,
- current_model_id=current_model_id if current_model_id or current_is_empty else available_models[0].model_id,
- )
- return None
|