pi-makora-provider 1.0.0 → 1.2.0

package/README.md

@@ -4,7 +4,7 @@
 
 **Open-weight models through [Makora](https://inference.makora.com)**
 
-_DeepSeek V4, Kimi K2.6, GLM 5.1, Qwen 3.6 — with client-side tool call repair for [pi](https://github.com/earendil-works/pi-coding-agent)._
+_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)._
 
 [![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)
@@ -19,21 +19,36 @@ _DeepSeek V4, Kimi K2.6, GLM 5.1, Qwen 3.6 — with client-side tool call repair
 | 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_content` field |
-| GLM 5.1 FP8 | `zai-org/GLM-5.1-FP8` | Yes | `enable_thinking` via `qwen-chat-template`; returns `reasoning_content` field; client-side tool call parsing (vLLM streaming parser bypass) |
-| GPT-OSS 120B | `openai/gpt-oss-120b` | Yes | Reasoning always on |
-| Kimi K2.6 NVFP4 | `nvidia/Kimi-K2.6-NVFP4` | Yes | Reasoning on by default; client-side tool call parsing (vLLM streaming parser bypass) |
-| Kimi K2.7 Code | `moonshotai/Kimi-K2.7-Code` | Yes | Reasoning on by default; client-side tool call parsing (vLLM streaming parser bypass) |
+| DeepSeek V4 Pro | `deepseek-ai/DeepSeek-V4-Pro` | Yes | `chat_template_kwargs.thinking` via `before_provider_request` payload rewrite; 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) |
 | 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 |  |
-| MiniMax M3 MXFP8 | `MiniMaxAI/MiniMax-M3-MXFP8` | Yes | Reasoning via `chat_template_kwargs.enable_thinking`; returns `reasoning_content` field |
-| Qwen 3.6 27B NVFP4 | `unsloth/Qwen3.6-27B-NVFP4` | Yes | `enable_thinking` via `qwen-chat-template`; 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`; 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; 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) |
 <!-- MODELS_TABLE_END -->
 
 ## Installation
 
-### Option 1: Using `pi install` (Recommended)
+### Option 1: Install from npm (Recommended)
+
+```bash
+pi install npm:pi-makora-provider
+```
+
+Then set your API key and run pi:
+```bash
+# Recommended: add to auth.json
+# See Authentication section below
+
+# Or set as environment variable
+export MAKORA_OPTIMIZE_TOKEN=your-api-key-here
+
+pi
+```
+
+### Option 2: Using `pi install` from GitHub
 
 Install directly from GitHub:
 
@@ -52,7 +67,7 @@ export MAKORA_OPTIMIZE_TOKEN=your-api-key-here
 pi
 ```
 
-### Option 2: Manual Clone
+### Option 3: Manual Clone
 
 1. Clone this repository:
    ```bash
@@ -146,17 +161,19 @@ Do **not** edit `models.json` directly — it is auto-generated from the API. To
 
 These issues are common to all vLLM-hosted providers and affect Makora models:
 
-- **GLM 5.1 tool calling**: vLLM's streaming tool call handling is broken for GLM — the model outputs Zhipu's native `<tool_call>` XML format as raw text. The `message_end` hook parses this into `toolCall` blocks so pi can execute the tools. A `context` hook then strips `tool_calls` from assistant messages before follow-up requests, converting them back to `<tool_call>` text to avoid a ZAI/vLLM server crash (500: `'str object' has no attribute 'items'`) that occurs when any assistant message contains a `tool_calls` field. If upstream fixes both the streaming parser and the 500 crash, the `message_end` hook gracefully skips (existing valid `toolCall` blocks are preserved), and the `context` hook's text-stripping is harmless (GLM natively understands `<tool_call>` format in conversation history).
+- **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.6 + Qwen 3.6 tool calling**: vLLM's streaming tool call handling is broken or missing for these models. The `before_provider_request` hook sets `tool_choice: "none"` and `skip_special_tokens: false` so the model's tool call tokens pass through as plain text. The `message_end` hook then re-parses into `toolCall` blocks:
+- **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.6**: Uses `<|tool_call_begin|>...<|tool_call_end|>` tokens. Makora's vLLM is missing both `--enable-auto-tool-choice` and `--tool-call-parser` for this model.
-    - **Qwen 3.6**: Uses hermes-style `<function=...>` XML, sometimes with `█` delimiters. Same vLLM flag limitation as Kimi.
+    - **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.1 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).
+- **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_content`.
+  - **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`.
-- **GLM 5.1 reasoning**: Returns `reasoning_content` (not `reasoning`). pi's OpenAI completions handler checks `reasoning_content` first, so this is handled correctly.
-- **MiniMax M3 reasoning**: Uses `chat_template_kwargs.enable_thinking` to toggle thinking (not `chat_template_kwargs.thinking` like DeepSeek). The `before_provider_request` hook rewrites the DeepSeek API-style `thinking` param into vLLM-native `chat_template_kwargs: { enable_thinking: true }`. Returns `reasoning_content` field.
+- **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

@@ -17,7 +17,7 @@
  *     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_content field.
+ *     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
@@ -34,11 +34,19 @@
  *     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.6 NVFP4 / Kimi K2.7 Code: reasoning always on by default;
- *     returns `reasoning` field. Can be toggled via enable_thinking.
+ *   - 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;
- *     returns `reasoning` field.
+ *     chatTemplateKwargs.preserve_thinking for multi-turn continuity.
+ *     Returns `reasoning` field.
  *   - MiniMax M3 MXFP8: reasoning via chat_template_kwargs.enable_thinking;
  *     returns reasoning_content field.
  *   - Llama 3.3 70B: not a reasoning model.
@@ -105,6 +113,10 @@ interface JsonModel {
     requiresToolResultName?: boolean;
     requiresAssistantAfterToolResult?: boolean;
     cacheControlFormat?: "anthropic";
+    /** Extra keys merged into vLLM `chat_template_kwargs` on every request.
+     *  Used for preserved-thinking flags like `preserve_thinking` / `clear_thinking`
+     *  that some chat templates require for multi-turn reasoning continuity. */
+    chatTemplateKwargs?: Record<string, unknown>;
   };
 }
 
@@ -129,6 +141,11 @@ 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 {
@@ -214,6 +231,38 @@ 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.
@@ -262,12 +311,82 @@ function rewriteVllmPayload(payload: Record<string, unknown>): Record<string, un
   return p;
 }
 
-export default function (pi: ExtensionAPI) {
-  const embeddedModels = modelsData as JsonModel[];
-  const customModels = customModelsData as JsonModel[];
-  const patches = patchData as PatchMap;
+/**
+ * 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).
+ */
 
-  const models = buildModels(embeddedModels, customModels, patches);
+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;
 
   // apiKey resolution order: auth.json ("makora" key) → MAKORA_OPTIMIZE_TOKEN env var
   pi.registerProvider(PROVIDER_ID, {
@@ -281,7 +400,12 @@ export default function (pi: ExtensionAPI) {
   pi.on("before_provider_request", (event) => {
     const payload = event.payload as Record<string, unknown> | undefined;
     if (!payload || typeof payload.model !== "string") return;
-    return rewriteVllmPayload(payload);
+
+    let result = rewriteVllmPayload(payload);
+    if (isMakoraGlmVllmModel(payload.model)) {
+      result = stripGlmToolCalls(result);
+    }
+    return result;
   });
 }
 

package/models.json

@@ -62,27 +62,6 @@
       "maxTokensField": "max_completion_tokens"
     }
   },
-  {
-    "id": "MiniMaxAI/MiniMax-M3-MXFP8",
-    "name": "MiniMax M3 MXFP8",
-    "reasoning": false,
-    "input": [
-      "text"
-    ],
-    "cost": {
-      "input": 0,
-      "output": 0,
-      "cacheRead": 0,
-      "cacheWrite": 0
-    },
-    "contextWindow": 1048576,
-    "maxTokens": 0,
-    "compat": {
-      "supportsDeveloperRole": false,
-      "supportsStore": false,
-      "maxTokensField": "max_completion_tokens"
-    }
-  },
   {
     "id": "moonshotai/Kimi-K2.7-Code",
     "name": "Kimi K2.7 Code",
@@ -105,8 +84,8 @@
     }
   },
   {
-    "id": "nvidia/Kimi-K2.6-NVFP4",
-    "name": "Kimi K2.6 NVFP4",
+    "id": "unsloth/Qwen3.6-27B-NVFP4",
+    "name": "Qwen 3.6 27B NVFP4",
     "reasoning": false,
     "input": [
       "text"
@@ -126,29 +105,8 @@
     }
   },
   {
-    "id": "openai/gpt-oss-120b",
-    "name": "GPT-OSS 120B",
-    "reasoning": false,
-    "input": [
-      "text"
-    ],
-    "cost": {
-      "input": 0,
-      "output": 0,
-      "cacheRead": 0,
-      "cacheWrite": 0
-    },
-    "contextWindow": 131072,
-    "maxTokens": 0,
-    "compat": {
-      "supportsDeveloperRole": false,
-      "supportsStore": false,
-      "maxTokensField": "max_completion_tokens"
-    }
-  },
-  {
-    "id": "unsloth/Qwen3.6-27B-NVFP4",
-    "name": "Qwen 3.6 27B NVFP4",
+    "id": "unsloth/Qwen3.6-35B-A3B-NVFP4",
+    "name": "Qwen 3.6 35B A3B NVFP4",
     "reasoning": false,
     "input": [
       "text"
@@ -168,8 +126,8 @@
     }
   },
   {
-    "id": "unsloth/Qwen3.6-35B-A3B-NVFP4",
-    "name": "Qwen 3.6 35B A3B NVFP4",
+    "id": "zai-org/GLM-5.2-FP8",
+    "name": "GLM 5.2 FP8",
     "reasoning": false,
     "input": [
       "text"
@@ -180,7 +138,7 @@
       "cacheRead": 0,
       "cacheWrite": 0
     },
-    "contextWindow": 262144,
+    "contextWindow": 1048576,
     "maxTokens": 0,
     "compat": {
       "supportsDeveloperRole": false,
@@ -189,8 +147,8 @@
     }
   },
   {
-    "id": "zai-org/GLM-5.1-FP8",
-    "name": "GLM 5.1 FP8",
+    "id": "zai-org/GLM-5.2-NVFP4",
+    "name": "GLM 5.2 NVFP4",
     "reasoning": false,
     "input": [
       "text"
@@ -201,7 +159,7 @@
       "cacheRead": 0,
       "cacheWrite": 0
     },
-    "contextWindow": 202752,
+    "contextWindow": 1048576,
     "maxTokens": 0,
     "compat": {
       "supportsDeveloperRole": false,

package/package.json

@@ -1,15 +1,9 @@
 {
   "name": "pi-makora-provider",
-  "version": "1.0.0",
-  "description": "Makora provider extension for pi - Access DeepSeek V4, GLM 5.1, Kimi K2.6, Llama 3.3, Qwen 3.6, and more through the Makora inference API",
+  "version": "1.2.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",
-  "scripts": {
-    "clean": "echo 'nothing to clean'",
-    "build": "echo 'nothing to build'",
-    "check": "echo 'nothing to check'",
-    "update-models": "node scripts/update-models.js"
-  },
   "keywords": [
     "pi",
     "extension",
@@ -37,5 +31,16 @@
     "extensions": [
       "./index.ts"
     ]
+  },
+  "devDependencies": {
+    "vitest": "^4.1.9"
+  },
+  "scripts": {
+    "clean": "echo 'nothing to clean'",
+    "build": "echo 'nothing to build'",
+    "check": "echo 'nothing to check'",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "update-models": "node scripts/update-models.js"
   }
-}
+}

package/patch.json

@@ -16,7 +16,7 @@
   },
   "deepseek-ai/DeepSeek-V4-Pro": {
     "reasoning": true,
-    "notes": "`chat_template_kwargs.thinking` via `before_provider_request` payload rewrite; returns `reasoning_content` field",
+    "notes": "`chat_template_kwargs.thinking` via `before_provider_request` payload rewrite; returns `reasoning` field",
     "thinkingLevelMap": {
       "minimal": null,
       "low": null,
@@ -60,26 +60,32 @@
   },
   "unsloth/Qwen3.6-27B-NVFP4": {
     "reasoning": true,
-    "notes": "`enable_thinking` via `qwen-chat-template`; 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; client-side tool call parsing (vLLM streaming parser bypass)",
     "thinkingLevelMap": {
       "minimal": "low",
       "xhigh": "high"
     },
     "compat": {
       "thinkingFormat": "qwen-chat-template",
-      "supportsReasoningEffort": true
+      "supportsReasoningEffort": true,
+      "chatTemplateKwargs": {
+        "preserve_thinking": true
+      }
     }
   },
   "unsloth/Qwen3.6-35B-A3B-NVFP4": {
     "reasoning": true,
-    "notes": "`enable_thinking` via `qwen-chat-template`; 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; client-side tool call parsing (vLLM streaming parser bypass)",
     "thinkingLevelMap": {
       "minimal": "low",
       "xhigh": "high"
     },
     "compat": {
       "thinkingFormat": "qwen-chat-template",
-      "supportsReasoningEffort": true
+      "supportsReasoningEffort": true,
+      "chatTemplateKwargs": {
+        "preserve_thinking": true
+      }
     }
   },
   "MiniMaxAI/MiniMax-M3-MXFP8": {
@@ -108,14 +114,17 @@
       "text",
       "image"
     ],
-    "notes": "Reasoning on by default; 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; client-side tool call parsing (vLLM streaming parser bypass)",
     "thinkingLevelMap": {
       "minimal": "low",
       "xhigh": "high"
     },
     "compat": {
       "thinkingFormat": "qwen-chat-template",
-      "supportsReasoningEffort": true
+      "supportsReasoningEffort": true,
+      "chatTemplateKwargs": {
+        "preserve_thinking": true
+      }
     }
   },
   "zai-org/GLM-5.1-FP8": {
@@ -131,5 +140,35 @@
       "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",
+    "thinkingLevelMap": {
+      "minimal": null,
+      "low": null,
+      "medium": null,
+      "high": "high",
+      "xhigh": "max"
+    },
+    "compat": {
+      "thinkingFormat": "qwen-chat-template",
+      "supportsReasoningEffort": true
+    }
+  },
+  "zai-org/GLM-5.2-NVFP4": {
+    "reasoning": true,
+    "notes": "`enable_thinking` via `qwen-chat-template`; effort via `reasoning_effort` (only `high`/`max` distinct, per vLLM GLM-5.2 recipe); returns `reasoning` field",
+    "thinkingLevelMap": {
+      "minimal": null,
+      "low": null,
+      "medium": null,
+      "high": "high",
+      "xhigh": "max"
+    },
+    "compat": {
+      "thinkingFormat": "qwen-chat-template",
+      "supportsReasoningEffort": true
+    }
   }
 }