@cydm/pie 2.3.0 → 2.4.0

package/dist/chunks/{chunk-P3QPJXS7.js → chunk-XVUV3IM2.js}

@@ -8,7 +8,7 @@ import {
   createSharedWebSearchTool,
   interpretShellExit,
   requestInteraction
-} from "./chunk-UPPICLVS.js";
+} from "./chunk-FKUEIYFQ.js";
 import {
   getBuiltinDir,
   getConfigDir
@@ -146,6 +146,43 @@ function truncateStringToBytesFromEnd(str, maxBytes) {
   return buf.slice(start).toString("utf-8");
 }
 
+// src/capabilities/bash/artifact-sink.ts
+function createArtifactSinkGate(sink, isActive) {
+  const sources = /* @__PURE__ */ new Set();
+  let drainHandler;
+  const onDrain = () => {
+    drainHandler = void 0;
+    if (!isActive()) return;
+    for (const source of sources) {
+      if (!source.destroyed) source.resume();
+    }
+  };
+  return {
+    registerSource(source) {
+      sources.add(source);
+    },
+    write(chunk) {
+      if (sink.write(chunk)) return;
+      for (const source of sources) {
+        if (!source.destroyed) source.pause();
+      }
+      if (!drainHandler) {
+        drainHandler = onDrain;
+        sink.once("drain", onDrain);
+      }
+    },
+    isBackpressured() {
+      return drainHandler !== void 0;
+    },
+    cleanup() {
+      if (drainHandler) {
+        sink.removeListener("drain", onDrain);
+        drainHandler = void 0;
+      }
+    }
+  };
+}
+
 // src/capabilities/bash/index.ts
 var bashSchema = Type.Object({
   command: Type.String({ description: "The bash command to execute" }),
@@ -165,6 +202,7 @@ var bashSchema = Type.Object({
 var DEFAULT_TIMEOUT_SECONDS = 120;
 var MAX_GENERIC_TIMEOUT_SECONDS = 120;
 var OUTPUT_DRAIN_TIMEOUT_MS = 1e3;
+var MAX_SHELL_EXIT_DRAIN_MS = 1e4;
 function resolveTimeoutPolicy(requestedTimeout, commandClass) {
   const requestedSeconds = requestedTimeout ?? DEFAULT_TIMEOUT_SECONDS;
   if (requestedSeconds > MAX_GENERIC_TIMEOUT_SECONDS && commandClass !== "package_manager" && commandClass !== "test_or_build") {
@@ -401,8 +439,9 @@ function formatCommandNonzeroHint(outcome) {
   if (outcome.kind !== "command_nonzero") return void 0;
   return `[Command outcome: ${outcome.summary}. The shell tool ran correctly; inspect this as command/test output, not as a tool malfunction.]`;
 }
-function killProcessTree(pid) {
+function killProcessTree(pid, leaderExited) {
   if (process.platform === "win32") {
+    if (leaderExited) return;
     try {
       spawn("taskkill", ["/F", "/T", "/PID", String(pid)], {
         stdio: "ignore",
@@ -411,14 +450,15 @@ function killProcessTree(pid) {
       }).unref();
     } catch {
     }
-  } else {
+    return;
+  }
+  try {
+    process.kill(-pid, "SIGKILL");
+  } catch {
+    if (leaderExited) return;
     try {
-      process.kill(-pid, "SIGKILL");
+      process.kill(pid, "SIGKILL");
     } catch {
-      try {
-        process.kill(pid, "SIGKILL");
-      } catch {
-      }
     }
   }
 }
@@ -489,6 +529,7 @@ function createBashTool(defaultCwd, options) {
         }
         let tempFilePath;
         let tempFileStream;
+        let tempFileSink;
         let settled = false;
         let totalBytes = 0;
         const chunks = [];
@@ -510,6 +551,8 @@ function createBashTool(defaultCwd, options) {
         let exitCode = null;
         let exitSignal = null;
         let drainTimer;
+        let shellExitAt = 0;
+        let lastPipeActivityAt = 0;
         const spawnCommand = buildSpawnCommand(resolvedShell, effectiveCommand);
         const child = (options?.spawnProcess ?? spawn)(spawnCommand.file, spawnCommand.args, {
           shell: spawnCommand.shell,
@@ -523,12 +566,25 @@ function createBashTool(defaultCwd, options) {
           child.stdout?.destroy();
           child.stderr?.destroy();
         };
+        const shellExitDrainPending = () => {
+          if (tempFileSink?.isBackpressured() === true) return true;
+          if (tempFileStream !== void 0 && !tempFileStream.closed && tempFileStream.writableLength > 0) return true;
+          return Date.now() - lastPipeActivityAt < OUTPUT_DRAIN_TIMEOUT_MS;
+        };
+        const onShellExitDrainDeadline = () => {
+          if (settled) return;
+          if (Date.now() - shellExitAt < MAX_SHELL_EXIT_DRAIN_MS && shellExitDrainPending()) {
+            drainTimer = setTimeout(onShellExitDrainDeadline, OUTPUT_DRAIN_TIMEOUT_MS);
+            return;
+          }
+          closePipes();
+          child.unref?.();
+          void finishExecution(exitCode, exitSignal, true);
+        };
         const timeoutId = setTimeout(() => {
           if (settled) return;
           timedOut = true;
-          if (child.pid && !processExited) {
-            killProcessTree(child.pid);
-          }
+          if (child.pid) killProcessTree(child.pid, processExited);
           closePipes();
           child.unref?.();
           void finishExecution(exitCode, exitSignal, true);
@@ -536,10 +592,11 @@ function createBashTool(defaultCwd, options) {
         const failExecution = (error) => {
           if (settled) return;
           settled = true;
+          tempFileSink?.cleanup();
           clearTimeout(timeoutId);
           if (drainTimer) clearTimeout(drainTimer);
           signal?.removeEventListener("abort", onAbort);
-          if (child.pid && !processExited) killProcessTree(child.pid);
+          if (child.pid) killProcessTree(child.pid, processExited);
           closePipes();
           child.unref?.();
           discardOutputArtifact(tempFilePath, tempFileStream);
@@ -549,26 +606,40 @@ function createBashTool(defaultCwd, options) {
           failExecution(new Error("Operation aborted"));
         };
         signal?.addEventListener("abort", onAbort, { once: true });
+        const ensureOutputArtifact = () => {
+          if (tempFileSink) return tempFileSink;
+          const artifact = (options?.createOutputArtifact ?? createPrivateOutputArtifact)();
+          tempFilePath = artifact.path;
+          tempFileStream = artifact.stream;
+          tempFileStream.once("error", failExecution);
+          tempFileSink = createArtifactSinkGate(artifact.stream, () => !settled);
+          if (child.stdout) tempFileSink.registerSource(child.stdout);
+          if (child.stderr) tempFileSink.registerSource(child.stderr);
+          return tempFileSink;
+        };
         child.stdout?.on("data", (data) => {
           if (settled) return;
+          lastPipeActivityAt = Date.now();
           totalBytes += data.length;
           captureHead(data);
           if (totalBytes > DEFAULT_MAX_BYTES && !tempFilePath) {
             try {
-              const artifact = createPrivateOutputArtifact();
-              tempFilePath = artifact.path;
-              tempFileStream = artifact.stream;
-              tempFileStream.once("error", failExecution);
+              const sink = ensureOutputArtifact();
+              for (const chunk of chunks) {
+                sink.write(chunk);
+              }
             } catch (error) {
               failExecution(error instanceof Error ? error : new Error(String(error)));
               return;
             }
-            for (const chunk of chunks) {
-              tempFileStream.write(chunk);
-            }
           }
-          if (tempFileStream) {
-            tempFileStream.write(data);
+          if (tempFileSink) {
+            try {
+              tempFileSink.write(data);
+            } catch (error) {
+              failExecution(error instanceof Error ? error : new Error(String(error)));
+              return;
+            }
           }
           chunks.push(data);
           chunksBytes += data.length;
@@ -607,24 +678,27 @@ function createBashTool(defaultCwd, options) {
         });
         child.stderr?.on("data", (data) => {
           if (settled) return;
+          lastPipeActivityAt = Date.now();
           totalBytes += data.length;
           captureHead(data);
           if (totalBytes > DEFAULT_MAX_BYTES && !tempFilePath) {
             try {
-              const artifact = createPrivateOutputArtifact();
-              tempFilePath = artifact.path;
-              tempFileStream = artifact.stream;
-              tempFileStream.once("error", failExecution);
+              const sink = ensureOutputArtifact();
+              for (const chunk of chunks) {
+                sink.write(chunk);
+              }
             } catch (error) {
               failExecution(error instanceof Error ? error : new Error(String(error)));
               return;
             }
-            for (const chunk of chunks) {
-              tempFileStream.write(chunk);
-            }
           }
-          if (tempFileStream) {
-            tempFileStream.write(data);
+          if (tempFileSink) {
+            try {
+              tempFileSink.write(data);
+            } catch (error) {
+              failExecution(error instanceof Error ? error : new Error(String(error)));
+              return;
+            }
           }
           chunks.push(data);
           chunksBytes += data.length;
@@ -636,6 +710,7 @@ function createBashTool(defaultCwd, options) {
         const finishExecution = async (code, sig, stdioIncomplete = false) => {
           if (settled) return;
           settled = true;
+          tempFileSink?.cleanup();
           try {
             clearTimeout(timeoutId);
             if (drainTimer) clearTimeout(drainTimer);
@@ -728,7 +803,7 @@ ${commandNonzeroHint}`;
               outputText += "\n[Timeout hint: split custom searches or service polls into smaller bounded steps with progress output, inspect partial results/logs, then make a decision. Avoid repeating long waits. Reserve long timeouts for installs, builds, and tests.]";
             }
             if (stdioIncomplete && !timedOut) {
-              outputText += "\n\n[Output capture ended after the command exited because a descendant kept stdio open. Captured output may be incomplete.]";
+              outputText += "\n\n[Output capture ended after the command exited because a descendant kept stdio open or the output artifact was still draining (bounded wait). Captured output may be incomplete.]";
             }
             if (timeoutPolicy.capped) {
               outputText += `
@@ -761,11 +836,8 @@ ${commandNonzeroHint}`;
           exitCode = code;
           exitSignal = sig;
           if (settled) return;
-          drainTimer = setTimeout(() => {
-            closePipes();
-            child.unref?.();
-            void finishExecution(code, sig, true);
-          }, OUTPUT_DRAIN_TIMEOUT_MS);
+          shellExitAt = Date.now();
+          drainTimer = setTimeout(onShellExitDrainDeadline, OUTPUT_DRAIN_TIMEOUT_MS);
         });
         child.on("close", (code, sig) => {
           processExited = true;

package/dist/chunks/{chunk-IM43UYVV.js → chunk-YRXXRLMQ.js}

@@ -1891,10 +1891,19 @@ var NodeHttpClient = class {
         reject(e);
       });
       if (options.signal) {
-        options.signal.addEventListener("abort", () => {
+        const requestSignal = options.signal;
+        const onRequestAbort = () => {
           logHttp("DEBUG", `Request [${reqTag}] aborted`);
           req.destroy(new Error("Request was aborted"));
-        }, { once: true });
+        };
+        if (requestSignal.aborted) {
+          onRequestAbort();
+        } else {
+          requestSignal.addEventListener("abort", onRequestAbort, { once: true });
+          req.once("close", () => {
+            requestSignal.removeEventListener("abort", onRequestAbort);
+          });
+        }
       }
       if (!tieredStreamTimeout) {
         req.on("timeout", () => {
@@ -1911,7 +1920,7 @@ var NodeHttpClient = class {
           req.destroy(requestTimeoutError);
         }, tieredFirstByteTimeoutMs);
         tieredFirstByteTimer.unref?.();
-        req.on("close", clearTieredFirstByteTimer);
+        req.once("close", clearTieredFirstByteTimer);
       }
       if (options.body) {
         req.write(options.body);
@@ -2380,7 +2389,7 @@ var FileSystemGateway = class {
     fs.renameSync(source, destination);
   }
   /**
-   * Delete file
+   * Delete a file
    */
   deleteFile(path) {
     if (!this.allowWrites) {
@@ -2399,6 +2408,53 @@ var FileSystemGateway = class {
       fs.unlinkSync(path);
     }
   }
+  /**
+   * Delete a directory and (by default) everything inside it.
+   */
+  deleteDirectory(path, options) {
+    if (!this.allowWrites) {
+      throw new Error(`Writes not allowed: ${path}`);
+    }
+    this.validatePath(path, "deleteDirectory");
+    const recursive = options?.recursive ?? true;
+    const platform = detectPlatform();
+    if (platform === "puerts" && typeof CS !== "undefined") {
+      if (CS.System.IO.Directory.Exists(path)) {
+        CS.System.IO.Directory.Delete(path, recursive);
+      }
+      return;
+    }
+    const fs = nodeRequire("fs");
+    fs.rmSync(path, { recursive, force: true });
+  }
+  /**
+   * Move a directory to a new path (destination must not exist).
+   * Unlike renameFile this is directory-aware on every host: Node renames,
+   * PuerTS uses Directory.Move.
+   */
+  moveDirectory(source, destination) {
+    if (!this.allowWrites) {
+      throw new Error(`Writes not allowed: ${destination}`);
+    }
+    this.validatePath(source, "moveDirectory");
+    this.validatePath(destination, "moveDirectory");
+    const platform = detectPlatform();
+    if (platform === "puerts" && typeof CS !== "undefined") {
+      if (!CS.System.IO.Directory.Exists(source)) {
+        throw new Error(`Directory not found: ${source}`);
+      }
+      if (CS.System.IO.Directory.Exists(destination)) {
+        throw new Error(`Move target already exists: ${destination}`);
+      }
+      CS.System.IO.Directory.Move(source, destination);
+      return;
+    }
+    const fs = nodeRequire("fs");
+    if (fs.existsSync(destination)) {
+      throw new Error(`Move target already exists: ${destination}`);
+    }
+    fs.renameSync(source, destination);
+  }
   /**
    * Create directory
    */
@@ -3022,7 +3078,7 @@ function logEmptyAssistantContentError(error, model, options) {
 var DEFAULT_OPENAI_COMPAT_STREAM_IDLE_TIMEOUT_MS = 2 * 60 * 1e3;
 var DEFAULT_OPENAI_COMPAT_FIRST_BYTE_TIMEOUT_MS = 3 * 60 * 1e3;
 var OPENAI_COMPAT_FIRST_BYTE_MAX_ESCALATION_STEPS = 3;
-var openAICompatConsecutiveFirstByteTimeouts = 0;
+var openAICompatFirstByteTimeoutsByEndpoint = /* @__PURE__ */ new Map();
 var OPENAI_COMPAT_PROTOCOL_ERROR_CODE = "provider_response_protocol_error";
 var OpenAICompatProtocolError = class extends Error {
   code = OPENAI_COMPAT_PROTOCOL_ERROR_CODE;
@@ -3039,15 +3095,20 @@ function getOpenAICompatFirstByteTimeoutBaseMs() {
   const value = Number(process.env.PIE_OPENAI_COMPAT_FIRST_BYTE_TIMEOUT_MS || "");
   return Number.isFinite(value) && value > 0 ? value : DEFAULT_OPENAI_COMPAT_FIRST_BYTE_TIMEOUT_MS;
 }
-function getOpenAICompatFirstByteTimeoutMs() {
+function firstByteEscalationKey(model) {
+  return `${model.provider}|${model.baseUrl}|${model.id}`;
+}
+function getOpenAICompatFirstByteTimeoutMs(model) {
   const base = getOpenAICompatFirstByteTimeoutBaseMs();
-  return base * 2 ** Math.min(openAICompatConsecutiveFirstByteTimeouts, OPENAI_COMPAT_FIRST_BYTE_MAX_ESCALATION_STEPS);
+  const consecutive = openAICompatFirstByteTimeoutsByEndpoint.get(firstByteEscalationKey(model)) ?? 0;
+  return base * 2 ** Math.min(consecutive, OPENAI_COMPAT_FIRST_BYTE_MAX_ESCALATION_STEPS);
 }
-function noteOpenAICompatFirstByteTimeout() {
-  openAICompatConsecutiveFirstByteTimeouts += 1;
+function noteOpenAICompatFirstByteTimeout(model) {
+  const key = firstByteEscalationKey(model);
+  openAICompatFirstByteTimeoutsByEndpoint.set(key, (openAICompatFirstByteTimeoutsByEndpoint.get(key) ?? 0) + 1);
 }
-function resetOpenAICompatFirstByteTimeoutEscalation() {
-  openAICompatConsecutiveFirstByteTimeouts = 0;
+function resetOpenAICompatFirstByteTimeoutEscalation(model) {
+  openAICompatFirstByteTimeoutsByEndpoint.delete(firstByteEscalationKey(model));
 }
 function normalizeTokenCount(value) {
   if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
@@ -3180,7 +3241,7 @@ var streamOpenAICompletions = (model, context, options) => {
         // providers with hidden reasoning are not killed repeatedly) plus a
         // stream-idle budget that any traffic resets.
         ...options?.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {
-          firstByteTimeoutMs: getOpenAICompatFirstByteTimeoutMs(),
+          firstByteTimeoutMs: getOpenAICompatFirstByteTimeoutMs(model),
           streamIdleTimeoutMs: getOpenAICompatStreamTimeoutMs()
         },
         // Log attribution only (never sent over the wire).
@@ -3491,13 +3552,13 @@ var streamOpenAICompletions = (model, context, options) => {
         throw new Error("An unknown error occurred");
       }
       assertAssistantHasContent(output);
-      resetOpenAICompatFirstByteTimeoutEscalation();
+      resetOpenAICompatFirstByteTimeoutEscalation(model);
       stream.push({ type: "done", reason: output.stopReason, message: output });
       stream.end();
     } catch (error) {
       logEmptyAssistantContentError(error, model, options);
       if (error instanceof Error && error.message.includes("Request timeout (first byte)")) {
-        noteOpenAICompatFirstByteTimeout();
+        noteOpenAICompatFirstByteTimeout(model);
       }
       output.stopReason = options?.signal?.aborted ? "aborted" : "error";
       output.errorMessage = error instanceof Error ? error.message : JSON.stringify(error);

package/dist/chunks/{chunk-QJH6YN2W.js → chunk-ZKHMNEXL.js}

@@ -3,7 +3,7 @@ import {
   EventStream,
   streamSimple,
   validateToolArguments
-} from "./chunk-IM43UYVV.js";
+} from "./chunk-YRXXRLMQ.js";
 
 // ../../packages/agent-core/src/agent-loop.ts
 function createLoopErrorMessage(error, config, signal) {

package/dist/chunks/{src-QSP2OPHU.js → src-SXUQ7OY6.js}

@@ -3,8 +3,8 @@ import {
   Agent,
   agentLoop,
   agentLoopContinue
-} from "./chunk-QJH6YN2W.js";
-import "./chunk-IM43UYVV.js";
+} from "./chunk-ZKHMNEXL.js";
+import "./chunk-YRXXRLMQ.js";
 import "./chunk-XXGYUYXI.js";
 import "./chunk-LZQXQOPJ.js";
 export {

package/dist/chunks/{test-stream-CVGWFLSX.js → test-stream-OD3B57AS.js}

@@ -1,7 +1,7 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   EventStream
-} from "./chunk-IM43UYVV.js";
+} from "./chunk-YRXXRLMQ.js";
 import "./chunk-XXGYUYXI.js";
 import "./chunk-LZQXQOPJ.js";