@nanhara/hara 0.112.1 → 0.112.3

package/CHANGELOG.md

@@ -5,6 +5,29 @@ 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.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
+  handler only clears the screen when the terminal gets *narrower*; on a *widen* (or a resize it doesn't
+  classify as narrowing) it just re-renders, so the old frame — reflowed at the new width — is never
+  erased, and the ~125ms spinner tick stacks a fresh copy each time (the "I moved the window and the UI
+  filled up with repeated `waiting for the model…` lines"). hara now hooks the resize event and, on ANY
+  resize, resets ink's tracked output (debounced across a drag's burst of events) so the next render
+  starts clean and subsequent ticks erase correctly. Not "just the terminal" — a real repaint fix.
+
 ## 0.112.1 — the background-job indicator is now LIVE (even at idle)
 
 - **`⚙ N bg running` updates in real time — including when hara is idle.** In 0.112.0 the indicator 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. */
@@ -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 },
             };
@@ -118,18 +147,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/tui/run.js

@@ -6,7 +6,35 @@ import { createElement } from "react";
 import { App } from "./App.js";
 export async function runTui(props) {
     const instance = render(createElement(App, props));
-    await instance.waitUntilExit();
+    // Resize repaint fix. ink 6.8's own resize handler only clears the screen when the terminal gets
+    // NARROWER; on a WIDEN (or a resize it doesn't classify as narrowing) it just re-renders, so the old
+    // frame — reflowed at the new width — is never erased, and the ~125ms spinner tick stacks a fresh copy
+    // each time (the "moved the window and the UI stacked up" garble). We complement it: on ANY resize,
+    // clear ink's tracked output so the next render starts clean. Debounced by a microtask so a burst of
+    // resize events during a window drag collapses to one clear.
+    const out = process.stdout;
+    let pending = false;
+    const onResize = () => {
+        if (pending)
+            return;
+        pending = true;
+        queueMicrotask(() => {
+            pending = false;
+            try {
+                instance.clear();
+            }
+            catch {
+                /* best-effort — never let a repaint fix crash the session */
+            }
+        });
+    };
+    out.on("resize", onResize);
+    try {
+        await instance.waitUntilExit();
+    }
+    finally {
+        out.off("resize", onResize);
+    }
 }
 // A tiny ink yes/no prompt for pre-TUI confirms (e.g. the first-run "create AGENTS.md?" offer).
 // MUST be ink, NOT readline: a readline question before the main TUI leaves stdin in a state ink

package/package.json

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