opencode-thinking-fix 3.1.4 → 3.3.0

package/README.md

@@ -10,23 +10,65 @@
 npm install opencode-thinking-fix
 ```
 
-> Fix for reasoning being dropped from multi-turn conversations with DeepSeek, Kimi, GLM, MiMo, and MiniMax-M3.
+> Restores reasoning content that clients and SDKs drop from multi-turn conversations — DeepSeek, Kimi, GLM, MiMo, MiniMax, OpenCode Go, and OpenRouter.
 >
-> **Zero config.** Install via `Ctrl+P`, restart OpenCode, done. The plugin auto-detects reasoning models and only patches when needed.
+> **Zero config.** Install via `Ctrl+P`, restart OpenCode, done. The plugin detects reasoning models and only patches when needed.
 >
 > Docs: [OpenCode Plugins](https://opencode.ai/docs/plugins)
 
-Your AI has a secret notebook.
+## The problem
 
-When DeepSeek or Kimi answers you, it scribbles notes first. "Let me think... the user wants a login page... I should use React Hook Form... check the API docs..." These notes are `reasoning_content`. You never see them. But the AI needs them.
+When DeepSeek or Kimi answers you, it scribbles notes first. "Let me think... the user wants a login page... I should use React Hook Form... check the API docs..." These notes are `reasoning_content`. You never see them. But the AI needs them — the provider docs require the notes to be sent back on every later turn.
 
-The client and its SDK throw the notebook away. Next turn, the AI reaches for it — but the request already went to the API without it. The request carries no notes, or a blank notebook. The AI doesn't crash, but it forgot everything it was thinking. That is why your AI seems dumber on turn 2. It's not dumber. It just lost its notes.
+The client and its SDK throw the notebook away. Next turn, the AI reaches for it, but the request already went out without it. The AI doesn't crash. It just forgot everything it was thinking. That is why your AI seems dumber on turn 2. It's not dumber. It lost its notes.
 
-The drop happens in SDK serializers and client transforms (truthy checks, missing type members, stripped signatures), not in the providers — the providers are doing exactly what their docs say.
+The drop happens in SDK serializers and client transforms (truthy checks, missing type members, stripped signatures), not in the providers. The providers do exactly what their docs say.
 
-**Without the plugin:** "Build me a login page." → AI builds it. "Now add password reset." → AI lost its notes, conversation degrades.
+**Without the fix:** "Build me a login page." → AI builds it. "Now add password reset." → notes gone, the answer comes back generic.
 
-**With the plugin:** "Build me a login page." → AI builds it, notes saved. "Now add password reset." → AI reads its notes: "I used React Hook Form for login, I'll extend that for password reset." → Works.
+**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
+
+You need OpenCode and any reasoning model. No proxy, no plugin — this reproduces the drop on a stock install.
+
+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.
+
+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).
+
+## Why you've probably never seen it
+
+This bug is conditional, and the conditions are "you work the tool hard":
+
+- **Short sessions never hit it.** The drop happens on turn 2+, worst after tool calls. A two-message chat looks fine.
+- **Most gateways don't enforce the contract.** On the free `opencode/zen` tier and OpenRouter, a missing field is accepted, so nothing errors. The model just quietly loses context. No 400, no warning, only worse answers.
+- **Non-reasoning models are unaffected.** GPT, Claude, Qwen, Gemini never emit the field.
+
+If you run long sessions, heavy tool calls, model switching, or subagents, you have probably been hit and blamed the model. That is who this fix is for. If you send three messages a day, you may genuinely never notice — and the plugin detects that and does nothing.
+
+## 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/).
+
+- **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).
+
+## For the skeptics
+
+Three objections come up every time this is posted. Fair questions, with the evidence:
+
+**"Works on my side."** Probably true. The drop is silent on most gateways — no 400, just worse answers, so nothing looks broken unless you compare turn-3 quality with and without. The A/B controls hold everything constant except the field. And the 68% stat rules out model switching as the explanation.
+
+**"Your config is broken."** The configs this was captured on are published, redacted, in [`proof/` directory](proof/). The root cause is in the client's message transform, not config — the SDK control shows the field surviving when only the client is removed from the path.
+
+**"The model cards already say to pass reasoning back."** They do. That is the point. The provider requires the field; the client drops it. The model card is the spec this repo implements.
 
 ---
 
@@ -72,7 +114,8 @@ causing cross-provider poisoning. v3.1 fixes that:
   filled all three fields, so a GLM turn stored under `reasoning` could poison a later
   DeepSeek replay that expects `reasoning_content`.
 - **R1 vs V4 split.** `deepseek-reasoner` (R1) must **not** receive reasoning echoed back
-  (400 if you do) while V4 must. R1 now routes with `reasoningKey: null`.
+  (400 if you do) while V4 must. R1 uses the v3.2 `reasoningKey: 'strip'` sentinel,
+  which actively removes reasoning fields before forwarding.
 - **Never fabricate reasoning.** Unknown models and providers that reject echo
   (Qwen, GPT, Claude, Gemini, Llama, Mistral, Cerebras-hosted GLM) default to
   `reasoningKey: null` — the body is forwarded untouched.
@@ -89,9 +132,9 @@ 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.
 
-## Plugin deprecation and derived sessions
+## Plugin optionality and derived sessions
 
-As of 3.0, plugin is deprecated. Proxy derives session identity from 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. Rare bounded collision: conversations sharing same first user message, model, and auth key share cache key, causing minor reasoning cross-talk that self-heals as turns diverge.
+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.
 
 ---
 
@@ -124,7 +167,7 @@ opencode plugin opencode-thinking-fix
 For a specific version:
 
 ```bash
-opencode plugin opencode-thinking-fix@3.1.4
+opencode plugin opencode-thinking-fix@3.3.0
 ```
 
 Restart OpenCode after installing.
@@ -149,13 +192,17 @@ See also: [OpenCode plugin docs](https://opencode.ai/docs/plugins)
 
 ---
 
-- [What problem this fixes](#what-problem-this-fixes)
+- [The problem](#the-problem)
+- [See it happen in 5 minutes](#see-it-happen-in-5-minutes)
+- [Why you've probably never seen it](#why-youve-probably-never-seen-it)
+- [The evidence](#the-evidence)
+- [For the skeptics](#for-the-skeptics)
 - [Option 1: Plugin (safety net)](#option-1-plugin-safety-net)
 - [Option 2: Proxy (replays real reasoning)](#option-2-proxy-replays-real-reasoning)
 - [Option 3: Watchdog (auto-recovery)](#option-3-watchdog-auto-recovery)
 - [How they work together](#how-they-work-together)
 - [Affected models](#affected-models)
-- [Model routing](#model-routing)
+- [Model routing](#model-routing-proxy-port-3457)
 - [Is it working?](#is-it-working)
 - [This bug is everywhere](#this-bug-is-everywhere)
 - [Files in this repo](#files-in-this-repo)
@@ -170,7 +217,7 @@ The client/SDK dropped the field before it reached the API — the providers are
 
 > **Deprecated:** the historical symptom of this drop — `HTTP 400: The reasoning_content in the thinking mode must be passed back to the API` — is **resolved** by this fix. This repo is about the drop itself, not the error it used to cause.
 
-DeepSeek V4 (and Kimi K2.7, GLM 5.x, MiMo V2.5) require that `reasoning_content` from every prior assistant turn gets included in subsequent API requests. The [docs](https://api-docs.deepseek.com/guides/thinking_mode) say it clearly: if you do not pass back `reasoning_content` correctly, the API rejects the request. All five providers confirm this in their official documentation:
+DeepSeek V4 (and Kimi K2.7, GLM 5.x, MiMo V2.5) require that `reasoning_content` from every prior assistant turn gets included in subsequent API requests. The [docs](https://api-docs.deepseek.com/guides/thinking_mode) describe the contract, and the strictness varies by provider and endpoint: some reject the request, some ignore the field, and the conversation still loses its context either way. All five providers confirm the passback requirement in their official documentation:
 
 - **DeepSeek**: "[The reasoning_content will be ignored by the API](https://api-docs.deepseek.com/guides/thinking_mode)", but the conversation history must contain the field.
 - **Z.AI / GLM**: "[Key: return reasoning_content to keep the reasoning coherent](https://docs.z.ai/en/api/thinking)."
@@ -348,6 +395,7 @@ The plugin is the safety net. If the proxy goes down, the plugin still injects e
 | MiMo V2.5 | Yes | Nice to have | `reasoning_content` on `api.xiaomimimo.com/v1` |
 | **MiniMax-M3** | Yes | **Recommended** | `reasoning_details[]` array; ~40% quality loss if stripped. Proxy injects `reasoning_split:true` to keep thinking separate from content. |
 | OpenCode Go | Yes | Recommended for chat/message routes | Chat uses `reasoning`; Anthropic messages are handled; unsupported response formats pass through |
+| OpenRouter (reasoning models via openrouter.ai) | Yes | Recommended | Field depends on the upstream model; the fixed-upstream proxy replays `reasoning_content` and passes everything else through |
 | Qwen, GPT, Claude, Gemini, Llama, Mistral | No | No | No reasoning_content |
 
 ---
@@ -359,7 +407,7 @@ The proxy auto-routes by model name prefix. All routes:
 | Prefix | Upstream | Reasoning |
 |---|---|---|
 | `deepseek-v4-pro`, `deepseek-v4-flash`, `deepseek-chat` | `https://api.deepseek.com` | Yes (`reasoning_content`) |
-| `deepseek-reasoner` | `https://api.deepseek.com` | **No — must NOT echo** (R1 contract) |
+| `deepseek-reasoner` | `https://api.deepseek.com` | **No — actively stripped** (R1 contract: reasoning must NOT be echoed) |
 | `kimi`, `moonshot` | `https://api.moonshot.ai/v1` | Yes (`reasoning_content`) |
 | `glm`, `zhipu` | `https://open.bigmodel.cn/api/paas/v4` | Yes (`reasoning_content`) |
 | `minimax` | `https://api.minimax.io/v1` | Yes (`reasoning_details`, `reasoning_split:true`) |
@@ -373,15 +421,37 @@ The proxy auto-routes by model name prefix. All routes:
 
 Unknown models fall back to `https://api.deepseek.com` with reasoning disabled.
 
+### OpenRouter (port 3462)
+
+OpenRouter wraps many upstream models, and reasoning models served through it lose their thinking the same way. Run a third fixed-upstream proxy and point your OpenRouter provider at it:
+
+```bash
+PORT=3462 UPSTREAM_URL=https://openrouter.ai/api/v1 REASONING_KEY=reasoning_content node proxy/proxy.js
+```
+
+```json
+{
+  "provider": {
+    "openrouter": {
+      "options": {
+        "baseURL": "http://127.0.0.1:3462/v1"
+      }
+    }
+  }
+}
+```
+
+The passive-tap corpus includes an OpenRouter lane: 22 session-confirmed drops, concentrated on `minimax/minimax-m3:free` within one long session — enough to show the pattern exists on OpenRouter, with the full model-by-model matrix left to a follow-up corpus. See [The evidence](#the-evidence).
+
 ---
 
 ## Is it working?
 
 The plugin writes a structured JSON log: `~/.local/share/opencode/thinking-fix.log`.
 
-628 unique sessions. 12,551 inspect events (the hook fires twice per message by design — first pass patches, second confirms clean). 297 reasoning model sessions patched, 331 non-reasoning correctly skipped. Zero false patches.
+Every request logs an `inspect` event (field coverage, whether the model is a reasoning model, how many turns were patched), so the plugin is auditable even when it patches nothing. Non-reasoning models are skipped by design — zero false patches is a property of the self-detection, not a promise bolted on.
 
-Before and after, from a real session:
+From a real 104-message session:
 
 ```
 Before:  reasoning dropped on every turn → AI forgets its thinking
@@ -443,20 +513,26 @@ OpenCode is not the only tool that drops `reasoning_content`. Here is a partial
 
 ```
 plugins/
-  opencode-thinking-fix-universal.ts   # self-detection plugin (92 lines)
+  opencode-thinking-fix-universal.ts   # self-detection plugin
 proxy/
-  core.js                               # pure logic: routes, cache, patching, parser (138 lines)
-  proxy.js                              # HTTP server + side effects (266 lines, 1 dep)
+  core.js                               # pure logic: routes, cache, patching, parser
+  proxy.js                              # HTTP server + side effects (1 dep)
 watchdog/
-  watchdog.sh                           # auto-recovery watchdog (64 lines)
+  watchdog.sh                           # auto-recovery watchdog
 systemd/
   reasoning-cache.service               # proxy systemd unit (port 3457)
   reasoning-cache-go.service            # OpenCode Go proxy unit (port 3458)
   reasoning-proxy-watchdog.service      # watchdog systemd unit
+tests/
+  test-proxy.js                         # 127 proxy assertions
+  test-plugin.js                        # 12 plugin assertions
+  live-minimax-replay.mjs               # self-contained replay gate (mock upstream)
+proof/                                  # evidence: captures, controls, CSVs, repro scripts
 ```
 
 ## Release highlights
 
+- **v3.2.0:** R1 `strip` sentinel (actively remove reasoning for `deepseek-r1`/`deepseek-reasoner`), multibyte-safe SSE decoding (StringDecoder), response hop-by-hop header stripping, oversized-reasoning skip-not-truncate, MiniMax replay shape behind `MINIMAX_REASONING_DETAILS_SHAPE` (default `minimal`), a real-core test suite (95 assertions), glm-5.2 go-mode `reasoning_content` key (live-verified across two turns), derived session keys, and `x-session-id` no longer forwarded upstream. See the changelog.
 - **v3.1.4:** proxy-owned structured JSONL logging with session identifiers truncated in logs.
 - **v3.1.3:** Anthropic-wire dialect detection for OpenCode Go routes.
 - **v3.1.2:** bounded cache/session memory, raw-stream preservation, hop-by-hop header removal, and safer parser failure handling.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-thinking-fix",
-  "version": "3.1.4",
-  "description": "Fix reasoning_content 400 errors for DeepSeek/Kimi/GLM/MiMo/MiniMax in OpenCode",
+  "version": "3.3.0",
+  "description": "Restores reasoning content dropped from multi-turn OpenCode conversations (DeepSeek, Kimi, GLM, MiMo, MiniMax, OpenCode Go). Plugin + proxy + watchdog.",
   "type": "module",
   "license": "MIT",
   "oc-plugin": [
@@ -26,10 +26,9 @@
     "thinking-mode",
     "tool-calls",
     "multi-turn",
-    "400-error",
-    "http-400",
     "proxy",
     "plugin",
+    "cli",
     "cursor",
     "cline",
     "aider",
@@ -44,7 +43,9 @@
     "chinese-llm",
     "agent",
     "mcp",
-    "api-fix"
+    "reasoning-preservation",
+    "thinking-blocks",
+    "context-restoration"
   ],
   "repository": {
     "type": "git",

package/proxy/core.js

@@ -5,6 +5,7 @@ import crypto from 'node:crypto'
 import { homedir } from 'node:os'
 import { join, dirname } from 'node:path'
 import { appendFileSync, mkdirSync } from 'node:fs'
+import { StringDecoder } from 'node:string_decoder'
 
 export function deriveSessionId(modelName, parsedBody, authHeader) {
   const messages = parsedBody?.messages
@@ -38,12 +39,29 @@ export function writeLog(entry) {
 const DEBUG = process.env.DEBUG === '1'
 
 export const ROUTES = {
-  // R1 aliases: reasoning must not be echoed.
-  'deepseek-r1': { base: 'https://api.deepseek.com', reasoningKey: null },
+  // Zen free-tier lane — BARE model ids as sent by the `opencode` provider
+  // section (port 3459, universal mode). MUST stay at the top: generic
+  // prefixes below ('deepseek-v4-flash', 'mimo', ...) would otherwise swallow
+  // these names and route free traffic to provider-native endpoints.
+  'x-preview-f-free': { base: 'https://opencode.ai/zen/v1', reasoningKey: 'reasoning_content' },
+  'hy3-free': { base: 'https://opencode.ai/zen/v1', reasoningKey: 'reasoning_content' },
+  'mimo-v2.5-free': { base: 'https://opencode.ai/zen/v1', reasoningKey: 'reasoning_content' },
+  'muse-spark-1.2-contributor-free': { base: 'https://opencode.ai/zen/v1', reasoningKey: 'reasoning_content' },
+  'deepseek-v4-flash-free': { base: 'https://opencode.ai/zen/v1', reasoningKey: 'reasoning_content' },
+  'ling-3.0-flash-fin-free': { base: 'https://opencode.ai/zen/v1', reasoningKey: 'reasoning_content' },
+  'laguna-s-2.1-free': { base: 'https://opencode.ai/zen/v1', reasoningKey: 'reasoning_content' },
+  'big-pickle': { base: 'https://opencode.ai/zen/v1', reasoningKey: 'reasoning_content' },
+  'ox-alpha-free': { base: 'https://opencode.ai/zen/v1', reasoningKey: 'reasoning_content' },
+  'nemotron-3-ultra-free': { base: 'https://opencode.ai/zen/v1', reasoningKey: 'reasoning_content' },
+  'nemotron-3.5-lightning-free': { base: 'https://opencode.ai/zen/v1', reasoningKey: 'reasoning_content' },
+  // R1 aliases: reasoning must not be echoed back — the 'strip' sentinel
+  // admits the request to patchRequestBody (to REMOVE any reasoning fields a
+  // client/plugin attached) while excluding it from response-side caching.
+  'deepseek-r1': { base: 'https://api.deepseek.com', reasoningKey: 'strip' },
   'deepseek-v4-pro': { base: 'https://api.deepseek.com', reasoningKey: 'reasoning_content' },
   'deepseek-v4-flash': { base: 'https://api.deepseek.com', reasoningKey: 'reasoning_content' },
   'deepseek-chat': { base: 'https://api.deepseek.com', reasoningKey: 'reasoning_content' },
-  'deepseek-reasoner': { base: 'https://api.deepseek.com', reasoningKey: null },
+  'deepseek-reasoner': { base: 'https://api.deepseek.com', reasoningKey: 'strip' },
   deepseek: { base: 'https://api.deepseek.com', reasoningKey: 'reasoning_content' },
   kimi: { base: 'https://api.moonshot.ai/v1', reasoningKey: 'reasoning_content' },
   moonshot: { base: 'https://api.moonshot.ai/v1', reasoningKey: 'reasoning_content' },
@@ -59,10 +77,30 @@ export const ROUTES = {
   gemini: { base: 'https://generativelanguage.googleapis.com/v1beta/openai', reasoningKey: null },
   llama: { base: 'https://api.together.xyz', reasoningKey: null },
   mistral: { base: 'https://api.mistral.ai', reasoningKey: null },
+  // opencode/ zen free-tier models — served by the OpenCode zen gateway at
+  // zen/v1 (chat/completions wire, reasoning_content carrier). Distinct from
+  // the opencode-go namespace (port 3458) handled by fixedUpstreamRoute.
+  // Explicit per-model prefixes only: no catch-all `opencode/` prefix, so paid
+  // opencode/* models keep their existing DEFAULT_ROUTE behavior.
+  'opencode/hy3-free': { base: 'https://opencode.ai/zen/v1', reasoningKey: 'reasoning_content' },
+  'opencode/mimo-v2.5-free': { base: 'https://opencode.ai/zen/v1', reasoningKey: 'reasoning_content' },
+  'opencode/muse-spark-1.2-contributor-free': { base: 'https://opencode.ai/zen/v1', reasoningKey: 'reasoning_content' },
+  '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' },
 }
 
 export const DEFAULT_ROUTE = { base: 'https://api.deepseek.com', reasoningKey: null }
 
+// F13 (2026-08-27): clients may speak either OpenAI-style relative paths
+// (/v1/...) or the upstream's full official prefix (/api/v1/... — OpenRouter's
+// documented base is https://openrouter.ai/api/v1). Never double the prefix.
+export function upstreamPathFor(reqUrl, basePath) {
+  if (!basePath || basePath === '/' || basePath === '/v1') return reqUrl
+  if (reqUrl === basePath || reqUrl.startsWith(basePath + '/')) return reqUrl
+  return basePath + reqUrl.replace(/^\/v1/, '')
+}
+
 export function route(modelName) {
   if (!modelName) return DEFAULT_ROUTE
   const lower = modelName.toLowerCase()
@@ -76,10 +114,27 @@ export function route(modelName) {
 const ANTHROPIC_WIRE_PREFIXES = ['minimax', 'qwen']
 
 export function fixedUpstreamRoute(modelName, requestUrl = '') {
-  const stripped = (modelName || '').toLowerCase().replace(/^opencode-go\//, '')
+  const stripped = (modelName || '').toLowerCase().replace(/^opencode-go(?:-(?:messages|responses))?\//, '')
   if (String(requestUrl).includes('/messages') && ANTHROPIC_WIRE_PREFIXES.some((p) => stripped.startsWith(p))) {
     return { base: '', reasoningKey: 'anthropic' }
   }
+  // F11 (validated 2026-08-19): the opencode-go gateway rejects the `reasoning`
+  // field on glm-5.2 chat/completions echo (400 "Extra inputs are not
+  // permitted") but accepts `reasoning_content`. glm-5.2 was live-validated
+  // two-turn; other Go models were NOT changed by F11 and keep the existing
+  // `reasoning` behavior below (no exhaustive per-model validation claimed).
+  if (stripped === 'glm-5.2' && String(requestUrl).includes('/chat/completions')) {
+    return { base: '', reasoningKey: 'reasoning_content' }
+  }
+  // REASONING_KEY env override (F12, 2026-08-27): lanes fixed to upstreams whose
+  // wire is reasoning_content-based (zen/v1 free models, OpenRouter normalized
+  // per-message passback) set REASONING_KEY=reasoning_content in their unit.
+  // OpenRouter docs define top-level `reasoning` as a config OBJECT on requests,
+  // so a string injection there must use reasoning_content instead. Units without
+  // the env (validated go lane, 3458) keep the unconditional 'reasoning' behavior.
+  if (process.env.REASONING_KEY) {
+    return { base: '', reasoningKey: process.env.REASONING_KEY }
+  }
   // Unconditional 'reasoning' for go mode: matches current working behavior
   // for chat/completions models; /responses bodies have no `messages` array
   // and pass through untouched.
@@ -113,11 +168,28 @@ const MAX_TURNS_PER_SESSION = Number.isFinite(parsedMaxTurns) && parsedMaxTurns
 const parsedMaxReasoning = parseInt(process.env.MAX_REASONING_CHARS || '200000', 10)
 const MAX_REASONING_CHARS = Number.isFinite(parsedMaxReasoning) && parsedMaxReasoning > 0 ? parsedMaxReasoning : 200000
 
+// MiniMax reasoning_details replay shape.
+//
+// NOTE (F6, 2026-08-19): in our opencode-go deployment (port 3458, Anthropic
+// /v1/messages wire) every MiniMax request resolves to reasoningKey 'anthropic'
+// via fixedUpstreamRoute(), so this constant and the reasoning_details branch
+// in patchRequestBody() are UNUSED in production. Retained defensively for the
+// port-3457 universal-mode / provider-native MiniMax fallback (ROUTES.minimax).
+//
+// 'full' emits the openai-responses-v1 item { type, format, index, text };
+// 'minimal' emits { type, text }. Default 'minimal' (smallest documented
+// outbound shape).
+const MINIMAX_REASONING_DETAILS_SHAPE = process.env.MINIMAX_REASONING_DETAILS_SHAPE === 'full' ? 'full' : 'minimal'
+
 class BoundedSessionMap extends Map {
   set(key, value) {
-    super.set(key, typeof value === 'string' ? value.slice(0, MAX_REASONING_CHARS) : value)
+    // Skip-not-truncate: an oversized reasoning value is dropped entirely
+    // rather than silently truncated (a truncated replay can be worse than a
+    // cache miss). Returns true when stored, false when skipped.
+    if (typeof value === 'string' && value.length > MAX_REASONING_CHARS) return false
+    super.set(key, value)
     while (this.size > MAX_TURNS_PER_SESSION) this.delete(this.keys().next().value)
-    return this
+    return true
   }
 }
 
@@ -164,14 +236,37 @@ export function patchRequestBody(body, sessionId, reasoningKey) {
         if (missingReasoning) { stats.misses++; report.misses++ }
       }
     } else if (reasoningKey === 'reasoning_details') {
+      // F6 (defensive): provider-native MiniMax on port 3457 universal mode
+      // replays reasoning into `reasoning_details`. Never executed in the
+      // opencode-go deployment (MiniMax always routes as 'anthropic' there) —
+      // retained for the universal-mode / provider-native fallback.
       const hasDetails = Array.isArray(msg.reasoning_details) ? msg.reasoning_details.length > 0 : !!msg.reasoning_details
       missingReasoning = !hasDetails && !msg.reasoning_content
       if (missingReasoning) report.missingReasoning++
       if (!hasDetails && !msg.reasoning_content && cached) {
-        msg.reasoning_details = [{ text: cached, type: 'thinking' }]; stats.hits++; report.hits++; report.turns.push({ index: assistantIndex, fields: ['reasoning_details'], source: 'hit' }); modified = true
+        msg.reasoning_details = MINIMAX_REASONING_DETAILS_SHAPE === 'full'
+          ? [{ type: 'reasoning.text', format: 'openai-responses-v1', index: assistantIndex, text: cached }]
+          : [{ type: 'reasoning.text', text: cached }]
+        stats.hits++; report.hits++; report.turns.push({ index: assistantIndex, fields: ['reasoning_details'], source: 'hit' }); modified = true
       } else if (missingReasoning) {
         stats.misses++; report.misses++
       }
+    } else if (reasoningKey === 'strip') {
+      // R1 sentinel: deepseek-r1 / deepseek-reasoner 400 when reasoning is
+      // echoed back. Actively remove any reasoning field a client/plugin may
+      // have attached rather than replay it.
+      const stripped = []
+      if (msg.reasoning_content !== undefined) { delete msg.reasoning_content; stripped.push('reasoning_content') }
+      if (msg.reasoning !== undefined) { delete msg.reasoning; stripped.push('reasoning') }
+      if (msg.reasoning_details !== undefined) { delete msg.reasoning_details; stripped.push('reasoning_details') }
+      if (Array.isArray(msg.content)) {
+        const kept = msg.content.filter((b) => !(b && (b.type === 'thinking' || b.type === 'redacted_thinking')))
+        if (kept.length !== msg.content.length) { msg.content = kept; stripped.push('content') }
+      }
+      if (stripped.length > 0) {
+        modified = true
+        report.turns.push({ index: assistantIndex, fields: stripped, source: 'strip' })
+      }
     } else if (!msg[reasoningKey] || msg[reasoningKey] === '') {
       missingReasoning = true
       report.missingReasoning++
@@ -192,7 +287,10 @@ export function extractReasoningFromJson(text) {
     // Anthropic buffered format: content[] with thinking blocks.
     if (Array.isArray(parsed?.content)) {
       const thinking = parsed.content
-        .filter((b) => b && b.type === 'thinking' && typeof b.thinking === 'string')
+        // Explicit redacted_thinking guard (redundant with the
+        // b.type === 'thinking' equality below, but kept for contract
+        // clarity: redacted blocks must never be replayed as reasoning).
+        .filter((b) => b && b.type === 'thinking' && b.type !== 'redacted_thinking' && typeof b.thinking === 'string')
         .map((b) => b.thinking)
         .join('\n')
       if (thinking) return thinking
@@ -213,6 +311,9 @@ export function extractReasoningFromJson(text) {
 
 export function createStreamParser(sessionId, baseIndex, onComplete) {
   let reasoningBuffer = ''
+  // StringDecoder buffers partial multibyte UTF-8 sequences across feed()
+  // calls, so a character split between two chunks is not corrupted.
+  const decoder = new StringDecoder('utf8')
   const parser = createParser({
     maxBufferSize: 1024 * 1024,
     onEvent(event) {
@@ -249,7 +350,11 @@ export function createStreamParser(sessionId, baseIndex, onComplete) {
     onError(error) { if (DEBUG) console.error(`[Proxy] SSE parse error (${sessionId.slice(-8)}):`, error.message) },
   })
   return {
-    feed(chunk) { parser.feed(chunk.toString('utf8')) },
-    flush() { if (reasoningBuffer) { onComplete(baseIndex, reasoningBuffer); reasoningBuffer = '' } },
+    feed(chunk) { parser.feed(decoder.write(chunk)) },
+    flush() {
+      const tail = decoder.end()
+      if (tail) parser.feed(tail)
+      if (reasoningBuffer) { onComplete(baseIndex, reasoningBuffer); reasoningBuffer = '' }
+    },
   }
 }

package/proxy/proxy.js

@@ -1,7 +1,7 @@
 'use strict'
 
 // ─────────────────────────────────────────────────────────────────────────────
-// OpenCode Reasoning Cache Proxy  —  v3.1 (performance + correctness + dialect)
+// OpenCode Reasoning Cache Proxy  —  v3.2 (performance + correctness + dialect)
 //
 // What it does:
 //   - Sits between OpenCode and DeepSeek/Kimi/GLM/MiMo/MiniMax on localhost:3457
@@ -35,6 +35,12 @@
 //   deepseek-reasoner (R1) is null: it must NOT receive reasoning echoed back.
 //   Unknown models default to null (never fabricate reasoning).
 //
+// Sentinel fix (v3.2):
+//   R1 (deepseek-r1 / deepseek-reasoner) now uses reasoningKey 'strip' — the
+//   request is admitted to patchRequestBody to actively REMOVE reasoning fields
+//   (shouldPatch), but excluded from response-side caching (shouldCache). All
+//   other null routes stay null (never fabricate, never strip). See v3.2.0.
+//
 // Deployment:
 //   node proxy.js
 //   PORT=3457  (universal model-routing proxy)
@@ -52,7 +58,7 @@ import https from 'node:https'
 import url   from 'node:url'
 import {
   ROUTES, cache, stats, route, fixedUpstreamRoute, getSessionCache, patchRequestBody,
-  extractReasoningFromJson, createStreamParser, writeLog, deriveSessionId,
+  extractReasoningFromJson, createStreamParser, writeLog, deriveSessionId, upstreamPathFor,
 } from './core.js'
 
 const PORT            = parseInt(process.env.PORT || '3457', 10)
@@ -108,6 +114,9 @@ const server = http.createServer((req, res) => {
       sessionId = deriveSessionId(modelName, parsedBody, req.headers['authorization']) || 'unknown'
     }
     const shouldPatch = isPost && isJson && !!routeTarget.reasoningKey && !!sessionId && sessionId !== 'unknown'
+    // 'strip' routes (R1) are admitted to patchRequestBody (to REMOVE reasoning)
+    // but never cached for replay — reasoning must never be echoed back to R1.
+    const shouldCache = shouldPatch && routeTarget.reasoningKey !== 'strip'
 
     if (!shouldPatch) {
       const reason = !isPost ? 'get'
@@ -131,12 +140,16 @@ const server = http.createServer((req, res) => {
         // Kimi/Moonshot hardcode sampling params for thinking models.
         const lower = modelName.toLowerCase()
         const isKimi = lower.startsWith('kimi') || lower.startsWith('moonshot')
-        if (isKimi) {
+        // F9: model-specific body tweaks are model-routing-mode only (3457).
+        // In fixed-upstream (OpenCode Go) mode the upstream owns per-model
+        // handling, so sampling params are left untouched.
+        if (!UPSTREAM_URL && isKimi) {
           for (const k of ['temperature', 'top_p', 'top_k', 'presence_penalty', 'frequency_penalty', 'n']) delete bj[k]
           if (lower.startsWith('kimi-k2.7')) { delete bj.thinking; delete bj.reasoning_effort }
         }
         // MiniMax: keep thinking separate from content.
-        if (lower.startsWith('minimax')) bj.reasoning_split = true
+        // F10: same mode gate — only inject reasoning_split in routing mode.
+        if (!UPSTREAM_URL && lower.startsWith('minimax')) bj.reasoning_split = true
 
         const patched = patchRequestBody(JSON.stringify(bj), sessionId, routeTarget.reasoningKey)
         bodyToSend = Buffer.from(patched.body, 'utf8')
@@ -157,13 +170,11 @@ const server = http.createServer((req, res) => {
     }
 
     // ── Upstream request options ──
-    let upstreamPath = req.url
-    const basePath = upstream.path || '/'
-    if (basePath !== '/' && basePath !== '/v1') {
-      upstreamPath = basePath + req.url.replace(/^\/v1/, '')
-    }
+    // F13: path normalization lives in core.js (upstreamPathFor) — never double
+    // the upstream's official prefix.
+    const upstreamPath = upstreamPathFor(req.url, upstream.path || '/')
     const transport = upstream.protocol === 'https:' ? https : http
-    const HOP_BY_HOP = new Set(['connection', 'keep-alive', 'te', 'trailer', 'transfer-encoding', 'upgrade', 'proxy-'])
+    const HOP_BY_HOP = new Set(['connection', 'keep-alive', 'te', 'trailer', 'transfer-encoding', 'upgrade', 'proxy-', 'x-session-id'])
     const safeHeaders = {}
     for (const [key, value] of Object.entries(req.headers)) {
       const lowerKey = key.toLowerCase()
@@ -218,20 +229,26 @@ const server = http.createServer((req, res) => {
       const isOk = (proxyRes.statusCode || 500) < 400
       const isCompressed = !!proxyRes.headers['content-encoding']
 
-      // Forward response headers unchanged; client must decode compressed bytes.
+      // Forward response headers, stripping hop-by-hop headers first (F2).
+      // Node manages transfer-encoding/content-length on the client leg, so
+      // forwarding the upstream's chunking/connection headers would corrupt
+      // the re-streamed response. This single site covers all three response
+      // paths below (buffered JSON, passthrough pipe, reasoning stream).
       const outHeaders = { ...proxyRes.headers }
+      for (const h of ['transfer-encoding', 'connection', 'keep-alive', 'te', 'trailer', 'upgrade', 'proxy-authenticate', 'proxy-authorization']) {
+        delete outHeaders[h]
+      }
       res.writeHead(proxyRes.statusCode, outHeaders)
 
       // Buffer ordinary JSON responses so reasoning can be cached too.
-      if (shouldPatch && !isStream && isOk && !isCompressed) {
+      if (shouldCache && !isStream && isOk && !isCompressed) {
         const responseChunks = []
         proxyRes.on('data', (chunk) => responseChunks.push(chunk))
         proxyRes.on('end', () => {
           if (responseClosed) return
           const responseBody = Buffer.concat(responseChunks)
           const reasoning = extractReasoningFromJson(responseBody.toString('utf8'))
-          if (reasoning) {
-            getSessionCache(sessionId).set(assistantCount, reasoning)
+          if (reasoning && getSessionCache(sessionId).set(assistantCount, reasoning)) {
             stats.stored++
             writeLog({ event: 'cache_store', session: sessionId.slice(-8), turn: assistantCount, chars: reasoning.length })
           }
@@ -243,7 +260,7 @@ const server = http.createServer((req, res) => {
         return
       }
 
-      if (!shouldPatch || !isStream || !isOk || isCompressed) {
+      if (!shouldCache || !isStream || !isOk || isCompressed) {
         proxyRes.pipe(res)
         proxyRes.on('error', closeResponse)
         proxyRes.on('aborted', closeResponse)
@@ -253,10 +270,11 @@ const server = http.createServer((req, res) => {
       // Reasoning stream: forward RAW bytes immediately, parse only for cache.
       const parser = createStreamParser(sessionId, assistantCount, (index, reasoning) => {
         const sc = getSessionCache(sessionId)
-        sc.set(index, reasoning)
-        stats.stored++
-        writeLog({ event: 'cache_store', session: sessionId.slice(-8), turn: index, chars: reasoning.length })
-        if (DEBUG) console.log(`[Cache] ${sessionId.slice(-8)}: stored turn ${index} (${reasoning.length} chars)`)
+        if (sc.set(index, reasoning)) {
+          stats.stored++
+          writeLog({ event: 'cache_store', session: sessionId.slice(-8), turn: index, chars: reasoning.length })
+          if (DEBUG) console.log(`[Cache] ${sessionId.slice(-8)}: stored turn ${index} (${reasoning.length} chars)`)
+        }
       })
 
       let parserDead = false
@@ -283,7 +301,7 @@ const server = http.createServer((req, res) => {
 })
 
 server.listen(PORT, '127.0.0.1', () => {
-  writeLog({ event: 'proxy_started', port: PORT, version: '3.1.4', upstream: UPSTREAM_URL || 'model-routing', pid: process.pid })
+  writeLog({ event: 'proxy_started', port: PORT, version: '3.2.0', upstream: UPSTREAM_URL || 'model-routing', pid: process.pid })
   if (UPSTREAM_URL) {
     console.log(`[Proxy] fixed-upstream proxy on http://127.0.0.1:${PORT} -> ${UPSTREAM_URL}`)
   } else {