opencode-thinking-fix 1.1.9 → 2.0.1

package/CHANGELOG.md

@@ -2,16 +2,37 @@
 
 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.
+- **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.
+- 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.
@@ -28,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
@@ -11,23 +12,40 @@ npm install opencode-thinking-fix
 
 > Fix for the `reasoning_content` 400 error that kills multi-turn conversations with DeepSeek, Kimi, GLM, MiMo, and MiniMax-M3 in OpenCode.
 >
+> **Zero config.** Install via `Ctrl+P`, restart OpenCode, done. The plugin auto-detects reasoning models and only patches when needed.
+>
 > Docs: [OpenCode Plugins](https://opencode.ai/docs/plugins)
 
+Your AI has a secret notebook.
+
+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.
+
+OpenCode throws the notebook away. Next turn, the AI reaches for it — but OpenCode already handed the request to the API without it. The API returns HTTP 400. Or worse, OpenCode hands back 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.
+
+**Without the plugin:** "Build me a login page." → AI builds it. "Now add password reset." → 400 error, conversation dead.  
+**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.
+
 ---
 
 ## 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 | Command | Best for |
+|--------|---------|----------|
+| **TUI** | `Ctrl+P` → type `install plugin` → `opencode-thinking-fix` | First-time users |
+| **CLI** | `opencode plugin opencode-thinking-fix` | Scripting |
+| **Manual** | Add `"plugin": ["opencode-thinking-fix"]` to `opencode.json` | Version pinning |
 
 ### 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.
+Check `~/.local/share/opencode/thinking-fix.log` for `plugin_loaded`. See [Is it working?](#is-it-working).
 
 ### Method 2: CLI (shell command)
 
@@ -38,7 +56,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.
@@ -55,10 +73,12 @@ Config file location:
 - **Linux/macOS:** `~/.config/opencode/opencode.json` (global) or `.opencode/opencode.json` (project)
 - **Windows:** `%APPDATA%/OpenCode/opencode.json` (global) or `.opencode/opencode.json` (project)
 
-Restart OpenCode after adding. You should see `[ThinkingFix] Plugin loaded` at startup.
+Restart OpenCode after adding. Check `~/.local/share/opencode/thinking-fix.log` for `plugin_loaded`. See [Is it working?](#is-it-working).
 
 See also: [OpenCode plugin docs](https://opencode.ai/docs/plugins)
 
+> **On Windows?** See [Windows notes](#windows-notes) for PowerShell commands, NSSM service setup, and config paths.
+
 ---
 
 - [What problem this fixes](#what-problem-this-fixes)
@@ -72,6 +92,7 @@ See also: [OpenCode plugin docs](https://opencode.ai/docs/plugins)
 - [Running tests](#running-tests)
 - [This bug is everywhere](#this-bug-is-everywhere)
 - [Files in this repo](#files-in-this-repo)
+- [Changelog](#changelog)
 
 ---
 
@@ -83,7 +104,15 @@ 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.
+This is OpenCode dropping the field before it reaches the API — the providers are doing exactly what their docs say.
+
+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 +124,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 +135,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 +160,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 +183,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 +198,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,35 +271,40 @@ 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.
+The plugin writes a structured JSON log: `~/.local/share/opencode/thinking-fix.log`.
 
-Turn 2+, check the console:
+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.
 
-**Plugin working:**
-```
-[ThinkingFix] patched 3 field(s) across 11 message(s)
-```
+Before and after, from a real session:
 
-**Proxy working:**
 ```
-[Cache] session abcdefgh: stored reasoning turn 0 (1842 chars)
-[Cache] session abcdefgh: replayed reasoning for turn 0 (1842 chars)
+Before:  HTTP 400: The reasoning_content in the thinking mode must be passed back to the API
+After:   34 fields patched across a 104-message session → conversation continues
 ```
 
-If nothing shows up, either it is a non-reasoning model (correct) or the plugin did not load (check for `[ThinkingFix] Plugin loaded` at startup).
+Here is a live excerpt from that session:
+
+```json
+{"ts":"2026-06-25T01:41:50.572Z","event":"inspect","isReasoningModel":true,
+ "totalMessages":104,"patchedFields":34,"turns":[
+   {"index":1,"fields":["text","reasoning"]},
+   {"index":5,"fields":["text"]},
+   {"index":9,"fields":["text"]},
+   {"index":42,"fields":["reasoning"]}
+ ]}
+```
 
-Quick proxy health check:
+**No output?** Either you are on a non-reasoning model (correct, no patching needed) or the plugin did not load. Check:
 
 ```bash
-curl http://127.0.0.1:3457/health
-# → {"ok":true,"uptime":42}
-curl http://127.0.0.1:3458/health
-# → {"ok":true,"uptime":42}
+grep plugin_loaded ~/.local/share/opencode/thinking-fix.log
 ```
 
-Proxy logs:
+Proxy health:
 
 ```bash
+curl http://127.0.0.1:3457/health          # → {"ok":true,"uptime":1225}
+curl http://127.0.0.1:3458/health          # → {"ok":true,"uptime":1225}
 journalctl --user -u reasoning-cache.service -f
 journalctl --user -u reasoning-cache-go.service -f
 ```
@@ -320,9 +354,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)
@@ -334,6 +368,12 @@ systemd/
   reasoning-proxy-watchdog.service      # watchdog systemd unit
 ```
 
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for release history. Current: **v2.0.0** — eventsource-parser, LRU cache, SIGTERM handling, 12+15 passing tests.
+
+---
+
 ## Tested on
 
 | Platform | Plugin | Proxy | Watchdog | Systemd |
@@ -346,7 +386,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,24 +1,57 @@
 {
   "name": "opencode-thinking-fix",
-  "version": "1.1.9",
+  "version": "2.0.1",
   "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",
+    "opencode-plugin",
+    "opencode-cli",
     "deepseek",
+    "deepseek-v4",
     "kimi",
+    "moonshot",
     "glm",
+    "zhipu",
     "mimo",
     "minimax",
-    "reasoning",
+    "xiaomi-mimo",
+    "reasoning-content",
     "reasoning_content",
-    "plugin"
+    "thinking-mode",
+    "tool-calls",
+    "multi-turn",
+    "400-error",
+    "http-400",
+    "proxy",
+    "plugin",
+    "cursor",
+    "cline",
+    "aider",
+    "roo-code",
+    "continue-dev",
+    "vscode",
+    "copilot",
+    "ai-coding",
+    "llm",
+    "chat-completion",
+    "openai-compatible",
+    "chinese-llm",
+    "agent",
+    "mcp",
+    "api-fix"
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/tbosancheros39/opencode-thinking-fix"
+    "url": "git+https://github.com/tbosancheros39/opencode-thinking-fix.git"
+  },
+  "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",
@@ -42,6 +75,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 +86,9 @@
       "optional": false
     }
   },
+  "engines": {
+    "node": ">=18"
+  },
   "devDependencies": {
     "typescript": "^6.0.3"
   }

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

@@ -3,36 +3,9 @@ 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
+//   Format: JSON lines, one entry per event
 //   View:  tail -f ~/.local/share/opencode/thinking-fix.log | jq
 // ─────────────────────────────────────────────────────────────────────────────
 
@@ -48,60 +21,6 @@ function writeLog(entry: Record<string, unknown>): void {
   }
 }
 
-// ─────────────────────────────────────────────────────────────────────────────
-// Message patching — self-detection, in-place mutation
-// ─────────────────────────────────────────────────────────────────────────────
-interface PatchResult {
-  patched:       number
-  totalMessages: number
-  turns:         Array<{ index: number; fields: string[] }>
-}
-
-function patchMessages(messages: any[]): PatchResult {
-  const result: PatchResult = { patched: 0, totalMessages: messages.length, turns: [] }
-
-  // ── Step 1: Self-detect reasoning model ──────────────────────────────────
-  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 ─────
-  if (!isReasoningModel) return result
-
-  // ── Step 3: Patch all assistant turns missing required fields ─────────────
-  messages.forEach((wrapper, index) => {
-    const msg = wrapper?.info ?? wrapper
-    if (!msg || msg.role !== 'assistant') return
-
-    const fields: string[] = []
-
-    // Fix 1: content must be non-null string on every assistant turn
-    if (!msg.content && msg.content !== '') {
-      msg.content = msg.tool_calls?.length ? 'call tool' : ''
-      fields.push('content')
-    }
-
-    // Fix 2: reasoning_content — absent causes HTTP 400 from DeepSeek/Kimi/GLM/MiMo on turn 2+
-    if (!('reasoning_content' in msg)) {
-      msg.reasoning_content = ''
-      fields.push('reasoning_content')
-    }
-
-    // Fix 3: reasoning — required for OpenCode Go provider on every turn
-    if (!('reasoning' in msg)) {
-      msg.reasoning = ''
-      fields.push('reasoning')
-    }
-
-    if (fields.length > 0) {
-      result.patched += fields.length
-      result.turns.push({ index, fields })
-    }
-  })
-
-  return result
-}
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Plugin
@@ -111,7 +30,7 @@ export const ThinkingFixPlugin: Plugin = async ({ client }) => {
 
   writeLog({ event: 'plugin_loaded', logFile: LOG_FILE })
 
-  await client.app.log({ body: { service: 'thinking-fix', level: 'info', message: `Plugin loaded — logging to ${LOG_FILE}` } })
+  await client.app.log({ body: { service: 'thinking-fix', level: 'info', message: `Plugin loaded, logging to ${LOG_FILE}` } })
 
   return {
     'chat.headers': async (input: any, output: any) => {
@@ -120,56 +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 assistantTurns = messages.filter((w: any) => {
+        // 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'
-        })
-        const isReasoningModel = assistantTurns.some((w: any) => {
-          const m = w?.info ?? w
-          return 'reasoning_content' in m || 'reasoning' in m
-        })
-        writeLog({
-          event:                  'inspect',
-          isReasoningModel,
-          totalMessages:          messages.length,
-          assistantTurns:         assistantTurns.length,
-          missingContent:         assistantTurns.filter((w: any) => {
-            const m = w?.info ?? w
-            return !m.content && m.content !== ''
-          }).length,
-          missingReasoningContent: assistantTurns.filter((w: any) => {
-            const m = w?.info ?? w
-            return !('reasoning_content' in m)
-          }).length,
-          missingReasoning:        assistantTurns.filter((w: any) => {
-            const m = w?.info ?? w
-            return !('reasoning' in m)
-          }).length,
+          return m?.role === 'assistant' && ('reasoning_content' in m || 'reasoning' in m)
         })
 
-        const result = patchMessages(messages)
+        if (!hasReasoning) {
+          writeLog({ event: 'inspect', isReasoningModel: false, totalMessages: messages.length })
+          return
+        }
 
-        if (result.patched > 0) {
-          writeLog({
-            event:         'patched',
-            patchedFields: result.patched,
-            totalMessages: result.totalMessages,
-            turns:         result.turns,
-          })
+        let patched = 0
+        const turns: Array<{ index: number; fields: string[] }> = []
+
+        messages.forEach((wrapper: any, index: number) => {
+          const msg = wrapper?.info ?? wrapper
+          if (!msg || msg.role !== 'assistant') return
+          const fields: string[] = []
+
+          if (!msg.content && msg.content !== '') {
+            msg.content = msg.tool_calls?.length ? 'call tool' : ''
+            fields.push('content')
+          }
+          if (!('reasoning_content' in msg)) { msg.reasoning_content = ''; fields.push('reasoning_content') }
+          if (!('reasoning' in msg)) { msg.reasoning = ''; fields.push('reasoning') }
+
+          if (fields.length > 0) {
+            patched += fields.length
+            turns.push({ index, fields })
+          }
+        })
+
+        writeLog({ event: 'inspect', isReasoningModel: true, totalMessages: messages.length, patchedFields: patched, turns })
 
-          await client.app.log({ body: { service: 'thinking-fix', level: 'info', message: `patched ${result.patched} field(s) across ${result.totalMessages} message(s)` } })
+        if (patched > 0) {
+          await client.app.log({ body: { service: 'thinking-fix', level: 'info', message: `patched ${patched} field(s) across ${messages.length} message(s)` } })
         }
       } catch (err: any) {
         writeLog({ event: 'error', message: err?.message ?? String(err) })
-        await client.app.log({ body: { service: 'thinking-fix', level: 'error', message: `Error — passing through unmodified: ${err?.message ?? err}` } })
+        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" ""