Upload 2 files

diffusion-gemma-http.cpp

README.md

@@ -0,0 +1,144 @@
+---
+license: mit
+language:
+- en
+- pt
+tags:
+- llama.cpp
+- gguf
+- text-diffusion
+- block-diffusion
+- diffusion-language-model
+- gemma
+- openai-api
+- server
+- cpu-inference
+- offline
+pipeline_tag: text-generation
+---
+
+<img src="https://huggingface.co/Brunobkr/REPO_NAME/resolve/main/capa.png" alt="ΩFFΣLLIα diffusion-gemma-http" width="100%"/>
+
+# ΩFFΣLLIα — diffusion-gemma-http
+
+**A native, single-file, OpenAI-compatible HTTP server for DiffusionGemma block text-diffusion models (GGUF / llama.cpp).**
+
+`diffusion-gemma-http.cpp` makes a block text-diffusion model behave like a regular `llama-server`: load the GGUF once, listen on a port, answer `/v1/chat/completions`. Everything — tokenization, chat template, the block-diffusion denoising loop, and the HTTP API — runs in a single C++ process on top of the llama.cpp diffusion fork. No Python, no external tokenizer files, no per-step IPC.
+
+Validated end-to-end on **CPU-only consumer hardware** (AMD Ryzen 5 5625U, 8 GB shared UMA, Kali Linux), serving a **DiffusionGemma 26B-A4B MoE (NVFP4 GGUF)** to a local chat UI over `:8080`.
+
+---
+
+## Why this exists
+
+Diffusion language models cannot be served by the standard `llama-server`: generation is not autoregressive token-by-token decoding, but iterative **denoising of a fixed-length canvas** (`[prompt | canvas]` bidirectional forwards, region-aware masks, self-conditioning). Until now the options were a raw logits server driven by an external Python loop, or a one-shot CLI. This tool closes the gap: a persistent HTTP server speaking the OpenAI Chat Completions protocol, with the entire diffusion decode loop in-process.
+
+## Features
+
+- **OpenAI-compatible API**: `POST /v1/chat/completions` (streaming via SSE and non-streaming), `GET /v1/models`, `GET /health`, `GET /`
+- **Native tokenization** from the GGUF vocabulary (control tokens parsed atomically; no tokenizer.json needed)
+- **Model chat template built in**: `<|turn>role\n … <turn|>` turns with `<|channel>thought … <channel|>` reasoning channels; thinking can be disabled per request (`"enable_thinking": false`, the default) by pre-filling an empty thought channel, or enabled globally with `--thinking`
+- **Entropy-bound block-diffusion sampler** (see below), with all parameters read from GGUF metadata
+- **Prompt-KV caching** (`DG_KVCACHE=1` / `--kvcache`): the prompt is prefilled once per block; each denoising step forwards only the canvas
+- **Self-conditioning** across denoising steps (previous-step logits fed back from step 2 onward)
+- **Multi-block generation**: when a block fills without an end-of-turn, it is appended to the prompt and a new canvas is denoised, until `max_tokens` or end of content
+- **Streaming per block** with correct `finish_reason` (`stop` vs `length`)
+- Memory-conscious: per-position statistics are computed in streaming passes over the logits — the probability matrix (`canvas × 262k vocab`) is never materialized
+
+## Requirements
+
+1. A **llama.cpp fork with the `diffusion-gemma` architecture** (the `DIFFUSION_GEMMA` model class providing `llama_diffusion_set_phase` / `llama_diffusion_set_sc`).
+2. A **DiffusionGemma GGUF** carrying the diffusion metadata:
+
+| GGUF key | Meaning |
+|---|---|
+| `diffusion.canvas_length` | Canvas size per block (required; the C++ graph splits `[prompt \| canvas]` on it) |
+| `diffusion.eb_max_steps` | Max denoising steps per block |
+| `diffusion.eb_t_min` / `diffusion.eb_t_max` | Temperature schedule (linear, `t_max → t_min`) |
+| `diffusion.eb_entropy_bound` | Per-position entropy bound for locking |
+| `diffusion.eb_stability_threshold` | Consecutive stable-argmax steps required to lock |
+| `diffusion.eb_confidence_threshold` | Reference-decoder parameter (read, reported, not used by this sampler — see Limitations) |
+
+3. The vendored headers already shipped with the llama.cpp tree: `vendor/cpp-httplib/httplib.h` (+ `httplib.cpp`) and `vendor/nlohmann/json.hpp`.
+
+## Build
+
+Place the file at `tools/diffusion-gemma-http/diffusion-gemma-http.cpp` inside the fork, then:
+
+```cmake
+# tools/diffusion-gemma-http/CMakeLists.txt
+set(TARGET llama-diffusion-gemma-http)
+add_executable(${TARGET}
+    diffusion-gemma-http.cpp
+    ${CMAKE_SOURCE_DIR}/vendor/cpp-httplib/httplib.cpp)
+target_include_directories(${TARGET} PRIVATE
+    ${CMAKE_SOURCE_DIR}/vendor/cpp-httplib
+    ${CMAKE_SOURCE_DIR}/vendor)
+target_link_libraries(${TARGET} PRIVATE llama Threads::Threads)
+target_compile_features(${TARGET} PRIVATE cxx_std_17)
+install(TARGETS ${TARGET} RUNTIME)
+```
+
+```bash
+echo 'add_subdirectory(diffusion-gemma-http)' >> tools/CMakeLists.txt
+cmake -B build
+cmake --build build --target llama-diffusion-gemma-http -j4
+```
+
+## Usage
+
+```bash
+DG_KVCACHE=1 ./build/bin/llama-diffusion-gemma-http \
+  -m model.gguf --port 8080 [--host 0.0.0.0] [-ngl N] [-c MAXTOK] [--thinking]
+```
+
+| Flag / env | Default | Description |
+|---|---|---|
+| `-m, --model` | — | GGUF path (positional also accepted) |
+| `--port` / `--host` | `8080` / `0.0.0.0` | Bind address |
+| `-c, --ctx` / `MAXTOK` | `2304` | Context budget = prompt + accumulated blocks. Non-causal forwards require the whole sequence in one ubatch, so the compute buffer scales with this — raise gradually on small-RAM machines |
+| `-ngl` / `NGL` | `0` | GPU layers |
+| `--kvcache` / `DG_KVCACHE=1` | off | Prompt-KV caching (strongly recommended on CPU) |
+| `--thinking` / `DG_THINKING=1` | off | Enable the reasoning channel by default |
+| `DG_MASK_ID` | auto (`<mask>`) | Override the canvas mask token id |
+| `FA=1` | off | Flash attention |
+
+### API
+
+```bash
+curl -s http://127.0.0.1:8080/v1/chat/completions -H 'Content-Type: application/json' -d '{
+  "messages": [{"role": "user", "content": "Explique em duas frases o que é um número primo."}],
+  "max_tokens": 200,
+  "stream": false
+}'
+```
+
+Any OpenAI-compatible client or front-end pointed at `http://host:8080` works unchanged. Per-request fields: `messages` (system merged into the first user turn), `max_tokens` / `max_completion_tokens`, `stream`, `enable_thinking`.
+
+## The sampler
+
+The decode loop implements an **entropy-bound block-diffusion sampler**:
+
+1. The canvas starts fully masked. Each step runs one bidirectional forward and computes, per position, the best **real** token (mask excluded), its confidence, and the entropy of the mask-excluded distribution — in streaming passes, without materializing probabilities.
+2. A position **locks** when its argmax has been stable for `stability_threshold` consecutive steps **and** its entropy is below `entropy_bound`.
+3. A prediction of `<mask>` never locks: it means "not ready yet / end of content". Positions still masked when the model proposes nothing new for 2 consecutive steps signal **end of content** (the model's native length control).
+4. Minimum progress per step is guaranteed by confidence ranking; **adjacent positions never lock in the same step**, and an **anti-echo guard** defers locking a token identical to an already-locked neighbor (legitimate repetition persists and passes; denoising echoes dissolve).
+5. Temperature follows a linear `t_max → t_min` schedule; self-conditioning on the previous step's logits is active from step 2.
+
+### Honest limitations
+
+- This sampler is a **validated approximation**, not a byte-exact port of the reference entropy-bound decoder: in particular, `diffusion.eb_confidence_threshold` is read and reported but plays no role in the locking rule, whose reference semantics differ from a naive confidence cutoff. Residual artifacts of parallel unmasking (rare token echoes) are mitigated by the guards above but not formally eliminated.
+- Single-flight inference: concurrent requests are serialized by a mutex.
+- Diffusion on CPU is compute-heavy: every denoising step is a dense forward over the canvas (plus the prompt without KV caching). Expect minutes, not seconds, for long answers on laptop-class CPUs.
+
+## Provenance
+
+Developed iteratively against a live DiffusionGemma 26B-A4B (MoE, 30 layers, 262k vocab, canvas 256, Harmony-style `<|turn>`/`<|channel>` template) quantized to NVFP4 GGUF, debugged end-to-end from raw logits to a working chat UI. Part of the **ΩFFΣLLIα** local-first, zero-telemetry tooling line.
+
+- Author: **Bruno Becker** — [huggingface.co/Brunobkr](https://huggingface.co/Brunobkr)
+- Research: [doi.org/10.5281/zenodo.20026837](https://doi.org/10.5281/zenodo.20026837)
+- Built on [llama.cpp](https://github.com/ggml-org/llama.cpp) (MIT) with a diffusion-gemma architecture fork; HTTP via [cpp-httplib](https://github.com/yhirose/cpp-httplib), JSON via [nlohmann/json](https://github.com/nlohmann/json).
+
+## License
+
+MIT, following the llama.cpp ecosystem it extends.

diffusion-gemma-http.cpp

@@ -0,0 +1,541 @@
+// diffusion-gemma-http.cpp — servidor HTTP OpenAI-compativel nativo para DiffusionGemma.
+// Substitui a ponte Python: tokenizacao (vocab do GGUF), template <|turn>/<|channel>,
+// loop block-diffusion entropy-bound e API /v1/chat/completions, tudo em C++ no mesmo processo.
+//
+// Endpoints: GET /health, GET /v1/models, POST /v1/chat/completions (stream e nao-stream).
+//
+// Uso:
+//   llama-diffusion-gemma-http -m model.gguf [--port 8080] [--host 0.0.0.0] [-ngl N] [-c MAXTOK]
+//   env: DG_KVCACHE=1 (prompt-KV cache), DG_THINKING=1, DG_MASK_ID, MAXTOK, NGL, FA
+//
+// Sampler (mesma semantica validada na ponte dg-bridge.py):
+//   - predicao de <mask> nunca trava (posicao fica aberta); mask remanescente = fim de conteudo
+//   - trava: argmax estavel >= stability E entropia (dist. sem mask) <= entropy_bound
+//   - progresso minimo por confianca; sem travar posicoes adjacentes no mesmo passo
+//   - schedule t_max -> t_min em max_steps; self-conditioning a partir do passo 2
+//   - parametros lidos dos metadados do GGUF (diffusion.canvas_length, diffusion.eb_*)
+
+#include "llama.h"
+#include "httplib.h"
+#include <nlohmann/json.hpp>
+
+#include <algorithm>
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <functional>
+#include <mutex>
+#include <string>
+#include <vector>
+
+using json = nlohmann::json;
+
+// ------------------------------------------------------------------ estado global
+struct EBParams {
+    int   max_steps     = 48;
+    float t_min         = 0.4f;
+    float t_max         = 0.8f;
+    float entropy_bound = 0.1f;
+    int   stability     = 1;
+    float confidence    = 0.005f; // lido do GGUF; semantica do decoder de referencia (nao usado no lock)
+};
+
+struct DG {
+    llama_model        * model = nullptr;
+    llama_context      * ctx   = nullptr;
+    const llama_vocab  * vocab = nullptr;
+    llama_batch          batch{};
+    std::string          model_name;
+
+    int  n_vocab = 0;
+    int  maxtok  = 2304;
+    int  canvas  = 0;
+    bool kvcache = false;
+    bool thinking_default = false;
+    EBParams eb;
+
+    llama_token id_mask = -1, id_turn_close = -1, id_channel_close = -1, id_eos = -1, id_bos = -1;
+
+    // estado do forward (single-flight; protegido por mtx)
+    std::vector<float>       sc_cache;   // logits do passo anterior (self-conditioning)
+    float                    prev_temp = 1.0f;
+    std::vector<llama_token> cur_prompt; // prompt atualmente no K,V store (DG_KVCACHE)
+    std::vector<float>       logits;     // scratch [C, n_vocab] do passo corrente
+
+    std::mutex mtx;
+};
+static DG G;
+
+// ------------------------------------------------------------------ helpers
+static bool meta_str(const char * key, std::string & out) {
+    char buf[512];
+    const int n = llama_model_meta_val_str(G.model, key, buf, sizeof(buf));
+    if (n < 0) return false;
+    out.assign(buf);
+    return true;
+}
+static bool meta_f(const char * key, float & v) { std::string s; if (!meta_str(key, s)) return false; v = strtof(s.c_str(), nullptr); return true; }
+static bool meta_i(const char * key, int   & v) { std::string s; if (!meta_str(key, s)) return false; v = (int) strtol(s.c_str(), nullptr, 10); return true; }
+
+static std::vector<llama_token> tokenize(const std::string & text, bool parse_special) {
+    int n = -llama_tokenize(G.vocab, text.c_str(), (int) text.size(), nullptr, 0, false, parse_special);
+    std::vector<llama_token> ids(std::max(n, 0));
+    if (n > 0) {
+        llama_tokenize(G.vocab, text.c_str(), (int) text.size(), ids.data(), n, false, parse_special);
+    }
+    return ids;
+}
+
+static std::string detok(const std::vector<llama_token> & ids, bool remove_special) {
+    if (ids.empty()) return "";
+    std::string out(ids.size() * 8 + 32, '\0');
+    int n = llama_detokenize(G.vocab, ids.data(), (int) ids.size(), out.data(), (int) out.size(),
+                             remove_special, /*unparse_special=*/false);
+    if (n < 0) {
+        out.resize(-n);
+        n = llama_detokenize(G.vocab, ids.data(), (int) ids.size(), out.data(), (int) out.size(),
+                             remove_special, false);
+    }
+    out.resize(std::max(n, 0));
+    return out;
+}
+
+static llama_token token_id(const char * s) {
+    auto ids = tokenize(s, /*parse_special=*/true);
+    return ids.size() == 1 ? ids[0] : -1;
+}
+
+static std::string trim(std::string s) {
+    const char * ws = " \t\r\n";
+    const auto a = s.find_first_not_of(ws);
+    if (a == std::string::npos) return "";
+    const auto b = s.find_last_not_of(ws);
+    return s.substr(a, b - a + 1);
+}
+
+// ------------------------------------------------------------------ forward [prompt | canvas]
+// Preenche G.logits [C, n_vocab] e atualiza o cache de self-conditioning. UNIFIED por padrao;
+// com DG_KVCACHE=1, PREFILL do prompt uma vez por bloco e DECODE so do canvas por passo.
+static bool dg_forward(const std::vector<llama_token> & prompt,
+                       const std::vector<llama_token> & canvas, bool use_sc, float temp) {
+    const int P = (int) prompt.size();
+    const int C = (int) canvas.size();
+    const int N = P + C;
+    if (N <= 0 || N > G.maxtok) return false;
+
+    if ((int) G.sc_cache.size() != C * G.n_vocab) G.sc_cache.assign((size_t) C * G.n_vocab, 0.0f);
+    if ((int) G.logits.size()   != C * G.n_vocab) G.logits.assign((size_t) C * G.n_vocab, 0.0f);
+
+    int row_base = P;
+    const bool use_kv = G.kvcache && P > 0;
+
+    if (!use_kv) {
+        llama_diffusion_set_phase(G.model, /*PKV_UNIFIED=*/0, 0);
+        G.batch.n_tokens = N;
+        for (int i = 0; i < N; ++i) {
+            G.batch.token[i]     = (i < P) ? prompt[i] : canvas[i - P];
+            G.batch.pos[i]       = i;
+            G.batch.n_seq_id[i]  = 1;
+            G.batch.seq_id[i][0] = 0;
+            G.batch.logits[i]    = (i >= P);
+        }
+        llama_diffusion_set_sc(G.model, G.sc_cache.data(), use_sc ? 1.0f : 0.0f,
+                               use_sc ? 1.0f / G.prev_temp : 1.0f, true);
+        if (llama_decode(G.ctx, G.batch) != 0) return false;
+        row_base = P;
+    } else {
+        bool new_block = ((int) G.cur_prompt.size() != P);
+        for (int i = 0; !new_block && i < P; ++i) new_block = (G.cur_prompt[i] != prompt[i]);
+        if (new_block) {
+            llama_diffusion_set_phase(G.model, /*PKV_PREFILL=*/1, P);
+            llama_diffusion_set_sc(G.model, G.sc_cache.data(), 0.0f, 1.0f, false);
+            G.batch.n_tokens = P;
+            for (int i = 0; i < P; ++i) {
+                G.batch.token[i]     = prompt[i];
+                G.batch.pos[i]       = i;
+                G.batch.n_seq_id[i]  = 1;
+                G.batch.seq_id[i][0] = 0;
+                G.batch.logits[i]    = (i == P - 1);
+            }
+            if (llama_decode(G.ctx, G.batch) != 0) { G.cur_prompt.clear(); return false; }
+            G.cur_prompt = prompt;
+        }
+        llama_diffusion_set_phase(G.model, /*PKV_DECODE=*/2, P);
+        llama_diffusion_set_sc(G.model, G.sc_cache.data(), use_sc ? 1.0f : 0.0f,
+                               use_sc ? 1.0f / G.prev_temp : 1.0f, true);
+        G.batch.n_tokens = C;
+        for (int i = 0; i < C; ++i) {
+            G.batch.token[i]     = canvas[i];
+            G.batch.pos[i]       = P + i;
+            G.batch.n_seq_id[i]  = 1;
+            G.batch.seq_id[i][0] = 0;
+            G.batch.logits[i]    = 1;
+        }
+        if (llama_decode(G.ctx, G.batch) != 0) return false;
+        row_base = 0;
+    }
+
+    for (int j = 0; j < C; ++j) {
+        const float * row = llama_get_logits_ith(G.ctx, row_base + j);
+        if (!row) return false;
+        memcpy(&G.logits[(size_t) j * G.n_vocab],   row, (size_t) G.n_vocab * sizeof(float));
+        memcpy(&G.sc_cache[(size_t) j * G.n_vocab], row, (size_t) G.n_vocab * sizeof(float));
+    }
+    G.prev_temp = temp;
+    return true;
+}
+
+// ------------------------------------------------------------------ denoise de um bloco
+static std::vector<llama_token> denoise_block(const std::vector<llama_token> & prompt) {
+    const int C = G.canvas;
+    const int V = G.n_vocab;
+    std::vector<llama_token> canvas(C, G.id_mask);
+    std::vector<uint8_t>     masked(C, 1);
+    std::vector<int>         stable(C, 0);
+    std::vector<llama_token> last(C, -1);
+    std::vector<llama_token> arg(C);
+    std::vector<float>       conf(C), ent(C);
+    std::vector<uint8_t>     pm(C);  // prefers_mask
+    int mask_stall = 0;
+    const int steps = G.eb.max_steps;
+
+    for (int step = 0; step < steps; ++step) {
+        const float t = G.eb.t_max + (G.eb.t_min - G.eb.t_max) * (float) step / (float) std::max(1, steps - 1);
+        if (!dg_forward(prompt, canvas, step > 0, t)) break;
+        const float s = 1.0f / std::max(t, 1e-4f);
+
+        // estatisticas por posicao em duas passadas, sem materializar a matriz de probs
+        for (int j = 0; j < C; ++j) {
+            const float * l = &G.logits[(size_t) j * V];
+            float m = -INFINITY; int amax = -1;
+            for (int v = 0; v < V; ++v) { const float x = s * l[v]; if (x > m) { m = x; amax = v; } }
+            double Z = 0.0, S1 = 0.0, zm = 0.0, s1m = 0.0;
+            float bx = -INFINITY; int bi = -1;
+            for (int v = 0; v < V; ++v) {
+                const float  x = s * l[v] - m;
+                const double e = exp((double) x);
+                Z += e; S1 += (double) x * e;
+                if (v == G.id_mask) { zm = e; s1m = (double) x * e; }
+                else if (x > bx)    { bx = x; bi = v; }
+            }
+            const double Zx  = std::max(Z - zm, 1e-300);
+            const double S1x = S1 - s1m;
+            pm[j]   = (amax == G.id_mask);                 // "deixa para depois / fim de conteudo"
+            arg[j]  = bi;                                  // melhor token real (mask excluido)
+            conf[j] = (float) (exp((double) bx) / Zx);
+            ent[j]  = (float) (log(Zx) - S1x / Zx);
+        }
+
+        for (int j = 0; j < C; ++j) {
+            stable[j] = (arg[j] == last[j]) ? stable[j] + 1 : 0;
+            last[j]   = arg[j];
+        }
+
+        bool any_locked = false;
+        for (int j = 0; j < C; ++j) if (!masked[j]) { any_locked = true; break; }
+        std::vector<int> cand;
+        for (int j = 0; j < C; ++j) if (masked[j] && !pm[j]) cand.push_back(j);
+        if (cand.empty()) {
+            if (!any_locked) {
+                for (int j = 0; j < C; ++j) if (masked[j]) cand.push_back(j); // passo frio: forca o inicio
+            } else {
+                if (++mask_stall >= 2) break;   // persistiu por 2 passos com conteudo: fim
+                continue;                       // mais um passo; contexto novo pode destravar
+            }
+        } else {
+            mask_stall = 0;
+        }
+
+        std::vector<uint8_t> lock(C, 0);
+        int nlock = 0;
+        for (int j : cand) {
+            if (ent[j] <= G.eb.entropy_bound && stable[j] >= G.eb.stability) { lock[j] = 1; ++nlock; }
+        }
+        const int need = (int) std::ceil((double) cand.size() / (double) std::max(1, steps - step));
+        if (nlock < need) {
+            std::vector<int> byconf = cand;
+            std::sort(byconf.begin(), byconf.end(), [&](int a, int b) { return conf[a] > conf[b]; });
+            for (int j : byconf) {
+                if (nlock >= need) break;
+                if (!lock[j]) { lock[j] = 1; ++nlock; }
+            }
+        }
+        // nao trava adjacentes no mesmo passo (evita duplicacao); mantem as de maior confianca
+        if (nlock > 1) {
+            std::vector<int> locked;
+            for (int j = 0; j < C; ++j) if (lock[j]) locked.push_back(j);
+            std::sort(locked.begin(), locked.end(), [&](int a, int b) { return conf[a] > conf[b]; });
+            std::vector<uint8_t> keep(C, 0);
+            for (int j : locked) {
+                if ((j > 0 && keep[j - 1]) || (j + 1 < C && keep[j + 1])) continue;
+                keep[j] = 1;
+            }
+            lock.swap(keep);
+        }
+
+        bool all_done = true;
+        for (int j = 0; j < C; ++j) {
+            if (lock[j]) { canvas[j] = arg[j]; masked[j] = 0; }
+            else if (masked[j]) canvas[j] = G.id_mask;
+            if (masked[j]) all_done = false;
+        }
+        if (all_done) break;
+    }
+    return canvas; // posicoes ainda em mask = fim de conteudo
+}
+
+// ------------------------------------------------------------------ geracao multi-bloco
+struct GenResult { std::vector<llama_token> ids; bool stopped = false; };
+
+static GenResult dg_generate(std::vector<llama_token> cur, int max_new,
+                             const std::function<void(const std::vector<llama_token> &, bool)> & on_block) {
+    GenResult r;
+    int produced = 0;
+    while (produced < max_new) {
+        if ((int) cur.size() + G.canvas > G.maxtok) { r.stopped = true; break; }
+        auto block = denoise_block(cur);
+        int cut = -1;
+        for (int i = 0; i < (int) block.size(); ++i) {
+            const llama_token t = block[i];
+            if (t == G.id_turn_close || t == G.id_eos || t == G.id_mask) { cut = i; break; }
+        }
+        if (cut >= 0) {
+            r.ids.insert(r.ids.end(), block.begin(), block.begin() + cut);
+            r.stopped = true;
+            on_block(r.ids, true);
+            break;
+        }
+        const int keep = std::min((int) block.size(), max_new - produced);
+        r.ids.insert(r.ids.end(), block.begin(), block.begin() + keep);
+        produced += keep;
+        cur.insert(cur.end(), block.begin(), block.end());
+        on_block(r.ids, produced >= max_new);
+    }
+    return r;
+}
+
+// resposta final = ids depois do ultimo <channel|>, cortados no primeiro stop; specials removidos no detok
+static std::string extract_text(const std::vector<llama_token> & ids) {
+    size_t start = 0;
+    for (size_t i = 0; i < ids.size(); ++i) if (ids[i] == G.id_channel_close) start = i + 1;
+    std::vector<llama_token> body;
+    for (size_t i = start; i < ids.size(); ++i) {
+        const llama_token t = ids[i];
+        if (t == G.id_turn_close || t == G.id_eos || t == G.id_mask) break;
+        body.push_back(t);
+    }
+    return trim(detok(body, /*remove_special=*/true));
+}
+
+// ------------------------------------------------------------------ template de chat
+static std::string build_prompt(const json & messages, bool thinking) {
+    std::string out, sysbuf;
+    for (const auto & m : messages) {
+        const std::string role = m.value("role", "user");
+        std::string content;
+        if (m.contains("content")) {
+            if (m["content"].is_string()) content = m["content"].get<std::string>();
+            else if (m["content"].is_array()) {
+                for (const auto & p : m["content"]) {
+                    if (p.value("type", "") == "text") content += p.value("text", "");
+                }
+            }
+        }
+        if (role == "system") {
+            if (!sysbuf.empty()) sysbuf += "\n";
+            sysbuf += content;
+            continue;
+        }
+        const std::string r = (role == "assistant") ? "model" : "user";
+        if (!sysbuf.empty() && r == "user") { content = sysbuf + "\n\n" + content; sysbuf.clear(); }
+        out += "<|turn>" + r + "\n" + trim(content) + "<turn|>\n";
+    }
+    out += "<|turn>model\n";
+    if (!thinking) out += "<|channel>thought\n<channel|>";  // enable_thinking=false do chat_template
+    return out;
+}
+
+static std::vector<llama_token> prompt_ids_for(const json & messages, bool thinking) {
+    auto ids = tokenize(build_prompt(messages, thinking), /*parse_special=*/true);
+    ids.insert(ids.begin(), G.id_bos);
+    if ((int) ids.size() + G.canvas > G.maxtok) {  // mantem o fim do prompt (trim pela esquerda)
+        ids.erase(ids.begin(), ids.end() - (G.maxtok - G.canvas));
+    }
+    return ids;
+}
+
+// ------------------------------------------------------------------ HTTP
+static json chunk_json(const std::string & rid, long created, const json & delta, const json & finish) {
+    return json{{"id", rid}, {"object", "chat.completion.chunk"}, {"created", created},
+                {"model", G.model_name},
+                {"choices", json::array({json{{"index", 0}, {"delta", delta}, {"finish_reason", finish}}})}};
+}
+
+int main(int argc, char ** argv) {
+    std::string model_path, host = "0.0.0.0";
+    int port = 8080;
+    int ngl  = atoi(getenv("NGL") ? getenv("NGL") : "0");
+    G.maxtok = atoi(getenv("MAXTOK") ? getenv("MAXTOK") : "2304");
+    G.kvcache = getenv("DG_KVCACHE") && atoi(getenv("DG_KVCACHE"));
+    G.thinking_default = getenv("DG_THINKING") && atoi(getenv("DG_THINKING"));
+
+    for (int i = 1; i < argc; ++i) {
+        const std::string a = argv[i];
+        if ((a == "-m" || a == "--model") && i + 1 < argc)      model_path = argv[++i];
+        else if (a == "--port" && i + 1 < argc)                 port = atoi(argv[++i]);
+        else if (a == "--host" && i + 1 < argc)                 host = argv[++i];
+        else if ((a == "-ngl" || a == "--gpu-layers") && i + 1 < argc) ngl = atoi(argv[++i]);
+        else if ((a == "-c" || a == "--ctx") && i + 1 < argc)   G.maxtok = atoi(argv[++i]);
+        else if (a == "--kvcache")                              G.kvcache = true;
+        else if (a == "--thinking")                             G.thinking_default = true;
+        else if (a[0] != '-' && model_path.empty())             model_path = a;  // posicional
+    }
+    if (model_path.empty()) {
+        fprintf(stderr, "usage: %s -m <model.gguf> [--port 8080] [--host 0.0.0.0] [-ngl N] [-c MAXTOK] [--kvcache] [--thinking]\n", argv[0]);
+        return 1;
+    }
+
+    llama_backend_init();
+    llama_model_params mparams = llama_model_default_params();
+    mparams.n_gpu_layers = ngl;
+    G.model = llama_model_load_from_file(model_path.c_str(), mparams);
+    if (!G.model) { fprintf(stderr, "failed to load model\n"); return 1; }
+    G.vocab   = llama_model_get_vocab(G.model);
+    G.n_vocab = llama_vocab_n_tokens(G.vocab);
+    { const auto p = model_path.find_last_of("/\\");
+      G.model_name = model_path.substr(p == std::string::npos ? 0 : p + 1);
+      const auto d = G.model_name.rfind(".gguf");
+      if (d != std::string::npos) G.model_name.resize(d); }
+
+    // metadados de diffusion
+    if (!meta_i("diffusion.canvas_length", G.canvas) || G.canvas <= 0) {
+        fprintf(stderr, "GGUF sem diffusion.canvas_length valido\n"); return 1;
+    }
+    meta_i("diffusion.eb_max_steps",            G.eb.max_steps);
+    meta_f("diffusion.eb_t_min",                G.eb.t_min);
+    meta_f("diffusion.eb_t_max",                G.eb.t_max);
+    meta_f("diffusion.eb_entropy_bound",        G.eb.entropy_bound);
+    meta_i("diffusion.eb_stability_threshold",  G.eb.stability);
+    meta_f("diffusion.eb_confidence_threshold", G.eb.confidence);
+
+    llama_context_params cparams = llama_context_default_params();
+    cparams.n_ctx    = G.maxtok;
+    cparams.n_batch  = G.maxtok;
+    cparams.n_ubatch = G.maxtok;   // non-causal: sequencia inteira em um ubatch
+    cparams.no_perf  = true;
+    cparams.flash_attn_type = getenv("FA") && atoi(getenv("FA"))
+                                ? LLAMA_FLASH_ATTN_TYPE_ENABLED : LLAMA_FLASH_ATTN_TYPE_DISABLED;
+    G.ctx = llama_init_from_model(G.model, cparams);
+    if (!G.ctx) { fprintf(stderr, "failed to create context\n"); return 1; }
+    llama_set_causal_attn(G.ctx, false);
+    G.batch = llama_batch_init(G.maxtok, 0, 1);
+
+    // ids de controle
+    G.id_bos           = llama_vocab_bos(G.vocab);
+    G.id_eos           = llama_vocab_eos(G.vocab);
+    G.id_turn_close    = token_id("<turn|>");
+    G.id_channel_close = token_id("<channel|>");
+    G.id_mask          = getenv("DG_MASK_ID") ? atoi(getenv("DG_MASK_ID")) : token_id("<mask>");
+    if (G.id_mask < 0 || G.id_turn_close < 0) {
+        fprintf(stderr, "tokens de controle ausentes: mask=%d turn_close=%d (defina DG_MASK_ID se preciso)\n",
+                G.id_mask, G.id_turn_close);
+        return 1;
+    }
+
+    fprintf(stderr, "diffusion-gemma-http: n_vocab=%d canvas=%d maxtok=%d kvcache=%d "
+                    "eb{steps=%d t=[%.2f,%.2f] ent=%.3f stab=%d conf=%.4f} mask=%d turn|=%d channel|=%d\n",
+            G.n_vocab, G.canvas, G.maxtok, (int) G.kvcache,
+            G.eb.max_steps, G.eb.t_min, G.eb.t_max, G.eb.entropy_bound, G.eb.stability, G.eb.confidence,
+            G.id_mask, G.id_turn_close, G.id_channel_close);
+
+    httplib::Server svr;
+
+    svr.Get("/", [](const httplib::Request &, httplib::Response & res) {
+        json j = {{"server", "diffusion-gemma-http"}, {"model", G.model_name},
+                  {"endpoints", json::array({"/health", "/v1/models", "/v1/chat/completions (POST)"})}};
+        res.set_content(j.dump(), "application/json");
+    });
+
+    svr.Get("/health", [](const httplib::Request &, httplib::Response & res) {
+        res.set_content("{\"status\":\"ok\"}", "application/json");
+    });
+
+    svr.Get("/v1/models", [](const httplib::Request &, httplib::Response & res) {
+        json j = {{"object", "list"},
+                  {"data", json::array({json{{"id", G.model_name}, {"object", "model"}, {"owned_by", "local"}}})}};
+        res.set_content(j.dump(), "application/json");
+    });
+
+    svr.Post("/v1/chat/completions", [](const httplib::Request & req, httplib::Response & res) {
+        json body = json::parse(req.body, nullptr, false);
+        if (body.is_discarded() || !body.contains("messages")) {
+            res.status = 400;
+            res.set_content("{\"error\":\"json invalido ou sem messages\"}", "application/json");
+            return;
+        }
+        int max_new = 0;
+        if (body.contains("max_tokens") && body["max_tokens"].is_number())            max_new = body["max_tokens"];
+        else if (body.contains("max_completion_tokens") && body["max_completion_tokens"].is_number())
+                                                                                       max_new = body["max_completion_tokens"];
+        if (max_new <= 0) max_new = 512;
+        const bool stream   = body.value("stream", false);
+        const bool thinking = body.value("enable_thinking", G.thinking_default);
+
+        const auto p_ids = prompt_ids_for(body["messages"], thinking);
+        char ridbuf[40]; snprintf(ridbuf, sizeof(ridbuf), "chatcmpl-%08x%08x", rand(), rand());
+        const std::string rid = ridbuf;
+        const long created = (long) time(nullptr);
+
+        if (!stream) {
+            std::lock_guard<std::mutex> lk(G.mtx);
+            auto r = dg_generate(p_ids, max_new, [](const std::vector<llama_token> &, bool) {});
+            const std::string text = extract_text(r.ids);
+            json j = {{"id", rid}, {"object", "chat.completion"}, {"created", created},
+                      {"model", G.model_name},
+                      {"choices", json::array({json{
+                          {"index", 0},
+                          {"message", json{{"role", "assistant"}, {"content", text}}},
+                          {"finish_reason", r.stopped ? "stop" : "length"}}})},
+                      {"usage", json{{"prompt_tokens", (int) p_ids.size()},
+                                     {"completion_tokens", (int) r.ids.size()},
+                                     {"total_tokens", (int) (p_ids.size() + r.ids.size())}}}};
+            res.set_content(j.dump(), "application/json");
+            return;
+        }
+
+        res.set_chunked_content_provider("text/event-stream",
+            [p_ids, max_new, rid, created](size_t, httplib::DataSink & sink) -> bool {
+                std::lock_guard<std::mutex> lk(G.mtx);
+                auto send = [&](const json & j) {
+                    const std::string s = "data: " + j.dump() + "\n\n";
+                    sink.write(s.data(), s.size());
+                };
+                send(chunk_json(rid, created, json{{"role", "assistant"}, {"content", ""}}, nullptr));
+                std::string sent;
+                auto r = dg_generate(p_ids, max_new,
+                    [&](const std::vector<llama_token> & acc, bool) {
+                        const std::string full = extract_text(acc);
+                        if (full.size() > sent.size()) {
+                            send(chunk_json(rid, created, json{{"content", full.substr(sent.size())}}, nullptr));
+                            sent = full;
+                        }
+                    });
+                send(chunk_json(rid, created, json::object(), r.stopped ? "stop" : "length"));
+                const std::string done = "data: [DONE]\n\n";
+                sink.write(done.data(), done.size());
+                sink.done();
+                return true;
+            });
+    });
+
+    fprintf(stderr, "diffusion-gemma-http escutando em http://%s:%d\n", host.c_str(), port);
+    printf("READY %d\n", G.n_vocab); fflush(stdout);
+    svr.listen(host, port);
+
+    llama_batch_free(G.batch);
+    llama_free(G.ctx);
+    llama_model_free(G.model);
+    llama_backend_free();
+    return 0;
+}