Skip to content

Run frontier MoE models on hardware you already own — pure C, zero deps, experts streamed from disk. Tiny engine, immense model. 🐦

C
11.8 KB
Raw Blame
#!/usr/bin/env python3
"""Il renderer di GLM-5.3 nel gateway, contro chat_template.jinja ufficiale.

Il gateway rende i prompt a mano invece di far girare jinja a ogni richiesta, e
quella scelta si paga in un modo solo: la copia scritta a mano puo' scostarsi
dall'originale senza che nessuno se ne accorga, perche' il modello risponde
comunque. Un a capo di troppo dentro il blocco degli strumenti non da' errore,
da' risposte peggiori.

Qui il template vero viene reso con jinja2 e confrontato byte per byte con
quello che produce il gateway, sui casi che contano: senza strumenti, con uno,
con due, con una chiamata e il suo risultato, e con i livelli di ragionamento.

Serve chat_template.jinja del checkpoint. Se non c'e' il test si dichiara
saltato invece di passare: un test che non ha trovato il suo riferimento non ha
verificato niente, e dirlo verde sarebbe peggio che non averlo -- percio' un
salto esce con codice 2, distinto dallo 0 di un confronto riuscito.

RIFERIMENTO (scaricato 2026-09-10):
  repo     zai-org/GLM-5.3-Flash
  file     chat_template.jinja
  sha256   34d5ee66b12fa6446cdae131c352b8f68cd85369e0e6fda115583805fada3891
  hf download zai-org/GLM-5.3-Flash chat_template.jinja

USO:
  python3 tests/glm53_chat_template_harness.py --template PATH/chat_template.jinja
"""
import argparse
import json
import sys
from pathlib import Path

CASES = {
    "senza strumenti": {
        "messages": [{"role": "user", "content": "ciao"}],
    },
    "un solo strumento": {
        "messages": [{"role": "user", "content": "che tempo fa a Roma?"}],
        "tools": [{"type": "function", "function": {
            "name": "meteo", "description": "Il tempo",
            "parameters": {"type": "object",
                           "properties": {"citta": {"type": "string"}},
                           "required": ["citta"]}}}],
    },
    "due strumenti": {
        "messages": [{"role": "user", "content": "x"}],
        "tools": [
            {"type": "function", "function": {"name": "meteo", "description": "Il tempo"}},
            {"type": "function", "function": {"name": "ora", "description": "L'ora"}},
        ],
    },
    "chiamata e risultato": {
        "messages": [
            {"role": "user", "content": "che tempo fa a Roma?"},
            {"role": "assistant", "content": "", "tool_calls": [
                {"type": "function", "function": {
                    "name": "meteo", "arguments": {"citta": "Roma"}}}]},
            {"role": "tool", "content": "sereno, 24 gradi"},
        ],
        "tools": [{"type": "function", "function": {
            "name": "meteo", "description": "Il tempo"}}],
    },
    "turno precedente con ragionamento": {
        "messages": [
            {"role": "user", "content": "a"},
            {"role": "assistant", "content": "<think>rifletto</think>b"},
            {"role": "user", "content": "c"},
        ],
    },
    "istruzione di sistema": {
        "messages": [
            {"role": "system", "content": "sii breve"},
            {"role": "user", "content": "ciao"},
        ],
    },
}

EFFORTS = {"low": "low", "high": "high", "xhigh": None, None: None}


def reference(template_text, *, messages, tools=None, reasoning_effort=None,
              add_generation_prompt=True):
    import jinja2
    environment = jinja2.Environment(trim_blocks=False, lstrip_blocks=False,
                                     extensions=["jinja2.ext.loopcontrols"])
    # jinja2 3.x non accetta ensure_ascii sul tojson incorporato; il template
    # lo passa esplicitamente, quindi il filtro va sostituito con uno che lo
    # capisce. Non cambia l'uscita, cambia solo la firma.
    environment.filters["tojson"] = (
        lambda value, ensure_ascii=False, **kw: json.dumps(value, ensure_ascii=ensure_ascii))
    rendered = environment.from_string(template_text)
    arguments = {"messages": messages, "add_generation_prompt": add_generation_prompt}
    if tools:
        arguments["tools"] = tools
    if reasoning_effort:
        arguments["reasoning_effort"] = reasoning_effort
    return rendered.render(**arguments)


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--template", type=Path, required=True)
    arguments = parser.parse_args()

    if not arguments.template.exists():
        print(f"SKIP: manca {arguments.template}; il riferimento non c'e' e "
              f"questo test non ha verificato nulla")
        return 2                                  # salto != successo (vedi docstring)
    try:
        import jinja2                              # noqa: F401
    except ImportError:
        print("SKIP: jinja2 non installato; senza non c'e' riferimento")
        return 2                                  # salto != successo (vedi docstring)

    sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
    import openai_server

    openai_server.ARCH = "glm53"
    template_text = arguments.template.read_text(encoding="utf-8")
    checked = 0
    for name, case in CASES.items():
        for effort, passed in EFFORTS.items():
            expected = reference(template_text, messages=case["messages"],
                                 tools=case.get("tools"), reasoning_effort=passed)
            # Il confronto col template e' sul ragionamento ACCESO, che e'
            # l'unica forma che il template conosce: per lui il modello ragiona
            # sempre e il prompt di generazione apre <think>.
            produced = openai_server.render_chat_for_arch(
                case["messages"], enable_thinking=True,
                reasoning_effort=effort, tools=case.get("tools"))
            if produced != expected:
                print(f"FAIL {name} (reasoning_effort={effort!r})")
                for position, (left, right) in enumerate(zip(produced, expected)):
                    if left != right:
                        start = max(0, position - 40)
                        print(f"  primo scostamento a {position}")
                        print(f"  gateway:  ...{produced[start:position + 40]!r}")
                        print(f"  template: ...{expected[start:position + 40]!r}")
                        break
                else:
                    print(f"  lunghezze diverse: {len(produced)} contro {len(expected)}")
                return 1
            checked += 1

    # Il ragionamento "spento" non e' una forma nostra: e' il livello minimo del
    # template. GLM-5.3 non sa non ragionare -- `effective_reasoning_effort` ha un
    # ramo else che vale 'max' e non e' mai none, e il prompt di generazione apre
    # sempre <think>. Quindi enable_thinking=False deve rendere ESATTAMENTE quello
    # che il template rende con reasoning_effort='low', e questo lo pretende
    # confrontando i due, non una forma scritta a mano qui.
    #
    # La versione precedente di questo blocco pretendeva l'opposto: nessuna riga di
    # effort e <think></think> chiuso. Era la mia teoria di #1282, misurata falsa e
    # ritirata su #1278, e il test la teneva in vita: due deviazioni dal template
    # trasformate in contratto. Un test puo' proteggere un errore tanto quanto una
    # correttezza -- per questo qui il riferimento e' il template, mai la mia idea
    # di cosa dovrebbe uscire.
    off = openai_server.render_chat_for_arch(
        [{"role": "user", "content": "ciao"}], enable_thinking=False)
    expected_off = reference(template_text,
                             messages=[{"role": "user", "content": "ciao"}],
                             reasoning_effort="low")
    if off != expected_off:
        print("FAIL: col ragionamento al minimo il gateway non rende il template")
        print(f"  gateway:  {off!r}")
        print(f"  template: {expected_off!r}")
        return 1
    if off.endswith("<think></think>"):
        print("FAIL: e' tornata la forma col blocco chiuso, che il modello non ha "
              "mai visto in questa posizione (#1278)")
        return 1
    if "Reasoning Effort" not in off:
        print("FAIL: manca la riga di effort, che il template emette sempre (#1278)")
        return 1
    checked += 1

    # Prosecuzione: l'ultimo turno assistant e' da CONTINUARE, non uno gia' finito. Nel
    # template e' add_generation_prompt=False -- l'altro ramo dell'`if` che il gateway
    # ha sempre fissato a True -- e il riferimento qui e' quel ramo reso con jinja2,
    # non una forma scritta a mano. Il prompt finisce dentro il turno, sull'apertura
    # del client, e non su un nuovo <|assistant|><think>.
    #
    # Nota su #1327: il blocco chiuso <think></think> in fondo al prompt e' fuori
    # distribuzione, e infatti resta vietato -- ma la posizione qui e' un'altra,
    # <think></think> seguito da contenuto vero, che e' la forma che il template
    # scrive davanti a ogni turno passato. Per questo una prosecuzione vuota e'
    # rifiutata a monte (tests/test_openai_server.py, TrailingAssistantTurnTest).
    aperto = [{"role": "user", "content": "capitale della Francia?"},
               {"role": "assistant", "content": "La capitale e'"}]
    # L'effort esce ESPLICITO su entrambi i lati, e su ognuno dei tre livelli che il
    # template sa esprimere: 'low' e 'high' passano invariati, 'xhigh' rende Max come il
    # default del template. 'minimal'/'medium' non sono qui apposta -- il gateway li
    # riduce a Low/High (la sua scala e' piu' ricca del template), quindi contro il
    # riferimento non c'e' niente da confrontare. Passare l'effort esplicito toglie di
    # mezzo la differenza sul default (gateway High, template Max), che non e' una
    # questione di prosecuzione: e' la scala dei livelli, e vale identica sul ramo True.
    for effort in ("low", "high", "xhigh"):
        produced = openai_server.render_chat_for_arch(
            aperto, enable_thinking=True, reasoning_effort=effort, add_generation_prompt=False)
        expected = reference(template_text, messages=aperto, reasoning_effort=effort,
                             add_generation_prompt=False)
        if produced != expected:
            print(f"FAIL prosecuzione (reasoning_effort={effort!r}): il turno aperto non "
                  f"rende come il template con add_generation_prompt=False")
            for position, (left, right) in enumerate(zip(produced, expected)):
                if left != right:
                    start = max(0, position - 40)
                    print(f"  primo scostamento a {position}")
                    print(f"  gateway:  ...{produced[start:position + 40]!r}")
                    print(f"  template: ...{expected[start:position + 40]!r}")
                    break
            else:
                print(f"  lunghezze diverse: {len(produced)} contro {len(expected)}")
            return 1
        if produced.endswith("<|assistant|><think>"):
            print(f"FAIL prosecuzione (reasoning_effort={effort!r}): il prompt finisce su un "
                  f"nuovo turno invece di proseguire quello del client")
            return 1
        if not produced.endswith("La capitale e'"):
            print(f"FAIL prosecuzione (reasoning_effort={effort!r}): il prompt non finisce "
                  f"sull'apertura del client: {produced[-60:]!r}")
            return 1
        # Controllo negativo: col ramo True lo stesso scambio DEVE finire sulla cue, o il
        # confronto qui sopra non starebbe distinguendo niente.
        if not openai_server.render_chat_for_arch(
                aperto, enable_thinking=True,
                reasoning_effort=effort).endswith("<|assistant|><think>"):
            print(f"FAIL prosecuzione (reasoning_effort={effort!r}): il ramo normale non "
                  f"emette piu' il prompt di generazione")
            return 1
    checked += 1

    print(f"PASS GLM-5.3 chat template: {checked} rese identiche a "
          f"chat_template.jinja, strumenti e livelli di ragionamento compresi, "
          f"piu' il livello minimo, che rende come il template con effort low, "
          f"piu' il turno aperto (add_generation_prompt=False)")
    return 0


if __name__ == "__main__":
    sys.exit(main())