pi-makora-provider 1.2.0 → 1.4.0

package/README.md

@@ -4,7 +4,7 @@
 
 **Open-weight models through [Makora](https://inference.makora.com)**
 
-_DeepSeek V4, Kimi K2.7 Code, GLM 5.2, Qwen 3.6 — with client-side tool call repair and preserved-thinking flags for [pi](https://github.com/earendil-works/pi-coding-agent)._
+_DeepSeek V4, Kimi K2.7 Code, GLM 5.2, Qwen 3.6 for [pi](https://github.com/earendil-works/pi-coding-agent)._
 
 [![pi extension](https://img.shields.io/badge/pi-extension-blueviolet)](https://github.com/earendil-works/pi-coding-agent)
 [![license](https://img.shields.io/badge/license-MIT-blue)](./LICENSE)
@@ -18,15 +18,15 @@ _DeepSeek V4, Kimi K2.7 Code, GLM 5.2, Qwen 3.6 — with client-side tool call r
 <!-- MODELS_TABLE_START -->
 | Model | ID | Reasoning | Notes |
 |-------|----|-----------|-------|
-| DeepSeek V4 Flash | `deepseek-ai/DeepSeek-V4-Flash` | Yes | `include_reasoning` + `chat_template_kwargs.thinking` via `before_provider_request` payload rewrite; returns `reasoning` field |
-| DeepSeek V4 Pro | `deepseek-ai/DeepSeek-V4-Pro` | Yes | `chat_template_kwargs.thinking` via `before_provider_request` payload rewrite; returns `reasoning` field |
+| DeepSeek V4 Flash | `deepseek-ai/DeepSeek-V4-Flash` | Yes | returns `reasoning` field |
+| DeepSeek V4 Pro | `deepseek-ai/DeepSeek-V4-Pro` | Yes | returns `reasoning` field |
 | GLM 5.2 FP8 | `zai-org/GLM-5.2-FP8` | Yes | `enable_thinking` via `qwen-chat-template`; effort via `reasoning_effort` (only `high`/`max` distinct, per vLLM GLM-5.2 recipe); thinking levels aligned with neuralwatt GLM 5.2; returns `reasoning` field |
 | GLM 5.2 NVFP4 | `zai-org/GLM-5.2-NVFP4` | Yes | `enable_thinking` via `qwen-chat-template`; effort via `reasoning_effort` (only `high`/`max` distinct, per vLLM GLM-5.2 recipe); returns `reasoning` field |
-| Kimi K2.7 Code | `moonshotai/Kimi-K2.7-Code` | Yes | Reasoning on by default (thinking-only model); `preserve_thinking` via `chatTemplateKwargs` for multi-turn continuity; returns `reasoning` field; client-side tool call parsing (vLLM streaming parser bypass) |
+| Kimi K2.7 Code | `moonshotai/Kimi-K2.7-Code` | Yes | Reasoning on by default (thinking-only model); `preserve_thinking` via `chatTemplateKwargs` for multi-turn continuity; returns `reasoning` field |
 | Llama 3.3 70B FP8 | `amd/Llama-3.3-70B-Instruct-FP8-KV` | No |  |
 | Llama 3.3 70B Instruct | `meta-llama/Llama-3.3-70B-Instruct` | No |  |
-| Qwen 3.6 27B NVFP4 | `unsloth/Qwen3.6-27B-NVFP4` | Yes | `enable_thinking` via `qwen-chat-template`; `preserve_thinking` via `chatTemplateKwargs` for multi-turn continuity; returns `reasoning` field; client-side tool call parsing (vLLM streaming parser bypass) |
-| Qwen 3.6 35B A3B NVFP4 | `unsloth/Qwen3.6-35B-A3B-NVFP4` | Yes | `enable_thinking` via `qwen-chat-template`; `preserve_thinking` via `chatTemplateKwargs` for multi-turn continuity; returns `reasoning` field; client-side tool call parsing (vLLM streaming parser bypass) |
+| Qwen 3.6 27B NVFP4 | `unsloth/Qwen3.6-27B-NVFP4` | Yes | `enable_thinking` via `qwen-chat-template`; `preserve_thinking` via `chatTemplateKwargs` for multi-turn continuity; returns `reasoning` field |
+| Qwen 3.6 35B A3B NVFP4 | `unsloth/Qwen3.6-35B-A3B-NVFP4` | Yes | `enable_thinking` via `qwen-chat-template`; `preserve_thinking` via `chatTemplateKwargs` for multi-turn continuity; returns `reasoning` field |
 <!-- MODELS_TABLE_END -->
 
 ## Installation
@@ -156,24 +156,3 @@ Do **not** edit `models.json` directly — it is auto-generated from the API. To
 - The API is OpenAI-compatible (chat completions format)
 - All models are hosted on vLLM
 - The `developer` role is not supported (prompts are silently dropped); `supportsDeveloperRole` is set to `false` for all models
-
-## vLLM Caveats
-
-These issues are common to all vLLM-hosted providers and affect Makora models:
-
-- **GLM tool calls — follow-up `tool_calls` crash workaround**: the ZAI chat template calls `.items()` on any assistant message that carries a `tool_calls` field (on the `tool_calls` list or on its JSON-string `arguments` field), raising a leaked Python `AttributeError` that vLLM returns as HTTP 400 (`'list object' has no attribute 'items'` / `'str object' has no attribute 'items'`). The `before_provider_request` hook (`stripGlmToolCalls`) strips `tool_calls` from assistant messages and converts them to GLM-native `<tool_call>` XML text in `content` — which the model natively understands in conversation history — before the follow-up request is sent. The hook is scoped to Makora's own GLM models via an exact model-id match (`isMakoraGlmVllmModel`): `before_provider_request` is global in pi (it fires for every loaded provider's requests and the event carries no `provider` field), so gating by model id is what keeps it from touching GLM models served by other providers. If upstream fixes the `.items()` crash, this transform is a harmless no-op (the XML text is valid GLM input either way).
-
-- **Kimi K2.7 Code + Qwen 3.6 tool calling**: vLLM's server-side streaming tool-call handling is broken or missing for these models — Makora's vLLM is missing both `--enable-auto-tool-choice` and `--tool-call-parser` for them, so they emit tool calls as raw text tokens rather than structured `tool_call` deltas.
-
-    - **Kimi K2.7 Code**: Uses `<|tool_call_begin|>...<|tool_call_end|>` tokens.
-    - **Qwen 3.6**: Uses hermes-style `<function=...>` XML, sometimes with `█` delimiters.
-
-- **GLM 5.2 CoT leak**: On some vLLM builds, disabling reasoning may still leak chain-of-thought into `content` terminated by a ``` marker. See [vllm-project/vllm#31319](https://github.com/vllm-project/vllm/issues/31319).
-
-- **DeepSeek V4 reasoning**: The official DeepSeek API uses `thinking: { type: "enabled" }` which Makora's vLLM silently ignores. The `before_provider_request` hook rewrites the payload to use vLLM-native params instead:
-  - **DS V4 Pro**: `chat_template_kwargs: { thinking: true }`. Returns `reasoning` (vLLM reasoning parser; the official DeepSeek API returns `reasoning_content`, but Makora's vLLM build returns `reasoning`).
-  - **DS V4 Flash**: `include_reasoning: true` + `chat_template_kwargs: { thinking: true }`. `include_reasoning` alone returns `reasoning: null` on this vLLM build — both params are required. Returns `reasoning`.
-- **Preserved thinking (multi-turn reasoning continuity)**: every reasoning model on Makora returns reasoning in the `reasoning` field (not `reasoning_content`). Pi sends prior assistant reasoning back on follow-up turns; Makora's vLLM chat templates accept it under either `reasoning` or `reasoning_content`. For models whose chat template defines an explicit preserved-thinking flag, the flag is sent via `compat.chatTemplateKwargs`:
-  - **Kimi K2.7 Code**: `preserve_thinking: true` (the model forces thinking-only mode with preserve_thinking on, per the vLLM recipe).
-  - **Qwen 3.6 27B / 35B**: `preserve_thinking: true` (Qwen 3.6 ships with preserve_thinking).
-  - **GLM 5.2**: no extra flag — the vLLM GLM-5.2 recipe uses only `enable_thinking` + `reasoning_effort`; preserved thinking works without a dedicated flag. Effort honors only `high` and `max` (lower pi levels resolve to the default `max`).

package/index.ts

@@ -13,42 +13,11 @@
  * Model resolution strategy: static models.json merged with custom-models.json
  *
  * Reasoning notes:
- *   - DeepSeek V4 Pro: reasoning via chat_template_kwargs.thinking on vLLM.
- *     pi sends thinking: { type } via the "deepseek" thinkingFormat, but vLLM
- *     ignores that — the before_provider_request hook rewrites the payload to
- *     use chat_template_kwargs: { thinking: true } instead.
- *     Returns reasoning field (vLLM reasoning parser; not reasoning_content).
- *   - DeepSeek V4 Flash: reasoning via include_reasoning +
- *     chat_template_kwargs.thinking on vLLM.
- *     The before_provider_request hook rewrites the payload to replace
- *     thinking: { type } with include_reasoning: true +
- *     chat_template_kwargs: { thinking: true }.
- *     include_reasoning alone returns reasoning: null on this vLLM build.
- *     Returns reasoning field.
- *   - GLM 5.1 FP8: reasoning via chat_template_kwargs.enable_thinking.
- *     NOTE: vLLM may leak chain-of-thought into content instead of the
- *     reasoning field on some builds. See
- *     https://github.com/vllm-project/vllm/issues/31319
- *     Also: vLLM's streaming parser omits delta.tool_calls when the model
- *     calls tools, finishing with finish_reason: "tool_calls" but an empty
- *     delta. Setting zaiToolStream: true sends tool_stream: true in the
- *     request, which forces vLLM to use the explicit tool streaming path
- *     that correctly emits tool call chunks.
- *   - GLM 5.2 FP8 / NVFP4: reasoning via chat_template_kwargs.enable_thinking.
- *     Effort uses vLLM's reasoning_effort field (only `high` and `max` are
- *     distinct levels per the vLLM GLM-5.2 recipe; lower pi levels resolve to
- *     the default). Thinking levels aligned with the neuralwatt provider's
- *     GLM 5.2 configuration and mapped through pi's qwen-chat-template
- *     thinkingFormat. Returns `reasoning` field.
- *   - GPT-OSS 120B: reasoning always on; returns `reasoning` field.
- *   - Kimi K2.7 Code: reasoning always on (thinking-only model);
- *     chatTemplateKwargs.preserve_thinking forces multi-turn reasoning
- *     continuity. Returns `reasoning` field. Can be toggled via enable_thinking.
- *   - Qwen 3.6 models: reasoning via chat_template_kwargs.enable_thinking;
- *     chatTemplateKwargs.preserve_thinking for multi-turn continuity.
- *     Returns `reasoning` field.
- *   - MiniMax M3 MXFP8: reasoning via chat_template_kwargs.enable_thinking;
- *     returns reasoning_content field.
+ *   - DeepSeek V4 Pro: returns `reasoning` field.
+ *   - DeepSeek V4 Flash: returns `reasoning` field.
+ *   - GLM 5.2 FP8 / NVFP4: returns `reasoning` field.
+ *   - Kimi K2.7 Code: returns `reasoning` field.
+ *   - Qwen 3.6 models: returns `reasoning` field.
  *   - Llama 3.3 70B: not a reasoning model.
  *
  * Developer role is NOT supported by any of the chat templates on Makora's
@@ -141,11 +110,6 @@ interface PatchEntry {
 
 type PatchMap = Record<string, PatchEntry>;
 
-/** Type guard: non-null, non-array object. */
-export function isObject(value: unknown): value is Record<string, unknown> {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
 // Patch Application
 
 function applyPatch(model: JsonModel, patch: PatchEntry): JsonModel {
@@ -224,166 +188,11 @@ function buildModels(
 const PROVIDER_ID = "makora";
 const BASE_URL = "https://inference.makora.com/v1";
 
-const DS_PRO_ID = "deepseek-ai/DeepSeek-V4-Pro";
-const DS_FLASH_ID = "deepseek-ai/DeepSeek-V4-Flash";
-const MINIMAX_M3_ID = "MiniMaxAI/MiniMax-M3-MXFP8";
-
-const DS_VLLM_MODELS = new Set([DS_PRO_ID, DS_FLASH_ID]);
-const ENABLE_THINKING_VLLM_MODELS = new Set([MINIMAX_M3_ID]);
-
-/**
- * Makora's GLM models, built from the same models list this extension
- * registers. `before_provider_request` is GLOBAL in pi — it fires for every
- * loaded provider's requests, not just makora's — and its event carries only
- * `payload` (no `provider` field to gate on). So the GLM tool_calls strip MUST
- * be scoped to makora's own GLM model ids. A loose `/glm/i` regex would also
- * rewrite tool_calls for every sibling provider that serves any GLM model
- * (baseten, io, lilac, neuralwatt, tensorix, fireworks, crofai, hypercharm,
- * wafer, parasail, umans, opencode, ...), silently breaking their tool calling
- * and clobbering the input their own before_provider_request handlers expect.
- *
- * Derived (not hardcoded) so it auto-tracks models.json refreshes — models.json
- * is auto-generated by scripts/update-models.js. All makora models run on vLLM,
- * so every GLM id here shares the ZAI chat-template `.items()` crash that
- * stripGlmToolCalls works around.
- */
 const allMakoraModels = buildModels(
   modelsData as JsonModel[],
   customModelsData as JsonModel[],
   patchData as PatchMap,
 );
-const GLM_VLLM_MODELS = new Set(
-  allMakoraModels.filter((m) => /glm/i.test(m.id)).map((m) => m.id),
-);
-
-/** Whether `model` is one of makora's GLM models — the only ids the
- *  before_provider_request hook should strip tool_calls for. Exported so the
- *  scoping can be unit-tested in isolation. */
-export function isMakoraGlmVllmModel(model: string): boolean {
-  return GLM_VLLM_MODELS.has(model);
-}
-
-/**
- * Intercept the request payload for models that need vLLM-specific thinking
- * param rewrites.
- *
- * pi's "deepseek" thinkingFormat sends `thinking: { type: "enabled" }` which
- * is the official DeepSeek API format — but Makora's vLLM deployment ignores
- * it. vLLM requires different params depending on the model:
- *   - DS V4 Pro:  `chat_template_kwargs: { thinking: true }` + `reasoning_effort`
- *   - DS V4 Flash: `include_reasoning: true` + `chat_template_kwargs: { thinking: true }`
- *     + `reasoning_effort`. `include_reasoning` alone returns `reasoning: null`
- *     on this vLLM build — both params are required.
- *   - MiniMax M3: `chat_template_kwargs: { enable_thinking: true }` +
- *     `reasoning_effort`. Returns `reasoning_content` field.
- *
- * This hook rewrites the payload accordingly.
- */
-function rewriteVllmPayload(payload: Record<string, unknown>): Record<string, unknown> {
-  const model = payload.model as string | undefined;
-  if (!model) return payload;
-
-  const p = { ...payload };
-
-  if (DS_VLLM_MODELS.has(model)) {
-    // Remove the DeepSeek API-style `thinking` param that vLLM ignores
-    delete p.thinking;
-
-    if (model === DS_PRO_ID) {
-      // DS Pro: chat_template_kwargs.thinking + reasoning_effort
-      const ctq = (p.chat_template_kwargs as Record<string, unknown>) ?? {};
-      p.chat_template_kwargs = { ...ctq, thinking: true };
-    } else if (model === DS_FLASH_ID) {
-      // DS Flash: include_reasoning + chat_template_kwargs.thinking + reasoning_effort
-      // vLLM requires *both* include_reasoning and chat_template_kwargs.thinking:
-      // include_reasoning alone returns reasoning: null.
-      p.include_reasoning = true;
-      const ctq = (p.chat_template_kwargs as Record<string, unknown>) ?? {};
-      p.chat_template_kwargs = { ...ctq, thinking: true };
-    }
-  } else if (ENABLE_THINKING_VLLM_MODELS.has(model)) {
-    // Models using chat_template_kwargs.enable_thinking (e.g. MiniMax M3)
-    delete p.thinking;
-    const ctq = (p.chat_template_kwargs as Record<string, unknown>) ?? {};
-    p.chat_template_kwargs = { ...ctq, enable_thinking: true };
-  }
-
-  return p;
-}
-
-/**
- * GLM models on Makora's vLLM crash with a leaked Python AttributeError
- * (`'list object' has no attribute 'items'` or `'str object' has no attribute 'items'`)
- * when any assistant message in the request contains a `tool_calls` field.
- * The ZAI/vLLM chat template calls `.items()` on the tool_calls list (or on the
- * JSON-string `arguments` field), which raises AttributeError and leaks into the
- * HTTP 400 response body.
- *
- * Fix: for makora's GLM models only (see GLM_VLLM_MODELS / isMakoraGlmVllmModel),
- * strip `tool_calls` from assistant messages in the before_provider_request hook
- * and convert them back to GLM's native
- * `<tool_call>` XML text in `content`. The model natively understands this
- * format in conversation history, and the `role: "tool"` result messages that
- * follow are rendered fine by the chat template's tool-observation branch.
- *
- * If upstream fixes both the streaming parser and the 500/400 crash, this
- * transform becomes a harmless no-op (the XML text is still valid GLM input).
- */
-
-export function toolCallToGlmXml(tc: Record<string, unknown>): string {
-  const fn = (isObject(tc.function) ? tc.function : {}) as Record<string, unknown>;
-  const name = typeof fn.name === "string" ? fn.name : "";
-  const argsStr = typeof fn.arguments === "string" ? fn.arguments : "{}";
-  let args: Record<string, unknown>;
-  try {
-    args = JSON.parse(argsStr) as Record<string, unknown>;
-  } catch {
-    args = {};
-  }
-  if (!isObject(args)) args = {};
-  const argLines = Object.entries(args).map(
-    ([key, value]) =>
-      `<arg_key>${key}</arg_key>\n<arg_value>${
-        typeof value === "string" ? value : JSON.stringify(value)
-      }</arg_value>`,
-  );
-  return `<tool_call>${name}\n${argLines.join("\n")}\n</tool_call>`;
-}
-
-export function stripGlmToolCalls(payload: Record<string, unknown>): Record<string, unknown> {
-  const messages = payload.messages;
-  if (!Array.isArray(messages)) return payload;
-
-  let modified = false;
-  const newMessages = messages.map((msg) => {
-    if (!isObject(msg)) return msg;
-    if (msg.role !== "assistant") return msg;
-
-    const toolCalls = msg.tool_calls;
-    if (!Array.isArray(toolCalls) || toolCalls.length === 0) return msg;
-
-    const xmlBlocks = toolCalls
-      .filter((tc): tc is Record<string, unknown> => isObject(tc))
-      .map(toolCallToGlmXml);
-    if (xmlBlocks.length === 0) return msg;
-
-    const toolCallText = xmlBlocks.join("\n");
-    // pi's openai-completions provider always serializes assistant content as a
-    // plain string, but guard against null/array content for robustness.
-    const existingContent = typeof msg.content === "string" ? msg.content : "";
-    const newContent = existingContent ? `${existingContent}\n${toolCallText}` : toolCallText;
-
-    modified = true;
-    const rest: Record<string, unknown> = {};
-    for (const [k, v] of Object.entries(msg)) {
-      if (k !== "tool_calls") rest[k] = v;
-    }
-    return { ...rest, content: newContent };
-  });
-
-  if (!modified) return payload;
-  return { ...payload, messages: newMessages };
-}
 
 export default function (pi: ExtensionAPI) {
   const models = allMakoraModels;
@@ -396,16 +205,4 @@ export default function (pi: ExtensionAPI) {
     api: "openai-completions",
     models,
   });
-
-  pi.on("before_provider_request", (event) => {
-    const payload = event.payload as Record<string, unknown> | undefined;
-    if (!payload || typeof payload.model !== "string") return;
-
-    let result = rewriteVllmPayload(payload);
-    if (isMakoraGlmVllmModel(payload.model)) {
-      result = stripGlmToolCalls(result);
-    }
-    return result;
-  });
 }
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-makora-provider",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Makora provider extension for pi - Access DeepSeek V4, GLM 5.2, Kimi K2.7 Code, Llama 3.3, Qwen 3.6, and more through the Makora inference API",
   "type": "module",
   "main": "index.ts",

package/patch.json

@@ -1,7 +1,7 @@
 {
   "deepseek-ai/DeepSeek-V4-Flash": {
     "reasoning": true,
-    "notes": "`include_reasoning` + `chat_template_kwargs.thinking` via `before_provider_request` payload rewrite; returns `reasoning` field",
+    "notes": "returns `reasoning` field",
     "thinkingLevelMap": {
       "minimal": null,
       "low": null,
@@ -16,7 +16,7 @@
   },
   "deepseek-ai/DeepSeek-V4-Pro": {
     "reasoning": true,
-    "notes": "`chat_template_kwargs.thinking` via `before_provider_request` payload rewrite; returns `reasoning` field",
+    "notes": "returns `reasoning` field",
     "thinkingLevelMap": {
       "minimal": null,
       "low": null,
@@ -30,37 +30,9 @@
       "requiresReasoningContentOnAssistantMessages": true
     }
   },
-  "nvidia/Kimi-K2.6-NVFP4": {
-    "reasoning": true,
-    "input": [
-      "text",
-      "image"
-    ],
-    "notes": "Reasoning on by default; client-side tool call parsing (vLLM streaming parser bypass)",
-    "thinkingLevelMap": {
-      "minimal": "low",
-      "xhigh": "high"
-    },
-    "compat": {
-      "thinkingFormat": "qwen-chat-template",
-      "supportsReasoningEffort": true
-    }
-  },
-  "openai/gpt-oss-120b": {
-    "reasoning": true,
-    "notes": "Reasoning always on",
-    "thinkingLevelMap": {
-      "minimal": "low",
-      "xhigh": "high"
-    },
-    "compat": {
-      "thinkingFormat": "qwen-chat-template",
-      "supportsReasoningEffort": true
-    }
-  },
   "unsloth/Qwen3.6-27B-NVFP4": {
     "reasoning": true,
-    "notes": "`enable_thinking` via `qwen-chat-template`; `preserve_thinking` via `chatTemplateKwargs` for multi-turn continuity; returns `reasoning` field; client-side tool call parsing (vLLM streaming parser bypass)",
+    "notes": "`enable_thinking` via `qwen-chat-template`; `preserve_thinking` via `chatTemplateKwargs` for multi-turn continuity; returns `reasoning` field",
     "thinkingLevelMap": {
       "minimal": "low",
       "xhigh": "high"
@@ -75,7 +47,7 @@
   },
   "unsloth/Qwen3.6-35B-A3B-NVFP4": {
     "reasoning": true,
-    "notes": "`enable_thinking` via `qwen-chat-template`; `preserve_thinking` via `chatTemplateKwargs` for multi-turn continuity; returns `reasoning` field; client-side tool call parsing (vLLM streaming parser bypass)",
+    "notes": "`enable_thinking` via `qwen-chat-template`; `preserve_thinking` via `chatTemplateKwargs` for multi-turn continuity; returns `reasoning` field",
     "thinkingLevelMap": {
       "minimal": "low",
       "xhigh": "high"
@@ -88,33 +60,13 @@
       }
     }
   },
-  "MiniMaxAI/MiniMax-M3-MXFP8": {
-    "reasoning": true,
-    "input": [
-      "text",
-      "image"
-    ],
-    "notes": "Reasoning via `chat_template_kwargs.enable_thinking`; returns `reasoning_content` field",
-    "thinkingLevelMap": {
-      "minimal": null,
-      "low": null,
-      "medium": null,
-      "high": "high",
-      "xhigh": "max"
-    },
-    "compat": {
-      "thinkingFormat": "deepseek",
-      "supportsReasoningEffort": true,
-      "requiresReasoningContentOnAssistantMessages": true
-    }
-  },
   "moonshotai/Kimi-K2.7-Code": {
     "reasoning": true,
     "input": [
       "text",
       "image"
     ],
-    "notes": "Reasoning on by default (thinking-only model); `preserve_thinking` via `chatTemplateKwargs` for multi-turn continuity; returns `reasoning` field; client-side tool call parsing (vLLM streaming parser bypass)",
+    "notes": "Reasoning on by default (thinking-only model); `preserve_thinking` via `chatTemplateKwargs` for multi-turn continuity; returns `reasoning` field",
     "thinkingLevelMap": {
       "minimal": "low",
       "xhigh": "high"
@@ -127,20 +79,6 @@
       }
     }
   },
-  "zai-org/GLM-5.1-FP8": {
-    "contextWindow": 200000,
-    "reasoning": true,
-    "notes": "`enable_thinking` via `qwen-chat-template`; returns `reasoning_content` field; client-side tool call parsing (vLLM streaming parser bypass)",
-    "thinkingLevelMap": {
-      "minimal": "low",
-      "xhigh": "high"
-    },
-    "compat": {
-      "thinkingFormat": "qwen-chat-template",
-      "supportsReasoningEffort": true,
-      "zaiToolStream": true
-    }
-  },
   "zai-org/GLM-5.2-FP8": {
     "reasoning": true,
     "notes": "`enable_thinking` via `qwen-chat-template`; effort via `reasoning_effort` (only `high`/`max` distinct, per vLLM GLM-5.2 recipe); thinking levels aligned with neuralwatt GLM 5.2; returns `reasoning` field",