@nuvin/nuvin-core 1.9.2 → 1.9.4

package/dist/VERSION

@@ -1,4 +1,4 @@
 {
-  "version": "1.9.2",
-  "commit": "28ede6b"
+  "version": "1.9.4",
+  "commit": "88246cb"
 }

package/dist/index.d.ts

@@ -1622,6 +1622,7 @@ declare class BashTool implements FunctionTool<BashParams, ToolExecutionContext,
      */
     execute(p: BashParams, ctx?: ToolExecutionContext): Promise<BashResult>;
     private execOnce;
+    private killProcessGroup;
     private defaultShell;
     private shellExists;
     private shellArgs;

package/dist/index.js

@@ -1406,7 +1406,7 @@ var AgentOrchestrator = class {
   toInvocations(toolCalls) {
     return convertToolCalls(toolCalls, {
       strict: this.cfg.strictToolValidation ?? false,
-      throwOnError: true
+      throwOnError: false
     });
   }
 };
@@ -3026,13 +3026,15 @@ var BashTool = class {
     const executable = this.defaultShell();
     const execArgs = this.shellArgs(cmd, executable);
     let child;
+    const isWindows = os3.platform() === "win32";
     try {
       child = spawn(executable, execArgs, {
         cwd,
         env: process.env,
         stdio: ["ignore", "pipe", "pipe"],
         shell: false,
-        windowsHide: true
+        windowsHide: true,
+        detached: !isWindows
       });
     } catch (error) {
       if (error instanceof Error && "code" in error && error.code === "ENOENT") {
@@ -3040,18 +3042,23 @@ var BashTool = class {
       }
       throw error;
     }
-    child.on("error", (err2) => {
+    child.once("error", (err2) => {
       if ("code" in err2 && err2.code === "ENOENT") {
-        child.emit("close", -1, null);
+        if (!child.killed) {
+          child.emit("close", -1, null);
+        }
       }
     });
     let timer = null;
+    let abortKillTimer = null;
+    let abortHandler = null;
     let timedOut = false;
+    let truncated = false;
     const deadline = new Promise((_, rej) => {
       timer = setTimeout(() => {
         timedOut = true;
         try {
-          child.kill("SIGKILL");
+          this.killProcessGroup(child, isWindows);
         } catch {
         }
         rej(new Error(`Command timed out after ${timeoutMs} ms`));
@@ -3059,13 +3066,16 @@ var BashTool = class {
     });
     const abort = new Promise((_, rej) => {
       if (signal) {
-        const abortHandler = () => {
-          if (timer) clearTimeout(timer);
+        abortHandler = () => {
+          if (timer) {
+            clearTimeout(timer);
+            timer = null;
+          }
           try {
-            child.kill("SIGTERM");
-            setTimeout(() => {
+            this.killProcessGroup(child, isWindows, "SIGTERM");
+            abortKillTimer = setTimeout(() => {
               if (child && !child.killed) {
-                child.kill("SIGKILL");
+                this.killProcessGroup(child, isWindows);
               }
             }, 1e3);
           } catch {
@@ -3081,29 +3091,69 @@ var BashTool = class {
     const stdout = [];
     const stderr = [];
     let total = 0;
-    const capPush = (arr, chunk) => {
+    const stdoutHandler = (chunk) => {
+      if (truncated) return;
+      total += chunk.length;
+      if (total > maxOutputBytes) {
+        truncated = true;
+        stdout.push(Buffer.from(`
+[truncated at ${maxOutputBytes} bytes]
+`));
+        this.killProcessGroup(child, isWindows);
+        return;
+      }
+      stdout.push(chunk);
+    };
+    const stderrHandler = (chunk) => {
+      if (truncated) return;
       total += chunk.length;
       if (total > maxOutputBytes) {
-        arr.push(Buffer.from(`
+        truncated = true;
+        stderr.push(Buffer.from(`
 [truncated at ${maxOutputBytes} bytes]
 `));
-        child.kill("SIGKILL");
+        this.killProcessGroup(child, isWindows);
         return;
       }
-      arr.push(chunk);
+      stderr.push(chunk);
     };
     if (child.stdout) {
-      child.stdout.on("data", (d) => capPush(stdout, d));
+      child.stdout.on("data", stdoutHandler);
     }
     if (child.stderr) {
-      child.stderr.on("data", (d) => capPush(stderr, d));
+      child.stderr.on("data", stderrHandler);
     }
+    const cleanup = () => {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      if (abortKillTimer) {
+        clearTimeout(abortKillTimer);
+        abortKillTimer = null;
+      }
+      if (signal && abortHandler) {
+        signal.removeEventListener("abort", abortHandler);
+        abortHandler = null;
+      }
+      if (child.stdout) {
+        child.stdout.off("data", stdoutHandler);
+      }
+      if (child.stderr) {
+        child.stderr.off("data", stderrHandler);
+      }
+      if (child && child.pid && !child.killed) {
+        try {
+          this.killProcessGroup(child, isWindows);
+        } catch {
+        }
+      }
+    };
     const exit = new Promise((res) => {
       child.on("close", (code, signal2) => res({ code, signal: signal2 }));
     });
     try {
       const { code, signal: exitSignal } = await Promise.race([exit, deadline, abort]);
-      if (timer) clearTimeout(timer);
       const outText = Buffer.concat(stdout).toString("utf8");
       const errText = Buffer.concat(stderr).toString("utf8");
       const output = stripAnsi ? stripAnsiAndControls(outText + errText) : outText + errText;
@@ -3125,7 +3175,6 @@ ${output}` : "";
       }
       return okText(output, { code, signal: exitSignal, cwd, stripped: stripAnsi });
     } catch (e) {
-      if (timer) clearTimeout(timer);
       const message = e instanceof Error ? e.message : String(e);
       if (message === "ABORTED" || signal?.aborted) {
         const outText = Buffer.concat(stdout).toString("utf8");
@@ -3140,6 +3189,24 @@ ${output}` : "";
         return err(message, { cwd }, "timeout" /* Timeout */);
       }
       return err(message, { cwd }, "unknown" /* Unknown */);
+    } finally {
+      cleanup();
+    }
+  }
+  killProcessGroup(child, isWindows, signal = "SIGKILL") {
+    if (!child.pid) return;
+    if (isWindows) {
+      try {
+        spawn("taskkill", ["/pid", child.pid.toString(), "/T", "/F"], { stdio: "ignore" });
+      } catch {
+        child.kill(signal);
+      }
+    } else {
+      try {
+        process.kill(-child.pid, signal);
+      } catch {
+        child.kill(signal);
+      }
     }
   }
   defaultShell() {
@@ -5953,6 +6020,7 @@ function normalizeModelLimits(provider, model) {
 }
 var FALLBACK_LIMITS = {
   zai: {
+    "glm-4.7": { contextWindow: 2e5, maxOutput: 128e3 },
     "glm-4.6": { contextWindow: 2e5, maxOutput: 128e3 }
   },
   openrouter: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuvin/nuvin-core",
-  "version": "1.9.2",
+  "version": "1.9.4",
   "description": "",
   "private": false,
   "main": "dist/index.js",