opencode-thinking-fix 3.3.3 → 4.0.0

package/README.md

@@ -28,15 +28,27 @@ The drop happens in SDK serializers and client transforms (truthy checks, missin
 
 **With the fix:** "Now add password reset." → AI reads its notes: "I used React Hook Form for login, I'll extend that." → works.
 
-## See it happen in 5 minutes
+## See it happen
 
-You need OpenCode and any reasoning model. No proxy, no plugin — this reproduces the drop on a stock install.
+You don't need a specific free-tier model. Use any reasoning model on your own API key (DeepSeek V4, Kimi K2.7, GLM-5, MiMo) or any reasoning-capable model from the routing table below.
 
-1. Start a session with a reasoning model (free tier works, e.g. `opencode/hy3-free`) and give it a real task. It thinks, answers, and emits `reasoning_content`.
-2. Ask a follow-up that depends on the first answer, then capture the outgoing request. Every `reasoning_content` field from turn 1 arrives empty or missing.
-3. The same request through the SDK alone keeps the field. The client is the difference.
+### 1. The 4-step reproduction
 
-Captured evidence for exactly this sequence: [`proof/free-models/`](proof/free-models/). The A/B controls that isolate the field as the only variable: [`proof/curl-control-results.txt`](proof/curl-control-results.txt).
+1. Start a session with a reasoning model and give it a task that requires a tool call ("List the files in this directory, then read the largest one").
+2. The model thinks, emits `reasoning_content`, and calls the tool.
+3. Ask a follow-up that depends on the first answer ("Now summarize what you just read").
+4. Capture the outgoing Turn-2 request. Every `reasoning_content` field from Turn 1 is missing or empty. The client dropped it.
+
+### 2. The dataset (the actual proof)
+
+If you don't want to run it yourself, the `proof/` directory contains the raw data from a week-long passive tap of real production traffic, byte-for-byte unmodified across DeepSeek, OpenCode Go, OpenCode Zen, and OpenRouter:
+
+- **1,968 drops captured** (turns that carried reasoning earlier in the session arrived at the API without it).
+- **2.29 million characters** of reasoning erased.
+- **22 of those drops were on OpenRouter** — proving it is not a direct-provider quirk.
+- **68% of drops happened with zero model change** (same model, same session, drop mid-conversation).
+
+Every number is recomputable from `proof/reasoning-drop/drops.csv`. The A/B controls isolating the client as the sole point of failure live in `proof/free-models/`. The headline is the dataset; the recipe is a courtesy.
 
 ## Why you've probably never seen it
 
@@ -50,15 +62,10 @@ If you run long sessions, heavy tool calls, model switching, or subagents, you h
 
 ## The evidence
 
-We ran four passive taps (DeepSeek, OpenCode Go, OpenCode Zen, OpenRouter) that forwarded traffic byte-for-byte untouched and logged only metadata. They ran for a week of real work, then were retired. Methodology and raw data: [`proof/` directory](proof/).
+The numbers above come from four passive taps (DeepSeek, OpenCode Go, OpenCode Zen, OpenRouter) that forwarded traffic byte-for-byte untouched and logged only metadata. They ran for a week of real work, then were retired. Methodology and raw data: [`proof/` directory](proof/).
 
-- **1,968 drops captured** — a turn that carried reasoning earlier in the same session arrives at the API without it.
-- **2.29 million characters** of reasoning erased over a week of real traffic.
-- **68% of drops happened with zero model change** — same model, same session. Not a model-switch artifact.
-- **OpenRouter drops it too** — 22 drops with confirmed session identity on models served through openrouter.ai, plus the same pattern on DeepSeek and OpenCode Go lanes.
 - **The SDK is innocent.** `@ai-sdk/openai-compatible` round-trips the field correctly; the drop happens in the client's own transform. Captured side by side in [`proof/free-models/`](proof/free-models/).
-
-Every number is recomputable from [`proof/reasoning-drop/drops.csv`](proof/reasoning-drop/drops.csv) and [`proof/reasoning-drop/switches.csv`](proof/reasoning-drop/switches.csv).
+- **Model-switch baseline** is in [`proof/reasoning-drop/switches.csv`](proof/reasoning-drop/switches.csv) so the 68% zero-model-change number is auditable independently of the drops file.
 
 ## For the skeptics
 
@@ -118,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:
@@ -130,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.
@@ -195,7 +229,7 @@ See also: [OpenCode plugin docs](https://opencode.ai/docs/plugins)
 ---
 
 - [The problem](#the-problem)
-- [See it happen in 5 minutes](#see-it-happen-in-5-minutes)
+- [See it happen](#see-it-happen)
 - [Why you've probably never seen it](#why-youve-probably-never-seen-it)
 - [The evidence](#the-evidence)
 - [For the skeptics](#for-the-skeptics)
@@ -245,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.
@@ -418,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 |
@@ -555,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.3",
-  "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