opencode-thinking-fix 3.1.4 → 3.2.0

package/README.md

@@ -10,7 +10,7 @@
 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, and OpenCode Go.
 >
 > **Zero config.** Install via `Ctrl+P`, restart OpenCode, done. The plugin auto-detects reasoning models and only patches when needed.
 >
@@ -72,7 +72,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 +90,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 +125,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.2.0
 ```
 
 Restart OpenCode after installing.
@@ -359,7 +360,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`) |
@@ -443,12 +444,12 @@ 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)
@@ -457,6 +458,7 @@ systemd/
 
 ## 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 (F11, live-verified), derived session keys (Option C), 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.2.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,14 @@ 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 },
+  // 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' },
@@ -76,10 +79,18 @@ 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' }
+  }
   // 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 +124,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 +192,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 +243,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 +267,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 +306,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)
@@ -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')
@@ -163,7 +176,7 @@ const server = http.createServer((req, res) => {
       upstreamPath = basePath + req.url.replace(/^\/v1/, '')
     }
     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 +231,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 +262,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 +272,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 +303,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 {