mlx-bun 0.0.11 → 0.0.13

package/src/anthropic.ts

@@ -469,58 +469,68 @@ export function translateOpenAiSse(
   const dec = new TextDecoder();
   let buf = "";
   let finalized = false;
+  let reader: ReadableStreamDefaultReader<Uint8Array> | null = null;
+  let cancelled = false;
   return new ReadableStream<Uint8Array>({
-    async start(controller) {
+    start(controller) {
       const emit = (frames: string[]) => {
         for (const f of frames) controller.enqueue(enc.encode(f));
       };
-      const reader = upstream.getReader();
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          buf += dec.decode(value, { stream: true });
-          let sep: number;
-          while ((sep = buf.indexOf("\n\n")) !== -1) {
-            const frame = buf.slice(0, sep);
-            buf = buf.slice(sep + 2);
-            const data = frame
-              .split("\n")
-              .find((l) => l.startsWith("data: "))
-              ?.slice(6);
-            if (data == null) continue;
-            if (data === "[DONE]" || data === '"[DONE]"') {
-              if (!finalized) {
-                finalized = true;
-                emit(translator.finalize());
+      reader = upstream.getReader();
+      void (async () => {
+        try {
+          while (!cancelled) {
+            const { done, value } = await reader!.read();
+            if (done) break;
+            buf += dec.decode(value, { stream: true });
+            let sep: number;
+            while ((sep = buf.indexOf("\n\n")) !== -1) {
+              const frame = buf.slice(0, sep);
+              buf = buf.slice(sep + 2);
+              const data = frame
+                .split("\n")
+                .find((l) => l.startsWith("data: "))
+                ?.slice(6);
+              if (data == null) continue;
+              if (data === "[DONE]" || data === '"[DONE]"') {
+                if (!finalized) {
+                  finalized = true;
+                  emit(translator.finalize());
+                }
+                continue;
               }
-              continue;
-            }
-            const parsed = JSON.parse(data);
-            if (parsed?.error) {
-              emit([
-                sse("error", {
-                  type: "error",
-                  error: { type: "api_error", message: parsed.error.message ?? "generation failed" },
-                }),
-              ]);
-              continue;
+              const parsed = JSON.parse(data);
+              if (parsed?.error) {
+                emit([
+                  sse("error", {
+                    type: "error",
+                    error: { type: "api_error", message: parsed.error.message ?? "generation failed" },
+                  }),
+                ]);
+                continue;
+              }
+              emit(translator.addChunk(parsed));
             }
-            emit(translator.addChunk(parsed));
           }
+          if (!cancelled && !finalized) emit(translator.finalize());
+        } catch (e) {
+          if (!cancelled)
+            emit([
+              sse("error", {
+                type: "error",
+                error: { type: "api_error", message: (e as Error).message },
+              }),
+            ]);
+        } finally {
+          reader?.releaseLock();
+          reader = null;
+          if (!cancelled) controller.close();
         }
-        if (!finalized) emit(translator.finalize());
-      } catch (e) {
-        emit([
-          sse("error", {
-            type: "error",
-            error: { type: "api_error", message: (e as Error).message },
-          }),
-        ]);
-      } finally {
-        reader.releaseLock();
-        controller.close();
-      }
+      })();
+    },
+    async cancel(reason) {
+      cancelled = true;
+      await reader?.cancel(reason);
     },
   });
 }

package/src/chat-template.ts

@@ -40,6 +40,134 @@ export interface RenderOptions {
   addGenerationPrompt?: boolean;
   tools?: ToolDefinition[] | null;
   enableThinking?: boolean;
+  /** Template-level reasoning depth (Qwen3.8: xhigh|medium|low — the template
+   *  RAISES on other values, so callers must map OpenAI levels first and only
+   *  set this for templates that read it; see ChatTemplate.readsReasoningEffort). */
+  reasoningEffort?: "xhigh" | "medium" | "low";
+  /** Keep think blocks from historical assistant turns in the rendered prompt
+   *  (Qwen3.8 `preserve_thinking`, template default true — better prompt-cache
+   *  reuse and agent-trace continuity). Only passed when the template reads it. */
+  preserveThinking?: boolean;
+}
+
+type ChatRenderer = (
+  messages: ChatMessage[],
+  options: RenderOptions,
+) => string;
+
+function glm52ContentText(content: ChatMessage["content"], label: string): string {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content))
+    throw new Error(`${label} must be a string or an array of text parts`);
+  return content.map((part, index) => {
+    if (
+      !part ||
+      (part.type !== "text" && part.type !== "input_text") ||
+      typeof part.text !== "string"
+    ) {
+      throw new Error(`${label}.${index}: GLM-5.2 supports text content only`);
+    }
+    return part.text;
+  }).join("");
+}
+
+/** Text/tool subset of the pinned GLM-5.2 template used by Colibri. */
+export function renderGlm52Chat(
+  messages: ChatMessage[],
+  options: RenderOptions = {},
+): string {
+  if (!Array.isArray(messages) || messages.length === 0)
+    throw new Error("GLM-5.2 messages must be a non-empty array");
+  const {
+    addGenerationPrompt = true,
+    tools = null,
+    enableThinking = false,
+  } = options;
+  const prompt = ["[gMASK]<sop>"];
+  if (enableThinking)
+    prompt.push("<|system|>Reasoning Effort: Max");
+
+  const normalizedTools = normalizeToolSchemas(tools);
+  if (normalizedTools && normalizedTools.length > 0) {
+    prompt.push(
+      "<|system|>\n# Tools\n\nYou may call one or more functions to assist with the " +
+      "user query.\n\nYou are provided with function signatures within <tools></tools> " +
+      "XML tags:\n<tools>\n",
+    );
+    for (const tool of normalizedTools) {
+      const fn = { ...tool.function } as Record<string, unknown>;
+      delete fn.defer_loading;
+      delete fn.strict;
+      prompt.push(`${JSON.stringify(fn)}\n`);
+    }
+    prompt.push(
+      "</tools>\n\nFor each function call, output the function name and arguments " +
+      "within the following XML format:\n<tool_call>{function-name}" +
+      "<arg_key>{arg-key-1}</arg_key><arg_value>{arg-value-1}</arg_value>" +
+      "<arg_key>{arg-key-2}</arg_key><arg_value>{arg-value-2}</arg_value>...</tool_call>",
+    );
+  }
+
+  let previousWasTool = false;
+  for (let index = 0; index < messages.length; index++) {
+    const message = messages[index]!;
+    const role = message.role;
+    if (role === "system" || role === "developer") {
+      prompt.push(
+        `<|system|>${glm52ContentText(message.content, `messages.${index}.content`)}`,
+      );
+    } else if (role === "user") {
+      prompt.push(
+        `<|user|>${glm52ContentText(message.content, `messages.${index}.content`)}`,
+      );
+    } else if (role === "assistant") {
+      const content = message.content === null || message.content === undefined
+        ? ""
+        : glm52ContentText(message.content, `messages.${index}.content`);
+      prompt.push(`<|assistant|><think></think>${content.trim()}`);
+      for (const call of message.tool_calls ?? []) {
+        const raw = call.function.arguments;
+        let args: Record<string, unknown> = {};
+        if (typeof raw === "string") {
+          try {
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+              args = parsed as Record<string, unknown>;
+          } catch {
+            // Match the pinned template path: malformed historical arguments
+            // contribute an empty call body rather than changing the prompt.
+          }
+        } else {
+          args = raw;
+        }
+        prompt.push(`<tool_call>${call.function.name}`);
+        for (const [key, value] of Object.entries(args)) {
+          prompt.push(
+            `<arg_key>${key}</arg_key><arg_value>` +
+            `${typeof value === "string" ? value : JSON.stringify(value)}</arg_value>`,
+          );
+        }
+        prompt.push("</tool_call>");
+      }
+    } else if (role === "tool") {
+      if (!previousWasTool) prompt.push("<|observation|>");
+      prompt.push(
+        `<tool_response>${glm52ContentText(message.content, `messages.${index}.content`)}` +
+        "</tool_response>",
+      );
+    } else {
+      throw new Error(`GLM-5.2 unsupported message role ${JSON.stringify(role)}`);
+    }
+    previousWasTool = role === "tool";
+  }
+  if (addGenerationPrompt) {
+    prompt.push(
+      enableThinking
+        ? "<|assistant|><think>"
+        : "<|assistant|><think></think>",
+    );
+  }
+  return prompt.join("");
 }
 
 /** JSON-schema type implied by a literal value. */
@@ -116,9 +244,18 @@ export function normalizeToolSchemas(tools: ToolDefinition[] | null): ToolDefini
 }
 
 export class ChatTemplate {
-  readonly #template: Template;
+  readonly #template: Template | null;
+  readonly #renderer: ChatRenderer | null;
   readonly #bosToken: string | null;
   readonly #eosToken: string | null;
+  /** True when the template reads `reasoning_effort` (Qwen3.8's xhigh/medium/
+   *  low depth control). Callers must not pass the variable otherwise — and
+   *  must never pass unmapped OpenAI level names; this template family raises
+   *  on values outside its supported set. */
+  readonly readsReasoningEffort: boolean;
+  /** True when the template reads `preserve_thinking` (Qwen3.8: keep think
+   *  blocks from historical turns; template default true). */
+  readonly readsPreserveThinking: boolean;
   /** Which reasoning format the template's `enable_thinking` channel uses, or
    *  null if the model has no switchable reasoning:
    *   - "think-tag": `<think>…</think>` text markers (Qwen3.5, MiniCPM5) — split
@@ -132,15 +269,22 @@ export class ChatTemplate {
   readonly supportsThinking: boolean;
 
   private constructor(
-    source: string,
+    source: string | null,
     bosToken: string | null,
     eosToken: string | null,
     forceNoThinking = false,
+    renderer: ChatRenderer | null = null,
+    explicitThinkingFormat: "think-tag" | "gemma-channel" | null = null,
   ) {
-    this.#template = new Template(source);
+    if (source === null && renderer === null)
+      throw new Error("ChatTemplate needs a Jinja source or renderer");
+    this.#template = source === null ? null : new Template(source);
+    this.#renderer = renderer;
     this.#bosToken = bosToken;
     this.#eosToken = eosToken;
-    const gatesThinking = source.includes("enable_thinking");
+    const gatesThinking = source?.includes("enable_thinking") ?? false;
+    this.readsReasoningEffort = source?.includes("reasoning_effort") ?? false;
+    this.readsPreserveThinking = source?.includes("preserve_thinking") ?? false;
     // `forceNoThinking` suppresses the switchable channel even when the template
     // carries the gemma markers. DiffusionGemma ships the shared gemma-family
     // template (with the `<|channel>thought…<channel|>` reasoning channel), but
@@ -149,13 +293,13 @@ export class ChatTemplate {
     // reasoning, no answer). The OptiQ reference never enables thinking for this
     // model — it always renders the template's `default(false)` pre-closed empty
     // channel and decodes the whole canvas as plain text. We match that.
-    this.thinkingFormat = forceNoThinking
+    this.thinkingFormat = explicitThinkingFormat ?? (forceNoThinking
       ? null
-      : gatesThinking && source.includes("<think>")
+      : gatesThinking && source!.includes("<think>")
         ? "think-tag"
-        : gatesThinking && source.includes("<|channel>")
+        : gatesThinking && source!.includes("<|channel>")
           ? "gemma-channel"
-          : null;
+          : null);
     this.supportsThinking = this.thinkingFormat !== null;
   }
 
@@ -169,7 +313,25 @@ export class ChatTemplate {
       const jinjaFile = Bun.file(`${modelDir}/chat_template.jinja`);
       if (await jinjaFile.exists()) source = await jinjaFile.text();
     }
-    if (!source) throw new Error(`${modelDir}: no chat template found`);
+    if (!source) {
+      const modelConfigFile = Bun.file(`${modelDir}/config.json`);
+      const modelConfig = await modelConfigFile.exists()
+        ? await modelConfigFile.json() as Record<string, unknown>
+        : null;
+      if (modelConfig?.model_type === "glm_moe_dsa") {
+        const tokenText = (t: unknown): string | null =>
+          t == null ? null : typeof t === "string" ? t : (t as any).content;
+        return new ChatTemplate(
+          null,
+          tokenText(config.bos_token),
+          tokenText(config.eos_token),
+          false,
+          renderGlm52Chat,
+          "think-tag",
+        );
+      }
+      throw new Error(`${modelDir}: no chat template found`);
+    }
     // @huggingface/jinja lacks the `min`/`max` array filters that real
     // Jinja2 has. MiniCPM5's template uses `[a, b]|min` in its assistant
     // tool-call history branch, so without this rewrite every multi-turn
@@ -189,14 +351,30 @@ export class ChatTemplate {
   }
 
   render(messages: ChatMessage[], options: RenderOptions = {}): string {
-    const { addGenerationPrompt = true, tools = null, enableThinking } = options;
-    return this.#template.render({
+    if (this.#renderer) return this.#renderer(messages, options);
+    const {
+      addGenerationPrompt = true,
+      tools = null,
+      enableThinking,
+      reasoningEffort,
+      preserveThinking,
+    } = options;
+    return this.#template!.render({
       messages,
       add_generation_prompt: addGenerationPrompt,
       // Guarantee every tool param schema has a `type` so templates that do
       // `value['type'] | upper` (Gemma) never see UndefinedValue.
       tools: normalizeToolSchemas(tools),
       ...(enableThinking !== undefined ? { enable_thinking: enableThinking } : {}),
+      // Only set for templates that read them: reasoning_effort values are
+      // template-validated (Qwen3.8 raises on unknown levels), and an unread
+      // variable in other templates is dead context at best.
+      ...(reasoningEffort !== undefined && this.readsReasoningEffort
+        ? { reasoning_effort: reasoningEffort }
+        : {}),
+      ...(preserveThinking !== undefined && this.readsPreserveThinking
+        ? { preserve_thinking: preserveThinking }
+        : {}),
       bos_token: this.#bosToken,
       eos_token: this.#eosToken,
     });

package/src/cli.ts

@@ -17,7 +17,15 @@ import { fit, skuMatrix, thisMachine } from "./fit";
 import { EvalDB } from "./evaldb";
 import pkg from "../package.json" with { type: "json" };
 import { renderHelp } from "./tui";
-import { isSupportedModelRecord } from "./model/support";
+import { isGlm52Config, isSupportedModelRecord } from "./model/support";
+import {
+  GLM52_G5_ASPIRATIONAL_DECODE_TPS,
+  GLM52_G5_DEFAULT_MAX_GENERATION_TOKENS,
+  GLM52_G5_DEFAULT_PROCESS_LIMIT_BYTES,
+  GLM52_G5_DIRECT_ORACLE_WARM_DECODE_TPS,
+  GLM52_G5_MEASURED_WARM_DECODE_TPS,
+  planGlm52MemoryForArtifact,
+} from "./model/glm52-memory";
 import type { JobEvent } from "./jobs/types";
 
 const argv = process.argv.slice(2);
@@ -153,6 +161,11 @@ Model & quality:
                             DSpark pins to its trained block width]
   --ngram-max <k>           Prompt-lookup longest match window  [default: 3]
   --ngram-min <k>           Prompt-lookup shortest match window  [default: 1]
+  --mtp <on|off>            GLM-5.2 checkpoint-native MTP. On by default;
+                            routes requests through the exact serial verify
+                            lane. off enables ordinary continuous batching.
+  --context-length <n>      GLM-5.2 resource-plan context reservation
+                            [default: 4096]
   --kv-quant <mode>         KV cache quantization: config (per-layer
                             kv_config.json when the model ships one), off
                             (bf16), 4 / 8 (uniform bits), or turbo[:k<bits>v
@@ -190,7 +203,8 @@ Model & quality:
                             [default: the model's generation_config.json]
   --max-tokens <n>          Completion cap when a request omits max_tokens
                             (mlx_lm.server flag; its default is 512 there)
-                            [default: 65536 chat / 512 raw completion]
+                            [default: 128 GLM-5.2; otherwise 65536 chat /
+                            512 raw completion]
   --hlg-sampling on|off     Piecewise tone-curve sampling (HLG): rolls off the
                             top, boosts the mids, gentles the tail. Gain folds
                             from --temperature. [default: off]
@@ -285,7 +299,9 @@ Options:
 
 Resumable (Range requests against partial blobs) and verified (sha256
 for LFS blobs). Re-running after an interruption continues where it
-stopped. Uses HF_TOKEN / hf auth login credentials when present.
+stopped. Before payload transfer, complete blobs and partial prefixes are
+credited and the target volume must fit the remainder plus a 1 GiB reserve.
+Uses HF_TOKEN / hf auth login credentials when present.
 When upstream pushed a new revision, the previous snapshot stays on
 disk — \`mlx-bun gc\` reclaims it.`,
 
@@ -1007,6 +1023,39 @@ function serverRuntimeFlags(): { port: number; serverOptions: import("./server")
   return { port: Number(opt("port", "8080")), serverOptions };
 }
 
+/** Direct Colibri runtime defaults shared by `serve` and the embedded `pi`
+ * server. Other model families ignore this load-only option block. */
+function glm52RuntimeFlags(
+  serverOptions: import("./server").ServerOptions,
+): import("./model/factory").Glm52RuntimeOpenOptions {
+  const mtpRaw = opt("mtp");
+  let enableMtp: boolean | undefined;
+  if (mtpRaw !== null) {
+    if (["on", "1", "true"].includes(mtpRaw)) enableMtp = true;
+    else if (["off", "0", "false"].includes(mtpRaw)) enableMtp = false;
+    else {
+      console.error(`--mtp expects on|off (got "${mtpRaw}")`);
+      process.exit(1);
+    }
+  }
+  const contextRaw = opt("context-length");
+  let contextTokens: number | undefined;
+  if (contextRaw !== null) {
+    contextTokens = Number(contextRaw);
+    if (!Number.isSafeInteger(contextTokens) || contextTokens < 1) {
+      console.error(`--context-length expects an integer >= 1 (got "${contextRaw}")`);
+      process.exit(1);
+    }
+  }
+  return {
+    memoryBudgetBytes: serverOptions.memoryBudgetBytes,
+    batchSize: serverOptions.batch ?? 8,
+    maxGenerationTokens: serverOptions.defaultMaxTokens ?? 128,
+    ...(contextTokens !== undefined ? { contextTokens } : {}),
+    ...(enableMtp !== undefined ? { enableMtp } : {}),
+  };
+}
+
 /** `--adapter <dir>` (alias `--adapter-path`, mlx_lm.server's spelling):
  *  mount a LoRA adapter at startup — the same machinery as POST /v1/adapters —
  *  and make it the default for requests that don't select one (a request's
@@ -1332,9 +1381,69 @@ switch (cmd) {
     if (reg.list().length === 0) await reg.scan();
     const m = reg.resolve(query);
     const config = await loadModelConfig(m.path);
-    const ctx = Number(opt("ctx", "8192"));
-    const r = fit(config, m.sizeBytes, ctx, thisMachine(), undefined, m.expertsBytes);
     const { box, table, style, h1, gradient } = await import("./tui");
+    const glm = isGlm52Config(config);
+    const ctx = Number(opt("ctx", glm ? "4096" : "8192"));
+    if (glm) {
+      const machine = thisMachine();
+      let plan;
+      try {
+        plan = await planGlm52MemoryForArtifact(m.path, {
+          machineBytes: machine.ramBytes,
+          processLimitBytes: Math.min(
+            GLM52_G5_DEFAULT_PROCESS_LIMIT_BYTES,
+            machine.ramBytes,
+          ),
+          contextTokens: ctx,
+          maxGenerationTokens: Math.min(
+            ctx,
+            GLM52_G5_DEFAULT_MAX_GENERATION_TOKENS,
+          ),
+          batchSize: 1,
+          enableMtp: true,
+        });
+      } catch (error) {
+        console.error(
+          `GLM-5.2 resource plan refused: ` +
+          `${error instanceof Error ? error.message : String(error)}`,
+        );
+        process.exitCode = 1;
+        break;
+      }
+      const gib = (bytes: number): string => `${(bytes / 2 ** 30).toFixed(2)} GiB`;
+      const li = plan.lineItems;
+      const kvBytes = li.targetKvBytes + li.mtpKvBytes;
+      const otherBytes = plan.plannedProcessBytes - li.residentWeightsBytes -
+        li.mainExpertSlabBytes - li.mtpExpertSlabBytes - kvBytes;
+      h1("will it fit?");
+      console.log(`  ${style.bold(m.repoId)} ${style.dim(`@ ${ctx.toLocaleString()} context · streamed GLM plan`)}`);
+      console.log();
+      box([
+        `artifact on disk  ${gib(m.sizeBytes).padStart(10)} ${style.dim("(streamed, not resident)")}`,
+        `resident weights  ${gib(li.residentWeightsBytes).padStart(10)}`,
+        `main expert slab  ${gib(li.mainExpertSlabBytes).padStart(10)}`,
+        `MTP expert slab   ${gib(li.mtpExpertSlabBytes).padStart(10)}`,
+        `target + MTP KV   ${gib(kvBytes).padStart(10)}`,
+        `runtime reserves  ${gib(otherBytes).padStart(10)}`,
+        `process plan      ${gib(plan.plannedProcessBytes).padStart(10)} ${style.dim(`of ${gib(plan.processLimitBytes)}`)}  ${style.green(style.bold("FITS"))}`,
+        `macOS headroom    ${gib(plan.machineHeadroomBytes).padStart(10)}`,
+        "",
+        `max safe context  ${style.bold(plan.contextTokens.toLocaleString())} tokens`,
+        `max generation    ${style.bold(plan.maxGenerationTokens.toLocaleString())} tokens`,
+        `measured warm     ${gradient(`${GLM52_G5_MEASURED_WARM_DECODE_TPS.toFixed(3)} tok/s`)} ${style.dim("(quality-preserving, MTP on)")}`,
+        `direct oracle     ${GLM52_G5_DIRECT_ORACLE_WARM_DECODE_TPS.toFixed(2)} tok/s`,
+        `aspirational      ${GLM52_G5_ASPIRATIONAL_DECODE_TPS.toFixed(1)} tok/s ${style.dim("(not a fit prediction or release gate)")}`,
+      ]);
+      if (flag("skus")) {
+        console.log(style.dim(
+          "  GLM-5.2's direct-container preset is validated on the M1 Max 32 GB; " +
+          "the generic resident-weight SKU projection does not apply.",
+        ));
+      }
+      console.log();
+      break;
+    }
+    const r = fit(config, m.sizeBytes, ctx, thisMachine(), undefined, m.expertsBytes);
     h1("will it fit?");
     console.log(`  ${style.bold(m.repoId)} ${style.dim(`@ ${ctx.toLocaleString()} context · this machine`)}`);
     console.log();
@@ -1529,6 +1638,7 @@ switch (cmd) {
     const t0 = performance.now();
     const ctx = await loadContext(m.path, m.repoId, {
       memoryBudgetBytes: rt.serverOptions.memoryBudgetBytes,
+      glm: glm52RuntimeFlags(rt.serverOptions),
       ...(draftModelDir || draftKind === "ngram"
         ? {
             ...(draftModelDir ? { draftModelDir } : {}),
@@ -1585,7 +1695,12 @@ switch (cmd) {
       process.exit(1);
     }
     const { loadTaskModel, generateText } = await import("./eval/runner");
-    const tm = await loadTaskModel(positional(0) ?? opt("query") ?? "");
+    const maxTokens = Number(opt("max-tokens", "256"));
+    const tm = await loadTaskModel(
+      positional(0) ?? opt("query") ?? "",
+      undefined,
+      { maxGenerationTokens: maxTokens, enableMtp: false },
+    );
     // Resolve the tier/--kv-quant KV scheme exactly the way serve does
     // (server.ts kvScheme): "config" = the model's kv_config.json (absent →
     // bf16, same silent fallback as serve), N = uniform bits from decode
@@ -1601,7 +1716,7 @@ switch (cmd) {
       : undefined;
     const num = (n: string): number | undefined => { const v = opt(n); return v == null ? undefined : Number(v); };
     const text = await generateText(tm, prompt, {
-      maxTokens: Number(opt("max-tokens", "256")),
+      maxTokens,
       useChat: !flag("raw"),
       ...(kvScheme !== undefined ? { kvScheme } : {}),
       sampler: { temperature: num("temperature") ?? num("temp"), topP: num("top-p"), topK: num("top-k"), seed: num("seed") },
@@ -1883,6 +1998,7 @@ switch (cmd) {
       "--draft-model", "--num-draft-tokens", "--draft-kind", "--ngram-max", "--ngram-min",
       "--compiled-decode", "--compiled-activations", "--fused-sdpa", "--thinking",
       "--temperature", "--temp", "--top-p", "--top-k", "--max-tokens",
+      "--mtp", "--context-length",
       "--hlg-sampling", "--hlg-width", "--hlg-shoulder", "--hlg-toe", "--hlg-pivot-offset",
       "--paged-kv-block-size",
     ]);
@@ -1948,7 +2064,10 @@ switch (cmd) {
       const { createServer, loadContext } = await import("./server");
       const sLoad = step(`loading ${m.repoId}`);
       const t0 = performance.now();
-      const ctx = await loadContext(m.path, m.repoId, { memoryBudgetBytes: rt.serverOptions.memoryBudgetBytes });
+      const ctx = await loadContext(m.path, m.repoId, {
+        memoryBudgetBytes: rt.serverOptions.memoryBudgetBytes,
+        glm: glm52RuntimeFlags(rt.serverOptions),
+      });
       await mountStartupAdapter(ctx, rt.serverOptions);
       createServer(ctx, port, { ...rt.serverOptions, owner: "pi-session" });
       startedServer = true;