HitonabiandClaude Opus 5.5
93f6613146
- Waechter (pruefe_kern): prueft jetzt gezielt das Modell mit der Rolle hermes und seinen
Zustand in llama-swap (/running, v257 listet auch ladende Modelle), statt das Hirn fuer
bereit zu halten, sobald irgendein Modell laeuft. Ein Ladevorgang ist kein Ausfall, aber
nur bis 10 Minuten (MC_WAECHTER_HIRN_LADEN_S), sonst bliebe ein immer neu startendes Hirn
unbemerkt. Sonst die ueblichen Takte (FAIL_AFTER); Knopf "Protokoll des Motors".
- llamaswap: modell_zustaende() und hirn_zustand(); lade_modell() meldet ok false mit
deutschem Grund und der Meldung der Engine, "laedt noch" nach der Wartezeit ist kein Fehler,
ein geladenes Modell ohne Chat (embed) zaehlt als geladen. POST /api/models/{id}/load
reicht das Ergebnis durch (Router duenn).
- Radar "Jetzt suchen": startet die Suche als Auftrag (Job-Engine, Gruppe radar, hoechstens
einer, radar_lauf.py --nur-suche) und antwortet sofort mit der Auftrags-ID. Die Ansicht
zeigt "Sucht ..." bis der Auftrag fertig ist, liest danach das Radar neu und nennt eine
gescheiterte Suche; die Auftragskarte zeigt den Stand.
- Tests: Hirn-Zustaende und Frist, Laden gegen eine llama-swap-Attrappe, Radar-Auftrag.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
763 lines
34 KiB
Python
763 lines
34 KiB
Python
"""
|
|
Engine-Service: liest/schreibt die llama-swap config.yaml und spricht die
|
|
llama-swap-API. Portiert & erweitert aus Mission Control v1.
|
|
|
|
NEU in 2.0: `groups` für Ko-Residenz (schnell + schwer gleichzeitig geladen,
|
|
`swap:false`) → Multi-Model-Delegation ohne Nachlade-Latenz.
|
|
"""
|
|
|
|
import functools
|
|
import logging
|
|
import os
|
|
import re
|
|
import threading
|
|
from contextlib import contextmanager
|
|
from pathlib import Path
|
|
|
|
import httpx
|
|
from config import (
|
|
CMD_TEMPLATE,
|
|
CONFIG_PATH,
|
|
DEFAULT_TTL,
|
|
DRAFTS_DIR,
|
|
LLAMA_SWAP_URL,
|
|
MODELS_DIR,
|
|
SPEC_DRAFT_MODEL_PATH,
|
|
SPEC_DRAFT_N_MAX,
|
|
SPEC_TYPE,
|
|
)
|
|
from ruamel.yaml.scalarstring import LiteralScalarString
|
|
|
|
try:
|
|
import fcntl
|
|
except ImportError: # Windows (Entwicklung): nur die Prozess-Sperre
|
|
fcntl = None
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
# Kanonische Serving-Rollen — EINE Quelle der Wahrheit (identisch zu sources.ROLE_IDS,
|
|
# maintenance, frontend ModelBadges.ROLES). `hermes` = Lucys Agent-Hirn (warm + ko-resident
|
|
# in der `brains`-Gruppe); UI-Label „Hirn".
|
|
ROLE_IDS = {"fast", "heavy", "coder", "vision", "scout", "hermes", "kritiker", "reranker"}
|
|
|
|
_CTX_RE = re.compile(r"-(?:c|-ctx-size)\s+(\d+)")
|
|
_PATH_RE = re.compile(r"-(?:m|-model)\s+([^\s]+)")
|
|
_QUANT_RE = re.compile(r"(Q\d_[A-Z0-9_]+|IQ\d_[A-Z0-9_]+|fp16|bf16)\.gguf", re.IGNORECASE)
|
|
_SPLIT_RE = re.compile(r"-(\d+)-of-(\d+)\.gguf$", re.IGNORECASE)
|
|
|
|
|
|
def _gguf_total_size(path: str) -> int | None:
|
|
"""Gesamtgröße eines GGUF inkl. ALLER Split-Teile (…-00001-of-00003.gguf).
|
|
Die Größe nur des ersten Teils ist bei Splits irreführend (oft nur ein Header)."""
|
|
try:
|
|
base = os.path.basename(path)
|
|
m = _SPLIT_RE.search(base)
|
|
if not m:
|
|
return os.path.getsize(path)
|
|
prefix, dirn = base[:m.start()], os.path.dirname(path)
|
|
total = sum(os.path.getsize(os.path.join(dirn, f))
|
|
for f in os.listdir(dirn)
|
|
if f.startswith(prefix) and _SPLIT_RE.search(f))
|
|
return total or os.path.getsize(path)
|
|
except OSError:
|
|
return None
|
|
|
|
|
|
# --- Sperre ------------------------------------------------------------------
|
|
# Die llama-swap-Config hat mehrere Schreiber: die Oberfläche, das Radar, das Aufräumen und die
|
|
# Hirn-Umstellung. Ohne Sperre gingen gleichzeitige Änderungen verloren (lesen, ändern, schreiben
|
|
# überlappten). Seit 24.09.2026 läuft jedes Lesen-Ändern-Schreiben unter dieser Sperre: im
|
|
# Prozess per RLock, zwischen Prozessen per flock auf einer Datei neben der Config.
|
|
_SPERRE = threading.RLock()
|
|
_SPERR_TIEFE = threading.local()
|
|
|
|
|
|
@contextmanager
|
|
def config_sperre():
|
|
with _SPERRE:
|
|
tiefe = getattr(_SPERR_TIEFE, "n", 0)
|
|
_SPERR_TIEFE.n = tiefe + 1
|
|
datei = None
|
|
try:
|
|
if tiefe == 0 and fcntl is not None:
|
|
try:
|
|
datei = open(CONFIG_PATH.with_name(".mc2-config.lock"), "a+")
|
|
fcntl.flock(datei, fcntl.LOCK_EX)
|
|
except OSError:
|
|
datei = None # ohne Sperrdatei (z. B. fehlende Rechte) bleibt die Prozess-Sperre
|
|
yield
|
|
finally:
|
|
_SPERR_TIEFE.n = tiefe
|
|
if datei is not None:
|
|
fcntl.flock(datei, fcntl.LOCK_UN)
|
|
datei.close()
|
|
|
|
|
|
# Sammel-Schreiben (24.09.2026): Jeder Schreibvorgang lässt llama-swap neu laden und ALLE Modelle
|
|
# entladen. Ein Modelltausch bestand aus bis zu sieben Schreibvorgängen (Eintragen, Befehl, Zwilling,
|
|
# Alias, Gruppe, ttl …). Innerhalb von sammeln() lesen alle Änderungen dieselbe Config aus dem
|
|
# Speicher, und geschrieben wird einmal am Ende — oder gar nicht, wenn etwas scheitert.
|
|
_SAMMEL = threading.local()
|
|
|
|
|
|
@contextmanager
|
|
def sammeln():
|
|
with config_sperre():
|
|
if getattr(_SAMMEL, "aktiv", False): # verschachtelt: der äußere schreibt
|
|
yield
|
|
return
|
|
_SAMMEL.aktiv, _SAMMEL.cfg = True, None
|
|
try:
|
|
yield
|
|
cfg = _SAMMEL.cfg
|
|
finally:
|
|
_SAMMEL.aktiv, _SAMMEL.cfg = False, None
|
|
if cfg is not None:
|
|
_schreiben(cfg)
|
|
|
|
|
|
def _mit_sperre(fn):
|
|
@functools.wraps(fn)
|
|
def huelle(*args, **kwargs):
|
|
with config_sperre():
|
|
return fn(*args, **kwargs)
|
|
return huelle
|
|
|
|
|
|
# --- Lesen -------------------------------------------------------------------
|
|
def read_config() -> dict:
|
|
if getattr(_SAMMEL, "aktiv", False):
|
|
if _SAMMEL.cfg is None:
|
|
_SAMMEL.cfg = _lesen()
|
|
return _SAMMEL.cfg
|
|
return _lesen()
|
|
|
|
|
|
def _lesen() -> dict:
|
|
if not CONFIG_PATH.exists():
|
|
return {"models": {}}
|
|
from ruamel.yaml import YAML
|
|
r_yaml = YAML()
|
|
r_yaml.preserve_quotes = True
|
|
with CONFIG_PATH.open("r", encoding="utf-8") as f:
|
|
data = r_yaml.load(f) or {}
|
|
if not data.get("models"):
|
|
data["models"] = {}
|
|
return data
|
|
|
|
|
|
def _parse_model(name: str, spec: dict) -> dict:
|
|
spec = spec or {}
|
|
cmd = str(spec.get("cmd", "")).strip()
|
|
ctx = int(m.group(1)) if (m := _CTX_RE.search(cmd)) else None
|
|
|
|
path = filename = quant = ""
|
|
size_bytes = None
|
|
if (m := _PATH_RE.search(cmd)):
|
|
path = m.group(1).replace("'", "").replace('"', "")
|
|
filename = os.path.basename(path)
|
|
if os.path.exists(path):
|
|
size_bytes = _gguf_total_size(path)
|
|
if (q := _QUANT_RE.search(path)):
|
|
quant = q.group(1).upper()
|
|
|
|
aliases = spec.get("aliases") or []
|
|
if isinstance(aliases, str):
|
|
aliases = [aliases]
|
|
aliases = [str(a) for a in aliases]
|
|
role = aliases[0].lower() if aliases else (name.lower() if name.lower() in ROLE_IDS else None)
|
|
|
|
prompt_cache = "--prompt-cache " in cmd or cmd.endswith("--prompt-cache") or "--prompt-cache-all" in cmd
|
|
# Draft-Modell erkennen — klassisch (--spec-draft-model) ODER MTP (--model-draft / -md).
|
|
spec_draft = None
|
|
if (m_draft := re.search(r"--(?:spec-draft-model|model-draft)\s+([^\s]+)", cmd)) \
|
|
or (m_draft := re.search(r"(?<![\w-])-md\s+([^\s]+)", cmd)):
|
|
spec_draft = os.path.basename(m_draft.group(1).replace("'", "").replace('"', ""))
|
|
spec_type = None
|
|
if (m_st := re.search(r"--spec-type\s+([^\s]+)", cmd)):
|
|
spec_type = m_st.group(1)
|
|
# Spec ist nur AKTIV, wenn BEIDES gesetzt ist (Draft-Modell UND --spec-type).
|
|
spec_active = bool(spec_draft and spec_type)
|
|
parallel_match = re.search(r"--parallel\s+(\d+)", cmd)
|
|
parallel_slots = int(parallel_match.group(1)) if parallel_match else 1
|
|
|
|
from services.caps import capabilities
|
|
return {
|
|
"name": name,
|
|
"role": role,
|
|
"aliases": aliases,
|
|
"api_ids": [name] + aliases,
|
|
"ctx": ctx,
|
|
"ttl": spec.get("ttl"),
|
|
"cmd": cmd,
|
|
"gguf_path": path,
|
|
"filename": filename,
|
|
"quant": quant,
|
|
"size_bytes": size_bytes,
|
|
"incomplete": not path,
|
|
"prompt_cache": prompt_cache,
|
|
"spec_draft_model": spec_draft,
|
|
"spec_type": spec_type,
|
|
"spec_active": spec_active,
|
|
"parallel_slots": parallel_slots,
|
|
"capabilities": capabilities(
|
|
name=filename or name, cmd=cmd,
|
|
gguf_path=(path if (path and os.path.exists(path)) else ""),
|
|
),
|
|
}
|
|
|
|
|
|
def list_models() -> list[dict]:
|
|
cfg = read_config()
|
|
return [_parse_model(name, spec) for name, spec in (cfg.get("models") or {}).items()]
|
|
|
|
|
|
def engine_reachable() -> bool:
|
|
try:
|
|
with httpx.Client(timeout=3.0) as c:
|
|
return c.get(f"{LLAMA_SWAP_URL}/v1/models").status_code == 200
|
|
except Exception:
|
|
return False
|
|
|
|
|
|
# --- Schreiben ---------------------------------------------------------------
|
|
def model_id_from_path(model_path: str) -> str:
|
|
"""Sprechende Modell-ID (= API-Name) aus dem GGUF-Pfad: Repo-Ordnername ohne
|
|
'-GGUF'. Fallback: Dateiname ohne Quant-Suffix.
|
|
Split-GGUFs liegen oft in einem Quant-Unterordner (…/Q4_K_M/file-00001-of-…) →
|
|
dann eine Ebene höher (Repo-Ordner) nehmen, sonst hieße das Modell 'Q4_K_M'."""
|
|
d = os.path.basename(os.path.dirname(model_path))
|
|
if re.fullmatch(r"(I?Q\d[\w]*|UD-Q\d[\w]*|F16|BF16|FP16|F32)", d, flags=re.IGNORECASE):
|
|
d = os.path.basename(os.path.dirname(os.path.dirname(model_path)))
|
|
name = re.sub(r"[-_]?GGUF$", "", d, flags=re.IGNORECASE).strip("-_")
|
|
if not name:
|
|
fn = re.sub(r"\.gguf$", "", os.path.basename(model_path), flags=re.IGNORECASE)
|
|
fn = re.sub(r"-\d+-of-\d+$", "", fn)
|
|
name = re.sub(r"[-_](Q\d[\w]*|IQ\d[\w]*|F16|BF16|FP16|F32)$", "", fn, flags=re.IGNORECASE)
|
|
return name or "modell"
|
|
|
|
|
|
# Lebenswichtige Aliase: hängen direkt an Lucys Denk- und Gedächtnis-Pfad. Sie dürfen
|
|
# beim Rollen-Umhängen NIE stillschweigend verloren gehen (Review 16.07.: Qwen3.6 hält
|
|
# live `hermes` UND `fast` — ein Rollen-Klick hätte beide gelöscht → Lucy tot).
|
|
PROTECTED_ALIASES = {"hermes", "embed"}
|
|
|
|
|
|
def protected_alias_of(model_id: str) -> str | None:
|
|
"""Hält dieses Modell gerade einen lebenswichtigen Alias? (für Guards in der API)"""
|
|
spec = (read_config().get("models") or {}).get(model_id)
|
|
if isinstance(spec, dict):
|
|
for a in spec.get("aliases") or []:
|
|
if str(a).lower() in PROTECTED_ALIASES:
|
|
return str(a).lower()
|
|
return None
|
|
|
|
|
|
def set_role_alias(cfg: dict, model_id: str, role: str | None) -> None:
|
|
"""Rolle als llama-swap-`aliases`-Eintrag setzen (vorher bei allen anderen Modellen
|
|
entfernen — deren übrige Aliase bleiben). role=None/leer entfernt die Rolle.
|
|
Lebenswichtige Aliase (PROTECTED_ALIASES) des Ziel-Modells bleiben IMMER erhalten."""
|
|
models = cfg.get("models") or {}
|
|
role = (role or "").strip().lower()
|
|
if role:
|
|
for mid, spec in models.items():
|
|
if mid == model_id or not isinstance(spec, dict):
|
|
continue
|
|
al = [a for a in (spec.get("aliases") or []) if str(a).lower() != role]
|
|
if al:
|
|
spec["aliases"] = al
|
|
else:
|
|
spec.pop("aliases", None)
|
|
spec = models.get(model_id)
|
|
if isinstance(spec, dict):
|
|
keep = [a for a in (spec.get("aliases") or [])
|
|
if str(a).lower() in PROTECTED_ALIASES and str(a).lower() != role]
|
|
new = keep + ([role] if role and role != model_id.lower() else [])
|
|
if new:
|
|
spec["aliases"] = new
|
|
else:
|
|
spec.pop("aliases", None)
|
|
|
|
|
|
def _augment_vision(cmd: str, model_path: str, mmproj_path: str | None) -> str:
|
|
"""Vision-Modelle brauchen --mmproj <projektor> und --jinja."""
|
|
if mmproj_path:
|
|
if "--mmproj" not in cmd:
|
|
cmd += f" --mmproj {mmproj_path}"
|
|
if "--jinja" not in cmd:
|
|
cmd += " --jinja"
|
|
return cmd
|
|
|
|
|
|
def write_config(cfg: dict) -> None:
|
|
"""Atomar schreiben (tmp + os.replace), damit llama-swap mit -watch-config nie
|
|
eine halbe Datei sieht. Fehlende Schreibrechte → klare Meldung. Innerhalb von sammeln()
|
|
wird nur vorgemerkt; geschrieben wird am Ende einmal."""
|
|
if getattr(_SAMMEL, "aktiv", False):
|
|
_SAMMEL.cfg = cfg
|
|
return
|
|
_schreiben(cfg)
|
|
|
|
|
|
def _schreiben(cfg: dict) -> None:
|
|
try:
|
|
CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
|
|
tmp = CONFIG_PATH.with_name(CONFIG_PATH.name + ".tmp")
|
|
from ruamel.yaml import YAML
|
|
r_yaml = YAML()
|
|
r_yaml.preserve_quotes = True
|
|
with tmp.open("w", encoding="utf-8") as f:
|
|
r_yaml.dump(cfg, f)
|
|
os.replace(tmp, CONFIG_PATH)
|
|
# llama-swap (-watch-config) lädt jetzt neu und verwirft dabei alle Modelle inkl. Hirn.
|
|
# Den Re-Warm-Wächter anstoßen, damit das Hirn nicht bis zum nächsten Tick kalt liegt.
|
|
try:
|
|
from services import warmer
|
|
warmer.nudge()
|
|
except Exception:
|
|
pass
|
|
except PermissionError as exc:
|
|
raise PermissionError(
|
|
f"Mission Control darf '{CONFIG_PATH}' nicht schreiben. "
|
|
f"Einmalig: sudo chown -R hitonabi:hitonabi {CONFIG_PATH.parent}"
|
|
) from exc
|
|
|
|
|
|
@_mit_sperre
|
|
def register_model(model_path: str, role: str | None = None, ctx: int = 8192,
|
|
ttl: int | None = None, mmproj_path: str | None = None,
|
|
jinja: bool = False, set_alias: bool = True) -> str:
|
|
"""Ein GGUF als llama-swap-Modell eintragen (cmd + Rolle-Alias). Gibt die
|
|
Modell-ID zurück. jinja=True erzwingt --jinja (Tool-Calling, z.B. fürs Agent-Hirn).
|
|
set_alias=False: Rolle nur für die cmd-Flags nutzen, den Alias aber NICHT umhängen —
|
|
der Install-Flow setzt ihn erst NACH fertigem Download (sonst zeigt die Rolle
|
|
minutenlang auf eine Datei, die noch gar nicht existiert)."""
|
|
cfg = read_config()
|
|
model_id = model_id_from_path(model_path)
|
|
cmd = CMD_TEMPLATE.replace("{model}", model_path).replace("{ctx}", str(ctx))
|
|
cmd = _augment_vision(cmd, model_path, mmproj_path)
|
|
if jinja and "--jinja" not in cmd:
|
|
cmd += " --jinja"
|
|
|
|
role_lower = (role or "").strip().lower()
|
|
# KV-Cache-Reuse über Turns (Prompt-Cache wiederverwenden) — hilft allen Chat-Modellen
|
|
# (Agent-Hirn, Coding, Multi-Turn). Spiegelt die auf der Box bewährten Flags wider, damit
|
|
# neu installierte Modelle nicht hinter dem hand-getunten Stand zurückbleiben (Drift-Fix).
|
|
# NICHT bei Vision-Modellen: --cache-reuse + --mmproj bricht llama-server (live verifiziert,
|
|
# deshalb fahren vision/scout auf der Box ohne cache-reuse).
|
|
if "--cache-reuse" not in cmd and "--mmproj" not in cmd:
|
|
cmd += " --cache-reuse 256 -cram 16384"
|
|
# IDE-Coding profitiert von Nebenläufigkeit; sonst Default 1 Slot = voller Kontext/Anfrage
|
|
# (--parallel teilt den Kontext HART auf die Slots auf, s. docs/archiv/2026-06-30-optimierungsplan.md §9.4 V6).
|
|
if role_lower == "coder" and "--parallel" not in cmd:
|
|
cmd += " --parallel 2"
|
|
# Vocab-kompatiblen Draft automatisch anhängen — klassisch (DRAFTS_DIR) ODER MTP-Kopf neben
|
|
# dem Modell. Self-guarding: ohne kompatiblen/vorhandenen Draft passiert nichts (später im UI
|
|
# setzbar). Bei frischem Install existiert die Modell-GGUF noch nicht → ebenfalls kein Draft.
|
|
if "--spec-draft-model" not in cmd and "--model-draft" not in cmd:
|
|
cmd += spec_draft_flags(model_path)
|
|
|
|
# Bestehende Aliase des Eintrags erhalten (Re-Install/Upgrade desselben Repos):
|
|
# die Rolle soll während des Downloads beim ALTEN Stand bleiben.
|
|
old_aliases = (cfg.get("models") or {}).get(model_id, {})
|
|
old_aliases = old_aliases.get("aliases") if isinstance(old_aliases, dict) else None
|
|
entry: dict = {
|
|
"cmd": LiteralScalarString(cmd + "\n"),
|
|
"ttl": ttl if ttl is not None else DEFAULT_TTL,
|
|
}
|
|
if old_aliases:
|
|
entry["aliases"] = old_aliases
|
|
cfg.setdefault("models", {})[model_id] = entry
|
|
if set_alias:
|
|
set_role_alias(cfg, model_id, role)
|
|
write_config(cfg)
|
|
return model_id
|
|
|
|
|
|
# --- Speculative-Draft / Vocab-Kompatibilität --------------------------------
|
|
def list_drafts() -> list[dict]:
|
|
"""Alle Draft-GGUFs in DRAFTS_DIR mit Tokenizer-Fingerprint."""
|
|
from services import gguf_meta
|
|
out = []
|
|
if DRAFTS_DIR.is_dir():
|
|
for p in sorted(DRAFTS_DIR.glob("*.gguf")):
|
|
out.append({
|
|
"path": str(p), "filename": p.name,
|
|
"size_bytes": p.stat().st_size if p.exists() else None,
|
|
"vocab": gguf_meta.fingerprint(str(p)),
|
|
})
|
|
return out
|
|
|
|
|
|
def _is_mtp_draft(draft_path: str) -> bool:
|
|
"""Ist dieser Draft ein MTP-Kopf (Multi-Token-Prediction) statt eines klassischen
|
|
Draft-Modells? MTP-Köpfe (z.B. gemma-4) laden mit `--model-draft … --spec-type
|
|
draft-mtp` statt `--spec-draft-model … --spec-type draft-simple`. Erkennung am Arch
|
|
('…-assistant' / 'mtp') oder Dateinamen ('mtp-*', '*-MTP', '*-assistant')."""
|
|
base = os.path.basename(draft_path).lower()
|
|
if base.startswith("mtp-") or "-mtp" in base or "assistant" in base:
|
|
return True
|
|
from services import gguf_meta
|
|
arch = ((gguf_meta.fingerprint(draft_path) or {}).get("arch") or "").lower()
|
|
return arch.endswith("-assistant") or "mtp" in arch
|
|
|
|
|
|
def _spec_flags_for_draft(draft_path: str) -> str:
|
|
"""Korrekte llama-server-Spec-Flags für einen (vocab-kompatiblen) Draft. MTP-Kopf →
|
|
`--model-draft … --spec-type draft-mtp --spec-draft-n-max N`; klassischer Draft →
|
|
`--spec-draft-model … --spec-type draft-simple`. (Beides nötig, sonst Spec inaktiv.)"""
|
|
if _is_mtp_draft(draft_path):
|
|
return (f" --model-draft {draft_path} --spec-type draft-mtp"
|
|
f" --spec-draft-n-max {SPEC_DRAFT_N_MAX}")
|
|
return f" --spec-draft-model {draft_path} --spec-type {SPEC_TYPE}"
|
|
|
|
|
|
def _sibling_mtp_drafters(target_path: str) -> list[str]:
|
|
"""MTP-Kopf-GGUFs NEBEN dem Zielmodell (gleicher Ordner): 'mtp-*.gguf', '*-MTP.gguf',
|
|
'*-assistant*.gguf'. Per Konstruktion vocab-identisch zum Modell → idealer Draft."""
|
|
out: list[str] = []
|
|
d = os.path.dirname(target_path)
|
|
if os.path.isdir(d):
|
|
for f in sorted(os.listdir(d)):
|
|
fl = f.lower()
|
|
if fl.endswith(".gguf") and (fl.startswith("mtp-") or "-mtp" in fl or "assistant" in fl):
|
|
p = os.path.join(d, f)
|
|
if p != target_path:
|
|
out.append(p)
|
|
return out
|
|
|
|
|
|
def find_compatible_draft(target_path: str) -> str | None:
|
|
"""Pfad eines vocab-kompatiblen Drafts für target_path, oder None.
|
|
Bevorzugt einen MTP-Kopf NEBEN dem Modell (höchste Qualität, by-construction),
|
|
dann MC_SPEC_DRAFT_MODEL (falls gesetzt+kompatibel), sonst der erste kompatible
|
|
Draft in DRAFTS_DIR. None auch, wenn target (noch) fehlt (nicht verifizierbar →
|
|
bewusst KEIN Draft anhängen)."""
|
|
if not target_path or not os.path.exists(target_path):
|
|
return None
|
|
from services import gguf_meta
|
|
candidates: list[str] = list(_sibling_mtp_drafters(target_path))
|
|
if SPEC_DRAFT_MODEL_PATH and os.path.exists(SPEC_DRAFT_MODEL_PATH):
|
|
candidates.append(SPEC_DRAFT_MODEL_PATH)
|
|
for d in list_drafts():
|
|
if d["path"] not in candidates:
|
|
candidates.append(d["path"])
|
|
for c in candidates:
|
|
if gguf_meta.compatible(target_path, c) is True:
|
|
return c
|
|
return None
|
|
|
|
|
|
def spec_draft_flags(target_path: str) -> str:
|
|
"""llama-server-Flags für Speculative Decoding (Draft + --spec-type), oder ''
|
|
wenn kein kompatibler Draft existiert. MTP-bewusst (s. _spec_flags_for_draft)."""
|
|
d = find_compatible_draft(target_path)
|
|
return _spec_flags_for_draft(d) if d else ""
|
|
|
|
|
|
# --- Groups (Ko-Residenz) ----------------------------------------------------
|
|
@_mit_sperre
|
|
def set_group(group: str, members: list[str], swap: bool = False, persist: bool = False) -> None:
|
|
"""llama-swap-`groups`-Eintrag setzen. swap=False → alle Mitglieder dürfen
|
|
GLEICHZEITIG laufen (Ko-Residenz, keine Nachlade-Latenz). persist=True →
|
|
Mitglieder werden nie von anderen Gruppen verdrängt.
|
|
|
|
llama-swap kennt dafür AUSSCHLIESSLICH den Key `persistent` — `persist` wird von ihm
|
|
stillschweigend ignoriert (so verlor das Hirn seinen Verdrängungsschutz; live gefunden
|
|
03.07.2026: Coder-Last warf die brains-Gruppe raus). `persist` wird zusätzlich weiter
|
|
geschrieben, weil MC2-API/UI (routers/models.py, agent.py, Frontend) diesen Key lesen."""
|
|
cfg = read_config()
|
|
groups = cfg.setdefault("groups", {})
|
|
groups[group] = {"swap": swap, "persist": persist, "persistent": persist,
|
|
# Eine immer-warme Gruppe darf nichts verdrängen. llama-swap macht Gruppen sonst
|
|
# `exclusive`, und JEDE Anfrage ans Hirn entlud den Coder samt Prompt-Cache
|
|
# (live gefunden 24.09.2026: Lucy-Anfrage → OpenChamber-Coder weg).
|
|
**({"exclusive": False} if persist else {}),
|
|
"members": list(members)}
|
|
# Härtung: eine persistente (immer-warme) Gruppe verlangt ttl:0 je Mitglied.
|
|
# `persistent` schützt NUR gegen Verdrängung durch andere Modelle, NICHT gegen
|
|
# ttl-Selbstentladen — ein Mitglied mit ttl>0 fällt trotz Gruppen-Mitgliedschaft
|
|
# nach Leerlauf aus dem Warm-Set (live gefunden 03.07.2026: VL-30B mit ttl 300
|
|
# entlud sich alle 5 Min). So kann dieser Fehler beim Warm-Set-Umbau nie wieder passieren.
|
|
if persist:
|
|
models = cfg.get("models") or {}
|
|
for mid in members:
|
|
spec = models.get(mid)
|
|
if isinstance(spec, dict):
|
|
spec["ttl"] = 0
|
|
write_config(cfg)
|
|
|
|
|
|
def list_groups() -> dict:
|
|
return read_config().get("groups") or {}
|
|
|
|
|
|
@_mit_sperre
|
|
def set_role(model_id: str, role: str | None) -> bool:
|
|
"""Rolle (llama-swap-Alias) eines bestehenden Modells setzen/ändern. So tauscht man
|
|
z.B. das `fast`-Hirn: Rolle `fast` auf ein anderes Modell legen (Alias wandert)."""
|
|
cfg = read_config()
|
|
if model_id not in (cfg.get("models") or {}):
|
|
return False
|
|
set_role_alias(cfg, model_id, role)
|
|
write_config(cfg)
|
|
return True
|
|
|
|
|
|
@_mit_sperre
|
|
def add_role(model_id: str, role: str) -> bool:
|
|
"""Wie set_role, aber die übrigen Aliase des Ziel-Modells bleiben — für Modelle mit zwei Rollen
|
|
(Coder: coder UND heavy). set_role behielte nur die geschützten Aliase und würfe coder wieder weg."""
|
|
cfg = read_config()
|
|
models = cfg.get("models") or {}
|
|
rolle = (role or "").strip().lower()
|
|
if model_id not in models or not rolle or not isinstance(models[model_id], dict):
|
|
return False
|
|
bisher = [a for a in (models[model_id].get("aliases") or []) if str(a).lower() != rolle]
|
|
set_role_alias(cfg, model_id, rolle) # nimmt die Rolle allen anderen Modellen weg
|
|
models[model_id]["aliases"] = bisher + [rolle]
|
|
write_config(cfg)
|
|
return True
|
|
|
|
|
|
@_mit_sperre
|
|
def set_ttl(model_id: str, ttl: int) -> bool:
|
|
"""Idle-TTL (Sekunden) eines bestehenden Modells setzen. ttl=0 → nie automatisch
|
|
entladen (für das Agent-Hirn, das dauerhaft warm bleiben muss)."""
|
|
cfg = read_config()
|
|
spec = (cfg.get("models") or {}).get(model_id)
|
|
if not isinstance(spec, dict):
|
|
return False
|
|
spec["ttl"] = int(ttl)
|
|
write_config(cfg)
|
|
return True
|
|
|
|
|
|
@_mit_sperre
|
|
def im_modellordner(pfad: str) -> bool:
|
|
"""Liegt der Pfad (aufgelöst) unter MODELS_DIR? Grenze für Löschen und Eintragen (24.09.2026)."""
|
|
try:
|
|
return Path(pfad).resolve().is_relative_to(MODELS_DIR.resolve())
|
|
except (OSError, ValueError):
|
|
return False
|
|
|
|
|
|
def delete_model(model_id: str) -> bool:
|
|
"""Entfernt einen Modell-Eintrag aus der config.yaml, löscht die zugehörigen
|
|
GGUF-Dateien (auch Splits) vom Datenträger und bereinigt leere Ordner.
|
|
"""
|
|
cfg = read_config()
|
|
models = cfg.get("models") or {}
|
|
if model_id not in models:
|
|
return False
|
|
|
|
model_spec = models[model_id] or {}
|
|
cmd = str(model_spec.get("cmd", "")).strip()
|
|
# Seit 24.09.2026 teilen sich die Bild-Zwillinge ihre Gewichte (und ggf. Projektoren) mit Hirn und Coder.
|
|
# Dateien, die ein anderer Eintrag noch nennt, bleiben liegen — sonst risse das Löschen eines Zwillings
|
|
# den Coder mit. Dann wird nur der Eintrag entfernt.
|
|
andere = " ".join(str((s or {}).get("cmd", "")) for mid, s in models.items() if mid != model_id)
|
|
if (m := _PATH_RE.search(cmd)) and m.group(1).replace("'", "").replace('"', "") in andere:
|
|
m = None
|
|
if m:
|
|
path = m.group(1).replace("'", "").replace('"', "")
|
|
if path and not im_modellordner(path):
|
|
log.warning("delete_model: %s liegt außerhalb von %s — nur der Eintrag wird entfernt", path, MODELS_DIR)
|
|
path = ""
|
|
if path:
|
|
# 1. Haupt-GGUF-Datei löschen
|
|
if os.path.exists(path):
|
|
try:
|
|
os.remove(path)
|
|
except Exception:
|
|
pass
|
|
|
|
# 2. Split-GGUF-Teile löschen (z.B. dateiname-00001-of-00005.gguf etc.)
|
|
dirname = os.path.dirname(path)
|
|
basename = os.path.basename(path)
|
|
if os.path.isdir(dirname):
|
|
split_idx = basename.find("-00001-of-")
|
|
if split_idx != -1:
|
|
prefix = basename[:split_idx]
|
|
for f in os.listdir(dirname):
|
|
if f.startswith(prefix) and f.endswith(".gguf"):
|
|
try:
|
|
os.remove(os.path.join(dirname, f))
|
|
except Exception:
|
|
pass
|
|
|
|
# mmproj-Datei (Vision adapter) aus dem Befehl parsen & löschen
|
|
if "mmproj" in cmd:
|
|
mmproj_match = re.search(r'--mmproj\s+[\'"]?([^\s\'"]+)[\'"]?', cmd)
|
|
if mmproj_match:
|
|
m_path = mmproj_match.group(1)
|
|
if os.path.exists(m_path) and m_path not in andere and im_modellordner(m_path):
|
|
try:
|
|
os.remove(m_path)
|
|
except Exception:
|
|
pass
|
|
|
|
# 3. Eltern-Ordner löschen, falls er leer ist und nicht der Modelle-Wurzelordner selbst ist
|
|
try:
|
|
if not os.listdir(dirname) and Path(dirname).resolve() != MODELS_DIR.resolve():
|
|
os.rmdir(dirname)
|
|
except Exception:
|
|
pass
|
|
|
|
del models[model_id]
|
|
for g in (cfg.get("groups") or {}).values():
|
|
if isinstance(g, dict) and model_id in (g.get("members") or []):
|
|
g["members"] = [m for m in g["members"] if m != model_id]
|
|
write_config(cfg)
|
|
return True
|
|
|
|
|
|
def brain_model_name() -> str | None:
|
|
"""Modellname von Lucys Agent-Hirn. Bevorzugt das Modell mit dem 'hermes'-Alias/-Rolle;
|
|
fällt auf Hermes' aktives `model.default` zurück (deckt den Fall ab, dass die Config direkt
|
|
auf einen Modellnamen statt den Alias zeigt)."""
|
|
models = list_models()
|
|
for m in models:
|
|
names = {str(a).lower() for a in (m.get("aliases") or [])}
|
|
if m.get("role"):
|
|
names.add(str(m["role"]).lower())
|
|
if "hermes" in names:
|
|
return m["name"]
|
|
# Fallback: das real von Hermes genutzte Hirn (model.default), per Alias/Name auflösen.
|
|
try:
|
|
from services.agent import _active_brain_name
|
|
brain = (_active_brain_name() or "").lower()
|
|
if brain and brain != "auto":
|
|
cur = next((m for m in models if (m.get("role") or "").lower() == brain), None) \
|
|
or next((m for m in models if brain in (m["name"] or "").lower()), None)
|
|
if cur:
|
|
return cur["name"]
|
|
except Exception:
|
|
log.debug("brain_model_name: Hermes-Fallback fehlgeschlagen", exc_info=True)
|
|
return None
|
|
|
|
|
|
def brain_status() -> dict:
|
|
"""Ist Lucys Agent-Hirn (Rolle 'hermes') WIRKLICH geladen & bereit? Prüft /running — ein
|
|
abgestürztes Modell (z.B. OOM/Crash nach Engine-Update) erscheint dort NICHT als running.
|
|
Fängt damit den Fall 'Engine erreichbar, aber Hirn tot', den engine_reachable() nicht sieht."""
|
|
name = brain_model_name()
|
|
running = get_running_models()
|
|
return {"role": "hermes", "model": name, "ready": bool(name and name in running)}
|
|
|
|
|
|
def get_running_models() -> list[str]:
|
|
"""Fragt den /running Endpunkt von llama-swap ab. Gibt die Namen der geladenen
|
|
Modelle zurück. Neuere llama-swap-Versionen liefern Objekte ({model, state, ...})
|
|
statt Strings — beide Formen werden auf Namens-Strings normalisiert."""
|
|
try:
|
|
with httpx.Client(timeout=2.0) as c:
|
|
r = c.get(f"{LLAMA_SWAP_URL}/running")
|
|
if r.status_code == 200:
|
|
data = r.json().get("running") or []
|
|
return [x.get("model", "") if isinstance(x, dict) else x for x in data]
|
|
except Exception:
|
|
log.warning("get_running_models fehlgeschlagen", exc_info=True)
|
|
return []
|
|
|
|
|
|
def modell_zustaende() -> dict[str, str] | None:
|
|
"""Zustand je Modell aus /running: Name → "ready" | "starting" | "stopping". Wer fehlt, ist nicht geladen.
|
|
llama-swap v257 listet dort jedes Modell, das weder „stopped“ noch „shutdown“ ist (internal/router/base.go,
|
|
RunningModels) — also auch eines, das gerade lädt. Ältere Fassungen lieferten nur Namen; die gelten als bereit.
|
|
None = /running nicht lesbar."""
|
|
try:
|
|
with httpx.Client(timeout=3.0) as c:
|
|
r = c.get(f"{LLAMA_SWAP_URL}/running")
|
|
if r.status_code != 200:
|
|
return None
|
|
eintraege = r.json().get("running") or []
|
|
except Exception:
|
|
log.warning("modell_zustaende: /running nicht lesbar", exc_info=True)
|
|
return None
|
|
zustaende: dict[str, str] = {}
|
|
for x in eintraege:
|
|
if isinstance(x, dict):
|
|
if x.get("model"):
|
|
zustaende[str(x["model"])] = str(x.get("state") or "ready")
|
|
elif x:
|
|
zustaende[str(x)] = "ready"
|
|
return zustaende
|
|
|
|
|
|
def hirn_zustand() -> dict:
|
|
"""Wie steht Lucys Hirn (Modell mit dem Alias/der Rolle „hermes“) in llama-swap? Gezielt dieses eine Modell —
|
|
bis 24.09.2026 galt das Hirn als bereit, sobald IRGENDEIN Modell lief (ein abgestürztes Hirn neben einem
|
|
geladenen Coder blieb unbemerkt).
|
|
Rückgabe {"modell": Name oder None, "zustand": "bereit" | "laedt" | "fehlt" | "unbekannt"};
|
|
„unbekannt“ heißt: /running antwortet nicht. Trägt kein Modell die Rolle, ist modell None und zustand "fehlt"."""
|
|
name = brain_model_name()
|
|
zustaende = modell_zustaende()
|
|
if zustaende is None:
|
|
return {"modell": name, "zustand": "unbekannt"}
|
|
zustand = zustaende.get(name or "")
|
|
if zustand == "ready":
|
|
return {"modell": name, "zustand": "bereit"}
|
|
if zustand == "starting":
|
|
return {"modell": name, "zustand": "laedt"}
|
|
return {"modell": name, "zustand": "fehlt"}
|
|
|
|
|
|
# Wie lange „Jetzt laden“ auf die Engine wartet. Große Modelle brauchen eine Weile (Lesen + Hochladen in den Speicher);
|
|
# was danach noch lädt, meldet lade_modell als „lädt noch“ statt als Fehler.
|
|
LADEN_WARTE_S = float(os.environ.get("MC_LADEN_WARTE_S", "90"))
|
|
|
|
|
|
def _engine_grund(r: httpx.Response) -> str:
|
|
"""Die Fehlermeldung der Engine aus ihrer Antwort (OpenAI-Format {"error": {"message"}}, {"error": "…"},
|
|
{"detail": "…"} oder reiner Text), auf eine Zeile gekürzt."""
|
|
text = ""
|
|
try:
|
|
daten = r.json()
|
|
except ValueError:
|
|
daten = None
|
|
if isinstance(daten, dict):
|
|
fehler = daten.get("error")
|
|
if isinstance(fehler, dict):
|
|
text = str(fehler.get("message") or "")
|
|
elif fehler:
|
|
text = str(fehler)
|
|
elif daten.get("detail"):
|
|
text = str(daten["detail"])
|
|
text = " ".join((text or r.text or "").split())
|
|
return text[:200] or "ohne Begründung"
|
|
|
|
|
|
def lade_modell(model_id: str, warte_s: float | None = None) -> dict:
|
|
"""Ein Modell laden und das ECHTE Ergebnis melden (seit 24.09.2026 — vorher hieß jede Antwort der Engine „ok“).
|
|
llama-swap lädt ein Modell mit der ersten Anfrage; dafür reicht eine Mini-Anfrage mit einem Token. Ob das Modell
|
|
danach wirklich geladen ist, entscheidet /running — so zählen auch Modelle, die gar nicht chatten (embed,
|
|
reranker), und ein Fehler der Anfrage selbst macht ein geladenes Modell nicht zum Fehlschlag.
|
|
Rückgabe: {"ok": True, "text": …} (bei "laedt": True lädt es nach der Wartezeit noch) oder
|
|
{"ok": False, "detail": deutscher Grund, mit der Meldung der Engine}."""
|
|
warte = LADEN_WARTE_S if warte_s is None else warte_s
|
|
anfrage = {"model": model_id, "messages": [{"role": "user", "content": "ping"}], "max_tokens": 1}
|
|
try:
|
|
with httpx.Client(timeout=warte) as c:
|
|
r = c.post(f"{LLAMA_SWAP_URL}/v1/chat/completions", json=anfrage)
|
|
except (httpx.ConnectError, httpx.ConnectTimeout) as exc:
|
|
return {"ok": False, "detail": f"{model_id} ließ sich nicht laden: Die Engine (llama-swap) ist nicht "
|
|
f"erreichbar ({exc.__class__.__name__})."}
|
|
except httpx.TimeoutException:
|
|
if (modell_zustaende() or {}).get(model_id) == "starting":
|
|
return {"ok": True, "laedt": True,
|
|
"text": f"{model_id} lädt noch. Große Modelle brauchen etwas; der Stand erscheint gleich unter Modelle."}
|
|
return {"ok": False, "detail": f"{model_id} ließ sich nicht laden: Die Engine hat nach {warte:.0f} Sekunden "
|
|
"nicht geantwortet, und das Modell lädt auch nicht."}
|
|
except httpx.HTTPError as exc:
|
|
return {"ok": False, "detail": f"{model_id} ließ sich nicht laden: {exc.__class__.__name__}: {exc}"[:300]}
|
|
if r.status_code == 200:
|
|
return {"ok": True, "text": f"{model_id} ist geladen."}
|
|
zustand = (modell_zustaende() or {}).get(model_id)
|
|
if zustand == "ready":
|
|
return {"ok": True, "text": f"{model_id} ist geladen."}
|
|
if zustand == "starting":
|
|
return {"ok": True, "laedt": True, "text": f"{model_id} lädt noch."}
|
|
return {"ok": False, "detail": f"{model_id} ließ sich nicht laden. Die Engine meldet (HTTP {r.status_code}): "
|
|
f"{_engine_grund(r)}"}
|