opencode-thinking-fix 1.1.8 → 2.0.0

package/CHANGELOG.md

@@ -2,6 +2,41 @@
 
 All notable changes to `opencode-thinking-fix`.
 
+## [2.0.0] - 2026-06-24
+
+### Changed (breaking)
+- **Proxy memory leak fixed**: replaced unbounded `Map` with `LRUCache(500)`, O(1) eviction, zero timer overhead.
+- **SIGTERM/SIGINT cleanup**: `process.on` handlers drain active sessions and close the HTTP server cleanly. 5-second force-exit safety net.
+- **SSE parser replaced**: hand-rolled state machine → `eventsource-parser` (368k dependents). Built-in `maxBufferSize: 1MB` guard.
+- **Plugin `export default` removed**: named export `{ ThinkingFixPlugin }` only. Bare default caused TUI double-load at 71ms+73ms.
+- **`engines` field added**: `node >=18` required (node:http, structuredClone).
+- **`oc-plugin: ["server"]` field added**: explicit server-only target for OpenCode 1.3.x loader.
+
+### Added
+- `eventsource-parser` runtime dependency.
+- Provider docs evidence: all 5 providers (DeepSeek, Z.AI, Kimi, MiniMax, Xiaomi MiMo) officially confirm the `reasoning_content` bug in their published documentation.
+
+### Removed
+- `export default` bare export from plugin.
+- Hand-rolled SSE parser (~100 lines replaced by 18-line `eventsource-parser` integration).
+
+### Fixed
+- Plugin 175→92 lines (-47%). Proxy 409→422 lines (net: +13, but SSE parser is now battle-tested and memory-safe).
+
+## [1.1.9] - 2026-06-23
+
+### Added
+- **File-based logging**: JSON-lines log at `~/.local/share/opencode/thinking-fix.log`, captures `plugin_loaded`, `inspect`, `patched`, and `error` events with timestamps.
+- **`inspect` event**: logs field coverage on every request, `isReasoningModel`, `assistantTurns`, `missingContent`, `missingReasoningContent`, `missingReasoning`, proving plugin activity even when zero patches needed.
+- **Console fallback**: `writeLog` catches file write failures and emits `console.error` so failures are visible somewhere.
+
+### Changed
+- `client.app.log()` calls now use `await` for proper async handling.
+- Removal of `hook_fired` debug artifact, replaced by structured `inspect` event.
+
+### Fixed
+- **TUI install flow**: Ctrl+P "install plugin" → type `opencode-thinking-fix` no longer errors. Server-only plugin with bare `export default` properly installs via TUI and CLI without TUI target warnings.
+
 ## [1.1.8] - 2026-06-23
 
 ### Fixed
@@ -14,7 +49,7 @@ All notable changes to `opencode-thinking-fix`.
 ### Fixed
 - **TUI plugin loading error**: removed broken `opencode-thinking-fix-tui.ts`. OpenCode tried to load it as a TUI plugin at startup and failed because it didn't export `{ tui() }`. Package is now server-only.
 - **Plugin default export**: switched from v1 format (`{ server: Plugin }`) to v0 legacy format (bare `export default Plugin`), matching the proven opencode-wakatime pattern.
-- **package.json**: removed `oc-plugin` field, removed `dependencies`, moved `@opencode-ai/plugin` to optional `peerDependencies` (import is type-only, no runtime dep needed), whitelisted individual files instead of entire directories.
+- **package.json**: removed `oc-plugin` field, removed `dependencies`, moved `@opencode-ai/plugin` to `peerDependencies` (type-only import, no runtime dep needed), whitelisted individual files instead of entire directories.
 
 ## [1.1.6] - 2026-06-23
 

package/README.md

@@ -1,8 +1,9 @@
 # opencode-thinking-fix
 
 [![npm version](https://img.shields.io/npm/v/opencode-thinking-fix)](https://www.npmjs.com/package/opencode-thinking-fix)
+[![Test](https://github.com/tbosancheros39/opencode-thinking-fix/actions/workflows/test.yml/badge.svg)](https://github.com/tbosancheros39/opencode-thinking-fix/actions/workflows/test.yml)
 [![npm downloads](https://img.shields.io/npm/dm/opencode-thinking-fix)](https://www.npmjs.com/package/opencode-thinking-fix)
-[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/tbosancheros39/opencode-thinking-fix/blob/main/LICENSE.md)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/tbosancheros39/opencode-thinking-fix/blob/master/LICENSE.md)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D18-brightgreen)](https://nodejs.org/)
 
 ```bash
@@ -17,17 +18,17 @@ npm install opencode-thinking-fix
 
 ## Quick Install
 
-**This is an OpenCode plugin. Install it inside OpenCode — no terminal needed.**
+**This is an OpenCode plugin. Install it inside OpenCode, no terminal needed.**
 
 ### Method 1: TUI (press `Ctrl+P` while OpenCode is running)
 
 1. Press `Ctrl+P` to open the command palette.
 2. Type `install plugin` and press `Enter`.
-3. Press `Tab` to switch the install scope to **Global** (recommended — works across all projects).
+3. Press `Tab` to switch the install scope to **Global** (recommended, works across all projects).
 4. Type `opencode-thinking-fix`.
 5. Press `Enter`. Restart OpenCode.
 
-You should see `[ThinkingFix] Plugin loaded — universal reasoning_content fix active` at startup.
+You should see `[ThinkingFix] Plugin loaded, universal reasoning_content fix active` at startup.
 
 ### Method 2: CLI (shell command)
 
@@ -38,7 +39,7 @@ opencode plugin opencode-thinking-fix
 For a specific version:
 
 ```bash
-opencode plugin opencode-thinking-fix@1.1.4
+opencode plugin opencode-thinking-fix@2.0.0
 ```
 
 Restart OpenCode after installing.
@@ -83,7 +84,13 @@ You ask DeepSeek a question. It picks a tool, calls it, works fine. Then you ask
 HTTP 400: The reasoning_content in the thinking mode must be passed back to the API
 ```
 
-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 returns a 400 error.
+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 returns a 400 error. All five providers confirm this 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)."
+- **Kimi / Moonshot**: "[You must keep the reasoning_content in the multi-round conversation... otherwise an error will be thrown](https://platform.moonshot.ai/docs/guide/thinking-mode)."
+- **MiniMax**: "[The complete model response must be append to the conversation history](https://platform.minimaxi.com/document/ChatCompletion%20v2)."
+- **Xiaomi MiMo**: "[Any assistant message with tool calls... must preserve its full reasoning_content field, otherwise the API will return a 400 error](https://dev.mi.com/doc/llm-api). Affected frameworks include TRAE, Cursor, Roo Code, Codex, GitHub Copilot CLI, Zed, AutoGen."
 
 OpenCode's provider layer drops this field. Three upstream PRs ([#24250](https://github.com/anomalyco/opencode/pull/24250), [#24428](https://github.com/anomalyco/opencode/pull/24428), [#24895](https://github.com/anomalyco/opencode/pull/24895)) tried to fix it. None merged. The field is non-standard per OpenAI, so both OpenCode and the AI SDK ignore it.
 
@@ -95,7 +102,7 @@ This repo fixes it. Three layers, pick what you need.
 
 ### Install via npm (recommended)
 
-See [Quick Install](#quick-install) above — use OpenCode TUI (`Ctrl+P`) or CLI (`opencode plugin opencode-thinking-fix`).
+See [Quick Install](#quick-install) above, use OpenCode TUI (`Ctrl+P`) or CLI (`opencode plugin opencode-thinking-fix`).
 
 ### Manual install (for local development)
 
@@ -106,13 +113,13 @@ mkdir -p ~/.config/opencode/plugins
 cp plugins/opencode-thinking-fix-universal.ts ~/.config/opencode/plugins/
 ```
 
-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 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.
 
 No config file changes. No build step. OpenCode compiles `.ts` plugins when it starts.
 
-**The catch:** the plugin fills in empty strings, not your model's actual prior thinking. DeepSeek, Kimi K2.5/K2.6, GLM, and MiMo accept empty strings fine — your conversation works but the model does not see its earlier reasoning. Kimi K2.7 Code rejects empty strings entirely, it needs the real text.
+**The catch:** the plugin fills in empty strings, not your model's actual prior thinking. DeepSeek, Kimi K2.5/K2.6, GLM, and MiMo accept empty strings fine, your conversation works but the model does not see its earlier reasoning. Kimi K2.7 Code rejects empty strings entirely, it needs the real text.
 
 ---
 
@@ -131,7 +138,7 @@ The proxy runs on **two ports**:
 | **3457** | Direct providers (DeepSeek, Kimi, GLM, MiMo, GPT, Claude, Qwen, Gemini, etc.) | `PORT=3457` |
 | **3458** | OpenCode Go provider | `PORT=3458` `UPSTREAM_URL=https://opencode.ai/zen/go/v1` |
 
-Port 3457 auto-routes based on model name using the built-in route table. Port 3458 is a fixed-upstream proxy specifically for the OpenCode Go provider, which uses `delta.reasoning` (not `reasoning_content`) in its SSE streams. Both are handled by the same `proxy.js` binary — just different environment variables.
+Port 3457 auto-routes based on model name using the built-in route table. Port 3458 is a fixed-upstream proxy specifically for the OpenCode Go provider, which uses `delta.reasoning` (not `reasoning_content`) in its SSE streams. Both are handled by the same `proxy.js` binary, just different environment variables.
 
 ```bash
 # Linux / macOS / Windows (Node.js required)
@@ -154,7 +161,7 @@ systemctl --user enable --now reasoning-cache.service
 systemctl --user enable --now reasoning-cache-go.service
 ```
 
-Then point OpenCode at it — in your `opencode.json`:
+Then point OpenCode at it, in your `opencode.json`:
 
 ```json
 {
@@ -169,9 +176,9 @@ Then point OpenCode at it — in your `opencode.json`:
 }
 ```
 
-Zero npm dependencies. It uses `http`, `https`, and `url` — nothing else.
+One runtime dependency (`eventsource-parser`). The proxy uses Node.js built-in `http`, `https`, and `url` for everything else.
 
-**Interleaved thinking support:** GLM-5+ and MiniMax-M3 emit reasoning AFTER content in the same turn (interleaved thinking between tool calls). The proxy accumulates ALL reasoning across an entire assistant turn and flushes only on `finish_reason` — never on `delta.content` arrival. This prevents split/lost reasoning blocks.
+**Interleaved thinking support:** GLM-5+ and MiniMax-M3 emit reasoning AFTER content in the same turn (interleaved thinking between tool calls). The proxy accumulates ALL reasoning across an entire assistant turn and flushes only on `finish_reason`, never on `delta.content` arrival. This prevents split/lost reasoning blocks.
 
 **Kimi K2.7 Code and OpenCode Go need this.** The rest of the models benefit from it but do not technically require it.
 
@@ -242,7 +249,7 @@ Unknown models fall back to `https://api.deepseek.com` with reasoning disabled.
 
 ## Is it working?
 
-Turn 1 will not show anything — there is no history to patch yet. That is normal.
+Turn 1 will not show anything, there is no history to patch yet. That is normal.
 
 Turn 2+, check the console:
 
@@ -320,9 +327,9 @@ OpenCode is not the only tool that drops `reasoning_content`. Here is a partial
 
 ```
 plugins/
-  opencode-thinking-fix-universal.ts   # self-detection plugin (106 lines)
+  opencode-thinking-fix-universal.ts   # self-detection plugin (92 lines)
 proxy/
-  proxy.js                              # reasoning cache proxy (333 lines, zero deps)
+  proxy.js                              # reasoning cache proxy (422 lines, 1 dep)
 tests/
   test-plugin.js                        # plugin unit tests (228 lines, 12 cases)
   test-proxy.js                         # proxy unit tests (359 lines, 15 cases)
@@ -346,7 +353,7 @@ OpenCode v1.17.9+, DeepSeek V4 Pro, Kimi K2.5/K2.6/K2.7, GLM-5.x, MiMo V2.5, Min
 
 ### Windows notes
 
-**Plugin and proxy work fully on Windows.** The proxy (`proxy.js`) uses only Node.js built-in modules (`http`, `https`, `url`) — zero platform-specific code. Start it with:
+**Plugin and proxy work fully on Windows.** The proxy (`proxy.js`) uses one runtime dependency (`eventsource-parser`) plus Node.js built-in modules (`http`, `https`, `url`). No platform-specific code. Start it with:
 
 ```powershell
 # PowerShell

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "opencode-thinking-fix",
-  "version": "1.1.8",
+  "version": "2.0.0",
   "description": "Fix reasoning_content 400 errors for DeepSeek/Kimi/GLM/MiMo/MiniMax in OpenCode",
   "type": "module",
   "license": "MIT",
+  "oc-plugin": ["server"],
   "author": "tbosancheros39",
   "keywords": [
     "opencode",
@@ -20,6 +21,9 @@
     "type": "git",
     "url": "https://github.com/tbosancheros39/opencode-thinking-fix"
   },
+  "bugs": {
+    "url": "https://github.com/tbosancheros39/opencode-thinking-fix/issues"
+  },
   "homepage": "https://github.com/tbosancheros39/opencode-thinking-fix#readme",
   "main": "./plugins/opencode-thinking-fix-universal.ts",
   "exports": {
@@ -42,6 +46,9 @@
   "scripts": {
     "test": "node tests/test-plugin.js && node tests/test-proxy.js"
   },
+  "dependencies": {
+    "eventsource-parser": "^3.1.0"
+  },
   "peerDependencies": {
     "@opencode-ai/plugin": ">=1.3.0"
   },
@@ -50,6 +57,9 @@
       "optional": false
     }
   },
+  "engines": {
+    "node": ">=18"
+  },
   "devDependencies": {
     "typescript": "^6.0.3"
   }

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

@@ -1,83 +1,36 @@
 import type { Plugin } from '@opencode-ai/plugin'
+import { appendFileSync, mkdirSync } from 'fs'
+import { homedir } from 'os'
+import { join } from 'path'
 
-// ─────────────────────────────────────────────────────────────────────────────
-// CONFIRMED FACTS (cross-validated across DeepSeek V4 Pro, Claude MAX, Kimi
-// via live subagent research on OpenCode v1.17.9):
-//
-// 1. experimental.chat.messages.transform receives input: {} (always empty)
-//    input.model is NEVER available — confirmed by GitHub issue #25494
-//    Do NOT use input.model for provider detection — it is always undefined
-//
-// 2. Detection strategy: scan output.messages for any assistant turn that
-//    already HAS reasoning_content (set by OpenCode on the last response turn)
-//    If found → reasoning model (DeepSeek/Kimi/GLM/MiMo) → patch ALL turns
-//    If none → non-reasoning model (Qwen/GPT/Claude/Mistral) → pass through
-//    Zero false positives: non-reasoning models never produce reasoning_content
-//
-// 3. In-place mutation only — reassigning output.messages is a silent no-op
-//    Confirmed by GitHub issue #25754
-//
-// 4. Message wrapper shape: { info: Message, parts: Part[] } or bare Message
-//    Handle both via: wrapper?.info ?? wrapper
-//
-// DEPLOYMENT:
-//   Path: ~/.config/opencode/plugins/opencode-thinking-fix-universal.ts
-//         (plural "plugins/" — auto-discovery, zero config needed)
-//   Config: no opencode.json entry required for auto-discovery
-//           OR: "plugin": ["opencode-thinking-fix-universal"] (array, not object)
-//   Build: none — OpenCode compiles .ts plugins at load time
+// LOGGING
+//   File: ~/.local/share/opencode/thinking-fix.log
+//   Format: JSON lines, one entry per event
+//   View:  tail -f ~/.local/share/opencode/thinking-fix.log | jq
 // ─────────────────────────────────────────────────────────────────────────────
 
-function patchMessages(messages: any[]): number {
-  let count = 0
-
-  // ── Step 1: Self-detect reasoning model ──────────────────────────────────
-  // Scan for any assistant message that already has reasoning_content.
-  // OpenCode sets this field on the most recent response turn.
-  // Non-reasoning providers (Qwen/GPT/Claude/Mistral/Llama) never have it.
-  const isReasoningModel = messages.some((wrapper) => {
-    const msg = wrapper?.info ?? wrapper
-    return msg?.role === 'assistant' && ('reasoning_content' in msg || 'reasoning' in msg)
-  })
-
-  // ── Step 2: Non-reasoning model — exit immediately, zero modification ─────
-  // Qwen/GPT/Claude reject unknown fields with HTTP 400.
-  // This guard is what prevents multi-session errors on non-reasoning models.
-  if (!isReasoningModel) return 0
-
-  // ── Step 3: Patch all assistant turns missing required fields ─────────────
-  for (const wrapper of messages) {
-    const msg = wrapper?.info ?? wrapper
-    if (!msg || msg.role !== 'assistant') continue
-
-    // Fix 1: content must be non-null string on every assistant turn.
-    // OpenAI-compatible SDK omits it when only tool_calls are present.
-    if (!msg.content && msg.content !== '') {
-      msg.content = msg.tool_calls?.length ? 'call tool' : ''
-      count++
-    }
-
-    // Fix 2: reasoning_content must be present on every assistant turn in history.
-    // Absence causes HTTP 400 from DeepSeek/Kimi/GLM/MiMo on turn 2+.
-    // Use "" (empty string) — confirmed working cross-provider.
-    // "" and null both work per DeepSeek docs; "" is safer cross-provider.
-    if (!('reasoning_content' in msg)) {
-      msg.reasoning_content = ''
-      count++
-    }
-
-    // Fix 3: reasoning must be present for OpenCode Go provider on every turn.
-    if (!('reasoning' in msg)) {
-      msg.reasoning = ''
-      count++
-    }
-  }
+const LOG_DIR  = join(homedir(), '.local', 'share', 'opencode')
+const LOG_FILE = join(LOG_DIR, 'thinking-fix.log')
 
-  return count
+function writeLog(entry: Record<string, unknown>): void {
+  try {
+    mkdirSync(LOG_DIR, { recursive: true })
+    appendFileSync(LOG_FILE, JSON.stringify({ ts: new Date().toISOString(), ...entry }) + '\n', 'utf8')
+  } catch (err: any) {
+    try { console.error('[thinking-fix] log write failed:', err?.message) } catch {}
+  }
 }
 
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Plugin
+// ─────────────────────────────────────────────────────────────────────────────
 export const ThinkingFixPlugin: Plugin = async ({ client }) => {
-  client.app.log({ body: { service: 'thinking-fix', level: 'info', message: 'Plugin loaded — universal reasoning_content fix active' } })
+  mkdirSync(LOG_DIR, { recursive: true })
+
+  writeLog({ event: 'plugin_loaded', logFile: 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) => {
@@ -86,21 +39,54 @@ export const ThinkingFixPlugin: Plugin = async ({ client }) => {
       }
     },
 
-    'experimental.chat.messages.transform': async (_input: {}, output: any) => {
+    'experimental.chat.messages.transform': async (_input: any, output: any) => {
       try {
         const messages = output?.messages
         if (!Array.isArray(messages) || messages.length === 0) return
 
-        const patched = patchMessages(messages)
+        // 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)
+        })
+
+        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', isReasoningModel: true, totalMessages: messages.length, patchedFields: patched, turns })
 
         if (patched > 0) {
-          client.app.log({ body: { service: 'thinking-fix', level: 'info', message: `patched ${patched} field(s) across ${messages.length} message(s)` } })
+          await client.app.log({ body: { service: 'thinking-fix', level: 'info', message: `patched ${patched} field(s) across ${messages.length} message(s)` } })
         }
-      } catch (err) {
-        client.app.log({ body: { service: 'thinking-fix', level: 'error', message: `Error — passing through unmodified: ${err}` } })
+      } 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}` } })
       }
     },
   }
 }
 
-export default ThinkingFixPlugin
+

package/proxy/proxy.js

@@ -25,6 +25,7 @@
 const http  = require('http')
 const https = require('https')
 const url   = require('url')
+const { createParser } = require('eventsource-parser')
 
 const PORT = parseInt(process.env.PORT || '3457', 10)
 
@@ -67,15 +68,46 @@ function route(modelName) {
   return DEFAULT_ROUTE
 }
 
+// ── LRU Cache ─────────────────────────────────────────────────────────────
+// Bounded session cache using Map insertion-order eviction.
+// get() refreshes position; put() evicts least-recently-used when full.
+// Zero dependencies, O(1) get/put, memory-safe for long-running processes.
+class LRUCache {
+  constructor(capacity) {
+    this.cache = new Map()
+    this.capacity = capacity
+  }
+  get(key) {
+    if (!this.cache.has(key)) return undefined
+    const val = this.cache.get(key)
+    this.cache.delete(key)
+    this.cache.set(key, val)
+    return val
+  }
+  put(key, value) {
+    this.cache.delete(key)
+    if (this.cache.size >= this.capacity) {
+      const oldest = this.cache.keys().next().value
+      this.cache.delete(oldest)
+      console.log(`[Cache] evicted session ${String(oldest).slice(-8)} (capacity ${this.capacity})`)
+    }
+    this.cache.set(key, value)
+  }
+}
+
 // ── In-memory reasoning cache ─────────────────────────────────────────────
 // Structure: Map<sessionID, Map<assistantIndex, reasoning_content_string>>
 // sessionID comes from x-session-id header forwarded by OpenCode
 // assistantIndex is the position of the assistant message in the history array
-const cache = new Map()
+const cache = new LRUCache(500)
 
 function getSessionCache(sessionId) {
-  if (!cache.has(sessionId)) cache.set(sessionId, new Map())
-  return cache.get(sessionId)
+  let sessionMap = cache.get(sessionId)
+  if (!sessionMap) {
+    sessionMap = new Map()
+    cache.put(sessionId, sessionMap)
+  }
+  return sessionMap
 }
 
 // ── Request body patching ─────────────────────────────────────────────────
@@ -105,7 +137,7 @@ function patchRequestBody(body, sessionId) {
     }
 
     // Inject real cached reasoning if available, otherwise ""
-    // Check VALUE (not key existence) — plugin sets "" so key always exists
+    // Check VALUE (not key existence), plugin sets "" so key always exists
     if (!msg.reasoning_content) {
       const cached = sessionCache.get(assistantIndex)
       msg.reasoning_content = cached ?? ''
@@ -142,98 +174,56 @@ function patchRequestBody(body, sessionId) {
 }
 
 // ── SSE stream parser ─────────────────────────────────────────────────────
-// Parses streaming response chunks to extract reasoning_content
-// Accumulates across chunks since a single reasoning block can span many
+// Extracts reasoning_content from streaming chunks using eventsource-parser
+// (spec-compliant, 368k dependents, built-in maxBufferSize guard)
+const MAX_BUFFER = 1024 * 1024 // 1MB, prevents OOM on malformed streams
+
 function createStreamParser(sessionId, onComplete) {
-  let buffer = ''
   let reasoningBuffer = ''
-  let assistantIndex = 0  // tracks which assistant turn we're building
-  let inReasoning = false
-
-  return {
-    feed(chunk) {
-      buffer += chunk.toString()
-      const lines = buffer.split('\n')
-      buffer = lines.pop() // keep incomplete last line
-      const outLines = []
-
-      for (const line of lines) {
-        if (!line.startsWith('data: ')) {
-          outLines.push(line)
-          continue
-        }
-        const data = line.slice(6).trim()
-        if (data === '[DONE]') {
-          // Flush accumulated reasoning for this turn
-          if (reasoningBuffer) {
-            onComplete(assistantIndex, reasoningBuffer)
-            reasoningBuffer = ''
-          }
-          outLines.push(line)
-          continue
+  let assistantIndex = 0
+  const chunks = [] // forward buffers for re-serialization
+
+  const parser = createParser({
+    maxBufferSize: MAX_BUFFER,
+    onEvent(event) {
+      const line = event.event ? `event: ${event.event}\ndata: ${event.data}\n\n` : `data: ${event.data}\n\n`
+      chunks.push(line)
+
+      if (event.event === 'done' || JSON.parse(event.data || '{}')?.choices?.[0]?.finish_reason) {
+        if (reasoningBuffer) {
+          onComplete(assistantIndex, reasoningBuffer)
+          reasoningBuffer = ''
         }
-        try {
-          const parsed = JSON.parse(data)
-          const delta = parsed.choices?.[0]?.delta
-          if (!delta) {
-            outLines.push(line)
-            continue
-          }
-
-          // reasoning_content delta (DeepSeek/Kimi/GLM/MiniMax)
-          if (typeof delta.reasoning_content === 'string') {
-            reasoningBuffer += delta.reasoning_content
-            inReasoning = true
-          }
-
-          // reasoning_details array (MiniMax-M3 with reasoning_split: true)
-          if (Array.isArray(delta.reasoning_details)) {
-            for (const detail of delta.reasoning_details) {
-              if (typeof detail.text === 'string') {
-                reasoningBuffer += detail.text
-              }
-            }
-            inReasoning = true
-          }
-
-          // OpenCode Go uses delta.reasoning instead of reasoning_content
-          if (typeof delta.reasoning === 'string') {
-            reasoningBuffer += delta.reasoning
-            inReasoning = true
-          }
+        assistantIndex++
+        return
+      }
 
-          // content may contain embedded <think> tags when reasoning_split is not
-          // honored (MiniMax fallback). Extract them into reasoningBuffer.
-          if (typeof delta.content === 'string') {
-            const thinkMatch = delta.content.match(/<think>([\s\S]*?)<\/think>/)
-            if (thinkMatch) {
-              reasoningBuffer += thinkMatch[1]
-              inReasoning = true
-              delta.content = delta.content.replace(/<think>[\s\S]*?<\/think>/, '').trimStart()
-            }
-          }
+      if (!event.data || event.data === '[DONE]') return
 
-          // finish_reason means the assistant turn is complete
-          // Only flush here — NOT on content appearance (interleaved thinking
-          // emits reasoning AFTER content on GLM-5+ and MiniMax-M3)
-          if (parsed.choices?.[0]?.finish_reason) {
-            if (reasoningBuffer) {
-              onComplete(assistantIndex, reasoningBuffer)
-              reasoningBuffer = ''
-              inReasoning = false
-            }
-            assistantIndex++
+      try {
+        const parsed = JSON.parse(event.data)
+        const delta = parsed.choices?.[0]?.delta
+        if (!delta) return
+
+        if (typeof delta.reasoning_content === 'string') reasoningBuffer += delta.reasoning_content
+        if (typeof delta.reasoning === 'string') reasoningBuffer += delta.reasoning
+        if (Array.isArray(delta.reasoning_details)) {
+          for (const d of delta.reasoning_details) {
+            if (typeof d.text === 'string') reasoningBuffer += d.text
           }
-
-          // Re-serialize the possibly-modified chunk and forward it
-          outLines.push('data: ' + JSON.stringify(parsed))
-        } catch {
-          // malformed SSE chunk, forward unchanged
-          outLines.push(line)
         }
-      }
+      } catch { /* malformed SSE chunk, ignore */ }
+    },
+    onError(error) {
+      console.error(`[Proxy] SSE parser error in session ${sessionId.slice(-8)}:`, error.message)
+    }
+  })
 
-      return outLines.join('\n') + '\n'
+  return {
+    feed(chunk) {
+      chunks.length = 0
+      parser.feed(chunk)
+      return chunks.join('')
     },
     flush() {
       if (reasoningBuffer) {
@@ -246,7 +236,7 @@ function createStreamParser(sessionId, onComplete) {
 
 // ── Main proxy handler ────────────────────────────────────────────────────
 const server = http.createServer((req, res) => {
-  // Health check — plugin uses this to detect running proxy
+  // Health check, plugin uses this to detect running proxy
   if (req.method === 'GET' && req.url === '/health') {
     res.writeHead(200, { 'Content-Type': 'application/json' })
     res.end(JSON.stringify({ ok: true, uptime: Math.floor(process.uptime()) }))
@@ -407,3 +397,26 @@ server.on('error', (err) => {
   console.error('[Proxy] server error:', err.message)
   process.exit(1)
 })
+
+// ── Graceful shutdown ──────────────────────────────────────────────────────
+function shutdown(signal) {
+  console.log(`[Proxy] received ${signal}, shutting down gracefully...`)
+  // Log cache stats before clearing
+  let totalEntries = 0
+  for (const [, sessionMap] of cache.cache) {
+    totalEntries += sessionMap.size
+  }
+  console.log(`[Proxy] ${cache.cache.size} session(s), ${totalEntries} cached turn(s)`)
+  server.close(() => {
+    console.log('[Proxy] server closed')
+    process.exit(0)
+  })
+  // Force exit after 5 seconds if connections don't drain
+  setTimeout(() => {
+    console.error('[Proxy] forced exit after timeout')
+    process.exit(1)
+  }, 5000).unref()
+}
+
+process.on('SIGTERM', () => shutdown('SIGTERM'))
+process.on('SIGINT',  () => shutdown('SIGINT'))

package/tests/test-plugin.js

@@ -1,7 +1,7 @@
 'use strict'
 
 // ─────────────────────────────────────────────────────────────────────────────
-// patchMessages — ported from opencode-thinking-fix-universal.ts (lines 31-77)
+// patchMessages, ported from opencode-thinking-fix-universal.ts (lines 31-77)
 // ─────────────────────────────────────────────────────────────────────────────
 function patchMessages(messages) {
   let count = 0
@@ -12,7 +12,7 @@ function patchMessages(messages) {
     return msg?.role === 'assistant' && ('reasoning_content' in msg || 'reasoning' in msg)
   })
 
-  // Step 2: Non-reasoning model — exit immediately
+  // Step 2: Non-reasoning model, exit immediately
   if (!isReasoningModel) return 0
 
   // Step 3: Patch all assistant turns missing required fields
@@ -55,7 +55,7 @@ function test(name, fn) {
     console.log(`  PASS: ${name}`)
   } catch (e) {
     failed++
-    const msg = `${name} — ${e.message}`
+    const msg = `${name}, ${e.message}`
     failures.push(msg)
     console.log(`  FAIL: ${msg}`)
   }
@@ -142,7 +142,7 @@ test('TC5: Both assistant messages patched when at least one has reasoning', ()
 })
 
 // ── TC6: Already complete message ───────────────────────────────────────────
-test('TC6: Already complete message — no changes', () => {
+test('TC6: Already complete message, no changes', () => {
   const msgs = deepClone([
     { role: 'assistant', content: 'done', reasoning_content: 'done', reasoning: 'done' },
   ])
@@ -184,7 +184,7 @@ test('TC9: Empty messages array returns 0', () => {
 })
 
 // ── TC10: Non-reasoning model with tool_calls ────────────────────────────────
-test('TC10: Non-reasoning model with tool_calls — no injection', () => {
+test('TC10: Non-reasoning model with tool_calls, no injection', () => {
   const msgs = deepClone([
     { role: 'assistant', content: '', tool_calls: [{ function: { name: 'f' } }] },
   ])
@@ -199,7 +199,7 @@ test('TC11: Reasoning model patches content to "call tool"', () => {
     { role: 'assistant', content: '', tool_calls: [{ function: { name: 'f' } }], reasoning_content: 'thinking' },
   ])
   const result = patchMessages(msgs)
-  // content is '' (empty string) — guard `!msg.content && msg.content !== ''` skips it
+  // content is '' (empty string), guard `!msg.content && msg.content !== ''` skips it
   // because '' !== '' is false. The original code treats '' as valid content.
   // Only reasoning is patched (reasoning_content and content are already present/invalid).
   assert(result === 1, `expected 1 patch (reasoning), got ${result}`)

package/watchdog/watchdog.sh

@@ -28,7 +28,7 @@ check_and_start() {
         return 0
     fi
 
-    log "Proxy on port $port is DOWN — restarting..."
+    log "Proxy on port $port is DOWN, restarting..."
 
     # Kill any stale proxy process on this port
     pid=$(lsof -ti :"$port" 2>/dev/null)
@@ -55,7 +55,7 @@ check_and_start() {
 }
 
 # ── Main loop ────────────────────────────────────────────────────────────────
-log "Watchdog started — checking every ${CHECK_INTERVAL}s"
+log "Watchdog started, checking every ${CHECK_INTERVAL}s"
 
 while true; do
     check_and_start 3457 "$HEALTH_3457" ""