@nanhara/hara 0.109.3 → 0.109.5

package/CHANGELOG.md

@@ -5,6 +5,40 @@ All notable changes to `@nanhara/hara`.
 > Versioning (pre-1.0, SemVer-style): the **minor** (middle) number bumps for a **new feature**; the
 > **patch** (last) number bumps for **optimizations/fixes of existing features**.
 
+## 0.109.5 — Enter enters the conversation instantly + reasoning off truly disables DashScope thinking
+
+- **Pressing Enter now enters the conversation flow instantly — the message no longer sits stuck in the
+  input box.** A turn's synchronous prep (reading an inlined `@file`, base64-encoding pasted images) used
+  to run *before* ink could paint, so with a heavy message (a big spec + two images) Enter looked dead
+  for seconds ("回车一直不动") until the work finished. The submit now yields one tick so the UI paints
+  the committed message + cleared input + spinner FIRST, then does the prep and the (often slow) model
+  call. Instant feedback regardless of how heavy the turn or how slow the first token.
+- **On DashScope, `reasoning off` now actually stops the thinking phase — not just hides it.** DashScope
+  models (Qwen, GLM, …) stream a "thinking" pass *before* the answer; that generation is the main latency
+  there (measured: **qwen3.7-plus ~14s with thinking → ~1.6s without**). hara previously assumed chat
+  models "can't be silenced server-side" and merely dropped the reasoning from the UI — so the model
+  still spent the time. It *can* be silenced: reasoning **off** now sends `enable_thinking: false` (fast),
+  low/medium/high sends `true`, and the dial **UNSET leaves the request untouched** (model default — zero
+  impact, the safe default). Detected by the **DashScope endpoint** (built-in `qwen`/`qwen-oauth`, or a
+  custom baseURL on `dashscope.aliyuncs.com`), not the model name — so a custom `qwen3.7-plus` profile is
+  covered. Set it with `HARA_REASONING_EFFORT=off` or `reasoningEffort: "off"` in `~/.hara/config.json`.
+  (A runtime `/reasoning` toggle — adjust it mid-session like Claude Code — is coming next.)
+- Note: `enable_thinking:false` is reliable on qwen3.x-plus; on some other DashScope models it only
+  suppresses the reasoning without the full speedup, which is why it's opt-in, not a forced default.
+- Context on prompt caching (from 0.109.1): that path only ever applied to the raw **Anthropic** provider.
+  DashScope/GLM/DeepSeek/gateway go through the OpenAI-compatible path, where caching is the provider's own
+  automatic prefix cache — and hara's system prompt is stable across turns, so it engages on its own.
+
+## 0.109.4 — a dropped file path is read, not "Unknown command"
+
+- **Dragging/pasting a file into the prompt no longer errors.** A dropped file pastes as an absolute path
+  (`/Users/…/spec.md`, often with trailing text or `[Image #N]` tokens). Because it starts with `/`, hara
+  treated it as a slash command and replied `Unknown command /Users/…`. Now the command parser only fires
+  when the first token has **no embedded slash** (real commands — `/help`, `/design` — never contain one),
+  so a path falls through to the normal turn. And when a message *begins* with an existing absolute path,
+  that path is rewritten to an `@`-mention so its content is **read into the turn** — i.e. "interpret this
+  file" just works. Fixed in both the TUI and the readline REPL.
+
 ## 0.109.3 — an empty model response no longer looks like a hang
 
 - **A turn that comes back with no text and no tool calls is no longer silently dropped.** The agent

package/dist/context/mentions.js

@@ -8,6 +8,23 @@ import { mediaTypeFor } from "../images.js";
 const MAX_FILE = 50_000;
 // @ at start-of-string or after whitespace; capture a path with no spaces/@ (avoids emails like a@b.com)
 const MENTION_RE = /(?:^|\s)@([^\s@]+)/g;
+/** A submitted line is a slash COMMAND only if it starts with '/' AND its first whitespace-delimited
+ *  token has no *embedded* '/'. A dropped/pasted absolute file path (`/Users/…/doc.md`, possibly followed
+ *  by text or `[Image #N]` tokens) has an embedded slash → it is NOT a command. Without this, dragging a
+ *  file into the prompt errored with "Unknown command /Users/…". Exported pure for tests. */
+export function isSlashCommand(line) {
+    return line.startsWith("/") && !line.slice(1).split(/\s+/)[0].includes("/");
+}
+/** If a message BEGINS with an absolute file path (a dragged/pasted file), rewrite that leading path into
+ *  an `@`-mention so expandMentions inlines the file's content into the turn — the "read/interpret this
+ *  file" the user meant. Space-free leading paths only (a mention can't contain spaces); a non-existent or
+ *  spaced path is left untouched. `exists` is injected so this stays pure/testable. */
+export function inlineLeadingPath(line, exists) {
+    if (!line.startsWith("/"))
+        return line;
+    const first = line.split(/\s+/)[0];
+    return exists(first) ? "@" + line : line;
+}
 /** Expand `@path` references **in place** — the file/dir content lands where it's referenced, not
  *  dumped at the bottom (so "compare @a.ts with @b.ts" reads in context). A repeated mention keeps
  *  the bare `@path` the second time (no double-inlining), and a non-readable ref is left untouched. */

package/dist/index.js

@@ -47,7 +47,7 @@ import { loadAgentsMd, hasAgentsMd, INIT_PROMPT, findProjectRoot } from "./conte
 import { getEmbedder } from "./search/embed.js";
 import { collectRepoChunks, collectDirChunks, buildIndex, indexPath, indexExists } from "./search/semindex.js";
 import { searchHybrid } from "./search/hybrid.js";
-import { expandMentions, fileCandidates } from "./context/mentions.js";
+import { expandMentions, fileCandidates, isSlashCommand, inlineLeadingPath } from "./context/mentions.js";
 import { newSessionId, shortId, resolveSessionId, saveSession, loadSession, listSessions, latestForCwd, titleFrom, slugify, } from "./session/store.js";
 import { setSessionForceModel, isSessionForceModel, effectiveRoleModel } from "./session/session-model.js";
 import { loadRoles, scaffoldRoles, subagentToolFilter } from "./org/roles.js";
@@ -2814,7 +2814,9 @@ program.action(async (opts) => {
             onClipboardImage: readClipboardImage,
             vim: cfg.vimMode,
             onSubmit: async (line, h, images) => {
-                if (line.startsWith("/")) {
+                // A dropped/pasted file path (`/Users/…/doc.md`, maybe trailing text/images) starts with '/' but
+                // is NOT a command — treat it as a file to read, not "Unknown command" (see isSlashCommand).
+                if (isSlashCommand(line)) {
                     const [nm, ...rest] = line.slice(1).split(/\s+/);
                     const arg = rest.join(" ").trim();
                     if (nm === "exit" || nm === "quit") {
@@ -3074,6 +3076,9 @@ program.action(async (opts) => {
                     const near = nearest(nm, [...byName.keys()]);
                     return void h.sink.notice(`Unknown command /${nm}.${near.length ? " Did you mean " + near.map((n) => "/" + n).join(", ") + "?" : ""}`);
                 }
+                // A message that begins with an absolute file path (the case skipped above) → inline it as an
+                // @-mention so its content is read into the turn (drag-a-file-in → interpret it).
+                line = inlineLeadingPath(line, existsSync);
                 const ui = { text: h.sink.assistantDelta, reasoning: h.sink.reasoningDelta, tool: h.sink.tool, diff: h.sink.diff, notice: h.sink.notice };
                 const appr = h.approval;
                 // Type-ahead steering: fold messages typed mid-turn into the next model call (codex-style) so a
@@ -3237,7 +3242,8 @@ program.action(async (opts) => {
         bar.renderBottom(); // bottom border + modes/usage
         if (!line)
             continue;
-        if (line.startsWith("/")) {
+        // A dropped/pasted file path starts with '/' but isn't a command — read it, don't error (see TUI path).
+        if (isSlashCommand(line)) {
             const [name, ...rest] = line.slice(1).split(/\s+/);
             const cmd = byName.get(name);
             if (!cmd) {
@@ -3275,6 +3281,7 @@ program.action(async (opts) => {
                 break;
             continue;
         }
+        line = inlineLeadingPath(line, existsSync); // leading dropped file path → @-mention so it's read in
         const userContent = (recalledContext ? `${recalledContext}\n\n---\n\n` : "") + expandMentions(line, cwd);
         recalledContext = "";
         history.push({ role: "user", content: userContent });

package/dist/providers/openai.js

@@ -51,6 +51,21 @@ export function toOpenAI(system, history) {
 export function isReasoningModel(model) {
     return /^(o1|o3|o4|gpt-5)/i.test(model);
 }
+/** DashScope (Alibaba — serves Qwen, GLM, …) runs a "thinking" phase that streams reasoning BEFORE the
+ *  answer — the main latency there (measured: qwen3.7-plus ~14s thinking vs ~1.6s without). It can be
+ *  silenced SERVER-SIDE with `enable_thinking:false` (actually stops generating the reasoning, not just
+ *  hides it). So map hara's reasoning dial onto it: an explicit **off** → thinking off (fast);
+ *  low/medium/high → on. Returns the flag to send, or `undefined` = leave the request UNTOUCHED — when
+ *  the dial is UNSET (keep the model's own default; zero impact — the safe default the user asked for)
+ *  or the endpoint isn't DashScope. Detected by the DashScope ENDPOINT (built-in qwen/qwen-oauth
+ *  providers, OR a custom baseURL on dashscope — which is how the reporter's `custom:qwen3.7-plus`
+ *  profile is set up), NOT the model name, so it covers custom Qwen/GLM profiles too. Exported for tests. */
+export function dashscopeThinking(effort, baseURL, label) {
+    const isDashscope = /dashscope\.aliyuncs\.com/i.test(baseURL ?? "") || label === "qwen" || label === "qwen-oauth";
+    if (!isDashscope || effort === undefined)
+        return undefined;
+    return effort !== "off";
+}
 /** OpenAI-compatible provider (works with OpenAI, Qwen/DashScope, GLM, Kimi, …). */
 export function createOpenAIProvider(opts) {
     const client = new OpenAI({ apiKey: opts.apiKey, maxRetries: 4, ...(opts.baseURL ? { baseURL: opts.baseURL } : {}) });
@@ -78,6 +93,11 @@ export function createOpenAIProvider(opts) {
             if (opts.reasoningEffort && opts.reasoningEffort !== undefined && isReasoningModel(opts.model)) {
                 params.reasoning_effort = opts.reasoningEffort === "off" ? "minimal" : opts.reasoningEffort;
             }
+            // DashScope: reasoning "off" REALLY disables the thinking phase (big speedup), not just hides it.
+            // Only fires on the DashScope endpoint + when the dial is set — UNSET stays untouched (zero impact).
+            const dsThink = dashscopeThinking(opts.reasoningEffort, opts.baseURL, opts.label);
+            if (dsThink !== undefined)
+                params.enable_thinking = dsThink;
             // Stream: emit text deltas live; accumulate tool-call args by index; grab usage from the tail chunk.
             let text = "";
             const acc = new Map();

package/dist/tui/App.js

@@ -515,6 +515,11 @@ export function App({ initialStatus, model, cwd, header, onSubmit, cycleApproval
             return askTextFn(question);
         };
         const setApprovalFn = (m) => setStatus((s) => ({ ...s, approval: m }));
+        // Enter the conversation flow INSTANTLY: yield one macrotask so ink paints the committed message +
+        // cleared input + spinner BEFORE the turn's synchronous prep runs (reading @-files, base64-encoding
+        // images) and before the model's slow first token. Without this, that sync prep blocks ink's flush,
+        // so pressing Enter leaves the message stuck in the input box for seconds ("回车一直不动"). One tick.
+        await new Promise((resolve) => setTimeout(resolve, 0));
         try {
             await onSubmit(t, { sink, confirm: confirmFn, select: selectFn, ask: askFn, setApproval: setApprovalFn, signal: ctrl.signal, exit, approval: statusRef.current.approval, drainQueue }, images);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanhara/hara",
-  "version": "0.109.3",
+  "version": "0.109.5",
   "description": "hara — a coding agent CLI that runs like an engineering org.",
   "bin": {
     "hara": "dist/index.js"