@xingjisoft/neutrino 0.2.0 → 0.2.1

package/README.md

@@ -17,8 +17,8 @@ A CLI coding agent that lives in your terminal. Neutrino gives you an interactiv
 - **Session history** — messages are saved before a turn starts, streamed replies are checkpointed every second, and tool calls/results are saved immediately. The history screen lists conversations started in the current working directory. Failed saves are shown in the terminal and browser UI.
 - **Auto-folding turns** — once a turn finishes, the work behind the reply (the thinking and the tool calls) folds into one summary line in both the terminal and the browser, while the answer itself always stays on screen. Click the line to read the whole round again; a turn with little to hide, or a long answer on its own, stays open. A turn stopped with `ESC ESC` is paused, not finished, so it stays open. Nothing is dropped: the transcript, the saved session and the model's context keep every message.
 - **Complete conversation history** — context compression keeps every original message and tool result on disk. The earlier portion starts collapsed in the terminal and browser; click **Earlier conversation** to expand it, including in reopened history. Model requests use a separate summary plus recent messages.
-- **Plan-first turns** — before a request is answered, a planner agent splits it into ordered, independent steps ("model the case from box.png", "animate the camera: push in, orbit, pull back"), and the worker then executes those steps one at a time, top to bottom. Every step is a concrete deliverable, so later work is explicit instead of one vague instruction. See [Plan-first turns](#plan-first-turns).
-- **The step card** — click `ⓘ` in the chat header (or press `Ctrl+P`) to open the info card in the top-right corner. It lists the plan as a vertical timeline of nodes: the step being worked on is highlighted, steps still to come are lit, and finished steps are drawn dark with a tick. The same card shows prompt/completion/total token counts when no plan is running.
+- **Plan-first turns** — before a request is answered, a planner agent splits it into ordered, independent steps ("model the case from box.png", "animate the camera: push in, orbit, pull back"), and the worker then executes those steps one at a time, top to bottom. Every step is a concrete deliverable, so later work is explicit instead of one vague instruction. See [Plan-first turns](#plan-first-turns).
+- **The step card** — click `ⓘ` in the chat header (or press `Ctrl+P`) to open the info card in the top-right corner. It lists the plan as a vertical timeline of nodes: the step being worked on is highlighted, steps still to come are lit, and finished steps are drawn dark with a tick. The same card shows prompt/completion/total token counts when no plan is running.
 - **Sub-agents** — independent work can be handed to a sub-agent: a second agent loop with its own context, its own tool calls and the same approval gate. Only its report comes back, so a survey that reads thirty files does not fill the conversation with thirty files. See [Sub-agents](#sub-agents).
 - **Agent history browser** — view past sessions from other CLI agents (Claude Code, Codex, OpenCode) directly from the history screen.
 - **Approval gate** — risky commands and paths outside the working directory need your sign-off. The header turns orange and reads **Request Approval**; press `Y` or `N`. Delete-class commands always ask, unless you explicitly granted full trust, and there is an opt-in reviewer agent for automatic decisions.
@@ -70,7 +70,7 @@ The browser UI is mounted at <http://127.0.0.1:8765> at the same time; see
 | `Ctrl+C` | Do nothing while text is selected; otherwise pause the running conversation or show the exit hint at the top |
 | `Ctrl+C` × 3 | Quit after three consecutive presses, no more than 1.5 seconds apart (another key, paste, click or scroll resets the count) |
 | `Ctrl+Shift+C` | Quit immediately (requires the terminal to forward the shortcut) |
-| `Ctrl+A` | Toggle Request Approval / Auto Approval in a conversation |
+| `Ctrl+A` | Toggle Request Approval / Auto Approval in a conversation |
 | `Ctrl+P` | Toggle the plan / token info card in the top-right corner |
 | `Y` | Approve the pending request (while the approval card is up) |
 | `N` / `Esc` | Deny the pending request |
@@ -101,75 +101,93 @@ highlight stops at the log's edge instead of spilling into the header or the
 input box, and the copy includes the lines that scrolled out of view. Scroll back
 and the selection shrinks again; press `Esc` to drop it.
 
-## Plan-first turns
-
-A request is answered in two passes. A **planner agent** first turns the message
-into an ordered list of independent steps; a **worker agent** then executes
-exactly one step per pass, from the top down. Each step names one deliverable, so
-a long request stops being a single vague instruction and becomes a sequence of
-concrete, verifiable ones. The plan is written into the conversation as a
-message and saved with the session, so the steps of a reopened conversation are
-still there.
-
-The steps are also listed in the `ⓘ` card in the top-right corner of the chat —
-click it, or press `Ctrl+P`:
-
-- nodes run top to bottom in execution order, joined by a connector,
-- the step being worked on is the highlighted row,
-- steps still to come are lit, and
-- finished steps are drawn dark with a tick; a failed one is marked in red.
-
-The card opens by itself as soon as a plan is written, and closing it loses
-nothing: `Ctrl+P` brings it back. On a short terminal the card shows a window
-around the running step and counts the steps above and below it.
-
-A step that fails stops the plan: the remaining steps stay pending and the next
-message can re-plan them. A turn paused with `Esc Esc` stops the plan and marks
-it **stopped**, so no step keeps looking live. When no usable plan comes back —
-a single-action request, a provider error, an answer that is not a plan — the
-turn runs in one pass exactly as before, so planning is never a new way to fail.
-
-The prompts are files, not code: [`assets/planner.txt`](./assets/planner.txt)
-says how steps are written, [`assets/step.txt`](./assets/step.txt) is the
-instruction for each step, and [`assets/prompt.txt`](./assets/prompt.txt) is the
-worker's base system prompt. Turn planning off for one run with
-`NEUTRINO_PLAN=off`, or permanently with `"plan_first": false` in `config.json`.
-
-## Sub-agents
-
-The agent can hand one self-contained sub-task to a **sub-agent**: a second agent
-loop with its own transcript, its own tool calls and the same working directory.
-Only its final report comes back — the files it read and the commands it ran
-never enter the main conversation. That is the point: surveying a large codebase
-or probing how a command behaves costs many messages, and the parent needs the
-conclusion, not the transcript. The child's tokens still count in the
-conversation's usage.
-
-- The parent calls the `delegate` tool with a complete task and, optionally, a
-  little context. The sub-agent cannot see the conversation and cannot ask the
-  user, so a task that refers to "the file above" fails; the system prompt tells
-  the model to write a brief that stands alone.
-- Its tool calls go through the **same approval gate**: a risky call parks the
-  turn and shows the usual card (the header turns orange, the browser shows its
-  banner). Denying it tells the sub-agent not to retry unchanged, and the parent
-  receives the refusal in the report.
-- Delegation is one level deep — `delegate` is not in a sub-agent's toolset — so
-  the work always has one owner and one pause button.
-- While it runs, the terminal status line and the browser badge name the current
-  phase (`Sub-agent — read_file`), and the `delegate` tool block shows the task
-  it was given. The report replaces that marker when it arrives, as the result of
-  the tool call.
-- The round limit (12) bounds a child that never finishes; the parent then gets
-  the partial report, clearly marked as partial. A paused turn aborts the
-  sub-agent and says so in the tool result.
-
-The sub-agent's prompt is a file too: [`assets/subagent.txt`](./assets/subagent.txt).
-
+## Plan-first turns
+
+A request is answered in two passes. A **planner agent** first turns the message
+into an ordered list of independent steps; a **worker agent** then executes
+exactly one step per pass, from the top down. Each step names one deliverable, so
+a long request stops being a single vague instruction and becomes a sequence of
+concrete, verifiable ones. The plan is written into the conversation as a
+message and saved with the session, so the steps of a reopened conversation are
+still there.
+
+The steps are also listed in the `ⓘ` card in the top-right corner of the chat —
+click it, or press `Ctrl+P`:
+
+- nodes run top to bottom in execution order, joined by a connector,
+- the step being worked on is the highlighted row,
+- steps still to come are lit, and
+- finished steps are drawn dark with a tick; a failed one is marked in red.
+
+The card opens by itself as soon as a plan is written, and closing it loses
+nothing: `Ctrl+P` brings it back. On a short terminal the card shows a window
+around the running step and counts the steps above and below it.
+
+A step that fails stops the plan: the remaining steps stay pending and the next
+message can re-plan them. A turn paused with `Esc Esc` stops the plan and marks
+it **stopped**, so no step keeps looking live. When no usable plan comes back —
+a single-action request, a provider error, an answer that is not a plan — the
+turn runs in one pass exactly as before, so planning is never a new way to fail.
+
+**Simple requests are not planned at all.** Planning costs a model round-trip
+before any work starts, and for "把这个变量改名" that round-trip is pure friction.
+A request is planned only when it shows a reason to be split:
+
+| Signal | Example |
+| --- | --- |
+| More than one thing to do | `先改配置，再更新文档`, `运行测试，并且把报错修掉` |
+| Its own structure | a numbered or bulleted list |
+| It reads as a brief | longer than about 180 columns |
+| It asks for a plan | `列个计划`, `plan`, `steps` |
+
+Everything else runs in one pass: no planner call, no plan card, and the agent
+still names the steps it is taking inside its own answer. The check lives in
+`needsPlan()` in `src/llm/plan.ts`.
+
+The prompts are files, not code: [`assets/planner.txt`](./assets/planner.txt)
+says how steps are written, [`assets/step.txt`](./assets/step.txt) is the
+instruction for each step, and [`assets/prompt.txt`](./assets/prompt.txt) is the
+worker's base system prompt. Turn planning off for one run with
+`NEUTRINO_PLAN=off`, or permanently with `"plan_first": false` in `config.json`.
+
+## Sub-agents
+
+The agent can hand one self-contained sub-task to a **sub-agent**: a second agent
+loop with its own transcript, its own tool calls and the same working directory.
+Only its final report comes back — the files it read and the commands it ran
+never enter the main conversation. That is the point: surveying a large codebase
+or probing how a command behaves costs many messages, and the parent needs the
+conclusion, not the transcript. The child's tokens still count in the
+conversation's usage.
+
+- The parent calls the `delegate` tool with a complete task and, optionally, a
+  little context. The sub-agent cannot see the conversation and cannot ask the
+  user, so a task that refers to "the file above" fails; the system prompt tells
+  the model to write a brief that stands alone.
+- Its tool calls go through the **same approval gate**: a risky call parks the
+  turn and shows the usual card (the header turns orange, the browser shows its
+  banner). Denying it tells the sub-agent not to retry unchanged, and the parent
+  receives the refusal in the report.
+- Delegation is one level deep — `delegate` is not in a sub-agent's toolset — so
+  the work always has one owner and one pause button.
+- While it runs, the terminal status line and the browser badge name the current
+  phase (`Sub-agent — read_file`), and the `delegate` tool block shows the task
+  it was given. The report replaces that marker when it arrives, as the result of
+  the tool call.
+- The round limit (12) bounds a child that never finishes; the parent then gets
+  the partial report, clearly marked as partial. A paused turn aborts the
+  sub-agent and says so in the tool result.
+
+The sub-agent's prompt is a file too: [`assets/subagent.txt`](./assets/subagent.txt).
+
 ## Configuration
 
 Settings are stored under `~/.neutrino/`:
 
 - `model.json` — provider and model definitions (edit to add your own endpoints).
+  DeepSeek-style thinking endpoints get `reasoning_content` sent back on their
+  assistant messages automatically; a differently named endpoint can opt in
+  with `"reasoning": true` (or opt out with `false`).
 - `config.json` — app configuration (selected provider/model/intensity, theme,
   language, approval mode, `auto_approve_extreme_risk`, `sound_alerts`,
   `web_console`).
@@ -184,7 +202,7 @@ A few environment variables override flags:
 | `NEUTRINO_WEB_PORT` | Web UI port: like `--port` in either mode, and it mounts the UI even when `web_console` is off. |
 | `NEUTRINO_WEB_HOST` | Interface to bind, like `--host`; also mounts the UI when `web_console` is off. |
 | `NEUTRINO_NETWORK_ATTEMPTS` | Total tries for a model request that keeps dropping (default 7). |
-| `NEUTRINO_RETRY_DELAY_MS` | Wait before the first retry in ms; each retry doubles it (default 5000). |
+| `NEUTRINO_RETRY_DELAY_MS` | Wait before the first retry in ms; each retry doubles it (default 5000). |
 | `NEUTRINO_PLAN` | `off` answers a request in one pass without planning it (overrides `plan_first`); `on` forces planning. |
 
 ### Approvals
@@ -389,7 +407,7 @@ The agent can call the following tools during a conversation:
 - `run_command` — execute a shell command (120s timeout, output capped).
 - `read_file` — read a text file (capped at 200KB).
 - `write_file` — write content to a file.
-- `list_files` — list directory contents.
+- `list_files` — list directory contents.
 - `delegate` — hand one self-contained sub-task to a sub-agent and return its report.
 
 Every tool takes an additional `reason` argument: one sentence saying what the
@@ -425,8 +443,8 @@ node scripts/test-compact.mjs    # verify context-compression planning
 node scripts/test-history-fold.mjs # verify full-history retention, folding and resume
 node scripts/test-web-history.mjs  # verify browser history disclosures and streaming state
 node scripts/test-web-default.mjs  # verify the web console starts and toggles by default
-node scripts/test-turn-fold.mjs    # verify folded turns keep their reply and every message
-node scripts/test-plan.mjs         # verify plan-first turns, step order, the step card and the fallback
+node scripts/test-turn-fold.mjs    # verify folded turns keep their reply and every message
+node scripts/test-plan.mjs         # verify plan-first turns, step order, the step card and the fallback
 node scripts/test-subagent.mjs     # verify delegation: isolation, approvals, abort, round limits
 node scripts/test-tools.mjs      # verify tool-output folding
 node scripts/test-web.mjs        # verify the web server, API, SSE stream and path-traversal guards

package/assets/prompt.txt

@@ -7,8 +7,9 @@ is described.
 - Your work is planned before it starts. When a turn carries a plan you are given
   exactly one step of it: do that step, verify it, and stop. Never start a later
   step, and never redo an earlier one.
-- Without a plan, state the numbered steps you are about to take in your first
-  message, then take them in that order.
+- Without a plan, just do the work. A single action goes straight to the answer —
+  do not decorate it with a plan. When you are taking several steps, name them in
+  one short line each and then take them in that order.
 - Look before you change: read the files you are about to edit, list the
   directory, run the command that shows the current state. Anything about the
   code you have not read is a guess, and guesses are the main source of bad

package/dist/config.js

@@ -11,6 +11,17 @@ export const NEUTRINO_DIR = path.join(os.homedir(), ".neutrino");
 export const MODEL_FILE = path.join(NEUTRINO_DIR, "model.json");
 export const SESSION_DIR = path.join(NEUTRINO_DIR, "session");
 export const CONFIG_FILE = path.join(NEUTRINO_DIR, "config.json");
+/**
+ * Whether assistant messages must be sent back with a `reasoning_content`
+ * field. DeepSeek's thinking mode requires one on *every* assistant message of
+ * a tools-bearing request (an empty string is accepted), and the plan message
+ * written by the planner is otherwise an assistant message without it.
+ */
+export function modelUsesReasoning(provider, model) {
+    if (typeof model.reasoning === "boolean")
+        return model.reasoning;
+    return provider === "DeepSeek" || /deepseek|reasoner|thinking/i.test(model.name);
+}
 export const DEFAULT_CONTEXT_WINDOW = 1_000_000;
 export const CONTEXT_COMPRESSION_RATIO = 0.8;
 export const CONTEXT_WINDOW_OPTIONS = [32_000, 64_000, 128_000, 200_000, 256_000, 512_000, 1_000_000, 2_000_000, 4_000_000];
@@ -57,7 +68,9 @@ export const DEFAULT_CONFIG = {
     theme: "default",
     default_intensity: "High",
     // Plan a request into steps before answering it: the planner agent writes the
-    // plan, the worker executes one step per turn. Off = answer in one pass.
+    // plan, the worker executes one step per turn. Requests that look like a
+    // single action are never planned (see needsPlan), and false turns planning
+    // off for every request.
     plan_first: true,
     // Default for new conversations; each conversation can override it.
     approval_mode: "request",

package/dist/llm/client.js

@@ -1,4 +1,4 @@
-import { INTENSITY_PARAMS } from "../config.js";
+import { INTENSITY_PARAMS, modelUsesReasoning } from "../config.js";
 import { HttpStatusError, describeError, isRetriableFailure, retryDelayMs, retryPolicy, waitBeforeRetry, } from "./retry.js";
 // Callers import `describeError` from this module; it lives next to the
 // classification helpers that share the same "is this a dropped connection?"
@@ -54,6 +54,12 @@ export class LLMClient {
     top_p;
     toolCalls = [];
     usage = null;
+    /**
+     * The thinking text streamed alongside the reply. DeepSeek's thinking mode
+     * requires it to be echoed back on the assistant message that carries a tool
+     * call, so the agent loops attach it to that message.
+     */
+    reasoningContent = "";
     constructor(model, provider, intensity) {
         this.model = model;
         this.provider = provider;
@@ -98,6 +104,7 @@ export class LLMClient {
     async *streamTurn(messages, tools, options = {}) {
         this.toolCalls = [];
         this.usage = null;
+        this.reasoningContent = "";
         try {
             if (this.provider === "Anthropic") {
                 yield* this.streamAnthropic(messages, options);
@@ -125,6 +132,7 @@ export class LLMClient {
         const policy = resolvePolicy(options);
         for (let attempt = 1;; attempt++) {
             this.toolCalls = [];
+            this.reasoningContent = "";
             let produced = false;
             try {
                 for await (const token of this.openAIAttempt(messages, tools)) {
@@ -141,6 +149,28 @@ export class LLMClient {
             }
         }
     }
+    /**
+     * DeepSeek's thinking mode rejects a tools-bearing request when any assistant
+     * message in its history carries no `reasoning_content` ("The
+     * `reasoning_content` in the thinking mode must be passed back to the API").
+     * An empty string is accepted, which is the honest value for a message that
+     * predates this turn's thinking: a compressed summary, the planner's plan, an
+     * error note or a session saved before this rule existed. Endpoints outside
+     * thinking mode must not receive the field at all.
+     */
+    wireMessages(messages) {
+        if (!modelUsesReasoning(this.provider, this.model)) {
+            return messages.map((message) => {
+                if (message.role !== "assistant" || message.reasoning_content === undefined)
+                    return message;
+                const { reasoning_content: _ignored, ...rest } = message;
+                return rest;
+            });
+        }
+        return messages.map((message) => message.role === "assistant" && typeof message.reasoning_content !== "string"
+            ? { ...message, reasoning_content: "" }
+            : message);
+    }
     /** A single streaming attempt; see `streamOpenAI` for the retry policy. */
     async *openAIAttempt(messages, tools) {
         const url = this.model.url.replace(/\/+$/, "") + "/chat/completions";
@@ -150,7 +180,7 @@ export class LLMClient {
         };
         const payload = {
             model: this.model.name,
-            messages,
+            messages: this.wireMessages(messages),
             temperature: this.temperature,
             top_p: this.top_p,
             stream: true,
@@ -216,6 +246,11 @@ export class LLMClient {
                     }
                     const choice = chunk.choices?.[0];
                     const delta = choice?.delta ?? {};
+                    // DeepSeek calls it reasoning_content; other compatible endpoints use
+                    // the shorter `reasoning`. Neither is part of the visible reply.
+                    const reasoning = delta.reasoning_content ?? delta.reasoning;
+                    if (typeof reasoning === "string" && reasoning)
+                        this.reasoningContent += reasoning;
                     const content = delta.content;
                     if (typeof content === "string" && content)
                         yield content;

package/dist/llm/plan.js

@@ -20,6 +20,55 @@ export const PLAN_MIN_STEPS = 2;
 export const PLAN_MAX_STEPS = 10;
 export const PLAN_MAX_TITLE = 160;
 export const PLAN_MAX_DETAIL = 400;
+// -------------------------------------------------------------- when to plan
+/**
+ * A request longer than this many columns is treated as a brief and planned.
+ * In practice that is roughly eighty Chinese characters or one hundred and
+ * eighty ASCII ones — past that, "one action" is already unlikely.
+ */
+export const PLAN_LENGTH_LIMIT = 180;
+/** The user brought their own structure: numbered steps or bullets. */
+const LIST_LINE = /^\s*(?:[-*•]|\d+[.)、])\s+/m;
+/**
+ * Wording that means "more than one thing to do".
+ *
+ * Chinese has no spaces, so the weak conjunctions only count after punctuation
+ * ("，并且…") or as a clear pair ("先…再…"): otherwise 合并, 并发 and 再运行一次
+ * would all read as sequencing.
+ */
+const SEQUENCING = /然后|接着|随后|之后再|并且|以及|[，,；;]\s*并|先[^。！？\n]{0,40}再|\b(?:then|after that|afterwards|finally|also|next|followed by)\b/iu;
+/** An explicit plan request: the user wants steps, however small the task. */
+const PLAN_REQUEST = /计划|规划|步骤|拆(?:分|解)|\bplan\b|\bsteps?\b/iu;
+/** Sentence terminators; an English full stop only counts before whitespace. */
+function sentenceMarks(text) {
+    const cjk = text.match(/[。！？!?]/gu)?.length ?? 0;
+    const dots = text.match(/\.(?=\s|$)/gu)?.length ?? 0;
+    return cjk + dots;
+}
+/**
+ * Does this request need a plan at all?
+ *
+ * Planning costs a model round-trip before any work starts, and for "rename
+ * this variable" that round-trip is pure friction. A request is planned only
+ * when it shows a reason to be split into steps: it asks for more than one
+ * thing, brings its own structure (a list), reads as a brief (long), or asks
+ * for a plan. Everything else runs in one pass, where the system prompt still
+ * has the agent state the steps it is taking in its own answer.
+ */
+export function needsPlan(request) {
+    const text = request.trim();
+    if (!text)
+        return false;
+    if (PLAN_REQUEST.test(text))
+        return true;
+    if (LIST_LINE.test(text))
+        return true;
+    if (SEQUENCING.test(text))
+        return true;
+    if (sentenceMarks(text) >= 2)
+        return true;
+    return displayWidth(text) > PLAN_LENGTH_LIMIT;
+}
 // ------------------------------------------------------------------ parsing
 function cleanText(value, max) {
     if (typeof value !== "string")

package/dist/llm/subagent.js

@@ -68,6 +68,9 @@ export async function runSubAgent(options) {
             messages.push({
                 role: "assistant",
                 content,
+                // A tool-call turn must carry the thinking that produced it back to a
+                // thinking-mode endpoint, or its next request is rejected.
+                ...(client.reasoningContent ? { reasoning_content: client.reasoningContent } : {}),
                 ...(toolCalls.length > 0
                     ? {
                         tool_calls: toolCalls.map((call) => ({

package/dist/screens/chat.js

@@ -1,6 +1,6 @@
 import { Screen } from "../terminal/screen.js";
 import { C } from "../colors.js";
-import { findModel, contextCompressionThreshold, loadConfig, loadPlannerPrompt, loadStepPrompt, loadSubAgentPrompt, normalizeApprovalMode, planFirstEnabled, loadPrompt, saveSession, } from "../config.js";
+import { findModel, contextCompressionThreshold, loadConfig, loadModels, loadPlannerPrompt, loadStepPrompt, loadSubAgentPrompt, normalizeApprovalMode, planFirstEnabled, loadPrompt, saveSession, } from "../config.js";
 import { drawHeader } from "../header.js";
 import { computeInputWindow, cursorFromColumn, drawInputBox, drawScrollbar, wrapText, approvalToggle, drawApprovalToggle, inRect } from "../ui.js";
 import { drawSpans, renderMarkdownText } from "../markdown.js";
@@ -8,7 +8,7 @@ import { ellipsize, displayWidth } from "../width.js";
 import { sanitizeText } from "../sanitize.js";
 import { LLMClient, describeError } from "../llm/client.js";
 import { formatDelay } from "../llm/retry.js";
-import { advancePlan, buildPlannerInput, lastRequestText, parsePlan, planCardRows, planMessage, planRowsWidth, planTranscript, renderStepDirective, resumePlan, stopPlan, } from "../llm/plan.js";
+import { advancePlan, buildPlannerInput, lastRequestText, needsPlan, parsePlan, planCardRows, planMessage, planRowsWidth, planTranscript, renderStepDirective, resumePlan, stopPlan, } from "../llm/plan.js";
 import { DELEGATE_TOOL, executeTool, getSubAgentToolDefinitions, getToolDefinitions } from "../llm/tools.js";
 import { buildSubAgentTask, formatSubAgentResult, runSubAgent as runSubAgentTask, } from "../llm/subagent.js";
 import { assessToolCall } from "../llm/risk.js";
@@ -173,6 +173,13 @@ export class ChatScreen extends Screen {
             api_key: st.selectedModelApiKey,
             supports_streaming: st.selectedModelStreaming,
         };
+        // The selected-state snapshot has no room for provider options; re-read the
+        // thinking-mode flag from model.json so a hand-configured endpoint keeps it.
+        const configured = loadModels().providers
+            .find((provider) => provider.name === this.modelProvider)?.models
+            .find((model) => model.name === this.model.name);
+        if (configured && typeof configured.reasoning === "boolean")
+            this.model.reasoning = configured.reasoning;
         this.intensity = this.loadedIntensity ?? st.selectedIntensity;
         if (this.loadedTokens) {
             this.tokens = { prompt: this.loadedTokens.prompt, completion: this.loadedTokens.completion };
@@ -668,6 +675,11 @@ export class ChatScreen extends Screen {
         const request = lastRequestText(this.messages);
         if (!request.trim())
             return null;
+        // A request that is one action is not planned: the planner round-trip would
+        // cost more than the steps are worth, and the worker states its steps in its
+        // own answer. The card then shows the token counts, not a one-line plan.
+        if (!needsPlan(request))
+            return null;
         this.planning = true;
         this.app.render();
         this.publishLive();
@@ -954,6 +966,9 @@ export class ChatScreen extends Screen {
                 apiMessages.push({
                     role: "assistant",
                     content,
+                    // DeepSeek's thinking mode needs the reasoning behind a tool call
+                    // returned with it; without it the next request is a 400.
+                    reasoning_content: client.reasoningContent ?? "",
                     tool_calls: toolCalls.map((tc) => ({
                         id: tc.id,
                         type: "function",

package/dist/web/session.js

@@ -13,7 +13,7 @@
 import { findModel, contextCompressionThreshold, loadConfig, loadPlannerPrompt, loadStepPrompt, loadSubAgentPrompt, normalizeApprovalMode, planFirstEnabled, loadModels, loadPrompt, saveSession, } from "../config.js";
 import { COMPACT_KEEP, planCompaction, transcriptFor, modelHistory, normalizeContext, } from "../compact.js";
 import { LLMClient, describeError } from "../llm/client.js";
-import { advancePlan, buildPlannerInput, lastRequestText, parsePlan, planMessage, planTranscript, renderStepDirective, resumePlan, stopPlan, } from "../llm/plan.js";
+import { advancePlan, buildPlannerInput, lastRequestText, needsPlan, parsePlan, planMessage, planTranscript, renderStepDirective, resumePlan, stopPlan, } from "../llm/plan.js";
 import { DELEGATE_TOOL, executeTool, getSubAgentToolDefinitions, getToolDefinitions } from "../llm/tools.js";
 import { buildSubAgentTask, formatSubAgentResult, runSubAgent as runSubAgentTask, } from "../llm/subagent.js";
 import { assessToolCall } from "../llm/risk.js";
@@ -371,6 +371,9 @@ export class WebSession {
         const request = lastRequestText(this.messages);
         if (!request.trim())
             return null;
+        // One action is not a plan: run the turn in one pass, as the terminal does.
+        if (!needsPlan(request))
+            return null;
         this.planning = true;
         this.publishLive();
         try {
@@ -472,13 +475,32 @@ export class WebSession {
                     this.tokens.completion += client.usage.completion;
                     this.lastPromptTokens = client.usage.prompt;
                 }
+                const toolCalls = client.toolCalls;
                 if (text.trim()) {
                     this.messages.push({ role: "assistant", content: text });
-                    apiMessages.push({ role: "assistant", content: text });
+                }
+                if (text.trim() || toolCalls.length > 0) {
+                    // The assistant message and the tool results it produced must stay
+                    // paired: a `tool` message without its `tool_calls` parent is
+                    // rejected by every OpenAI-compatible endpoint. The reasoning is the
+                    // thinking that produced the calls, which DeepSeek requires back.
+                    apiMessages.push({
+                        role: "assistant",
+                        content: text,
+                        reasoning_content: client.reasoningContent ?? "",
+                        ...(toolCalls.length > 0
+                            ? {
+                                tool_calls: toolCalls.map((call) => ({
+                                    id: call.id,
+                                    type: "function",
+                                    function: { name: call.name, arguments: call.arguments },
+                                })),
+                            }
+                            : {}),
+                    });
                 }
                 this.save();
                 this.publishLive();
-                const toolCalls = client.toolCalls;
                 if (toolCalls.length === 0)
                     break;
                 for (const call of toolCalls) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xingjisoft/neutrino",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "XINGJI Neutrino - a CLI coding agent in the terminal.",
   "type": "module",
   "license": "Apache-2.0",