opencode-thinking-fix 3.3.4 → 4.0.0

package/README.md

@@ -125,6 +125,17 @@ causing cross-provider poisoning. v3.1 fixes that:
   (Qwen, GPT, Claude, Gemini, Llama, Mistral, Cerebras-hosted GLM) default to
   `reasoningKey: null` — the body is forwarded untouched.
 
+## v3.4 — Z.ai Preserved Thinking (F12, intel-driven)
+
+The proxy injects the field, but some providers strip it *server-side* before it reaches the model. Z.ai is the most common case: the standard Chat Completions endpoint defaults `thinking.clear_thinking` to `true`, so prior `reasoning_content` is removed from context even when the client passes it back correctly. The result is a GLM session that re-derives from scratch every turn, loops, and burns tokens — with the proxy fully active.
+
+v3.4 fixes this on every Z.ai-reachable lane:
+
+- **What is injected.** `thinking.clear_thinking: false` on the request body, which opts the session into Z.ai Preserved Thinking. The field is idempotently merged with any client-supplied `thinking` (e.g. `thinking.type: "enabled"`), so client choices are preserved.
+- **Where it fires.** Any lane that ends at a Z.ai-reachable host: port 3457 universal (BigModel direct), port 3458 (OpenCode Go gateway), port 3462 (OpenRouter → Z.ai under the hood). The host allowlist is conservative — unknown upstreams are skipped.
+- **What is skipped.** The injection is skipped when the client explicitly disabled thinking (`thinking: false`) — forcing preserved thinking on top of disabled thinking would be incoherent. The Coding Plan endpoint already defaults `clear_thinking: false`, so the merge is a no-op there.
+- **Source of truth.** [docs.z.ai/guides/capabilities/thinking-mode](https://docs.z.ai/guides/capabilities/thinking-mode) (Preserved Thinking section) and the [chat completion API reference](https://docs.z.ai/api-reference/llm/chat-completion) (the `thinking.clear_thinking` parameter, type `boolean`, default `true`).
+
 ### "Another way" — do you even need the plugin now?
 
 The reasoning-drop is fixed at the wire layer by the proxy, so you have three options:
@@ -137,6 +148,22 @@ The reasoning-drop is fixed at the wire layer by the proxy, so you have three op
 
 **Recommendation:** run the proxy, and slim the plugin down to *just* the `x-session-id` header injection (delete its message-transform hook). That gives you real reasoning replay with the least overhead.
 
+## v3.4.1 — InclusionAI Ling 3.0 Flash route (F19)
+
+Three new entries in the port 3457 model-routing table cover InclusionAI's flagship flash reasoning model:
+
+| Model id | Upstream | Why this route |
+|---|---|---|
+| `inclusionai/ling-3.0-flash` (paid) | `https://openrouter.ai/api/v1` | Primary distribution; OR exposes `delta.reasoning` + `delta.reasoning_details` on the response side and normalizes `reasoning_content` on the input side |
+| `inclusionai/ling-3.0-flash:free` (free tier) | `https://openrouter.ai/api/v1` | Same model on the same upstream; rate-limited per upstream (Novita/DeepInfra) but otherwise identical |
+| `opencode/ling-3.0-flash-fin-free` | `https://opencode.ai/zen/v1` | OpenCode Zen free-tier lane, same carrier as the other Zen free models; previously fell through to the DeepSeek default and 400'd |
+
+No code change to the proxy logic itself — only the route table. Reasoning replay works the same way as for the other Chinese reasoning models: the SSE parser reads `delta.reasoning` (and the array form from `delta.reasoning_details`), the proxy caches it keyed by `x-session-id` + assistant index, and the next turn echoes it back as `reasoning_content` (which OpenRouter normalizes on outbound to the upstream).
+
+Live-verified with a two-turn reasoning-continuity test on port 3457. Turn 1 emitted 271 chars of reasoning on a 7×6 step-by-step; turn 2 (with the cached `reasoning_content` echoed back) referenced the prior step ("The user previously asked for 7 times 6, and I was in the process of showing step-by-step work. The result of 7 × 6 is 42.") and continued to 42+5=47. Upstream was Novita.
+
+Sources: [openrouter.ai/inclusionai/ling-3.0-flash](https://openrouter.ai/inclusionai/ling-3.0-flash) (model page), [ant-ling.com/en/docs/api-reference/openai/](https://ant-ling.com/en/docs/api-reference/openai/) (native ant-ling OpenAI-compatible API), [huggingface.co/inclusionAI/Ling-3.0-flash](https://huggingface.co/inclusionAI/Ling-3.0-flash) (model card), [github.com/inclusionAI](https://github.com/inclusionAI) (org), [arxiv.org/abs/2606.15079](https://arxiv.org/abs/2606.15079) (Ling/Ring 2.6 technical report).
+
 ## Plugin optionality and derived sessions
 
 As of 3.2.0, the plugin is optional. The shipped npm plugin still contains the transform hook; without it, derived keys keep caching functional; with it, you add exact session IDs + schema padding. The proxy derives session identity from the request when `x-session-id` is absent. Formula: `sha256(authHeader + '||' + modelName + '||' + firstUserMessageText)`, prefixed with `derived:` and truncated to 32 hex characters; header wins when present. The key is fixed at the first user message, so cross-talk is bounded to sessions sharing the same auth header, model, and first user prompt; replayed text is still valid reasoning for that model, so the impact is quality-level, never a 400.
@@ -252,8 +279,20 @@ Drop the plugin file in your OpenCode plugins directory and restart:
 ```bash
 mkdir -p ~/.config/opencode/plugins
 cp plugins/opencode-thinking-fix-universal.ts ~/.config/opencode/plugins/
+# Manual V1 copies also need the shared plugin package (npm installs and V2 hosts provide it):
+cd ~/.config/opencode && npm i @opencode/plugin
+```
+
+For the V2 API, add the package to `plugins` instead of `plugin`:
+
+```jsonc
+{
+  "plugins": ["opencode-thinking-fix"]
+}
 ```
 
+The same package supports both APIs from one default export. V2 reads `setup()`; V1 (>= 1.18.29) reads `server()`.
+
 It scans outgoing messages for any assistant turn that already has `reasoning_content`. If it finds one (meaning you are using a reasoning model), it adds `reasoning_content: ""` to every assistant turn missing it. If it finds nothing (Qwen, GPT, Claude, they never produce this field), it does nothing.
 
 It also handles `reasoning` for the OpenCode Go provider, and patches empty `content` fields that OpenAI-compatible SDKs sometimes omit.
@@ -425,6 +464,8 @@ The proxy auto-routes by model name prefix. All routes:
 | `glm`, `zhipu` | `https://open.bigmodel.cn/api/paas/v4` | Yes (`reasoning_content`) |
 | `minimax` | `https://api.minimax.io/v1` | Yes (`reasoning_details`, `reasoning_split:true`) |
 | `mimo` | `https://api.xiaomimimo.com/v1` | Yes (`reasoning_content`) |
+| `inclusionai/ling-3.0-flash` (and `:free`) | `https://openrouter.ai/api/v1` | Yes — OR normalizes to `delta.reasoning` + `delta.reasoning_details`; passback as `reasoning_content` is honored |
+| `opencode/ling-3.0-flash-fin-free` | `https://opencode.ai/zen/v1` | Yes (`reasoning_content`) |
 | `gpt`, `o1` | `https://api.openai.com` | No |
 | `claude`, `anthropic` | `https://api.anthropic.com` | No |
 | `qwen` | `https://dashscope-intl.aliyuncs.com/compatible-mode/v1` | No |
@@ -562,7 +603,7 @@ proof/                                  # evidence: captures, controls, CSVs, re
 | **macOS** | ✅ | ✅ | ✅ (bash) | ❌ (use launchd) |
 | **Windows** | ✅ | ✅ | ❌ (bash) | ❌ |
 
-OpenCode v1.17.9+, DeepSeek V4 Pro, Kimi K2.5/K2.6/K2.7, GLM-5.x, MiMo V2.5, MiniMax-M3, OpenCode Go.
+OpenCode v1.17.9+ (V1 plugin), OpenCode v2.0+ (V2 plugin), DeepSeek V4 Pro, Kimi K2.5/K2.6/K2.7, GLM-5.x, MiMo V2.5, MiniMax-M3, OpenCode Go.
 
 ### Windows notes
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-thinking-fix",
-  "version": "3.3.4",
-  "description": "Restores reasoning content dropped from multi-turn OpenCode conversations (DeepSeek, Kimi, GLM, MiMo, MiniMax, OpenCode Go, OpenRouter). Plugin + proxy + watchdog.",
+  "version": "4.0.0",
+  "description": "Restores reasoning content dropped from multi-turn OpenCode conversations (DeepSeek, Kimi, GLM, MiMo, MiniMax, InclusionAI/Ling, OpenCode Go, OpenRouter). V1 + V2 plugin, proxy, and watchdog.",
   "type": "module",
   "license": "MIT",
   "oc-plugin": [
@@ -20,6 +20,8 @@
     "zhipu",
     "mimo",
     "minimax",
+    "inclusionai",
+    "ling-3.0-flash",
     "openrouter",
     "xiaomi-mimo",
     "reasoning-content",
@@ -73,15 +75,12 @@
     "LICENSE.md"
   ],
   "dependencies": {
+    "@opencode/plugin": "^2.0.32",
     "eventsource-parser": "^3.1.0"
   },
-  "peerDependencies": {
-    "@opencode-ai/plugin": ">=1.3.0"
-  },
-  "peerDependenciesMeta": {
-    "@opencode-ai/plugin": {
-      "optional": false
-    }
+  "scripts": {
+    "test": "node tests/test-plugin.js && node tests/test-plugin-v2.js && node tests/test-proxy.js",
+    "typecheck": "tsc --noEmit"
   },
   "engines": {
     "node": ">=18"

package/plugins/opencode-thinking-fix-universal.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from '@opencode-ai/plugin'
+import { Plugin } from '@opencode/plugin'
 import { appendFileSync, mkdirSync } from 'fs'
 import { homedir } from 'os'
 import { join } from 'path'
@@ -21,16 +21,98 @@ function writeLog(entry: Record<string, unknown>): void {
   }
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// V1 message patching (OpenCode 1.x)
+//   Assistant turns must carry reasoning_content / reasoning so providers that
+//   require the passback do not reject the next request.
+// ─────────────────────────────────────────────────────────────────────────────
+
+function patchV1Messages(messages: any[]): { patched: number; reasoningModel: boolean; turns: Array<{ index: number; fields: string[] }> } {
+  // Self-detect: if any assistant turn has reasoning_content → reasoning model
+  const reasoningModel = messages.some((wrapper: any) => {
+    const msg = wrapper?.info ?? wrapper
+    return msg?.role === 'assistant' && ('reasoning_content' in msg || 'reasoning' in msg)
+  })
+
+  if (!reasoningModel) return { patched: 0, reasoningModel: false, turns: [] }
+
+  let patched = 0
+  const turns: Array<{ index: number; fields: string[] }> = []
+
+  messages.forEach((wrapper: any, index: number) => {
+    const msg = wrapper?.info ?? wrapper
+    if (!msg || msg.role !== 'assistant') return
+    const fields: string[] = []
+
+    if (!msg.content && msg.content !== '') {
+      msg.content = msg.tool_calls?.length ? 'call tool' : ''
+      fields.push('content')
+    }
+    if (!('reasoning_content' in msg)) { msg.reasoning_content = ''; fields.push('reasoning_content') }
+    if (!('reasoning' in msg)) { msg.reasoning = ''; fields.push('reasoning') }
+
+    if (fields.length > 0) {
+      patched += fields.length
+      turns.push({ index, fields })
+    }
+  })
+
+  return { patched, reasoningModel: true, turns }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// V2 message patching (OpenCode 2.x)
+//   V2 normalizes assistant turns into `content` parts, so the passback field
+//   is carried on `native.openaiCompatible.reasoning_content`. The OpenAI Chat
+//   protocol reads it when it builds the outbound body.
+// ─────────────────────────────────────────────────────────────────────────────
+
+function patchV2Messages(messages: any[]): { patched: number; reasoningModel: boolean } {
+  const reasoningModel = messages.some((msg: any) => {
+    if (!msg || msg.role !== 'assistant') return false
+    if (Array.isArray(msg.content) && msg.content.some((part: any) => part?.type === 'reasoning')) return true
+    const native = msg.native?.openaiCompatible
+    return !!native && (typeof native.reasoning_content === 'string' || typeof native.reasoning === 'string')
+  })
+
+  if (!reasoningModel) return { patched: 0, reasoningModel: false }
+
+  let patched = 0
+  for (const msg of messages) {
+    if (!msg || msg.role !== 'assistant') continue
+    if (msg.native === undefined) msg.native = {}
+    if (msg.native.openaiCompatible === undefined) msg.native.openaiCompatible = {}
+    const native = msg.native.openaiCompatible
+    if (typeof native.reasoning_content !== 'string') {
+      native.reasoning_content = ''
+      patched++
+    }
+  }
+
+  return { patched, reasoningModel: true }
+}
 
 // ─────────────────────────────────────────────────────────────────────────────
-// Plugin
+// V1 plugin (OpenCode 1.x)
 // ─────────────────────────────────────────────────────────────────────────────
-export const ThinkingFixPlugin: Plugin = async ({ client }) => {
+
+type V1Input = {
+  client?: {
+    app?: {
+      log?: (args: { body: { service: string; level: string; message: string } }) => Promise<unknown>
+    }
+  }
+}
+
+type V1Hooks = Record<string, (input: any, output: any) => Promise<void>>
+
+const ThinkingFixPluginV1 = async (input: V1Input = {}): Promise<V1Hooks> => {
+  const { client } = input
   mkdirSync(LOG_DIR, { recursive: true })
 
-  writeLog({ event: 'plugin_loaded', logFile: LOG_FILE })
+  writeLog({ event: 'plugin_loaded', runtime: 'v1', logFile: LOG_FILE })
 
-  await client.app.log({ body: { service: 'thinking-fix', level: 'info', message: `Plugin loaded, logging to ${LOG_FILE}` } })
+  await client?.app?.log?.({ body: { service: 'thinking-fix', level: 'info', message: `Plugin loaded, logging to ${LOG_FILE}` } })
 
   return {
     'chat.headers': async (input: any, output: any) => {
@@ -44,49 +126,91 @@ export const ThinkingFixPlugin: Plugin = async ({ client }) => {
         const messages = output?.messages
         if (!Array.isArray(messages) || messages.length === 0) return
 
-        // Self-detect: if any assistant turn has reasoning_content → reasoning model
-        const hasReasoning = messages.some((w: any) => {
-          const m = w?.info ?? w
-          return m?.role === 'assistant' && ('reasoning_content' in m || 'reasoning' in m)
-        })
+        const result = patchV1Messages(messages)
 
-        if (!hasReasoning) {
-          writeLog({ event: 'inspect', isReasoningModel: false, totalMessages: messages.length })
-          return
-        }
-
-        let patched = 0
-        const turns: Array<{ index: number; fields: string[] }> = []
-
-        messages.forEach((wrapper: any, index: number) => {
-          const msg = wrapper?.info ?? wrapper
-          if (!msg || msg.role !== 'assistant') return
-          const fields: string[] = []
-
-          if (!msg.content && msg.content !== '') {
-            msg.content = msg.tool_calls?.length ? 'call tool' : ''
-            fields.push('content')
-          }
-          if (!('reasoning_content' in msg)) { msg.reasoning_content = ''; fields.push('reasoning_content') }
-          if (!('reasoning' in msg)) { msg.reasoning = ''; fields.push('reasoning') }
-
-          if (fields.length > 0) {
-            patched += fields.length
-            turns.push({ index, fields })
-          }
+        writeLog({
+          event: 'inspect',
+          runtime: 'v1',
+          isReasoningModel: result.reasoningModel,
+          totalMessages: messages.length,
+          patchedFields: result.patched,
+          turns: result.turns,
         })
 
-        writeLog({ event: 'inspect', isReasoningModel: true, totalMessages: messages.length, patchedFields: patched, turns })
-
-        if (patched > 0) {
-          await client.app.log({ body: { service: 'thinking-fix', level: 'info', message: `patched ${patched} field(s) across ${messages.length} message(s)` } })
+        if (result.patched > 0) {
+          await client?.app?.log?.({
+            body: {
+              service: 'thinking-fix',
+              level: 'info',
+              message: `patched ${result.patched} field(s) across ${messages.length} message(s)`,
+            },
+          })
         }
       } catch (err: any) {
-        writeLog({ event: 'error', message: err?.message ?? String(err) })
-        await client.app.log({ body: { service: 'thinking-fix', level: 'error', message: `Error, passing through unmodified: ${err?.message ?? err}` } })
+        writeLog({ event: 'error', runtime: 'v1', message: err?.message ?? String(err) })
+        await client?.app?.log?.({
+          body: {
+            service: 'thinking-fix',
+            level: 'error',
+            message: `Error, passing through unmodified: ${err?.message ?? err}`,
+          },
+        })
       }
     },
   }
 }
 
+// ─────────────────────────────────────────────────────────────────────────────
+// V2 plugin (OpenCode 2.x)
+//   chat.headers            → ctx.session.hook('model.request', ...)
+//   chat.messages.transform → ctx.session.hook('context', ...)
+// ─────────────────────────────────────────────────────────────────────────────
+
+const ThinkingFixPluginV2 = Plugin.define({
+  id: 'opencode-thinking-fix',
+  async setup(ctx) {
+    mkdirSync(LOG_DIR, { recursive: true })
+    writeLog({ event: 'plugin_loaded', runtime: 'v2', directory: ctx.location.directory, logFile: LOG_FILE })
+
+    await ctx.session.hook('model.request', (event) => {
+      if (event.sessionID && !event.headers['x-session-id']) {
+        event.headers['x-session-id'] = event.sessionID
+      }
+    })
+
+    const inspect = (messages: any[]) => {
+      try {
+        if (!Array.isArray(messages) || messages.length === 0) return
+
+        const result = patchV2Messages(messages)
+
+        writeLog({
+          event: 'inspect',
+          runtime: 'v2',
+          isReasoningModel: result.reasoningModel,
+          totalMessages: messages.length,
+          patchedFields: result.patched,
+        })
+      } catch (err: any) {
+        writeLog({ event: 'error', runtime: 'v2', message: err?.message ?? String(err) })
+      }
+    }
+
+    // `context` covers the agent loop; `compaction` covers checkpoint summaries.
+    await ctx.session.hook('context', (event) => inspect(event.messages as any[]))
+    await ctx.session.hook('compaction', (event) => inspect(event.messages as any[]))
+  },
+})
 
+// ─────────────────────────────────────────────────────────────────────────────
+// Entrypoint
+//   V2 reads the default export's id/setup. V1 (>=1.18.29) reads server().
+//   Keeping one default object avoids loading the plugin twice on V1.
+// ─────────────────────────────────────────────────────────────────────────────
+
+export default {
+  ...ThinkingFixPluginV2,
+  async server(input: V1Input) {
+    return ThinkingFixPluginV1(input)
+  },
+}

package/proxy/core.js

@@ -88,6 +88,24 @@ export const ROUTES = {
   'opencode/deepseek-v4-flash-free': { base: 'https://opencode.ai/zen/v1', reasoningKey: 'reasoning_content' },
   'opencode/nemotron-3-ultra-free': { base: 'https://opencode.ai/zen/v1', reasoningKey: 'reasoning_content' },
   'opencode/nemotron-3.5-lightning-free': { base: 'https://opencode.ai/zen/v1', reasoningKey: 'reasoning_content' },
+  // F19 (2026-09-03): InclusionAI Ling 3.0 Flash — Chinese MoE reasoning model
+  // (124B/5.1B active, 262K ctx). Primary distribution is OpenRouter
+  // (`inclusionai/ling-3.0-flash` paid, `:free` free tier). On OR the response
+  // wire uses `delta.reasoning` (string) + `delta.reasoning_details` (array
+  // of `reasoning.text` items with `format: "unknown"`); OR also accepts
+  // `reasoning_content` as an input alias and normalizes on outbound to the
+  // upstream (Novita, DeepInfra). Native ant-ling.com uses
+  // `thinking.type: enabled|disabled`; not routed here (no client key).
+  'inclusionai/ling-3.0-flash': { base: 'https://openrouter.ai/api/v1', reasoningKey: 'reasoning_content' },
+  'inclusionai/ling-3.0-flash:free': { base: 'https://openrouter.ai/api/v1', reasoningKey: 'reasoning_content' },
+  // Zen free-tier lane: `opencode/ling-3.0-flash-fin-free` is served by the
+  // OpenCode Zen gateway at zen/v1 (chat/completions wire, DeepSeek-style
+  // `reasoning_content` carrier). Add the prefixed form here so 3457 model-
+  // routing sends it to Zen, not the default DeepSeek fallback.
+  'opencode/ling-3.0-flash-fin-free': { base: 'https://opencode.ai/zen/v1', reasoningKey: 'reasoning_content' },
+  // Catch-all for future InclusionAI variants (Ling-2.x, Ring-2.6-1T, etc.)
+  // that may be added to OpenRouter before this proxy gets a per-model entry.
+  'inclusionai': { base: 'https://openrouter.ai/api/v1', reasoningKey: 'reasoning_content' },
 }
 
 export const DEFAULT_ROUTE = { base: 'https://api.deepseek.com', reasoningKey: null }
@@ -358,3 +376,78 @@ export function createStreamParser(sessionId, baseIndex, onComplete) {
     },
   }
 }
+
+// F12 (2026-09-01): provider-specific request-body injections applied before
+// forwarding. Currently a single rule: Z.ai preserved-thinking opt-in. Future
+// F-tags (per-provider `thinking.keep`, sampling-constraint strips, etc.) can
+// be added here without growing the patchRequestBody signature.
+//
+// Z.ai `clear_thinking` is the server-side opt-in for Preserved Thinking on
+// the standard Z.ai Chat Completions endpoint. Default is `true` on the
+// standard API, `false` on the Coding Plan endpoint. With `true`, the server
+// strips prior reasoning_content from context even when the client passes it
+// back — which silently degrades multi-turn GLM sessions to "re-derive from
+// scratch every turn, loop, burn tokens". The OpenCode Go gateway and
+// OpenRouter do NOT change this default on the user's behalf; the client must
+// opt in.
+//
+// Docs:
+//   https://docs.z.ai/guides/capabilities/thinking-mode
+//     "This capability is enabled by default on the Coding Plan endpoint and
+//      disabled by default on the standard API endpoint. If you want to enable
+//      Preserved Thinking in your product … you can turn it on for the API
+//      endpoint by setting clear_thinking: false, and you must return the
+//      complete, unmodified reasoning_content back to the API."
+//   https://docs.z.ai/api-reference/llm/chat-completion
+//     thinking.clear_thinking — type boolean, default true.
+//
+// Z.ai-reachable hosts (allowlist, conservative):
+//   - open.bigmodel.cn       (BigModel direct, port 3457 universal mode)
+//   - api.z.ai               (Z.ai international, future-proofing)
+//   - opencode.ai/zen/go     (OpenCode Go gateway, port 3458)
+//   - openrouter.ai          (OpenRouter, port 3462; routes GLM to Z.ai under the hood)
+function isZAiReachableBase(base) {
+  if (!base || typeof base !== 'string') return false
+  let host, path
+  try { const u = new URL(base); host = u.hostname.toLowerCase(); path = u.pathname.toLowerCase() } catch { return false }
+  if (host === 'open.bigmodel.cn') return true
+  if (host === 'api.z.ai') return true
+  if (host === 'opencode.ai' && path.startsWith('/zen/go')) return true
+  if (host === 'openrouter.ai') return true
+  return false
+}
+
+export function applyProviderBodyInjections(modelName, body, routeTarget) {
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return { body, modified: false, injections: [] }
+  const injections = []
+  let modified = false
+  const lower = (modelName || '').toLowerCase()
+  const base = (routeTarget && routeTarget.base) || ''
+
+  // F12: GLM / Zhipu on any Z.ai-reachable lane — opt in to Preserved Thinking
+  // so the server keeps prior reasoning_content across turns instead of
+  // silently stripping it. Skipped when the client explicitly disabled
+  // thinking (forcing preserved thinking on top of disabled thinking would be
+  // incoherent). The merge is idempotent: a client-supplied thinking.type is
+  // preserved alongside the injected clear_thinking:false.
+  //
+  // Model-name detection accepts both bare names (glm-5.2, zhipu-glm-5) and
+  // gateway-prefixed slugs (z-ai/glm-5.2, zhipu/glm-4.5, opencode-go/glm-5.2).
+  // The "/glm" or "/zhipu" path-segment check catches the prefixed slugs that
+  // don't start with the bare name.
+  const isZAiModel = lower.startsWith('glm')
+    || lower.startsWith('zhipu')
+    || lower.includes('/glm')
+    || lower.includes('/zhipu')
+  if (isZAiModel && isZAiReachableBase(base)) {
+    if (body.thinking !== false) {
+      const before = body.thinking
+      const preserved = before && typeof before === 'object' && !Array.isArray(before) ? before : {}
+      body.thinking = { ...preserved, clear_thinking: false }
+      if (before !== body.thinking) modified = true
+      injections.push({ tag: 'F12', field: 'thinking.clear_thinking', value: false })
+    }
+  }
+
+  return { body, modified, injections }
+}

package/proxy/proxy.js

@@ -59,6 +59,7 @@ import url   from 'node:url'
 import {
   ROUTES, cache, stats, route, fixedUpstreamRoute, getSessionCache, patchRequestBody,
   extractReasoningFromJson, createStreamParser, writeLog, deriveSessionId, upstreamPathFor,
+  applyProviderBodyInjections,
 } from './core.js'
 
 const PORT            = parseInt(process.env.PORT || '3457', 10)
@@ -151,6 +152,21 @@ const server = http.createServer((req, res) => {
         // F10: same mode gate — only inject reasoning_split in routing mode.
         if (!UPSTREAM_URL && lower.startsWith('minimax')) bj.reasoning_split = true
 
+        // F12 (2026-09-01): provider-specific request-body injections.
+        // Currently a single rule: Z.ai clear_thinking:false on any Z.ai-reachable
+        // lane (3457 direct, 3458 Go, 3462 OpenRouter). Unlike F9/F10 this is NOT
+        // gated by !UPSTREAM_URL — Preserved Thinking is the Z.ai contract, not a
+        // port-3457-specific behavior. The host allowlist inside
+        // applyProviderBodyInjections() keeps the rule conservative.
+        const providerInjections = applyProviderBodyInjections(modelName, bj, routeTarget)
+        for (const inj of providerInjections.injections) {
+          if (DEBUG) console.log(`[F12] ${modelName} -> ${inj.field}=${JSON.stringify(inj.value)} (host=${routeTarget.base || 'unknown'})`)
+        }
+        if (providerInjections.injections.length > 0) {
+          writeLog({ event: 'provider_injection', model: modelName, session: sessionId.slice(-8),
+            injections: providerInjections.injections, host: routeTarget.base || '' })
+        }
+
         const patched = patchRequestBody(JSON.stringify(bj), sessionId, routeTarget.reasoningKey)
         bodyToSend = Buffer.from(patched.body, 'utf8')
         assistantCount = patched.assistantCount