@cuylabs/agent-core 0.8.0 → 0.10.0

package/dist/{chunk-P6YF7USR.js → chunk-Q742PSH3.js}

@@ -34,7 +34,7 @@ function normalizeToolReplayPolicy(policy, fileOps) {
 }
 
 // src/tool/truncation.ts
-import * as fs from "fs/promises";
+import * as fsSync from "fs";
 import * as path from "path";
 import * as os from "os";
 import * as crypto from "crypto";
@@ -55,8 +55,11 @@ function truncateOutput(output, options = {}) {
   }
   const hash = crypto.createHash("sha256").update(output).digest("hex").slice(0, 16);
   const outputPath = path.join(TRUNCATE_DIR, `output-${hash}.txt`);
-  fs.mkdir(TRUNCATE_DIR, { recursive: true }).then(() => fs.writeFile(outputPath, output, "utf-8")).catch(() => {
-  });
+  try {
+    fsSync.mkdirSync(TRUNCATE_DIR, { recursive: true });
+    fsSync.writeFileSync(outputPath, output, "utf-8");
+  } catch {
+  }
   let truncated;
   if (lines.length > maxLines) {
     const keepLines = Math.floor(maxLines / 2);
@@ -71,9 +74,10 @@ function truncateOutput(output, options = {}) {
       ...lastPart
     ].join("\n");
   } else {
+    const buf = Buffer.from(output, "utf-8");
     const keepBytes = Math.floor(maxBytes / 2);
-    const start = output.slice(0, keepBytes);
-    const end = output.slice(-keepBytes);
+    const start = buf.subarray(0, keepBytes).toString("utf-8");
+    const end = buf.subarray(buf.length - keepBytes).toString("utf-8");
     const omittedBytes = bytes - keepBytes * 2;
     truncated = `${start}
 ... (${omittedBytes} bytes omitted, full output saved to ${outputPath}) ...
@@ -85,11 +89,6 @@ ${end}`;
     outputPath
   };
 }
-function formatSize(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
 
 // src/tool/tool.ts
 import { z } from "zod";
@@ -102,17 +101,22 @@ var Tool;
     );
     return {
       id,
+      capabilitiesHint: options.capabilitiesHint,
       replayPolicy: staticReplayPolicy,
+      deferred: options.deferred,
+      searchKeywords: options.searchKeywords,
       init: async (initCtx) => {
         const toolInfo = typeof init === "function" ? await init(initCtx) : init;
         const replayPolicy = normalizeToolReplayPolicy(
           toolInfo.replayPolicy ?? staticReplayPolicy,
           toolInfo.fileOps
         );
+        const perToolMaxBytes = toolInfo.capabilities?.maxOutputChars;
         const originalExecute = toolInfo.execute;
         const execute = async (params, ctx) => {
+          let validated;
           try {
-            toolInfo.parameters.parse(params);
+            validated = toolInfo.parameters.parse(params);
           } catch (error) {
             if (error instanceof z.ZodError && toolInfo.formatValidationError) {
               throw new Error(toolInfo.formatValidationError(error), {
@@ -125,16 +129,19 @@ Please rewrite the input so it satisfies the expected schema.`,
               { cause: error }
             );
           }
-          const result = await originalExecute(params, ctx);
-          if (result.metadata.truncated !== void 0) {
+          const result = await originalExecute(validated, ctx);
+          const meta = result.metadata ?? {};
+          if (meta.truncated !== void 0) {
             return result;
           }
-          const truncated = truncateOutput(result.output);
+          const truncated = truncateOutput(result.output, {
+            ...perToolMaxBytes !== void 0 ? { maxBytes: perToolMaxBytes } : {}
+          });
           return {
             ...result,
             output: truncated.content,
             metadata: {
-              ...result.metadata,
+              ...meta,
               truncated: truncated.truncated,
               ...truncated.truncated && { outputPath: truncated.outputPath }
             }
@@ -149,34 +156,12 @@ Please rewrite the input so it satisfies the expected schema.`,
     };
   }
   Tool2.define = define;
-  function defineSimple(id, config) {
-    return define(id, config);
-  }
-  Tool2.defineSimple = defineSimple;
 })(Tool || (Tool = {}));
-function defineTool(definition) {
-  return Tool.define(definition.id, {
-    description: definition.description,
-    parameters: definition.parameters,
-    execute: async (params, ctx) => {
-      const result = await definition.execute(params, ctx);
-      return {
-        title: result.title,
-        output: result.output,
-        metadata: result.metadata ?? {}
-      };
-    }
-  });
-}
 
 export {
   normalizeToolReplayPolicy,
   MAX_LINES,
   MAX_BYTES,
-  TRUNCATE_DIR,
-  TRUNCATE_GLOB,
   truncateOutput,
-  formatSize,
-  Tool,
-  defineTool
+  Tool
 };