@ai-setting/roy-agent-core 1.5.88 → 1.5.90

package/dist/shared/@ai-setting/{roy-agent-core-3arrpf7n.js → roy-agent-core-hxsbegfc.js}

@@ -1,3 +1,7 @@
+import {
+  AUTO_TASK_METADATA_BEGIN,
+  AUTO_TASK_METADATA_END
+} from "./roy-agent-core-yanpq5gb.js";
 import {
   AskUserError,
   init_workflow_hil
@@ -25,8 +29,6 @@ import {
 import {
   __require
 } from "./roy-agent-core-fs0mn2jk.js";
-// src/env/tool/tool-component.ts
-import { z } from "zod";
 
 // src/env/tool/registry.ts
 class ToolRegistry {
@@ -144,6 +146,7 @@ class ToolValidator {
 }
 
 // src/env/tool/tool-component.ts
+import { z } from "zod";
 init_logger();
 init_global_hook_manager();
 
@@ -178,7 +181,138 @@ var TOOL_CONFIG_REGISTRATION = {
 // src/env/tool/tool-component.ts
 init_workflow_hil();
 init_env_context();
-var logger = createLogger("tool");
+
+// src/utils/temp-file-manager.ts
+init_logger();
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import * as crypto from "node:crypto";
+var logger = createLogger("temp-file-manager");
+
+class TempFileManager {
+  static _instance = null;
+  _files = new Set;
+  _hooksRegistered = false;
+  static FILE_PREFIX = "roy-agent-truncation";
+  static FILE_EXT = ".txt";
+  static LARGE_FILE_THRESHOLD = 10 * 1024 * 1024;
+  static STALE_FILE_AGE_MS = 24 * 60 * 60 * 1000;
+  constructor() {
+    this.sweepStaleFiles().catch((err) => {
+      logger.warn(`[TempFileManager] Stale file sweep failed: ${err}`);
+    });
+  }
+  static getInstance() {
+    if (!TempFileManager._instance) {
+      TempFileManager._instance = new TempFileManager;
+    }
+    return TempFileManager._instance;
+  }
+  static _resetForTesting() {
+    if (TempFileManager._instance) {
+      TempFileManager._instance.cleanupAll().catch(() => {});
+    }
+    TempFileManager._instance = null;
+  }
+  async writeTempFile(content, prefix = "default") {
+    this.ensureHooksRegistered();
+    if (content.length > TempFileManager.LARGE_FILE_THRESHOLD) {
+      logger.warn(`[TempFileManager] Writing large temp file: ${content.length} bytes (> ${TempFileManager.LARGE_FILE_THRESHOLD} bytes). Consider increasing maxOutputSize or filtering output.`);
+    }
+    const sanitizedPrefix = this.sanitizePrefix(prefix);
+    const uuid = crypto.randomUUID();
+    const filename = `${TempFileManager.FILE_PREFIX}-${process.pid}-${uuid}-${sanitizedPrefix}${TempFileManager.FILE_EXT}`;
+    const filePath = path.join(os.tmpdir(), filename);
+    await fs.promises.writeFile(filePath, content, "utf-8");
+    this._files.add(filePath);
+    logger.debug(`[TempFileManager] Created temp file: ${filePath} (${content.length} bytes)`);
+    return filePath;
+  }
+  async cleanupAll() {
+    const files = Array.from(this._files);
+    this._files.clear();
+    const results = await Promise.allSettled(files.map(async (filePath) => {
+      try {
+        await fs.promises.unlink(filePath);
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          logger.warn(`[TempFileManager] Failed to delete ${filePath}: ${err.message}`);
+        }
+      }
+    }));
+    const succeeded = results.filter((r) => r.status === "fulfilled").length;
+    logger.debug(`[TempFileManager] Cleanup complete: ${succeeded}/${files.length} files deleted`);
+  }
+  getActiveFileCount() {
+    return this._files.size;
+  }
+  async sweepStaleFiles(maxAgeMs = TempFileManager.STALE_FILE_AGE_MS) {
+    const tmpDir = os.tmpdir();
+    const now = Date.now();
+    let deletedCount = 0;
+    let entries;
+    try {
+      entries = await fs.promises.readdir(tmpDir);
+    } catch (err) {
+      logger.warn(`[TempFileManager] Failed to read tmpdir ${tmpDir}: ${err.message}`);
+      return 0;
+    }
+    for (const entry of entries) {
+      if (!entry.startsWith(`${TempFileManager.FILE_PREFIX}-`))
+        continue;
+      const filePath = path.join(tmpDir, entry);
+      try {
+        const stat = await fs.promises.stat(filePath);
+        const age = now - stat.mtimeMs;
+        if (age > maxAgeMs) {
+          await fs.promises.unlink(filePath);
+          deletedCount++;
+        }
+      } catch (err) {
+        if (err.code !== "ENOENT") {
+          logger.warn(`[TempFileManager] Failed to sweep ${filePath}: ${err.message}`);
+        }
+      }
+    }
+    if (deletedCount > 0) {
+      logger.info(`[TempFileManager] Swept ${deletedCount} stale files from ${tmpDir}`);
+    }
+    return deletedCount;
+  }
+  ensureHooksRegistered() {
+    if (this._hooksRegistered)
+      return;
+    if (typeof process === "undefined" || !process.on) {
+      return;
+    }
+    const cleanup = () => {
+      for (const filePath of this._files) {
+        try {
+          fs.unlinkSync(filePath);
+        } catch (err) {}
+      }
+      this._files.clear();
+    };
+    process.on("exit", cleanup);
+    process.on("SIGINT", () => {
+      cleanup();
+      process.exit(130);
+    });
+    process.on("SIGTERM", () => {
+      cleanup();
+      process.exit(143);
+    });
+    this._hooksRegistered = true;
+    logger.debug("[TempFileManager] Process exit hooks registered");
+  }
+  sanitizePrefix(prefix) {
+    return prefix.replace(/[\/\\<>:"|?*\x00-\x1f]/g, "-").replace(/\s+/g, "-").substring(0, 32) || "default";
+  }
+}
+
+// src/env/tool/tool-component.ts
+var logger2 = createLogger("tool");
 var configComponentInstance = null;
 function setToolConfigComponent(component) {
   configComponentInstance = component;
@@ -199,6 +333,29 @@ function truncateOutput(output, maxSize) {
       metadata: {}
     };
   }
+  const beginIdx = output.indexOf(AUTO_TASK_METADATA_BEGIN);
+  const endIdx = output.indexOf(AUTO_TASK_METADATA_END, beginIdx >= 0 ? beginIdx + AUTO_TASK_METADATA_BEGIN.length : 0);
+  if (beginIdx >= 0 && endIdx > beginIdx) {
+    const metaEnd = endIdx + AUTO_TASK_METADATA_END.length;
+    const metadataBlock = output.substring(beginIdx, metaEnd);
+    const remainder = output.substring(0, beginIdx) + output.substring(metaEnd);
+    const budget = Math.max(0, maxSize - metadataBlock.length);
+    const truncatedRemainder = remainder.substring(0, budget);
+    const isRemainderTruncated = remainder.length > budget;
+    const truncationNotice2 = isRemainderTruncated ? `
+
+[OUTPUT TRUNCATED: ${remainder.length} → ${budget} characters. Use offset/limit parameters or pipe to file for full content.]` : "";
+    return {
+      output: metadataBlock + `
+
+` + truncatedRemainder + truncationNotice2,
+      metadata: {
+        output_truncated: isRemainderTruncated,
+        original_output_size: output.length,
+        truncated_output_size: maxSize
+      }
+    };
+  }
   const truncatedOutput = output.substring(0, maxSize);
   const truncationNotice = `
 
@@ -212,6 +369,49 @@ function truncateOutput(output, maxSize) {
     }
   };
 }
+var TOOL_MAX_OUTPUT_SIZE_OVERRIDES = {
+  grep: 51200,
+  read_file: 204800,
+  glob: 10240
+};
+function getMaxOutputSizeForTool(toolName, overrideMaxSize) {
+  if (typeof overrideMaxSize === "number" && overrideMaxSize >= 0) {
+    return overrideMaxSize;
+  }
+  if (toolName && TOOL_MAX_OUTPUT_SIZE_OVERRIDES[toolName] !== undefined) {
+    return TOOL_MAX_OUTPUT_SIZE_OVERRIDES[toolName];
+  }
+  return getMaxOutputSize();
+}
+function truncateOutputInline(result, maxSize, overrideMaxSize, toolName) {
+  const cloned = {
+    success: result.success,
+    output: result.output,
+    error: result.error,
+    metadata: result.metadata ? { ...result.metadata } : { execution_time_ms: 0 }
+  };
+  const effectiveMax = typeof maxSize === "number" ? maxSize : getMaxOutputSizeForTool(toolName, overrideMaxSize);
+  if (effectiveMax <= 0) {
+    return cloned;
+  }
+  if (typeof cloned.output === "string") {
+    const truncated = truncateOutput(cloned.output, effectiveMax);
+    cloned.output = truncated.output;
+    cloned.metadata = {
+      ...cloned.metadata,
+      ...truncated.metadata
+    };
+  }
+  if (typeof cloned.error === "string" && cloned.error.length > effectiveMax) {
+    const truncated = truncateOutput(cloned.error, effectiveMax);
+    cloned.error = truncated.output;
+    cloned.metadata = {
+      ...cloned.metadata,
+      ...truncated.metadata
+    };
+  }
+  return cloned;
+}
 
 class ToolComponent extends BaseComponent {
   name = "tool";
@@ -238,7 +438,7 @@ class ToolComponent extends BaseComponent {
     if (this.config?.builtInTools?.enabled !== false) {
       await this.loadBuiltInTools();
     }
-    logger.info(`ToolComponent initialized with ${this.getToolCount()} tools`);
+    logger2.info(`ToolComponent initialized with ${this.getToolCount()} tools`);
   }
   async registerConfig(options) {
     const configComponent = options.configComponent;
@@ -336,7 +536,7 @@ class ToolComponent extends BaseComponent {
     });
   }
   onConfigChange(event) {
-    logger.info(`Tool config changed: ${event.key}`, {
+    logger2.info(`Tool config changed: ${event.key}`, {
       oldValue: event.oldValue,
       newValue: event.newValue
     });
@@ -354,7 +554,7 @@ class ToolComponent extends BaseComponent {
       source,
       enabled: true
     });
-    logger.debug(`Registered tool: ${tool.name}`);
+    logger2.debug(`Registered tool: ${tool.name}`);
     globalHookManager.execute(ToolHookPoints.AFTER_REGISTER, { tool });
   }
   registerMany(tools, source = "dynamic") {
@@ -422,13 +622,32 @@ class ToolComponent extends BaseComponent {
       }
       if (typeof result.output === "string") {
         const maxOutputSize = getMaxOutputSize();
+        let fullOutput = null;
         if (maxOutputSize > 0) {
+          fullOutput = result.output;
           const { output: truncatedOutput, metadata: truncationMeta } = truncateOutput(result.output, maxOutputSize);
           result.output = truncatedOutput;
           result.metadata = {
             ...result.metadata,
             ...truncationMeta
           };
+          if (truncationMeta.output_truncated === true && tool.name !== "read_file" && fullOutput !== null) {
+            try {
+              const tempFilePath = await TempFileManager.getInstance().writeTempFile(fullOutput, tool.name);
+              result.metadata = {
+                ...result.metadata,
+                truncation_temp_file: tempFilePath
+              };
+              result.output += `
+
+⚠️ 输出被截断（原 ${truncationMeta.original_output_size} 字符，截断到 ${truncationMeta.truncated_output_size} 字符）
+\uD83D\uDCC1 完整内容保存到: ${tempFilePath}
+\uD83D\uDD0D 使用 read_file 工具按需读取`;
+              logger2.debug(`[tool-component] Truncated output saved to temp file: ${tempFilePath} (${truncationMeta.original_output_size} bytes)`);
+            } catch (err) {
+              logger2.warn(`[tool-component] Failed to write temp file for truncated output: ${err}`);
+            }
+          }
         }
         const currentTaskId = getCurrentTaskId();
         if (currentTaskId !== undefined) {
@@ -471,9 +690,9 @@ class ToolComponent extends BaseComponent {
       const { getAllBuiltInTools } = await import("../../env/tool/built-in/index.js");
       const tools = getAllBuiltInTools();
       this.registerMany(tools, "built-in");
-      logger.info(`Loaded ${tools.length} built-in tools`);
+      logger2.info(`Loaded ${tools.length} built-in tools`);
     } catch (err) {
-      logger.warn(`Failed to load built-in tools: ${err.message}`);
+      logger2.warn(`Failed to load built-in tools: ${err.message}`);
     }
   }
   getHookPoints() {
@@ -503,4 +722,5 @@ var ToolComponentConfigSchema = z.object({
     maxConcurrency: z.number().int().positive().default(4)
   }).default({})
 });
-export { ToolRegistry, ToolValidator, setToolConfigComponent, getMaxOutputSize, ToolComponent };
+
+export { ToolRegistry, ToolValidator, setToolConfigComponent, getMaxOutputSize, truncateOutputInline, ToolComponent };