opencode-thinking-fix 1.1.0 → 1.1.2

package/README.md

@@ -9,7 +9,47 @@
 npm install opencode-thinking-fix
 ```
 
-> Fix for the `reasoning_content` 400 error that kills multi-turn conversations with DeepSeek, Kimi, GLM, and MiMo in OpenCode.
+> Fix for the `reasoning_content` 400 error that kills multi-turn conversations with DeepSeek, Kimi, GLM, MiMo, and MiniMax-M3 in OpenCode.
+
+---
+
+## Quick Install
+
+**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 scope to **Global** (recommended — works across all projects)
+4. Type `opencode-thinking-fix`
+5. Press Enter — done. Restart OpenCode.
+
+### Method 2: CLI (shell command)
+
+```bash
+opencode plugin opencode-thinking-fix
+```
+
+For specific version:
+
+```bash
+opencode plugin opencode-thinking-fix@1.1.0
+```
+
+### Method 3: Manual config (add to opencode.json)
+
+```json
+{
+  "plugin": ["opencode-thinking-fix"]
+}
+```
+
+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.
 
 ## Table of Contents
 
@@ -45,7 +85,13 @@ This repo fixes it. Three layers, pick what you need.
 
 ## Option 1: plugin (stops the crashes)
 
-One file. Drop it in `~/.config/opencode/plugins/` and restart:
+### Install via npm (recommended)
+
+See [Quick Install](#quick-install) above — use OpenCode TUI (`Ctrl+P`) or CLI (`opencode plugin opencode-thinking-fix`).
+
+### Manual install (for local development)
+
+Drop the plugin file in your OpenCode plugins directory and restart:
 
 ```bash
 mkdir -p ~/.config/opencode/plugins
@@ -80,13 +126,15 @@ The proxy runs on **two ports**:
 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
-# run port 3457 (direct providers)
+# Linux / macOS / Windows (Node.js required)
 node proxy/proxy.js
 
-# run port 3458 (OpenCode Go)
+# OpenCode Go proxy
 PORT=3458 UPSTREAM_URL=https://opencode.ai/zen/go/v1 node proxy/proxy.js
 ```
 
+> **Windows PowerShell:** use `$env:PORT=3457; node proxy/proxy.js` (PowerShell) or `set PORT=3457 && node proxy/proxy.js` (CMD).
+
 ### Install as systemd services (auto-start at boot)
 
 ```bash
@@ -115,6 +163,8 @@ Then point OpenCode at it — in your `opencode.json`:
 
 Zero npm dependencies. It uses `http`, `https`, and `url` — nothing 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.
+
 **Kimi K2.7 Code and OpenCode Go need this.** The rest of the models benefit from it but do not technically require it.
 
 ---
@@ -153,9 +203,10 @@ The plugin is the safety net. If the proxy goes down, the plugin still injects e
 | Kimi K2.5 / K2.6 | Yes | Nice to have | Accepts `""` |
 | **Kimi K2.7 Code** | **Not enough alone** | **Required** | Needs real text |
 | GLM-5.x / Zhipu | Yes | Nice to have | Accepts `""` |
-| MiMo V2.5 / MiniMax | Yes | Nice to have | Accepts `""` |
+| MiMo V2.5 / MiniMax | Yes | Nice to have | Accepts `""` (default mode embeds `<think>` in `content`) |
+| **MiniMax-M3** | Yes | **Recommended** | `reasoning_details[]` array; ~40% quality loss if stripped. Proxy injects `reasoning_split:true` to keep thinking separate from content. |
 | OpenCode Go | Yes | Required | Uses `reasoning` field |
-| Qwen, GPT, Claude, Gemini, Llama, Mistral | No | No | Do not use reasoning_content |
+| Qwen, GPT, Claude, Gemini, Llama, Mistral | No | No | No reasoning_content |
 
 ---
 
@@ -277,4 +328,40 @@ systemd/
 
 ## Tested on
 
-OpenCode v1.17.9, Kubuntu 24.04, DeepSeek V4 Pro, OpenCode Go.
+| Platform | Plugin | Proxy | Watchdog | Systemd |
+|----------|--------|-------|----------|---------|
+| **Linux** (Kubuntu 24.04) | ✅ | ✅ | ✅ (bash) | ✅ |
+| **macOS** | ✅ | ✅ | ✅ (bash) | ❌ (use launchd) |
+| **Windows** | ✅ | ✅ | ❌ (bash) | ❌ |
+
+OpenCode v1.17.9+, DeepSeek V4 Pro, Kimi K2.5/K2.6/K2.7, GLM-5.x, MiMo V2.5, MiniMax-M3, OpenCode Go.
+
+### 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:
+
+```powershell
+# PowerShell
+$env:PORT=3457; node proxy\proxy.js
+```
+
+**Watchdog and systemd are Linux-only.** For Windows auto-restart, use **Task Scheduler** or **NSSM** (Non-Sucking Service Manager) to run the proxy as a Windows service:
+
+```powershell
+# Using NSSM (install once: winget install nssm)
+nssm install ReasoningCacheProxy node.exe proxy\proxy.js
+nssm set ReasoningCacheProxy AppDirectory C:\path\to\opencode-thinking-fix
+nssm set ReasoningCacheProxy AppEnvironmentExtra PORT=3457
+nssm start ReasoningCacheProxy
+```
+
+Repeat for the Go proxy on PORT=3458 with `UPSTREAM_URL=https://opencode.ai/zen/go/v1`.
+
+**OpenCode config paths on Windows:**
+
+| Scope | Path |
+|-------|------|
+| Global | `%APPDATA%\OpenCode\opencode.json` |
+| Project | `<project>\.opencode\opencode.json` |
+| Plugins dir | `%APPDATA%\OpenCode\plugins\` |
+| npm cache | `%LOCALAPPDATA%\opencode\node_modules\` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-thinking-fix",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Fix DeepSeek/Kimi/GLM/MiMo reasoning_content 400 errors in OpenCode. Plugin + proxy + watchdog.",
   "license": "MIT",
   "author": "tbosancheros39",
@@ -17,9 +17,11 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/tbosancheros39/opencode-thinking-fix.git"
+    "url": "git+https://github.com/tbosancheros39/opencode-thinking-fix.git"
   },
-  "oc-plugin": ["server"],
+  "oc-plugin": [
+    "server"
+  ],
   "main": "./plugins/opencode-thinking-fix-universal.ts",
   "exports": {
     "./server": {

package/proxy/proxy.js

@@ -115,6 +115,16 @@ function patchRequestBody(body, sessionId) {
       modified = true
     }
 
+    // MiniMax-M3 reasoning_details array format (reasoning_split: true)
+    if (!msg.reasoning_details && !msg.reasoning_content) {
+      const cached = sessionCache.get(assistantIndex)
+      if (cached) {
+        msg.reasoning_details = [{ text: cached, type: 'thinking' }]
+        console.log(`[Cache] session ${sessionId.slice(-8)}: replayed reasoning_details for turn ${assistantIndex} (${cached.length} chars)`)
+        modified = true
+      }
+    }
+
     // OpenCode Go uses reasoning instead of reasoning_content
     if (!msg.reasoning) {
       const cached = sessionCache.get(assistantIndex)
@@ -162,28 +172,31 @@ function createStreamParser(sessionId, onComplete) {
           const delta = parsed.choices?.[0]?.delta
           if (!delta) continue
 
-          // reasoning_content delta (DeepSeek/Kimi/GLM native)
+          // 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
           }
 
-          // When content starts after reasoning, the reasoning block is done
-          if (typeof delta.content === 'string' && delta.content && inReasoning) {
-            if (reasoningBuffer) {
-              onComplete(assistantIndex, reasoningBuffer)
-              reasoningBuffer = ''
-              inReasoning = false
-            }
-          }
-
           // 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)
@@ -244,7 +257,17 @@ const server = http.createServer((req, res) => {
     // Patch request body if this is a reasoning provider
     let bodyToSend = rawBody
     if (shouldPatch && rawBody.length > 0) {
-      const patched = patchRequestBody(rawBody.toString('utf8'), sessionId)
+      // Inject reasoning_split for MiniMax models (avoids <think> tags in content)
+      const isMiniMax = modelName.toLowerCase().startsWith('minimax') || modelName.toLowerCase().startsWith('mimo')
+      let bodyStr = rawBody.toString('utf8')
+      if (isMiniMax) {
+        try {
+          const bj = JSON.parse(bodyStr)
+          bj.reasoning_split = true
+          bodyStr = JSON.stringify(bj)
+        } catch { /* pass */ }
+      }
+      const patched = patchRequestBody(bodyStr, sessionId)
       bodyToSend = Buffer.from(patched, 'utf8')
     }