@robota-sdk/agent-tools 3.0.0-beta.61 → 3.0.0-beta.62

package/dist/node/index.cjs

@@ -1,60 +1,16 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+'use strict';
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  E2BSandboxClient: () => E2BSandboxClient,
-  FunctionTool: () => FunctionTool,
-  InMemorySandboxClient: () => InMemorySandboxClient,
-  OpenAPITool: () => OpenAPITool,
-  ToolRegistry: () => ToolRegistry,
-  applyWorkspaceManifest: () => applyWorkspaceManifest,
-  bashTool: () => bashTool,
-  createBashTool: () => createBashTool,
-  createEditTool: () => createEditTool,
-  createFunctionTool: () => createFunctionTool,
-  createOpenAPITool: () => createOpenAPITool,
-  createReadTool: () => createReadTool,
-  createWriteTool: () => createWriteTool,
-  createZodFunctionTool: () => createZodFunctionTool,
-  editTool: () => editTool,
-  globTool: () => globTool,
-  grepTool: () => grepTool,
-  readTool: () => readTool,
-  validateWorkspaceManifestPath: () => validateWorkspaceManifestPath,
-  webFetchTool: () => webFetchTool,
-  webSearchTool: () => webSearchTool,
-  writeTool: () => writeTool,
-  zodToJsonSchema: () => zodToJsonSchema
-});
-module.exports = __toCommonJS(index_exports);
+var promises = require('fs/promises');
+var path = require('path');
+var agentCore = require('@robota-sdk/agent-core');
+var child_process = require('child_process');
+var zod = require('zod');
+var crypto = require('crypto');
+var fg = require('fast-glob');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var fg__default = /*#__PURE__*/_interopDefault(fg);
 
 // src/sandbox/e2b-sandbox-client.ts
 var E2BSandboxClient = class {
@@ -170,10 +126,6 @@ var InMemorySandboxClient = class {
     return this.files.get(path);
   }
 };
-
-// src/sandbox/workspace-manifest.ts
-var import_promises = require("fs/promises");
-var import_node_path = require("path");
 var DEFAULT_TARGET_ROOT = "/workspace";
 var WINDOWS_ABSOLUTE_PATH_PATTERN = /^[A-Za-z]:[\\/]/;
 var SHELL_QUOTE_PATTERN = /'/g;
@@ -251,7 +203,7 @@ function createAppliedEntry(path, type) {
 }
 async function copyLocalFile(sandboxClient, source, targetPath, targetRoot, options) {
   const hostSourcePath = resolveHostSourcePath(source, options.hostRoot);
-  const content = await (0, import_promises.readFile)(hostSourcePath, "utf8");
+  const content = await promises.readFile(hostSourcePath, "utf8");
   await writeSandboxFile(sandboxClient, targetPath, targetRoot, content);
 }
 async function copyLocalDirectory(sandboxClient, source, targetPath, options) {
@@ -260,16 +212,16 @@ async function copyLocalDirectory(sandboxClient, source, targetPath, options) {
 }
 async function copyLocalDirectoryRecursive(sandboxClient, sourcePath, targetPath) {
   await createSandboxDirectory(sandboxClient, targetPath);
-  const entries = await (0, import_promises.readdir)(sourcePath, { withFileTypes: true });
+  const entries = await promises.readdir(sourcePath, { withFileTypes: true });
   for (const entry of entries) {
-    const childSourcePath = (0, import_node_path.join)(sourcePath, entry.name);
+    const childSourcePath = path.join(sourcePath, entry.name);
     const childTargetPath = joinSandboxPath(targetPath, entry.name);
     if (entry.isDirectory()) {
       await copyLocalDirectoryRecursive(sandboxClient, childSourcePath, childTargetPath);
       continue;
     }
     if (entry.isFile()) {
-      const content = await (0, import_promises.readFile)(childSourcePath, "utf8");
+      const content = await promises.readFile(childSourcePath, "utf8");
       await sandboxClient.writeFile(childTargetPath, content);
     }
   }
@@ -283,7 +235,7 @@ async function cloneGitRepository(sandboxClient, entry, targetPath) {
   );
 }
 async function writeSandboxFile(sandboxClient, targetPath, targetRoot, content) {
-  const parentPath = import_node_path.posix.dirname(targetPath);
+  const parentPath = path.posix.dirname(targetPath);
   if (parentPath !== targetRoot) {
     await createSandboxDirectory(sandboxClient, parentPath);
   }
@@ -302,7 +254,7 @@ ${result.stderr ?? result.stdout}`
   }
 }
 function resolveHostSourcePath(source, hostRoot) {
-  return (0, import_node_path.isAbsolute)(source) ? (0, import_node_path.resolve)(source) : (0, import_node_path.resolve)(hostRoot ?? process.cwd(), source);
+  return path.isAbsolute(source) ? path.resolve(source) : path.resolve(hostRoot ?? process.cwd(), source);
 }
 function normalizeSandboxRoot(root) {
   const normalized = root.replace(/\\/g, "/").replace(/\/+$/, "");
@@ -324,10 +276,6 @@ function quoteShellArg(value) {
 function assertUnreachable(value) {
   throw new Error(`unsupported workspace manifest entry: ${JSON.stringify(value)}`);
 }
-
-// src/registry/tool-registry.ts
-var import_agent_core = require("@robota-sdk/agent-core");
-var import_agent_core2 = require("@robota-sdk/agent-core");
 var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
   /**
@@ -335,18 +283,18 @@ var ToolRegistry = class {
    */
   register(tool) {
     if (!tool.schema?.name) {
-      throw new import_agent_core.ValidationError("Tool must have a valid schema with name");
+      throw new agentCore.ValidationError("Tool must have a valid schema with name");
     }
     const toolName = tool.schema.name;
     this.validateToolSchema(tool.schema);
     if (this.tools.has(toolName)) {
-      import_agent_core2.logger.warn(`Tool "${toolName}" is already registered, overriding`, {
+      agentCore.logger.warn(`Tool "${toolName}" is already registered, overriding`, {
         toolName,
         existingTool: this.tools.get(toolName)?.constructor.name
       });
     }
     this.tools.set(toolName, tool);
-    import_agent_core2.logger.debug(`Tool "${toolName}" registered successfully`, {
+    agentCore.logger.debug(`Tool "${toolName}" registered successfully`, {
       toolName,
       toolType: tool.constructor.name,
       parameters: Object.keys(tool.schema.parameters?.properties || {})
@@ -357,11 +305,11 @@ var ToolRegistry = class {
    */
   unregister(name) {
     if (!this.tools.has(name)) {
-      import_agent_core2.logger.warn(`Attempted to unregister non-existent tool "${name}"`);
+      agentCore.logger.warn(`Attempted to unregister non-existent tool "${name}"`);
       return;
     }
     this.tools.delete(name);
-    import_agent_core2.logger.debug(`Tool "${name}" unregistered successfully`);
+    agentCore.logger.debug(`Tool "${name}" unregistered successfully`);
   }
   /**
    * Get tool by name
@@ -380,7 +328,7 @@ var ToolRegistry = class {
    */
   getSchemas() {
     const tools = this.getAll();
-    import_agent_core2.logger.debug("[TOOL-FLOW] ToolRegistry.getSchemas() - Tools before schema extraction", {
+    agentCore.logger.debug("[TOOL-FLOW] ToolRegistry.getSchemas() - Tools before schema extraction", {
       count: tools.length,
       tools: tools.map((t) => ({
         name: t.schema?.name ?? "unnamed",
@@ -403,7 +351,7 @@ var ToolRegistry = class {
   clear() {
     const toolCount = this.tools.size;
     this.tools.clear();
-    import_agent_core2.logger.debug(`Cleared ${toolCount} tools from registry`);
+    agentCore.logger.debug(`Cleared ${toolCount} tools from registry`);
   }
   /**
    * Get tool names
@@ -429,26 +377,26 @@ var ToolRegistry = class {
    */
   validateToolSchema(schema) {
     if (!schema.name || typeof schema.name !== "string") {
-      throw new import_agent_core.ValidationError("Tool schema must have a valid name");
+      throw new agentCore.ValidationError("Tool schema must have a valid name");
     }
     if (!schema.description || typeof schema.description !== "string") {
-      throw new import_agent_core.ValidationError("Tool schema must have a description");
+      throw new agentCore.ValidationError("Tool schema must have a description");
     }
     if (!schema.parameters || typeof schema.parameters !== "object" || schema.parameters === null || Array.isArray(schema.parameters)) {
-      throw new import_agent_core.ValidationError("Tool schema must have parameters object");
+      throw new agentCore.ValidationError("Tool schema must have parameters object");
     }
     if (schema.parameters.type !== "object") {
-      throw new import_agent_core.ValidationError('Tool parameters type must be "object"');
+      throw new agentCore.ValidationError('Tool parameters type must be "object"');
     }
     if (schema.parameters.properties) {
       for (const propName of Object.keys(schema.parameters.properties)) {
         const propSchema = schema.parameters.properties[propName];
         if (!propSchema?.type) {
-          throw new import_agent_core.ValidationError(`Parameter "${propName}" must have a type`);
+          throw new agentCore.ValidationError(`Parameter "${propName}" must have a type`);
         }
         const validTypes = ["string", "number", "boolean", "array", "object"];
         if (!validTypes.includes(propSchema.type)) {
-          throw new import_agent_core.ValidationError(
+          throw new agentCore.ValidationError(
             `Parameter "${propName}" has invalid type "${propSchema.type}"`
           );
         }
@@ -458,7 +406,7 @@ var ToolRegistry = class {
       const properties = schema.parameters.properties || {};
       for (const requiredField of schema.parameters.required) {
         if (!properties[requiredField]) {
-          throw new import_agent_core.ValidationError(
+          throw new agentCore.ValidationError(
             `Required parameter "${requiredField}" is not defined in properties`
           );
         }
@@ -467,9 +415,6 @@ var ToolRegistry = class {
   }
 };
 
-// src/implementations/function-tool.ts
-var import_agent_core3 = require("@robota-sdk/agent-core");
-
 // src/implementations/function-tool/schema-converter.ts
 function zodToJsonSchema(schema, options = {}) {
   const properties = {};
@@ -703,17 +648,17 @@ var FunctionTool = class {
         this.schema.parameters.properties || {},
         this.schema.parameters.additionalProperties
       );
-      throw new import_agent_core3.ValidationError(`Invalid parameters for tool "${toolName}": ${errors.join(", ")}`);
+      throw new agentCore.ValidationError(`Invalid parameters for tool "${toolName}": ${errors.join(", ")}`);
     }
     const startTime = Date.now();
     let result;
     try {
       result = await this.fn(parameters, context);
     } catch (error) {
-      if (error instanceof import_agent_core3.ToolExecutionError || error instanceof import_agent_core3.ValidationError) {
+      if (error instanceof agentCore.ToolExecutionError || error instanceof agentCore.ValidationError) {
         throw error;
       }
-      throw new import_agent_core3.ToolExecutionError(
+      throw new agentCore.ToolExecutionError(
         `Function tool execution failed: ${error instanceof Error ? error.message : String(error)}`,
         toolName,
         error instanceof Error ? error : new Error(String(error)),
@@ -767,13 +712,13 @@ var FunctionTool = class {
    */
   validateConstructorInputs() {
     if (!this.schema) {
-      throw new import_agent_core3.ValidationError("Tool schema is required");
+      throw new agentCore.ValidationError("Tool schema is required");
     }
     if (!this.fn || typeof this.fn !== "function") {
-      throw new import_agent_core3.ValidationError("Tool function is required and must be a function");
+      throw new agentCore.ValidationError("Tool function is required and must be a function");
     }
     if (!this.schema.name) {
-      throw new import_agent_core3.ValidationError("Tool schema must have a name");
+      throw new agentCore.ValidationError("Tool schema must have a name");
     }
   }
 };
@@ -795,7 +740,7 @@ function createZodFunctionTool(name, description, zodSchema, fn) {
   const wrappedFn = async (parameters2, context) => {
     const parseResult = zodSchema.safeParse(parameters2);
     if (!parseResult.success) {
-      throw new import_agent_core3.ValidationError(`Zod validation failed: ${parseResult.error}`);
+      throw new agentCore.ValidationError(`Zod validation failed: ${parseResult.error}`);
     }
     const result = await fn(parseResult.data || parameters2, context);
     return typeof result === "string" ? result : JSON.stringify(result);
@@ -803,9 +748,6 @@ function createZodFunctionTool(name, description, zodSchema, fn) {
   return new FunctionTool(schema, wrappedFn);
 }
 
-// src/implementations/openapi-tool.ts
-var import_agent_core4 = require("@robota-sdk/agent-core");
-
 // src/implementations/openapi-schema-converter.ts
 var HTTP_METHODS = [
   "get",
@@ -957,7 +899,7 @@ var OpenAPITool = class {
     const toolName = this.schema.name;
     const validation = this.validateParameters(parameters);
     if (!validation.isValid) {
-      throw new import_agent_core4.ValidationError(
+      throw new agentCore.ValidationError(
         `Invalid parameters for OpenAPI tool "${toolName}": ${validation.errors.join(", ")}`
       );
     }
@@ -976,11 +918,11 @@ var OpenAPITool = class {
         }
       };
     } catch (error) {
-      if (error instanceof import_agent_core4.ToolExecutionError || error instanceof import_agent_core4.ValidationError) {
+      if (error instanceof agentCore.ToolExecutionError || error instanceof agentCore.ValidationError) {
         throw error;
       }
       const safeError = error instanceof Error ? error : new Error(String(error));
-      throw new import_agent_core4.ToolExecutionError(
+      throw new agentCore.ToolExecutionError(
         `OpenAPI tool execution failed: ${safeError.message}`,
         toolName,
         safeError,
@@ -1127,15 +1069,11 @@ var OpenAPITool = class {
 function createOpenAPITool(config) {
   return new OpenAPITool(config);
 }
-
-// src/builtins/bash-tool.ts
-var import_node_child_process = require("child_process");
-var import_zod = require("zod");
 var DEFAULT_TIMEOUT_MS = 12e4;
-var BashSchema = import_zod.z.object({
-  command: import_zod.z.string().describe("The bash command to execute"),
-  timeout: import_zod.z.number().optional().describe("Optional timeout in milliseconds (max 600000). Default is 120000 (2 minutes)"),
-  workingDirectory: import_zod.z.string().optional().describe("Working directory for the command. Defaults to the current working directory")
+var BashSchema = zod.z.object({
+  command: zod.z.string().describe("The bash command to execute"),
+  timeout: zod.z.number().optional().describe("Optional timeout in milliseconds (max 600000). Default is 120000 (2 minutes)"),
+  workingDirectory: zod.z.string().optional().describe("Working directory for the command. Defaults to the current working directory")
 });
 async function runBash(args, options = {}) {
   const { command, timeout = DEFAULT_TIMEOUT_MS, workingDirectory } = args;
@@ -1168,7 +1106,7 @@ ${sandboxResult.stderr}` : sandboxResult.stdout;
     const stderrChunks = [];
     let timedOut = false;
     let settled = false;
-    const child = (0, import_node_child_process.spawn)("sh", ["-c", command], {
+    const child = child_process.spawn("sh", ["-c", command], {
       cwd: workingDirectory ?? process.cwd(),
       env: process.env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -1236,17 +1174,13 @@ function createBashTool(options = {}) {
   );
 }
 var bashTool = createBashTool();
-
-// src/builtins/read-tool.ts
-var import_promises2 = require("fs/promises");
-var import_zod2 = require("zod");
 var DEFAULT_LIMIT = 2e3;
-var ReadSchema = import_zod2.z.object({
-  filePath: import_zod2.z.string().describe("The absolute path to the file to read"),
-  offset: import_zod2.z.number().optional().describe(
+var ReadSchema = zod.z.object({
+  filePath: zod.z.string().describe("The absolute path to the file to read"),
+  offset: zod.z.number().optional().describe(
     "The line number to start reading from (1-based). Only provide if the file is too large to read at once"
   ),
-  limit: import_zod2.z.number().optional().describe(
+  limit: zod.z.number().optional().describe(
     `The number of lines to read (default: ${DEFAULT_LIMIT}). Only provide if the file is too large to read at once`
   )
 });
@@ -1302,7 +1236,7 @@ async function readFileTool(args, options = {}) {
   }
   let fileStats;
   try {
-    fileStats = await (0, import_promises2.stat)(filePath);
+    fileStats = await promises.stat(filePath);
   } catch (err) {
     const result = {
       success: false,
@@ -1321,7 +1255,7 @@ async function readFileTool(args, options = {}) {
   }
   let buffer;
   try {
-    buffer = await (0, import_promises2.readFile)(filePath);
+    buffer = await promises.readFile(filePath);
   } catch (err) {
     const result = {
       success: false,
@@ -1352,26 +1286,18 @@ function createReadTool(options = {}) {
   );
 }
 var readTool = createReadTool();
-
-// src/builtins/write-tool.ts
-var import_zod3 = require("zod");
-
-// src/builtins/atomic-file-write.ts
-var import_node_crypto = require("crypto");
-var import_promises3 = require("fs/promises");
-var import_node_path2 = require("path");
 var TEMP_RANDOM_BYTES = 6;
 var PRESERVED_MODE_BITS = 4095;
 var MISSING_FILE_ERROR_CODE = "ENOENT";
 function createTempFilePath(filePath) {
-  const dir = (0, import_node_path2.dirname)(filePath);
-  const name = (0, import_node_path2.basename)(filePath);
-  const suffix = (0, import_node_crypto.randomBytes)(TEMP_RANDOM_BYTES).toString("hex");
-  return (0, import_node_path2.join)(dir, `.${name}.robota-tmp-${process.pid}-${Date.now()}-${suffix}`);
+  const dir = path.dirname(filePath);
+  const name = path.basename(filePath);
+  const suffix = crypto.randomBytes(TEMP_RANDOM_BYTES).toString("hex");
+  return path.join(dir, `.${name}.robota-tmp-${process.pid}-${Date.now()}-${suffix}`);
 }
 async function readExistingMode(filePath) {
   try {
-    const fileStats = await (0, import_promises3.stat)(filePath);
+    const fileStats = await promises.stat(filePath);
     return fileStats.mode & PRESERVED_MODE_BITS;
   } catch (error) {
     if (error instanceof Error && hasErrorCode(error, MISSING_FILE_ERROR_CODE)) return void 0;
@@ -1382,26 +1308,26 @@ function hasErrorCode(error, code) {
   return "code" in error && error.code === code;
 }
 async function atomicWriteUtf8File(filePath, content) {
-  const dir = (0, import_node_path2.dirname)(filePath);
-  await (0, import_promises3.mkdir)(dir, { recursive: true });
+  const dir = path.dirname(filePath);
+  await promises.mkdir(dir, { recursive: true });
   const existingMode = await readExistingMode(filePath);
   const tempFilePath = createTempFilePath(filePath);
   try {
-    await (0, import_promises3.writeFile)(tempFilePath, content, "utf8");
+    await promises.writeFile(tempFilePath, content, "utf8");
     if (existingMode !== void 0) {
-      await (0, import_promises3.chmod)(tempFilePath, existingMode);
+      await promises.chmod(tempFilePath, existingMode);
     }
-    await (0, import_promises3.rename)(tempFilePath, filePath);
+    await promises.rename(tempFilePath, filePath);
   } catch (error) {
-    await (0, import_promises3.rm)(tempFilePath, { force: true }).catch(() => void 0);
+    await promises.rm(tempFilePath, { force: true }).catch(() => void 0);
     throw error;
   }
 }
 
 // src/builtins/write-tool.ts
-var WriteSchema = import_zod3.z.object({
-  filePath: import_zod3.z.string().describe("The absolute path to the file to write"),
-  content: import_zod3.z.string().describe("The content to write to the file")
+var WriteSchema = zod.z.object({
+  filePath: zod.z.string().describe("The absolute path to the file to write"),
+  content: zod.z.string().describe("The content to write to the file")
 });
 async function writeFileTool(args, options = {}) {
   const { filePath, content } = args;
@@ -1436,15 +1362,11 @@ function createWriteTool(options = {}) {
   );
 }
 var writeTool = createWriteTool();
-
-// src/builtins/edit-tool.ts
-var import_promises4 = require("fs/promises");
-var import_zod4 = require("zod");
-var EditSchema = import_zod4.z.object({
-  filePath: import_zod4.z.string().describe("The absolute path to the file to modify"),
-  oldString: import_zod4.z.string().describe("The text to replace (must be an exact match of existing content)"),
-  newString: import_zod4.z.string().describe("The text to replace it with (must be different from old_string)"),
-  replaceAll: import_zod4.z.boolean().optional().describe(
+var EditSchema = zod.z.object({
+  filePath: zod.z.string().describe("The absolute path to the file to modify"),
+  oldString: zod.z.string().describe("The text to replace (must be an exact match of existing content)"),
+  newString: zod.z.string().describe("The text to replace it with (must be different from old_string)"),
+  replaceAll: zod.z.boolean().optional().describe(
     "Replace all occurrences of old_string (default: false). Useful for renaming variables"
   )
 });
@@ -1452,7 +1374,7 @@ async function editFileTool(args, options = {}) {
   const { filePath, oldString, newString, replaceAll = false } = args;
   let content;
   try {
-    content = options.sandboxClient ? await options.sandboxClient.readFile(filePath) : await (0, import_promises4.readFile)(filePath, "utf8");
+    content = options.sandboxClient ? await options.sandboxClient.readFile(filePath) : await promises.readFile(filePath, "utf8");
   } catch (err) {
     const result2 = {
       success: false,
@@ -1518,28 +1440,22 @@ function createEditTool(options = {}) {
   );
 }
 var editTool = createEditTool();
-
-// src/builtins/glob-tool.ts
-var import_promises5 = require("fs/promises");
-var import_node_path3 = require("path");
-var import_fast_glob = __toESM(require("fast-glob"), 1);
-var import_zod5 = require("zod");
 var DEFAULT_MAX_RESULTS = 1e3;
-var GlobSchema = import_zod5.z.object({
-  pattern: import_zod5.z.string().describe('The glob pattern to match files against (e.g. "**/*.ts", "src/**/*.tsx")'),
-  path: import_zod5.z.string().optional().describe(
+var GlobSchema = zod.z.object({
+  pattern: zod.z.string().describe('The glob pattern to match files against (e.g. "**/*.ts", "src/**/*.tsx")'),
+  path: zod.z.string().optional().describe(
     "The directory to search in. Defaults to the current working directory. Must be a valid directory path if provided"
   ),
-  limit: import_zod5.z.number().optional().describe(
+  limit: zod.z.number().optional().describe(
     "Maximum number of results to return (default: 1000). Use a smaller limit to save context space"
   )
 });
 async function globFileTool(args) {
   const { pattern, path: basePath } = args;
-  const cwd = basePath ? (0, import_node_path3.resolve)(basePath) : process.cwd();
+  const cwd = basePath ? path.resolve(basePath) : process.cwd();
   let matches;
   try {
-    matches = await (0, import_fast_glob.default)(pattern, {
+    matches = await fg__default.default(pattern, {
       cwd,
       ignore: ["**/node_modules/**", "**/.git/**"],
       dot: true,
@@ -1555,9 +1471,9 @@ async function globFileTool(args) {
   }
   const withMtime = await Promise.all(
     matches.map(async (p) => {
-      const absPath = (0, import_node_path3.resolve)(cwd, p);
+      const absPath = path.resolve(cwd, p);
       try {
-        const s = await (0, import_promises5.stat)(absPath);
+        const s = await promises.stat(absPath);
         return { path: p, mtime: s.mtimeMs };
       } catch {
         return { path: p, mtime: 0 };
@@ -1590,21 +1506,16 @@ var globTool = createZodFunctionTool(
     return globFileTool(params);
   }
 );
-
-// src/builtins/grep-tool.ts
-var import_promises6 = require("fs/promises");
-var import_node_path4 = require("path");
-var import_zod6 = require("zod");
-var GrepSchema = import_zod6.z.object({
-  pattern: import_zod6.z.string().describe("The regular expression pattern to search for in file contents"),
-  path: import_zod6.z.string().optional().describe("File or directory to search in. Defaults to the current working directory"),
-  glob: import_zod6.z.string().optional().describe(
+var GrepSchema = zod.z.object({
+  pattern: zod.z.string().describe("The regular expression pattern to search for in file contents"),
+  path: zod.z.string().optional().describe("File or directory to search in. Defaults to the current working directory"),
+  glob: zod.z.string().optional().describe(
     'Glob pattern to filter files (e.g. "*.ts", "*.{ts,tsx}"). Only files matching this pattern will be searched'
   ),
-  contextLines: import_zod6.z.number().optional().describe(
+  contextLines: zod.z.number().optional().describe(
     'Number of context lines to show before and after each match. Only applies when outputMode is "content". Default: 0'
   ),
-  outputMode: import_zod6.z.enum(["files_with_matches", "content"]).optional().describe(
+  outputMode: zod.z.enum(["files_with_matches", "content"]).optional().describe(
     'Output mode: "files_with_matches" shows only file paths (default), "content" shows matching lines with context'
   )
 });
@@ -1621,16 +1532,16 @@ async function collectFiles(dirPath, glob) {
   async function walk(current) {
     let entryNames;
     try {
-      entryNames = await (0, import_promises6.readdir)(current);
+      entryNames = await promises.readdir(current);
     } catch {
       return;
     }
     for (const name of entryNames) {
       if (name === "node_modules" || name === ".git") continue;
-      const fullPath = (0, import_node_path4.join)(current, name);
+      const fullPath = path.join(current, name);
       let fileStat;
       try {
-        fileStat = await (0, import_promises6.stat)(fullPath);
+        fileStat = await promises.stat(fullPath);
       } catch {
         continue;
       }
@@ -1686,7 +1597,7 @@ async function grepFileTool(args) {
     contextLines = 0,
     outputMode = "files_with_matches"
   } = args;
-  const targetPath = searchPath ? (0, import_node_path4.resolve)(searchPath) : process.cwd();
+  const targetPath = searchPath ? path.resolve(searchPath) : process.cwd();
   let regex;
   try {
     regex = new RegExp(pattern);
@@ -1700,7 +1611,7 @@ async function grepFileTool(args) {
   }
   let targetStat;
   try {
-    targetStat = await (0, import_promises6.stat)(targetPath);
+    targetStat = await promises.stat(targetPath);
   } catch {
     const result2 = {
       success: false,
@@ -1719,7 +1630,7 @@ async function grepFileTool(args) {
   for (const filePath of files) {
     let content;
     try {
-      const buffer = await (0, import_promises6.readFile)(filePath);
+      const buffer = await promises.readFile(filePath);
       const checkLen = Math.min(buffer.length, 8192);
       let hasBinary = false;
       for (let i = 0; i < checkLen; i++) {
@@ -1750,14 +1661,11 @@ var grepTool = createZodFunctionTool(
     return grepFileTool(params);
   }
 );
-
-// src/builtins/web-fetch-tool.ts
-var import_zod7 = require("zod");
 var DEFAULT_TIMEOUT_MS2 = 3e4;
 var MAX_RESPONSE_BYTES = 5e6;
-var WebFetchSchema = import_zod7.z.object({
-  url: import_zod7.z.string().describe("The URL to fetch"),
-  headers: import_zod7.z.record(import_zod7.z.string()).optional().describe("Optional HTTP headers as key-value pairs")
+var WebFetchSchema = zod.z.object({
+  url: zod.z.string().describe("The URL to fetch"),
+  headers: zod.z.record(zod.z.string()).optional().describe("Optional HTTP headers as key-value pairs")
 });
 function htmlToText(html) {
   return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/\s+/g, " ").trim();
@@ -1818,14 +1726,11 @@ var webFetchTool = createZodFunctionTool(
   WebFetchSchema,
   async (params) => runWebFetch(params)
 );
-
-// src/builtins/web-search-tool.ts
-var import_zod8 = require("zod");
 var DEFAULT_LIMIT2 = 10;
 var DEFAULT_TIMEOUT_MS3 = 15e3;
-var WebSearchSchema = import_zod8.z.object({
-  query: import_zod8.z.string().describe("The search query"),
-  limit: import_zod8.z.number().optional().describe(`Maximum number of results to return (default: ${DEFAULT_LIMIT2})`)
+var WebSearchSchema = zod.z.object({
+  query: zod.z.string().describe("The search query"),
+  limit: zod.z.number().optional().describe(`Maximum number of results to return (default: ${DEFAULT_LIMIT2})`)
 });
 async function runWebSearch(args) {
   const { query, limit = DEFAULT_LIMIT2 } = args;
@@ -1882,29 +1787,27 @@ var webSearchTool = createZodFunctionTool(
   WebSearchSchema,
   async (params) => runWebSearch(params)
 );
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  E2BSandboxClient,
-  FunctionTool,
-  InMemorySandboxClient,
-  OpenAPITool,
-  ToolRegistry,
-  applyWorkspaceManifest,
-  bashTool,
-  createBashTool,
-  createEditTool,
-  createFunctionTool,
-  createOpenAPITool,
-  createReadTool,
-  createWriteTool,
-  createZodFunctionTool,
-  editTool,
-  globTool,
-  grepTool,
-  readTool,
-  validateWorkspaceManifestPath,
-  webFetchTool,
-  webSearchTool,
-  writeTool,
-  zodToJsonSchema
-});
+
+exports.E2BSandboxClient = E2BSandboxClient;
+exports.FunctionTool = FunctionTool;
+exports.InMemorySandboxClient = InMemorySandboxClient;
+exports.OpenAPITool = OpenAPITool;
+exports.ToolRegistry = ToolRegistry;
+exports.applyWorkspaceManifest = applyWorkspaceManifest;
+exports.bashTool = bashTool;
+exports.createBashTool = createBashTool;
+exports.createEditTool = createEditTool;
+exports.createFunctionTool = createFunctionTool;
+exports.createOpenAPITool = createOpenAPITool;
+exports.createReadTool = createReadTool;
+exports.createWriteTool = createWriteTool;
+exports.createZodFunctionTool = createZodFunctionTool;
+exports.editTool = editTool;
+exports.globTool = globTool;
+exports.grepTool = grepTool;
+exports.readTool = readTool;
+exports.validateWorkspaceManifestPath = validateWorkspaceManifestPath;
+exports.webFetchTool = webFetchTool;
+exports.webSearchTool = webSearchTool;
+exports.writeTool = writeTool;
+exports.zodToJsonSchema = zodToJsonSchema;