minimax-reasoning 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 openopencode
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,167 @@
+# minimax-reasoning
+
+OpenCode plugin that fixes the `<think>` tag leakage in the TUI for **MiniMax M3** and other OpenAI-compatible reasoning models.
+
+> Without this plugin, the model's chain-of-thought shows up as raw text in your TUI:
+>
+> ```
+> <think>The user is asking me to calculate 17 * 23. Let me compute...391.</think>
+> 391
+> ```
+>
+> With this plugin, the thinking is split into a separate part and rendered as a **collapsible thinking block**:
+>
+> ```
+> ▼ [Thinking]
+>   The user is asking me to calculate 17 * 23...
+>   391
+> ```
+
+## Why this exists
+
+OpenAI's Chat Completions spec predates reasoning models — it has no field for chain-of-thought. When MiniMax exposes M3's reasoning through that spec, it embeds the thinking inside the normal `content` field wrapped in `<think>...</think>` tags.
+
+OpenCode's TUI **does not parse `<think>` tags** inside text. It only renders a collapsible thinking block when the reasoning arrives on a dedicated `reasoning_content` field (which is the shape Anthropic, OpenAI Responses, and DeepSeek use natively).
+
+This plugin bridges the gap by injecting the official MiniMax `reasoning_split: true` flag into the LLM request. The server then returns the same thinking in a separate `message.reasoning_content` field, which OpenCode renders correctly.
+
+> **Even better:** MiniMax also offers an Anthropic-compatible API at `/anthropic/v1`. If you can switch to that, you don't need this plugin at all — see [When to use this plugin](#when-to-use-this-plugin) below.
+
+## Quick install
+
+Edit `~/.config/opencode/opencode.json` and add the plugin:
+
+```json
+{
+  "plugin": [
+    "oh-my-openagent@latest",
+    "minimax-reasoning@latest"
+  ]
+}
+```
+
+OpenCode will install the plugin on next startup. Restart any active TUI session.
+
+### Local install (development / offline)
+
+```json
+{
+  "plugin": [
+    "./local-plugins/minimax-reasoning"
+  ]
+}
+```
+
+## When to use this plugin
+
+Use this plugin **only when** you need to keep using MiniMax's OpenAI-compatible Chat Completions endpoint (`baseURL: https://api.minimaxi.com/v1`, `npm: @ai-sdk/openai-compatible`).
+
+If you can switch endpoints, the cleaner fix is to use the Anthropic-compatible API natively:
+
+```json
+{
+  "provider": {
+    "minimax": {
+      "npm": "@ai-sdk/anthropic",
+      "options": {
+        "apiKey": "...",
+        "baseURL": "https://api.minimaxi.com/anthropic/v1"
+      }
+    }
+  }
+}
+```
+
+The Anthropic endpoint returns reasoning as native `thinking` content blocks, so OpenCode's TUI handles them out of the box — no plugin needed.
+
+## How it works
+
+OpenCode exposes a `chat.params` plugin hook that fires just before the LLM call. The hook receives a mutable `output.options` object; whatever you set there gets routed through OpenCode's `Oo.providerOptions()` translation layer into the AI SDK's `providerOptions[<sdk-key>]`, which the openai-compatible provider's `getArgs()` spreads into the HTTP request body.
+
+This plugin sets `output.options.reasoning_split = true`, which the MiniMax server reads and uses to move thinking out of `content` and into `reasoning_content` in the response.
+
+The AI SDK's openai-compatible provider already parses `delta.reasoning_content` natively, emitting `reasoning-start` / `reasoning-delta` / `reasoning-end` events. OpenCode's event adapter then creates a separate `reasoning` part in the database, which the TUI renders as a collapsible block.
+
+**Zero custom rendering code in this plugin.** All the reasoning-block UI is OpenCode's native behavior, just unlocked by the right request flag.
+
+## Configuration
+
+| Env var | Values | Default | Effect |
+|---|---|---|---|
+| `OPENCODE_REASONING_SPLIT_MODE` | `split` / `disable` / `off` | `split` | Operating mode |
+
+- **`split`** (default): inject `reasoning_split: true` → thinking stays on, just split into a separate field
+- **`disable`**: inject `thinking: { type: "disabled" }` → model skips emitting thinking tags (faster, cheaper, no thinking shown)
+- **`off`**: plugin does nothing (effectively disabled)
+
+## Adding more providers
+
+Edit `PROVIDERS` in `src/index.ts`:
+
+```ts
+const PROVIDERS: Record<string, Partial<Record<Mode, Record<string, unknown>>>> = {
+  minimax: {
+    split: { reasoning_split: true },
+    disable: { thinking: { type: "disabled" } },
+  },
+  myProvider: {
+    split:    { some_flag: true },
+    disable: { another_flag: "off" },
+  },
+}
+```
+
+Then rebuild: `npm run build`.
+
+## Verify it works
+
+```bash
+# 1. Run a simple prompt
+opencode run "Reply: 17 * 23 = ? Just the answer." --model minimax/MiniMax-M3
+# Expected: no `<think>` block in visible output
+
+# 2. Inspect DB to confirm reasoning is a separate part
+SID=$(sqlite3 ~/.local/share/opencode/opencode.db \
+  "SELECT id FROM session ORDER BY time_created DESC LIMIT 1")
+sqlite3 ~/.local/share/opencode/opencode.db \
+  "SELECT json_extract(p.data, '\$.type'), length(json_extract(p.data, '\$.text'))
+   FROM part p JOIN message m ON p.message_id = m.id
+   WHERE m.session_id = '$SID'
+   AND json_extract(p.data, '\$.type') IN ('text', 'reasoning')"
+# Expected output: two rows — one 'reasoning' and one 'text'
+```
+
+## Caveats
+
+- **Multi-turn thinking continuity**: MiniMax's docs require the **entire `response_message`** (including `reasoning_details`) to be preserved in message history for the model's chain-of-thought to stay coherent across turns. This plugin preserves the thinking text in a separate DB part, but OpenCode's OpenAI-compatible path may not replay the full `reasoning_details` array on subsequent turns. If you see thinking quality degrade over long agentic sessions, switch to the Anthropic endpoint or set `OPENCODE_REASONING_SPLIT_MODE=disable`.
+- **M2.x models**: According to MiniMax's docs, `thinking: { type: "disabled" }` is a soft hint — M2.x models continue to reason even with this flag set, but the response is just cleaner.
+
+## Related ecosystem
+
+- **[OpenCode PR #31426](https://github.com/anomalyco/opencode/pull/31426)** — merged: enables MiniMax M3 thinking on the Anthropic interface
+- **[OpenCode PR #26233](https://github.com/anomalyco/opencode/pull/26233)** — open: would add `provider.options.extraBody` as a config-only solution (no plugin needed) once merged
+- **[Pi Agent's MiniMax provider](https://github.com/badlogic/pi-mono/blob/main/packages/ai/src/providers/minimax.ts)** — uses the Anthropic-compatible endpoint natively
+
+## Development
+
+```bash
+# Clone
+git clone https://github.com/openopencode/minimax-reasoning.git
+cd minimax-reasoning
+
+# Install deps
+npm install
+
+# Build
+npm run build
+
+# Test locally — link into OpenCode's plugin dir
+ln -s "$PWD" ~/.config/opencode/plugins/minimax-reasoning
+
+# Or reference as file path in opencode.json:
+#   "plugin": ["/absolute/path/to/minimax-reasoning"]
+```
+
+## License
+
+MIT — see [LICENSE](./LICENSE).

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from "@opencode-ai/plugin";
+declare const ReasoningSplit: Plugin;
+export default ReasoningSplit;
+export { ReasoningSplit };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AA0CjD,QAAA,MAAM,cAAc,EAAE,MAoBrB,CAAA;AAED,eAAe,cAAc,CAAA;AAG7B,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/dist/index.js

@@ -0,0 +1,55 @@
+const PROVIDERS = {
+    // MiniMax (minimaxi.com / MiniMax.io)
+    // The default Chat Completions endpoint embeds chain-of-thought inside
+    // `content` as `<think>...</think>` tags. Setting `reasoning_split: true`
+    // makes the server return the same thinking under a separate
+    // `message.reasoning_content` field, which OpenCode's TUI already knows
+    // how to render as a collapsible thinking block.
+    minimax: {
+        split: { reasoning_split: true },
+        // `thinking: { type: "disabled" }` is documented as a "soft hint" for M3
+        // (the model still reasons internally but skips emitting <think> tags).
+        // Useful when you don't want to see the thinking trace at all.
+        disable: { thinking: { type: "disabled" } },
+    },
+    // Add more providers here as needed. Example:
+    //   "<providerID>": {
+    //     split:    { some_flag: true },
+    //     disable: { another_flag: "off" },
+    //   },
+};
+const MODES = new Set(["split", "disable"]);
+function getMode() {
+    const v = process.env.OPENCODE_REASONING_SPLIT_MODE;
+    if (v === "off")
+        return null;
+    if (v === "disable" || v === "split")
+        return v;
+    // Default: split (keeps reasoning visible, just split into the right field)
+    return "split";
+}
+const ReasoningSplit = async () => {
+    return {
+        "chat.params": async (input, output) => {
+            const mode = getMode();
+            if (mode === null)
+                return;
+            const providerID = input.model.providerID;
+            const extra = PROVIDERS[providerID]?.[mode];
+            if (!extra)
+                return;
+            // OpenCode merges `output.options` into providerOptions via its
+            // Oo.providerOptions() translation layer. For openai-compatible and
+            // anthropic AI SDK providers, those options are then spread into the
+            // request body by the SDK's getArgs().
+            output.options ??= {};
+            for (const [k, v] of Object.entries(extra)) {
+                output.options[k] = v;
+            }
+        },
+    };
+};
+export default ReasoningSplit;
+// Named export for users who prefer `import { ReasoningSplit } from ...`
+export { ReasoningSplit };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAWA,MAAM,SAAS,GAAmE;IAChF,sCAAsC;IACtC,uEAAuE;IACvE,0EAA0E;IAC1E,6DAA6D;IAC7D,wEAAwE;IACxE,iDAAiD;IACjD,OAAO,EAAE;QACP,KAAK,EAAE,EAAE,eAAe,EAAE,IAAI,EAAE;QAChC,yEAAyE;QACzE,wEAAwE;QACxE,+DAA+D;QAC/D,OAAO,EAAE,EAAE,QAAQ,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE,EAAE;KAC5C;IACD,8CAA8C;IAC9C,sBAAsB;IACtB,qCAAqC;IACrC,wCAAwC;IACxC,OAAO;CACR,CAAA;AAED,MAAM,KAAK,GAAsB,IAAI,GAAG,CAAO,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC,CAAA;AAEpE,SAAS,OAAO;IACd,MAAM,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,6BAA6B,CAAA;IACnD,IAAI,CAAC,KAAK,KAAK;QAAE,OAAO,IAAI,CAAA;IAC5B,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,OAAO;QAAE,OAAO,CAAC,CAAA;IAC9C,4EAA4E;IAC5E,OAAO,OAAO,CAAA;AAChB,CAAC;AAED,MAAM,cAAc,GAAW,KAAK,IAAI,EAAE;IACxC,OAAO;QACL,aAAa,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE;YACrC,MAAM,IAAI,GAAG,OAAO,EAAE,CAAA;YACtB,IAAI,IAAI,KAAK,IAAI;gBAAE,OAAM;YAEzB,MAAM,UAAU,GAAG,KAAK,CAAC,KAAK,CAAC,UAAU,CAAA;YACzC,MAAM,KAAK,GAAG,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC,IAAI,CAAC,CAAA;YAC3C,IAAI,CAAC,KAAK;gBAAE,OAAM;YAElB,gEAAgE;YAChE,oEAAoE;YACpE,qEAAqE;YACrE,uCAAuC;YACvC,MAAM,CAAC,OAAO,KAAK,EAAE,CAAA;YACrB,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC3C,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,CAAA;YACvB,CAAC;QACH,CAAC;KACF,CAAA;AACH,CAAC,CAAA;AAED,eAAe,cAAc,CAAA;AAE7B,yEAAyE;AACzE,OAAO,EAAE,cAAc,EAAE,CAAA"}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "minimax-reasoning",
+  "version": "0.1.0",
+  "description": "OpenCode plugin that fixes MiniMax M3 <think> tag leakage in the TUI by injecting reasoning_split into the chat params. Also works for any OpenAI-compatible provider that uses the same pattern.",
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "minimax",
+    "minimax-m3",
+    "reasoning",
+    "thinking",
+    "mcp",
+    "ai",
+    "llm"
+  ],
+  "homepage": "https://github.com/openopencode/minimax-reasoning",
+  "bugs": "https://github.com/openopencode/minimax-reasoning/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/openopencode/minimax-reasoning.git"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.0.0"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.17.0",
+    "@types/node": "^20.0.0",
+    "typescript": "^5.6.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "sideEffects": false
+}