@nanhara/hara 0.112.2 → 0.112.4

package/CHANGELOG.md

@@ -5,6 +5,37 @@ 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.112.4 — reasoning models don't false-timeout · cross-provider fallback routes correctly
+
+- **A reasoning model (qwen3.7-plus / GLM / DeepSeek) thinking on a long context no longer false-times-out.**
+  These models stream `reasoning_content` (the thought) for a while — often long — before the first real
+  `content` token. The stall watchdog was only fed by rendered output, so on a big context (e.g. 58
+  messages) the model could still be thinking when the 120s "no output" timer fired. Now **every stream
+  chunk — reasoning, tool-args, even suppressed reasoning — resets the watchdog** (new `onActivity`), and
+  the default stall timeout is **120s → 240s** (still `HARA_STALL_TIMEOUT`-tunable). Confirmed: simple
+  calls always worked; only the long-context interactive case timed out — a hara bug, not the API.
+- **`bash` default timeout 120s → 300s** — a long file transform/build legitimately runs past two minutes;
+  it was erroring out. (Set `timeout_ms`, or `background:true` for a server.)
+- **Cross-provider fallback now targets the right endpoint.** With `fallbackModel` set but no
+  `fallbackBaseURL`, the fallback reused the PRIMARY baseURL — so e.g. a `deepseek-v4-pro` fallback got
+  posted to `coding.dashscope` → 400. New **`fallbackProvider`** config routes the fallback to that
+  vendor's endpoint + its own key (`fallbackBaseURL`/`fallbackApiKey` still override); and a mismatched
+  fallback (a different-vendor model with no routing configured) is now refused with a clear warning
+  instead of silently 400-ing on failover.
+
+## 0.112.3 — big file write no longer traps the model in a "params not passed" loop
+
+- **Fixed the loop where a model (glm-5 / qwen via DashScope) repeats `write_file` / `bash` with empty or
+  `undefined` arguments.** Two problems compounded: the OpenAI-compatible path capped output at
+  `max_tokens: 8192`, so a large `write_file` (e.g. a 64-hexagram data file) ran PAST the limit and its
+  tool-call-arguments JSON was cut off — and hara then **silently swallowed the unparseable JSON into an
+  empty `{}`**. So the tool ran with no path/content (`bash` got `command: undefined` →
+  `/bin/sh: undefined: command not found`), the model saw the failure, "fixed" it by calling again, and
+  looped — never realizing its *output* had been truncated. Now: (1) `max_tokens` is raised to 32000
+  (glm-5/qwen accept it), and (2) **truncated/malformed tool arguments surface as an actionable error**
+  ("the model hit its output-length limit mid tool-call — write the file in smaller parts") instead of a
+  silent `{}`, so the loop breaks and the fix is obvious.
+
 ## 0.112.2 — moving/resizing the window no longer garbles the UI
 
 - **Terminal resize no longer stacks the status row + input box into a garble.** ink 6.8's resize

package/dist/agent/loop.js

@@ -23,8 +23,8 @@ const FILE_TOUCH_TOOLS = new Set(["read_file", "edit_file", "write_file"]);
  *  hidden-reasoning models can legitimately go quiet for a while; HARA_STALL_TIMEOUT (ms) tunes it,
  *  floor 1s (tests). codex's equivalent is its 2–9s stream-idle timeout. */
 export function stallMs() {
-    const raw = Number(process.env.HARA_STALL_TIMEOUT ?? 120_000);
-    return Math.max(1_000, Number.isFinite(raw) && raw > 0 ? raw : 120_000);
+    const raw = Number(process.env.HARA_STALL_TIMEOUT ?? 240_000);
+    return Math.max(1_000, Number.isFinite(raw) && raw > 0 ? raw : 240_000);
 }
 /** Spinner verb (terminal mode + reused by TUI tests): when the agent has an in_progress todo,
  *  surface its activeForm/text so the bottom-of-screen line reads concretely ("▶ updating tests… 3s")
@@ -192,6 +192,11 @@ export async function runAgent(history, opts) {
                 system: composeSystem(ctx.cwd, opts.projectContext, opts.systemOverride, opts.memory),
                 history,
                 tools: specs,
+                // Any stream chunk keeps the connection considered alive — even suppressed reasoning_content, so a
+                // reasoning model thinking for a long while before its first `content` token can't be false-timed-out.
+                onActivity: () => {
+                    lastEvent = Date.now();
+                },
                 onText: (d) => {
                     alive();
                     if (opts.quiet)

package/dist/config.js

@@ -30,7 +30,7 @@ const PROVIDER_DEFAULTS = {
     },
     "hara-gateway": { model: "", envKey: "HARA_GATEWAY_TOKEN" }, // B-end: enrolled device → token in ~/.hara/org.json, routed by the gateway
 };
-export const CONFIG_KEYS = ["provider", "apiKey", "model", "baseURL", "approval", "sandbox", "theme", "evolve", "assetCapture", "computerUse", "computerApps", "visionModel", "visionBaseURL", "visionApiKey", "embedProvider", "embedModel", "embedBaseURL", "embedApiKey", "routeModel", "routeBaseURL", "routeApiKey", "guardian", "notify", "vimMode", "autoCompact", "fileCheckpoints", "updateCheck", "fallbackModel", "fallbackBaseURL", "fallbackApiKey", "reasoningEffort"];
+export const CONFIG_KEYS = ["provider", "apiKey", "model", "baseURL", "approval", "sandbox", "theme", "evolve", "assetCapture", "computerUse", "computerApps", "visionModel", "visionBaseURL", "visionApiKey", "embedProvider", "embedModel", "embedBaseURL", "embedApiKey", "routeModel", "routeBaseURL", "routeApiKey", "guardian", "notify", "vimMode", "autoCompact", "fileCheckpoints", "updateCheck", "fallbackModel", "fallbackProvider", "fallbackBaseURL", "fallbackApiKey", "reasoningEffort"];
 export const REASONING_EFFORTS = ["off", "low", "medium", "high"];
 export const APPROVAL_MODES = ["suggest", "auto-edit", "full-auto"];
 export const SANDBOX_MODES = ["off", "workspace-write", "read-only"];
@@ -160,13 +160,14 @@ export function loadConfig(opts = {}) {
     const fileCheckpoints = !(process.env.HARA_CHECKPOINTS === "0" || merged.fileCheckpoints === false || merged.fileCheckpoints === "false"); // default ON
     const updateCheck = !(process.env.HARA_UPDATE_CHECK === "0" || merged.updateCheck === false || merged.updateCheck === "false"); // default ON
     const fallbackModel = process.env.HARA_FALLBACK_MODEL ?? merged.fallbackModel;
+    const fallbackProvider = (process.env.HARA_FALLBACK_PROVIDER ?? merged.fallbackProvider);
     const fallbackBaseURL = process.env.HARA_FALLBACK_BASE_URL ?? merged.fallbackBaseURL;
     const fallbackApiKey = process.env.HARA_FALLBACK_API_KEY ?? merged.fallbackApiKey;
     const reasoningRaw = process.env.HARA_REASONING_EFFORT ?? merged.reasoningEffort;
     const reasoningEffort = reasoningRaw && ["off", "low", "medium", "high"].includes(reasoningRaw)
         ? reasoningRaw
         : undefined;
-    return { provider, apiKey, model, baseURL, approval, sandbox, theme, evolve, assetCapture, computerUse, computerApps, visionModel, visionBaseURL, visionApiKey, modelVision, embedProvider, embedModel, embedBaseURL, embedApiKey, routeModel, routeBaseURL, routeApiKey, guardian, hooks, notify, vimMode, autoCompact, fileCheckpoints, updateCheck, fallbackModel, fallbackBaseURL, fallbackApiKey, reasoningEffort, mcpServers, cwd: process.cwd() };
+    return { provider, apiKey, model, baseURL, approval, sandbox, theme, evolve, assetCapture, computerUse, computerApps, visionModel, visionBaseURL, visionApiKey, modelVision, embedProvider, embedModel, embedBaseURL, embedApiKey, routeModel, routeBaseURL, routeApiKey, guardian, hooks, notify, vimMode, autoCompact, fileCheckpoints, updateCheck, fallbackModel, fallbackProvider, fallbackBaseURL, fallbackApiKey, reasoningEffort, mcpServers, cwd: process.cwd() };
 }
 export function providerEnvKey(provider) {
     return (PROVIDER_DEFAULTS[provider] ?? PROVIDER_DEFAULTS.anthropic).envKey;

package/dist/index.js

@@ -2105,8 +2105,34 @@ program.action(async (opts) => {
     if (opts.model)
         cfg.model = opts.model;
     const provider0 = await withRouting(await buildProvider(cfg), cfg);
-    const fallbackProvider = provider0 && cfg.fallbackModel && cfg.fallbackModel !== cfg.model ? await buildProvider({ ...cfg, model: cfg.fallbackModel, baseURL: cfg.fallbackBaseURL ?? cfg.baseURL, apiKey: cfg.fallbackApiKey ?? cfg.apiKey }) : null;
-    const fbOpt = fallbackProvider ? { provider: fallbackProvider } : undefined; // app-failover for the main chat turns
+    // Fallback provider, built correctly for CROSS-PROVIDER failover. The old `baseURL: fallbackBaseURL ??
+    // baseURL` sent the fallback model to the PRIMARY endpoint when no fallbackBaseURL was set — e.g.
+    // deepseek-v4-pro posted to coding.dashscope → 400. Now: `fallbackProvider` routes to that vendor's
+    // endpoint + its own key (fallbackBaseURL/fallbackApiKey still override); without it we stay on the
+    // primary endpoint (correct only for a same-endpoint fallback).
+    let fallbackProv = null;
+    if (provider0 && cfg.fallbackModel && cfg.fallbackModel !== cfg.model) {
+        const fp = cfg.fallbackProvider;
+        const cross = !!fp && fp !== cfg.provider;
+        const family = (m) => m.toLowerCase().split(/[-.:/]/)[0];
+        if (cross && !cfg.fallbackApiKey && !cfg.apiKey) {
+            process.stderr.write(`hara: fallbackProvider '${fp}' needs its own key — set fallbackApiKey. Fallback disabled.\n`);
+        }
+        else if (!fp && !cfg.fallbackBaseURL && family(cfg.fallbackModel) !== family(cfg.model)) {
+            // A different-looking vendor with no routing set would hit the primary endpoint and 400 on failover.
+            process.stderr.write(`hara: fallbackModel '${cfg.fallbackModel}' looks like a different vendor than '${cfg.model}', but no fallbackProvider/fallbackBaseURL is set — it would hit the PRIMARY endpoint (likely 400). Set fallbackProvider (+ fallbackApiKey). Fallback disabled.\n`);
+        }
+        else {
+            fallbackProv = await buildProvider({
+                ...cfg,
+                provider: fp ?? cfg.provider,
+                model: cfg.fallbackModel,
+                baseURL: cfg.fallbackBaseURL ?? (fp ? providerDefaultBaseURL(fp) : cfg.baseURL),
+                apiKey: cfg.fallbackApiKey ?? (cross ? undefined : cfg.apiKey),
+            });
+        }
+    }
+    const fbOpt = fallbackProv ? { provider: fallbackProv } : undefined; // app-failover for the main chat turns
     const guardianOpt = await buildGuardian(cfg, provider0); // internal safety layer (high-risk actions only)
     if (!provider0) {
         // First-run friendliness: offer the setup wizard instead of just erroring (interactive TTY only).

package/dist/providers/openai.js

@@ -2,6 +2,35 @@ import OpenAI from "openai";
 import { imageToBase64 } from "../images.js";
 import { reasoningParams } from "./reasoning.js";
 import { resolvePlatform } from "./registry.js";
+/** Assemble streamed tool-call fragments into tool uses. CRITICAL: non-empty arguments that don't parse
+ *  mean the model was cut off MID tool-call (almost always the output-length limit on a big write_file /
+ *  bash). Silently substituting `{}` makes the model loop forever — it calls write_file with no path, bash
+ *  with `command: undefined` (`/bin/sh: undefined: command not found`), sees the failure, and retries,
+ *  never realizing its OUTPUT was truncated. So we surface it as an actionable error instead. Exported for
+ *  tests. */
+export function assembleToolCalls(entries, finish) {
+    let truncated = false;
+    const toolUses = entries
+        .filter((t) => t.id && t.name)
+        .map((t) => {
+        let input = {};
+        const raw = (t.args || "").trim();
+        if (raw) {
+            try {
+                input = JSON.parse(raw);
+            }
+            catch {
+                truncated = true;
+            }
+        }
+        return { id: t.id, name: t.name, input };
+    });
+    if (truncated) {
+        const why = finish === "length" ? "the model hit its output-length limit mid tool-call" : "the model emitted malformed tool-call arguments";
+        return { toolUses: [], error: `Tool call dropped — ${why}, so its arguments were incomplete. For a large file, write it in smaller parts (several write_file/edit calls) rather than one giant call.` };
+    }
+    return { toolUses };
+}
 // Re-exported for callers that still import it from here (the reasoning-family check now lives in reasoning.ts).
 export { isReasoningModel } from "./reasoning.js";
 /** Build OpenAI chat-completions messages from neutral history. */
@@ -55,7 +84,7 @@ export function createOpenAIProvider(opts) {
     return {
         id: opts.label ?? "openai",
         model: opts.model,
-        async turn({ system, history, tools, onText, onReasoning, signal }) {
+        async turn({ system, history, tools, onText, onReasoning, onActivity, signal }) {
             const oaiTools = tools.map((t) => ({
                 type: "function",
                 function: { name: t.name, description: t.description, parameters: t.input_schema },
@@ -63,7 +92,7 @@ export function createOpenAIProvider(opts) {
             const params = {
                 model: opts.model,
                 messages: toOpenAI(system, history),
-                max_tokens: 8192,
+                max_tokens: 32000, // was 8192 — too small: a big write_file's args got truncated → unparseable → loop
                 stream: true,
                 stream_options: { include_usage: true },
             };
@@ -83,6 +112,7 @@ export function createOpenAIProvider(opts) {
             try {
                 const stream = await client.chat.completions.create(params, { signal });
                 for await (const chunk of stream) {
+                    onActivity?.(); // ANY chunk (reasoning, tool-args, content, even a keep-alive) → the model is alive
                     const choice = chunk.choices?.[0];
                     const delta = choice?.delta;
                     if (delta?.content) {
@@ -118,18 +148,9 @@ export function createOpenAIProvider(opts) {
                     return { text: "", toolUses: [], stop: "error", errorMsg: "interrupted" };
                 return { text: "", toolUses: [], stop: "error", errorMsg: `${e?.status ?? ""} ${e?.message ?? e}` };
             }
-            const toolUses = [...acc.values()]
-                .filter((t) => t.id && t.name)
-                .map((t) => {
-                let input = {};
-                try {
-                    input = JSON.parse(t.args || "{}");
-                }
-                catch {
-                    input = {};
-                }
-                return { id: t.id, name: t.name, input };
-            });
+            const { toolUses, error: argsError } = assembleToolCalls([...acc.values()], finish);
+            if (argsError)
+                return { text, toolUses: [], stop: "error", errorMsg: argsError, usage };
             const stop = finish === "tool_calls" || toolUses.length ? "tool_use" : "end";
             return { text, toolUses, stop, usage };
         },

package/dist/tools/builtin.js

@@ -78,7 +78,7 @@ registerTool({
         type: "object",
         properties: {
             command: { type: "string" },
-            timeout_ms: { type: "number", description: "default 120000" },
+            timeout_ms: { type: "number", description: "default 300000 (5 min); raise for a long build/transform, or use background:true for a server" },
             background: { type: "boolean", description: "run as a background job (dev server, watcher, long task); returns a job id immediately — tail/kill it with the `job` tool" },
         },
         required: ["command"],
@@ -104,7 +104,7 @@ registerTool({
                 : undefined;
         try {
             const { stdout, stderr } = await runShell(input.command, ctx.cwd, ctx.sandbox ?? "off", {
-                timeout: input.timeout_ms ?? 120_000,
+                timeout: input.timeout_ms ?? 300_000, // was 120s — a long file transform/build legitimately runs longer
                 maxBuffer: 10 * 1024 * 1024,
                 onData: live,
             });

package/package.json

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