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
31.3 KB
Raw Blame
#!/usr/bin/env python3
"""Il protocollo di serve del motore GLM-5.3, parlato per intero.

`coli chat`, `coli serve` e `coli web` non chiamano la CLI: aprono una pipa e
parlano il protocollo di docs/serve_protocol.md. Fra la CLI che funziona e il
server che funziona ci sono l'handshake, il frame a byte contati, la
tokenizzazione del payload, la decodifica dei token in uscita e i codici di
errore, e nessuna di queste cose e' coperta da un test sui token.

Il confronto e' con la CLI sullo stesso prompt: la stessa domanda posta nei due
modi deve dare la stessa risposta, altrimenti la differenza sta nel protocollo.

Si controllano anche i rifiuti, perche' un server che accetta un frame rotto
invece di dirlo si disallinea sullo stream e da li' in poi risponde a domande
che nessuno ha fatto.
"""
import argparse
import os
import tempfile
import subprocess
import sys
from pathlib import Path


NOTES = tempfile.mktemp(suffix=".glm53.stderr")


def reuse_reported():
    """Quanti token di prefisso il motore dice di aver riusato."""
    try:
        text = open(NOTES, "r", errors="replace").read()
    except OSError:
        return 0
    return sum(int(line.split()[2]) for line in text.splitlines()
               if line.startswith("REUSE "))


def reuse_line(request_id):
    """La riga REUSE di una richiesta, spezzata in campi (vuota se non c'e')."""
    try:
        text = open(NOTES, "r", errors="replace").read()
    except OSError:
        return []
    for line in text.splitlines():
        if line.startswith(f"REUSE {request_id} "):
            return line.split()
    return []


def engine(binary, fixture, extra=None):
    # GLM53_VERBOSE: il riuso del prefisso si racconta solo su richiesta,
    # perche' `coli chat` eredita lo stderr del server e quella riga finirebbe
    # a schermo dopo ogni risposta.
    environment = {**os.environ, "SERVE": "1", "SERVE_BATCH": "1",
                   "SNAP": str(fixture), "GLM53_BITS": "32", "GLM53_VERBOSE": "1"}
    environment.update(extra or {})
    # stderr in un file: il riuso del prefisso si racconta li', perche' nel
    # protocollo una riga in piu' farebbe cadere il gateway (di proposito).
    return subprocess.Popen([binary], stdin=subprocess.PIPE, stdout=subprocess.PIPE,
                            stderr=open(NOTES, "wb"), env=environment)


def read_line(stream):
    line = stream.readline()
    if not line:
        raise AssertionError("il motore ha chiuso lo stream prima del previsto")
    return line.decode("utf-8", "replace").rstrip("\n")


def handshake(process):
    ready = read_line(process.stdout)
    if "READY" not in ready:
        raise AssertionError(f"prima riga {ready!r}, atteso il sentinello READY")
    stat = read_line(process.stdout)
    while stat.startswith("CAPS "):        # CAPS vision=<0|1> sits between READY and STAT
        stat = read_line(process.stdout)
    if not stat.startswith("STAT "):
        raise AssertionError(f"seconda riga {stat!r}, atteso STAT")


def submit_bytes(process, request_id, body, max_tokens=4, temperature=0.0, top_p=1.0):
    header = (f"SUBMIT {request_id} 0 {len(body)} {max_tokens} "
              f"{temperature} {top_p}\n").encode("utf-8")
    process.stdin.write(header + body + b"\n")
    process.stdin.flush()


def submit(process, request_id, payload, max_tokens=4, temperature=0.0, top_p=1.0):
    submit_bytes(process, request_id, payload.encode("utf-8"), max_tokens,
                 temperature, top_p)


def collect(process, request_id):
    """I DATA fino al DONE della richiesta, o l'ERROR che li sostituisce.

    Restituisce anche quanto prefisso lo slot ha riusato, se il motore lo dice."""
    pieces = []
    while True:
        line = read_line(process.stdout)
        if line.startswith("DATA "):
            _, got_id, count = line.split()
            if int(got_id) != request_id:
                raise AssertionError(f"DATA per {got_id}, atteso {request_id}")
            payload = process.stdout.read(int(count) + 1)      # payload piu' '\n'
            pieces.append(payload[:int(count)])
        elif line.startswith("DONE ") or line.startswith("ERROR "):
            return b"".join(pieces), line, reuse_reported()


def fresh_answer(binary, fixture, body, tokens):
    """La risposta di un motore appena partito: il riferimento per ogni riuso.
    Un motore suo, perche' lo slot di un altro potrebbe riusare qualcosa."""
    reference = engine(binary, fixture)
    try:
        handshake(reference)
        submit_bytes(reference, 1, body, max_tokens=tokens)
        answer, done, _ = collect(reference, 1)
        reference.stdin.close()
        reference.wait(timeout=60)
    finally:
        if reference.poll() is None:
            reference.kill()
    if not done.startswith("DONE 1 "):
        raise AssertionError(f"il riferimento ha chiuso con {done!r}")
    return answer


def cli_answer(binary, fixture, prompt, tokens):
    """L'uscita della CLI in BYTE.

    Un tokenizzatore a livello di byte emette byte grezzi, e un carattere
    multibyte si spezza fra due token: la risposta di un modello a pesi casuali
    non e' UTF-8 valido ne' deve esserlo. Decodificarla qui vorrebbe dire
    rompere il test su un fatto normale del formato."""
    result = subprocess.run(
        [binary, "--model", str(fixture), "--prompt", prompt, "--greedy", str(tokens)],
        capture_output=True, check=True,
        env={**os.environ, "GLM53_BITS": "32"})
    return result.stdout


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--binary", required=True)
    parser.add_argument("--fixture", type=Path, required=True)
    arguments = parser.parse_args()
    if not (arguments.fixture / "ref.json").exists():
        # Un traceback su un file che manca fa sembrare rotto il
        # motore; chi arriva per la prima volta non puo' distinguere
        # le due cose. Il generatore vuole transformers 5.16.1.
        print(f"SKIP: manca {arguments.fixture}; generalo con\n"
              f"  python3 tools/make_glm53_multimodal_tiny.py --output <dir>")
        return 2  # un salto non e' un successo
    binary = os.path.abspath(arguments.binary)
    prompt, tokens = "gu", 4

    process = engine(binary, arguments.fixture)
    try:
        handshake(process)

        submit(process, 7, prompt, max_tokens=tokens)
        served, done, _ = collect(process, 7)
        if not done.startswith("DONE 7 STAT "):
            print(f"FAIL: chiusura {done!r}")
            return 1
        fields = done.split()
        if len(fields) != 9:
            print(f"FAIL: DONE con {len(fields)} campi invece di 9: {done!r}")
            return 1
        emitted = int(fields[3])
        if emitted != tokens:
            print(f"FAIL: {emitted} token emessi, chiesti {tokens}")
            return 1

        # Un prompt vuoto e' un rifiuto, non una risposta vuota.
        submit(process, 8, "", max_tokens=tokens)
        _, empty, _ = collect(process, 8)
        if empty != "ERROR 8 EMPTY_PROMPT":
            print(f"FAIL: prompt vuoto -> {empty!r}, atteso ERROR 8 EMPTY_PROMPT")
            return 1

        # Dopo un rifiuto lo stream deve restare allineato.
        submit(process, 9, prompt, max_tokens=1)
        after, done9, _ = collect(process, 9)
        if not done9.startswith("DONE 9 "):
            print(f"FAIL: dopo un errore lo stream si e' disallineato: {done9!r}")
            return 1
        if not served.startswith(after):
            print(f"FAIL: la stessa domanda ha dato due risposte diverse\n"
                  f"  4 token: {served!r}\n  1 token: {after!r}")
            return 1

        # --- slot KV: un secondo turno che estende il primo ---
        #
        # Il tokenizzatore e' a livello di byte senza merge, quindi tokenizzare
        # una concatenazione da' la concatenazione delle tokenizzazioni: il
        # prompt del secondo turno estende davvero la sequenza del primo, che e'
        # la condizione perche' lo slot possa riusarla.
        second = prompt.encode() + served + b"z"
        submit_bytes(process, 10, second, max_tokens=2)
        turn2, done10, reused = collect(process, 10)
        if not done10.startswith("DONE 10 "):
            print(f"FAIL: secondo turno {done10!r}")
            return 1
        if not reused:
            print("FAIL: lo slot non ha riusato niente su un prompt che estende "
                  "quello di prima")
            return 1
        if reuse_line(7)[-1:] != ["cold"] or reuse_line(10)[-1:] != ["extend"]:
            print(f"FAIL: motivi del riuso {reuse_line(7)!r} / {reuse_line(10)!r}, "
                  f"attesi cold e extend")
            return 1
        # Il turno 7 si e' fermato al limite di token: la storia dello slot ha
        # un token in piu' di quelli in cache, e il prompt del turno 10 combacia
        # anche con quello. <in comune> non deve superare <in cache>.
        if reuse_line(10)[5] != reuse_line(10)[4]:
            print(f"FAIL: REUSE 10 dice {reuse_line(10)[5]} in comune ma "
                  f"{reuse_line(10)[4]} in cache: {reuse_line(10)!r}")
            return 1

        # --- CANCEL a meta' turno (#1332) ---
        #
        # Un CANCEL che arriva mentre il turno gira deve fermarlo. Prima
        # serve_read_req era l'unico posto che leggeva il comando, e serve_loop
        # la chiama solo fra una richiesta e l'altra: il CANCEL restava nella
        # pipa fino alla fine dei token chiesti, e il gateway -- che manda
        # CANCEL e poi aspetta l'ack tenendo l'ammissione dello scheduler --
        # non liberava niente, quindi un client che si disconnetteva lasciava
        # le richieste successive in coda dietro una generazione che nessuno
        # voleva piu'.
        #
        # La prova che il turno e' stato interrotto davvero e' il numero di
        # DATA arrivati: molti meno dei max_tokens chiesti. Un motore che
        # leggesse il CANCEL solo a fine turno ne emetterebbe `budget`.
        budget = 512
        submit(process, 12, prompt, max_tokens=budget)
        emitted_before = 0
        cancelled_text = b""
        while True:
            line = read_line(process.stdout)
            if line.startswith("DONE ") or line.startswith("ERROR "):
                break
            if not line.startswith("DATA "):
                continue    # EMAP, HITS, PROF: si ignorano, come fa il gateway
            _, got_id, count = line.split()
            if int(got_id) != 12:
                raise AssertionError(f"DATA per {got_id}, atteso 12")
            cancelled_text += process.stdout.read(int(count) + 1)[:int(count)]
            emitted_before += 1
            if emitted_before == 1:
                process.stdin.write(b"CANCEL 12\n")
                process.stdin.flush()
        if line != "ERROR 12 CANCELLED":
            print(f"FAIL: CANCEL a meta' turno -> {line!r}, atteso "
                  f"ERROR 12 CANCELLED (il turno ha emesso {emitted_before} token)")
            return 1
        if emitted_before >= budget:
            print(f"FAIL: il turno ha emesso tutti i {budget} token chiesti prima "
                  f"di rispondere al CANCEL: non e' stato onorato a meta' turno")
            return 1

        # La riga CANCEL su stderr: e' l'unico modo di sapere, dopo, quanti
        # token il motore ha mandato e quanti ne tiene in cache. Qui la pipa
        # non perde niente, quindi `emitted` deve essere esattamente i DATA
        # letti; e `filled` deve essere prompt piu' emessi, che e' quello che
        # un Continue dovra' superare per riusare lo slot.
        notes = open(NOTES, "r", errors="replace").read().splitlines()
        cancel_lines = [line.split() for line in notes if line.startswith("CANCEL 12 ")]
        if len(cancel_lines) != 1 or len(cancel_lines[0]) != 5:
            print(f"FAIL: attesa una riga 'CANCEL 12 <prompt> <emessi> <filled>' "
                  f"su stderr, trovate {cancel_lines!r}")
            return 1
        cancel_prompt, cancel_emitted, cancel_filled = map(int, cancel_lines[0][2:])
        if cancel_emitted != emitted_before:
            print(f"FAIL: CANCEL dice {cancel_emitted} token emessi, ne sono "
                  f"arrivati {emitted_before}")
            return 1
        if cancel_filled != cancel_prompt + cancel_emitted:
            print(f"FAIL: CANCEL con filled {cancel_filled}, atteso prompt "
                  f"{cancel_prompt} + emessi {cancel_emitted}")
            return 1
        if not any(line.startswith("REUSE 12 ") for line in notes):
            print("FAIL: il turno interrotto non ha lasciato la sua riga REUSE")
            return 1

        # Il Continue di un client che ha ricevuto tutto: il prompt di prima
        # piu' esattamente i token arrivati. Coincide con la cache, token per
        # token, quindi non resta niente da macinare: il motore riprende dai
        # logit tenuti alla fine del turno interrotto, senza rifare il
        # prefill, e deve rispondere come un motore appena partito.
        continued = prompt.encode() + cancelled_text
        submit_bytes(process, 20, continued, max_tokens=1)
        resumed20, done20, _ = collect(process, 20)
        if not done20.startswith("DONE 20 "):
            print(f"FAIL: Continue dopo il CANCEL -> {done20!r}")
            return 1
        why20 = reuse_line(20)
        if why20[2:] != [str(cancel_filled)] * 4 + ["equal"]:
            print(f"FAIL: Continue identico alla cache -> REUSE {why20!r}, atteso "
                  f"{cancel_filled} riusati su {cancel_filled}, motivo equal")
            return 1
        if resumed20 != fresh_answer(binary, arguments.fixture, continued, 1):
            print(f"FAIL: ripreso dai logit tenuti, il Continue risponde "
                  f"{resumed20!r} e un motore appena partito no")
            return 1

        # Dopo un CANCEL lo stream deve restare allineato come dopo un errore:
        # il gateway riusa la stessa pipa per la richiesta successiva.
        submit(process, 13, prompt, max_tokens=1)
        _, done13, _ = collect(process, 13)
        if not done13.startswith("DONE 13 "):
            print(f"FAIL: dopo un CANCEL lo stream si e' disallineato: {done13!r}")
            return 1

        # --- STOP a meta' turno ---
        #
        # STOP non e' CANCEL, e i due non possono finire nello stesso posto. Il
        # protocollo: "STOP ends generation through the normal successful DONE
        # path. Statistics, usage history, and KV state are persisted". Il
        # gateway lo manda quando un template di stop combacia -- cioe' quando
        # la risposta e' completa e va consegnata -- e dopo averlo mandato
        # continua a leggere fino al DONE trattandolo come riuscito (alza
        # ClientCancelled solo se aveva mandato CANCEL). Rispondere
        # ERROR <id> CANCELLED butterebbe via una risposta che il client ha gia'
        # ricevuto per intero.
        stop_budget = 512
        submit(process, 14, prompt, max_tokens=stop_budget)
        emitted_stop = 0
        done14 = None
        while True:
            line = read_line(process.stdout)
            if line.startswith("DATA "):
                _, got_id, count = line.split()
                if int(got_id) != 14:
                    raise AssertionError(f"DATA per {got_id}, atteso 14")
                process.stdout.read(int(count) + 1)
                emitted_stop += 1
                if emitted_stop == 1:
                    process.stdin.write(b"STOP 14\n")
                    process.stdin.flush()
            elif line.startswith("DONE ") or line.startswith("ERROR "):
                done14 = line
                break
            # HITS, PROF e compagnia: si ignorano, come fa il gateway.
        if not done14.startswith("DONE 14 "):
            print(f"FAIL: STOP a meta' turno -> {done14!r}, atteso un DONE "
                  f"(il protocollo vuole il percorso riuscito, non CANCELLED)")
            return 1
        if emitted_stop >= stop_budget:
            print(f"FAIL: il turno ha emesso tutti i {stop_budget} token chiesti "
                  f"prima di rispondere allo STOP: non e' stato onorato a meta' "
                  f"turno")
            return 1

        # --- SUBMIT mentre lo slot e' occupato ---
        #
        # Non puo' legalmente arrivare -- il gateway serve una richiesta per
        # volta e aspetta il DONE -- ma se arriva non lo si tiene in coda: si
        # risponde SLOT_BUSY, che e' il codice che il protocollo documenta.
        # `BUSY` non esiste: un gateway che lo ricevesse non saprebbe che farsene
        # e il suo thread resterebbe appeso su una pipa che nessuno legge.
        #
        # La seconda meta' del controllo e' che il payload del SUBMIT rifiutato
        # venga comunque consumato: e' a byte contati, e lasciarlo nello stream
        # disallineerebbe tutto quello che segue.
        busy_budget = 8
        submit(process, 15, prompt, max_tokens=busy_budget)
        sent_intruder = False
        busy = None
        done15 = None
        while True:
            line = read_line(process.stdout)
            if line.startswith("DATA "):
                _, got_id, count = line.split()
                if int(got_id) != 15:
                    raise AssertionError(f"DATA per {got_id}, atteso 15")
                process.stdout.read(int(count) + 1)
                if not sent_intruder:
                    sent_intruder = True
                    submit(process, 16, prompt, max_tokens=1)
            elif line.startswith("ERROR "):
                busy = line
            elif line.startswith("DONE "):
                done15 = line
                break
        if busy != "ERROR 16 SLOT_BUSY":
            print(f"FAIL: SUBMIT a slot occupato -> {busy!r}, atteso "
                  f"ERROR 16 SLOT_BUSY")
            return 1
        if not done15.startswith("DONE 15 "):
            print(f"FAIL: il turno in volo e' finito con {done15!r}, atteso DONE 15")
            return 1

        # Il SUBMIT rifiutato non deve aver lasciato il suo payload nella pipa:
        # se ci fosse ancora, la richiesta dopo leggerebbe i suoi byte come
        # header e lo stream sarebbe perso.
        submit(process, 17, prompt, max_tokens=1)
        _, done17, _ = collect(process, 17)
        if not done17.startswith("DONE 17 "):
            print(f"FAIL: dopo un SUBMIT rifiutato lo stream si e' disallineato: "
                  f"{done17!r}")
            return 1

        process.stdin.close()
        process.wait(timeout=60)
    finally:
        if process.poll() is None:
            process.kill()

    # --- EOF su stdin a meta' turno ---
    #
    # "EOF on stdin = graceful shutdown: in-flight requests finish first." La
    # pipa che si chiude sotto un turno in volo non e' un motivo per troncare la
    # risposta: il turno finisce, il DONE parte, e solo dopo il motore esce.
    #
    # La prova non e' che il DONE arrivi -- arriverebbe anche troncando, perche'
    # il ciclo esce e il DONE e' la riga dopo -- ma che i token siano gli
    # STESSI di un turno con la pipa aperta. Greedy e a temperatura zero, quindi
    # lo stesso prompt deve dare la stessa sequenza: se il turno si fermasse al
    # primo token, qui si vedrebbe.
    def turn_with_eof(close_stdin):
        eof_process = engine(binary, arguments.fixture)
        try:
            handshake(eof_process)
            submit(eof_process, 19, prompt, max_tokens=8)
            if close_stdin:
                eof_process.stdin.close()
            pieces, done, _ = collect(eof_process, 19)
            if not done.startswith("DONE 19 "):
                return None, done
            if close_stdin:
                eof_process.wait(timeout=60)
            else:
                eof_process.stdin.close()
                eof_process.wait(timeout=60)
            return pieces, done
        finally:
            if eof_process.poll() is None:
                eof_process.kill()

    control, done_control = turn_with_eof(False)
    interrupted, done_interrupted = turn_with_eof(True)
    if control is None or interrupted is None:
        print(f"FAIL: EOF a meta' turno -> controllo {done_control!r}, "
              f"con la pipa chiusa {done_interrupted!r}, attesi due DONE")
        return 1
    if interrupted != control:
        print(f"FAIL: la pipa chiusa a meta' turno ha troncato la risposta\n"
              f"  pipa aperta: {control!r} ({len(control)} byte)\n"
              f"  pipa chiusa: {interrupted!r} ({len(interrupted)} byte)")
        return 1
    emitted_eof = len(control)

    # Lo stesso prompt su una sessione pulita: il riuso deve essere esatto, non
    # solo veloce. Se qui la risposta cambia, la cache tenuta fra i turni sta
    # dando al modello un contesto diverso da quello che il client crede.
    fresh = engine(binary, arguments.fixture)
    try:
        handshake(fresh)
        submit_bytes(fresh, 11, second, max_tokens=2)
        clean, done11, reused_clean = collect(fresh, 11)
        if not done11.startswith("DONE 11 "):
            print(f"FAIL: sessione pulita {done11!r}")
            return 1
        if reused_clean:
            print(f"FAIL: una sessione pulita dice di aver riusato {reused_clean} token")
            return 1
        fresh.stdin.close()
        fresh.wait(timeout=60)
    finally:
        if fresh.poll() is None:
            fresh.kill()

    if turn2 != clean:
        print(f"FAIL: il riuso del prefisso cambia la risposta\n"
              f"  con slot riusato: {turn2!r}\n"
              f"  da sessione pulita: {clean!r}")
        return 1

    # --- Continue senza la corsa di spazi finale ---
    #
    # Il gateway rifiuta un turno da continuare che finisce con spazi (il
    # template li toglie), e il client li toglie prima di mandarlo: il
    # Continue arriva corto della corsa di spazi che il motore ha generato e
    # gia' in cache. Il motore tiene lo stato di prima di quella corsa e
    # riprende da li'.
    #
    # Serve una risposta con testo e poi almeno due token di soli spazi. Il
    # modello a pesi casuali non si sceglie, quindi si cerca un prompt che la
    # dia. Il budget ferma il turno prima di macinare il suo ultimo token, e
    # si prova due volte:
    # - fino al secondo spazio compreso: il primo e' macinato, quindi la cache
    #   ha un token piu' del Continue tagliato e si deve davvero riavvolgere;
    # - un token dopo: sono macinati tutti e due, come dopo un client che se
    #   ne va, e il secondo passa anche lui dal punto dove si scatta. Lo
    #   scatto deve restare quello del primo. Un motore che scattasse a ogni
    #   spazio riprenderebbe solo dal secondo, il Continue non combacerebbe e
    #   si rifarebbe il prefill: giusto ma lento, e nessun altro caso se ne
    #   accorgerebbe. (Tre spazi di fila la fixture non li da' in 400 prompt.)
    spaces = set(b" \t\n\r\x0b\x0c")
    scout = engine(binary, arguments.fixture)
    found = None
    try:
        handshake(scout)
        for attempt in range(400):
            candidate = f"gu{attempt}".encode()
            submit_bytes(scout, 100 + attempt, candidate, max_tokens=48)
            pieces = []
            while True:
                line = read_line(scout.stdout)
                if line.startswith("DATA "):
                    count = int(line.split()[2])
                    pieces.append(scout.stdout.read(count + 1)[:count])
                elif line.startswith("DONE ") or line.startswith("ERROR "):
                    break
            for k in range(1, len(pieces) - 1):
                head = pieces[:k + 2]
                if all(len(piece) == 1 for piece in head) \
                        and head[k - 1][0] not in spaces \
                        and head[k][0] in spaces and head[k + 1][0] in spaces:
                    found = (candidate, pieces[:k], k)
                    break
            if found:
                break
        scout.stdin.close()
        scout.wait(timeout=60)
    finally:
        if scout.poll() is None:
            scout.kill()
    if not found:
        print("FAIL: nessun prompt fra 400 da' testo seguito da due spazi; la "
              "fixture e' cambiata e il caso del riavvolgimento non si prova")
        return 1
    blank_prompt, kept, k = found
    trimmed = blank_prompt + b"".join(kept)
    for fed, first in ((1, 40), (2, 44)):
        rewound = engine(binary, arguments.fixture, {"GLM53_REWIND": "1"})
        try:
            handshake(rewound)
            submit_bytes(rewound, first, blank_prompt, max_tokens=k + fed + 1)
            _, done_run, _ = collect(rewound, first)
            submit_bytes(rewound, first + 1, trimmed, max_tokens=4)
            from_rewind, done_continue, _ = collect(rewound, first + 1)
            rewound.stdin.close()
            rewound.wait(timeout=60)
        finally:
            if rewound.poll() is None:
                rewound.kill()
        if not done_run.startswith(f"DONE {first} ") \
                or not done_continue.startswith(f"DONE {first + 1} "):
            print(f"FAIL: riavvolgimento -> {done_run!r} / {done_continue!r}")
            return 1
        expected = [str(len(trimmed)), str(len(trimmed)), str(len(blank_prompt) + k + fed),
                    str(len(trimmed)), "shorter"]
        if reuse_line(first + 1)[2:] != expected:
            print(f"FAIL: il Continue senza i {fed} spazi finali in cache doveva "
                  f"riprendere dai {len(trimmed)} token prima della corsa: "
                  f"{reuse_line(first + 1)!r}")
            return 1
        if from_rewind != fresh_answer(binary, arguments.fixture, trimmed, 4):
            print(f"FAIL: riavvolto di {fed} spazi, il Continue risponde "
                  f"{from_rewind!r} e un motore appena partito no")
            return 1
    # Lo stesso senza GLM53_REWIND, cioe' il default: niente scatto, prefill
    # da capo.
    unwound = engine(binary, arguments.fixture)
    try:
        handshake(unwound)
        submit_bytes(unwound, 42, blank_prompt, max_tokens=k + 2)
        collect(unwound, 42)
        submit_bytes(unwound, 43, trimmed, max_tokens=4)
        collect(unwound, 43)
        unwound.stdin.close()
        unwound.wait(timeout=60)
    finally:
        if unwound.poll() is None:
            unwound.kill()
    if reuse_line(43)[2] != "0":
        print(f"FAIL: senza GLM53_REWIND il Continue non doveva riusare: "
              f"{reuse_line(43)!r}")
        return 1

    # --- CANCEL durante il prefill ---
    #
    # Il CANCEL si guarda anche fra un pezzo di prefill e l'altro: prima un
    # client che se ne andava a meta' di un prompt lungo lasciava il motore a
    # macinarlo fino in fondo per nessuno. Il motore si ferma a un confine di
    # pezzo, risponde CANCELLED senza DATA, e tiene quello che ha fatto: un
    # nuovo tentativo dello stesso prompt ne e' un'estensione stretta e lo
    # riusa, con la stessa risposta di una sessione pulita.
    #
    # Deterministico, non una corsa: il turno 29 mette in cache i primi 10
    # token, e il CANCEL del turno 30 parte nella stessa scrittura del SUBMIT,
    # quindi la guardata prima del primo pezzo lo trova gia' li'.
    long_prompt = prompt + "abcdefghijklmnopqrstuvwxyz0123"
    chunked = {"GLM53_PREFILL_CHUNK": "1"}
    halted = engine(binary, arguments.fixture, chunked)
    try:
        handshake(halted)
        submit(halted, 29, long_prompt[:10], max_tokens=1)
        _, done29, _ = collect(halted, 29)
        if not done29.startswith("DONE 29 "):
            print(f"FAIL: turno che prepara la cache -> {done29!r}")
            return 1
        body = long_prompt.encode()
        halted.stdin.write(f"SUBMIT 30 0 {len(body)} 4 0.0 1.0\n".encode() + body
                           + b"\nCANCEL 30\n")
        halted.stdin.flush()
        prefill_data, done30, _ = collect(halted, 30)
        if done30 != "ERROR 30 CANCELLED" or prefill_data:
            print(f"FAIL: CANCEL durante il prefill -> {done30!r} con "
                  f"{len(prefill_data)} byte di DATA, atteso ERROR 30 CANCELLED "
                  f"senza DATA")
            return 1
        notes = open(NOTES, "r", errors="replace").read().splitlines()
        halted_line = [line.split() for line in notes if line.startswith("CANCEL 30 ")]
        if halted_line != [["CANCEL", "30", str(len(body)), "0", "10"]]:
            print(f"FAIL: CANCEL durante il prefill doveva fermarsi ai 10 token "
                  f"gia' in cache su {len(body)}: {halted_line!r}")
            return 1
        submit(halted, 31, long_prompt, max_tokens=4)
        retried, done31, _ = collect(halted, 31)
        if not done31.startswith("DONE 31 "):
            print(f"FAIL: nuovo tentativo dopo il CANCEL -> {done31!r}")
            return 1
        if reuse_line(31)[2:4] != ["10", str(len(body))] or reuse_line(31)[-1] != "extend":
            print(f"FAIL: il nuovo tentativo doveva riusare i 10 token del prefill "
                  f"interrotto: {reuse_line(31)!r}")
            return 1
        halted.stdin.close()
        halted.wait(timeout=60)
    finally:
        if halted.poll() is None:
            halted.kill()
    clean_engine = engine(binary, arguments.fixture, chunked)
    try:
        handshake(clean_engine)
        # Lo stesso CANCEL su uno slot vuoto: si ferma prima di macinare
        # qualsiasi cosa, e la storia che resta ha zero token. Il motore deve
        # rispondere CANCELLED e poi servire il turno dopo da freddo.
        clean_engine.stdin.write(f"SUBMIT 33 0 {len(body)} 4 0.0 1.0\n".encode()
                                 + body + b"\nCANCEL 33\n")
        clean_engine.stdin.flush()
        _, done33, _ = collect(clean_engine, 33)
        empty_line = [line.split() for line in
                      open(NOTES, "r", errors="replace").read().splitlines()
                      if line.startswith("CANCEL 33 ")]
        if done33 != "ERROR 33 CANCELLED" or \
                empty_line != [["CANCEL", "33", str(len(body)), "0", "0"]]:
            print(f"FAIL: CANCEL prima del primo pezzo su uno slot vuoto -> "
                  f"{done33!r}, {empty_line!r}")
            return 1
        submit(clean_engine, 32, long_prompt, max_tokens=4)
        from_clean, done32, _ = collect(clean_engine, 32)
        clean_engine.stdin.close()
        clean_engine.wait(timeout=60)
    finally:
        if clean_engine.poll() is None:
            clean_engine.kill()
    if reuse_line(32)[-1:] != ["cold"]:
        print(f"FAIL: dopo un CANCEL a zero token il turno doveva partire da "
              f"freddo: {reuse_line(32)!r}")
        return 1
    if not done32.startswith("DONE 32 ") or retried != from_clean:
        print(f"FAIL: dopo un prefill interrotto la risposta cambia\n"
              f"  riusando: {retried!r}\n  da pulito: {from_clean!r} ({done32!r})")
        return 1

    # La CLI stampa la risposta e poi un a capo; quello che conta e' che i byte
    # della risposta siano gli stessi.
    from_cli = cli_answer(binary, arguments.fixture, prompt, tokens)
    if served not in from_cli:
        print(f"FAIL: il server e la CLI non rispondono uguale\n"
              f"  server: {served!r}\n  CLI:    {from_cli!r}")
        return 1

    print(f"PASS GLM-5.3 serve: handshake, frame a byte contati, {emitted} token "
          f"decodificati identici alla CLI, prompt vuoto rifiutato, stream "
          f"ancora allineato dopo l'errore, {reused} token di prefisso riusati "
          f"al secondo turno con la stessa risposta di una sessione pulita, "
          f"CANCEL onorato a meta' turno dopo {emitted_before} token su {budget}, "
          f"STOP chiuso col DONE dopo {emitted_stop} token su {stop_budget}, "
          f"Continue senza gli spazi finali ripreso a {len(trimmed)} token, "
          f"CANCEL durante il prefill fermo a 10 token su {len(body)} e riusato "
          f"dal nuovo tentativo, "
          f"SUBMIT a slot occupato rifiutato con SLOT_BUSY, "
          f"{emitted_eof} token portati a termine con la pipa gia' chiusa")
    return 0


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