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

package/dist/node/index.cjs

@@ -1,56 +1,281 @@
-"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 });
+'use strict';
+
+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 {
+  sandbox;
+  connectSandbox;
+  createSandboxFromSnapshot;
+  constructor(options) {
+    this.sandbox = options.sandbox;
+    this.connectSandbox = options.connectSandbox;
+    this.createSandboxFromSnapshot = options.createSandboxFromSnapshot;
+  }
+  async run(command, options) {
+    const result = await this.sandbox.commands.run(command, {
+      background: false,
+      timeoutMs: options?.timeoutMs,
+      cwd: options?.workingDirectory
+    });
+    return {
+      stdout: result.stdout ?? "",
+      stderr: result.stderr ?? "",
+      exitCode: result.exitCode ?? result.exit_code ?? 0
+    };
+  }
+  async readFile(path) {
+    const content = await this.sandbox.files.read(path);
+    return typeof content === "string" ? content : Buffer.from(content).toString("utf8");
+  }
+  async writeFile(path, content) {
+    await this.sandbox.files.write(path, content);
+  }
+  async snapshot() {
+    if (this.sandbox.createSnapshot) {
+      const snapshot = await this.sandbox.createSnapshot();
+      const snapshotId = snapshot.snapshotId ?? snapshot.id;
+      if (!snapshotId) {
+        throw new Error("E2B createSnapshot() did not return a snapshot id.");
+      }
+      return snapshotId;
+    }
+    const sandboxId = this.sandbox.sandboxId;
+    if (!sandboxId) {
+      throw new Error("E2B sandboxId is required to create a resumable sandbox snapshot.");
+    }
+    if (!this.sandbox.pause) {
+      throw new Error("E2B sandbox adapter does not expose pause().");
+    }
+    await this.sandbox.pause();
+    return sandboxId;
+  }
+  async restore(snapshotId) {
+    if (this.createSandboxFromSnapshot) {
+      this.sandbox = await this.createSandboxFromSnapshot(snapshotId);
+      return;
+    }
+    if (this.connectSandbox) {
+      this.sandbox = await this.connectSandbox(snapshotId);
+      return;
+    }
+    if (this.sandbox.sandboxId === snapshotId && this.sandbox.connect) {
+      this.sandbox = await this.sandbox.connect();
+      return;
+    }
+    throw new Error(
+      "E2B sandbox restore requires connectSandbox(snapshotId) or sandbox.connect()."
+    );
   }
-  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);
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  FunctionTool: () => FunctionTool,
-  OpenAPITool: () => OpenAPITool,
-  ToolRegistry: () => ToolRegistry,
-  bashTool: () => bashTool,
-  createFunctionTool: () => createFunctionTool,
-  createOpenAPITool: () => createOpenAPITool,
-  createZodFunctionTool: () => createZodFunctionTool,
-  editTool: () => editTool,
-  globTool: () => globTool,
-  grepTool: () => grepTool,
-  readTool: () => readTool,
-  webFetchTool: () => webFetchTool,
-  webSearchTool: () => webSearchTool,
-  writeTool: () => writeTool,
-  zodToJsonSchema: () => zodToJsonSchema
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/registry/tool-registry.ts
-var import_agent_core = require("@robota-sdk/agent-core");
-var import_agent_core2 = require("@robota-sdk/agent-core");
+// src/sandbox/in-memory-sandbox-client.ts
+var InMemorySandboxClient = class {
+  files = /* @__PURE__ */ new Map();
+  snapshots = /* @__PURE__ */ new Map();
+  runHandler;
+  snapshotSequence = 0;
+  constructor(options = {}) {
+    for (const [path, content] of Object.entries(options.files ?? {})) {
+      this.files.set(path, content);
+    }
+    this.runHandler = options.runHandler;
+  }
+  async run(command, options) {
+    if (this.runHandler) {
+      return this.runHandler(command, options, this.files);
+    }
+    return { stdout: "", stderr: "", exitCode: 0 };
+  }
+  async readFile(path) {
+    const content = this.files.get(path);
+    if (content === void 0) {
+      throw new Error(`Sandbox file not found: ${path}`);
+    }
+    return content;
+  }
+  async writeFile(path, content) {
+    this.files.set(path, content);
+  }
+  async snapshot() {
+    const snapshotId = `snapshot-${++this.snapshotSequence}`;
+    this.snapshots.set(snapshotId, new Map(this.files));
+    return snapshotId;
+  }
+  async restore(snapshotId) {
+    const snapshot = this.snapshots.get(snapshotId);
+    if (!snapshot) {
+      throw new Error(`Sandbox snapshot not found: ${snapshotId}`);
+    }
+    this.files.clear();
+    for (const [path, content] of snapshot.entries()) {
+      this.files.set(path, content);
+    }
+  }
+  getFile(path) {
+    return this.files.get(path);
+  }
+};
+var DEFAULT_TARGET_ROOT = "/workspace";
+var WINDOWS_ABSOLUTE_PATH_PATTERN = /^[A-Za-z]:[\\/]/;
+var SHELL_QUOTE_PATTERN = /'/g;
+async function applyWorkspaceManifest(sandboxClient, manifest, options = {}) {
+  if (sandboxClient.applyManifest) {
+    return sandboxClient.applyManifest(manifest, options);
+  }
+  const targetRoot = normalizeSandboxRoot(options.targetRoot ?? DEFAULT_TARGET_ROOT);
+  const appliedEntries = [];
+  for (const [rawPath, entry] of Object.entries(manifest.entries)) {
+    const path = validateWorkspaceManifestPath(rawPath);
+    const targetPath = joinSandboxPath(targetRoot, path);
+    appliedEntries.push(
+      await applyManifestEntry(sandboxClient, path, targetPath, targetRoot, entry, options)
+    );
+  }
+  return { entries: appliedEntries };
+}
+function validateWorkspaceManifestPath(path) {
+  if (path.length === 0) {
+    throw new Error("workspace manifest path must not be empty");
+  }
+  if (path.includes("\0")) {
+    throw new Error("workspace manifest path must not contain NUL bytes");
+  }
+  if (path.startsWith("/") || path.startsWith("\\") || WINDOWS_ABSOLUTE_PATH_PATTERN.test(path)) {
+    throw new Error("workspace manifest path must be workspace-relative");
+  }
+  const parts = path.replace(/\\/g, "/").split("/").filter(Boolean);
+  if (parts.length === 0) {
+    throw new Error("workspace manifest path must not resolve to the workspace root");
+  }
+  if (parts.some((part) => part === "..")) {
+    throw new Error("workspace manifest path cannot contain traversal segments");
+  }
+  const normalizedParts = parts.filter((part) => part !== ".");
+  if (normalizedParts.length === 0) {
+    throw new Error("workspace manifest path must not resolve to the workspace root");
+  }
+  return normalizedParts.join("/");
+}
+async function applyManifestEntry(sandboxClient, path, targetPath, targetRoot, entry, options) {
+  switch (entry.type) {
+    case "file":
+      await writeSandboxFile(sandboxClient, targetPath, targetRoot, entry.content);
+      return createAppliedEntry(path, entry.type);
+    case "dir":
+      await createSandboxDirectory(sandboxClient, targetPath);
+      return createAppliedEntry(path, entry.type);
+    case "localFile":
+      await copyLocalFile(sandboxClient, entry.src, targetPath, targetRoot, options);
+      return createAppliedEntry(path, entry.type);
+    case "localDir":
+      await copyLocalDirectory(sandboxClient, entry.src, targetPath, options);
+      return createAppliedEntry(path, entry.type);
+    case "gitRepo":
+      await cloneGitRepository(sandboxClient, entry, targetPath);
+      return createAppliedEntry(path, entry.type);
+    case "s3Mount":
+    case "gcsMount":
+    case "r2Mount":
+    case "azureBlobMount":
+      return {
+        path,
+        type: entry.type,
+        status: "unsupported",
+        message: `${entry.type} requires a provider-specific sandbox adapter.`
+      };
+    default:
+      return assertUnreachable(entry);
+  }
+}
+function createAppliedEntry(path, type) {
+  return { path, type, status: "applied" };
+}
+async function copyLocalFile(sandboxClient, source, targetPath, targetRoot, options) {
+  const hostSourcePath = resolveHostSourcePath(source, options.hostRoot);
+  const content = await promises.readFile(hostSourcePath, "utf8");
+  await writeSandboxFile(sandboxClient, targetPath, targetRoot, content);
+}
+async function copyLocalDirectory(sandboxClient, source, targetPath, options) {
+  const hostSourcePath = resolveHostSourcePath(source, options.hostRoot);
+  await copyLocalDirectoryRecursive(sandboxClient, hostSourcePath, targetPath);
+}
+async function copyLocalDirectoryRecursive(sandboxClient, sourcePath, targetPath) {
+  await createSandboxDirectory(sandboxClient, targetPath);
+  const entries = await promises.readdir(sourcePath, { withFileTypes: true });
+  for (const entry of entries) {
+    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 promises.readFile(childSourcePath, "utf8");
+      await sandboxClient.writeFile(childTargetPath, content);
+    }
+  }
+}
+async function cloneGitRepository(sandboxClient, entry, targetPath) {
+  const shallowArgs = entry.shallow === false ? "" : " --depth 1";
+  const refArgs = entry.ref ? ` --branch ${quoteShellArg(entry.ref)}` : "";
+  await runSandboxCommand(
+    sandboxClient,
+    `git clone${shallowArgs}${refArgs} ${quoteShellArg(entry.url)} ${quoteShellArg(targetPath)}`
+  );
+}
+async function writeSandboxFile(sandboxClient, targetPath, targetRoot, content) {
+  const parentPath = path.posix.dirname(targetPath);
+  if (parentPath !== targetRoot) {
+    await createSandboxDirectory(sandboxClient, parentPath);
+  }
+  await sandboxClient.writeFile(targetPath, content);
+}
+async function createSandboxDirectory(sandboxClient, targetPath) {
+  await runSandboxCommand(sandboxClient, `mkdir -p ${quoteShellArg(targetPath)}`);
+}
+async function runSandboxCommand(sandboxClient, command) {
+  const result = await sandboxClient.run(command);
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `workspace manifest command failed: ${command}
+${result.stderr ?? result.stdout}`
+    );
+  }
+}
+function resolveHostSourcePath(source, hostRoot) {
+  return path.isAbsolute(source) ? path.resolve(source) : path.resolve(hostRoot ?? process.cwd(), source);
+}
+function normalizeSandboxRoot(root) {
+  const normalized = root.replace(/\\/g, "/").replace(/\/+$/, "");
+  if (!normalized.startsWith("/")) {
+    throw new Error("workspace manifest targetRoot must be an absolute sandbox path");
+  }
+  return normalized.length === 0 ? "/" : normalized;
+}
+function joinSandboxPath(root, path) {
+  const normalizedRoot = normalizeSandboxRoot(root);
+  if (normalizedRoot === "/") {
+    return `/${path}`;
+  }
+  return `${normalizedRoot}/${path}`;
+}
+function quoteShellArg(value) {
+  return `'${value.replace(SHELL_QUOTE_PATTERN, "'\\''")}'`;
+}
+function assertUnreachable(value) {
+  throw new Error(`unsupported workspace manifest entry: ${JSON.stringify(value)}`);
+}
 var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
   /**
@@ -58,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 || {})
@@ -80,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
@@ -103,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",
@@ -126,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
@@ -152,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}"`
           );
         }
@@ -181,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`
           );
         }
@@ -190,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 = {};
@@ -426,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)),
@@ -490,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");
     }
   }
 };
@@ -518,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);
@@ -526,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",
@@ -680,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(", ")}`
       );
     }
@@ -699,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,
@@ -850,24 +1069,44 @@ 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) {
+async function runBash(args, options = {}) {
   const { command, timeout = DEFAULT_TIMEOUT_MS, workingDirectory } = args;
-  return new Promise((resolve3) => {
+  if (options.sandboxClient) {
+    try {
+      const sandboxResult = await options.sandboxClient.run(command, {
+        timeoutMs: timeout,
+        workingDirectory
+      });
+      const output = sandboxResult.stderr ? `${sandboxResult.stdout}
+stderr:
+${sandboxResult.stderr}` : sandboxResult.stdout;
+      const result = {
+        success: true,
+        output,
+        exitCode: sandboxResult.exitCode
+      };
+      return JSON.stringify(result);
+    } catch (err) {
+      const result = {
+        success: false,
+        output: "",
+        error: err instanceof Error ? err.message : String(err)
+      };
+      return JSON.stringify(result);
+    }
+  }
+  return new Promise((resolve4) => {
     const stdoutChunks = [];
     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"]
@@ -891,7 +1130,7 @@ async function runBash(args) {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      resolve3(JSON.stringify(result));
+      resolve4(JSON.stringify(result));
     }
     child.on("error", (err) => {
       settle({
@@ -924,25 +1163,24 @@ ${stderr}` : stdout;
     });
   });
 }
-var bashTool = createZodFunctionTool(
-  "Bash",
-  "Executes a given bash command and returns its output.\n\nThe working directory persists between commands, but shell state does not.\n\nIMPORTANT: Avoid using this tool to run `find`, `grep`, `cat`, `head`, `tail`, `sed`, `awk`, or `echo` commands. Instead, use the appropriate dedicated tool:\n - File search: Use Glob (NOT find or ls)\n - Content search: Use Grep (NOT grep or rg)\n - Read files: Use Read (NOT cat/head/tail)\n - Edit files: Use Edit (NOT sed/awk)\n\nFor simple commands, keep the description brief (5-10 words). For complex commands, include enough context to clarify what the command does.\n\nOutput is limited to 30,000 characters. Longer output will be middle-truncated.",
-  BashSchema,
-  async (params) => {
-    return runBash(params);
-  }
-);
-
-// src/builtins/read-tool.ts
-var import_promises = require("fs/promises");
-var import_zod2 = require("zod");
+function createBashTool(options = {}) {
+  return createZodFunctionTool(
+    "Bash",
+    "Executes a given bash command and returns its output.\n\nThe working directory persists between commands, but shell state does not.\n\nIMPORTANT: Avoid using this tool to run `find`, `grep`, `cat`, `head`, `tail`, `sed`, `awk`, or `echo` commands. Instead, use the appropriate dedicated tool:\n - File search: Use Glob (NOT find or ls)\n - Content search: Use Grep (NOT grep or rg)\n - Read files: Use Read (NOT cat/head/tail)\n - Edit files: Use Edit (NOT sed/awk)\n\nFor simple commands, keep the description brief (5-10 words). For complex commands, include enough context to clarify what the command does.\n\nOutput is limited to 30,000 characters. Longer output will be middle-truncated.",
+    BashSchema,
+    async (params) => {
+      return runBash(params, options);
+    }
+  );
+}
+var bashTool = createBashTool();
 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`
   )
 });
@@ -961,94 +1199,105 @@ function formatWithLineNumbers(lines, startLine) {
     return `${lineNum}	${line}`;
   }).join("\n");
 }
-async function readFileTool(args) {
+function formatReadResult(filePath, content, startLine, limit) {
+  const allLines = content.split("\n");
+  if (allLines[allLines.length - 1] === "") {
+    allLines.pop();
+  }
+  const zeroBasedStart = startLine - 1;
+  const selectedLines = allLines.slice(zeroBasedStart, zeroBasedStart + limit);
+  const output = formatWithLineNumbers(selectedLines, startLine);
+  const totalLines = allLines.length;
+  const returnedLines = selectedLines.length;
+  const header = returnedLines < totalLines ? `[File: ${filePath} (lines ${startLine}-${startLine + returnedLines - 1} of ${totalLines})]
+` : `[File: ${filePath} (${totalLines} lines)]
+`;
+  const result = {
+    success: true,
+    output: header + output
+  };
+  return JSON.stringify(result);
+}
+async function readFileTool(args, options = {}) {
   const { filePath, offset, limit = DEFAULT_LIMIT } = args;
   const startLine = offset !== void 0 && offset > 0 ? offset : 1;
+  if (options.sandboxClient) {
+    try {
+      const content2 = await options.sandboxClient.readFile(filePath);
+      return formatReadResult(filePath, content2, startLine, limit);
+    } catch (err) {
+      const result = {
+        success: false,
+        output: "",
+        error: err instanceof Error ? err.message : String(err)
+      };
+      return JSON.stringify(result);
+    }
+  }
   let fileStats;
   try {
-    fileStats = await (0, import_promises.stat)(filePath);
+    fileStats = await promises.stat(filePath);
   } catch (err) {
-    const result2 = {
+    const result = {
       success: false,
       output: "",
       error: `File not found: ${filePath}`
     };
-    return JSON.stringify(result2);
+    return JSON.stringify(result);
   }
   if (!fileStats.isFile()) {
-    const result2 = {
+    const result = {
       success: false,
       output: "",
       error: `Path is not a file: ${filePath}`
     };
-    return JSON.stringify(result2);
+    return JSON.stringify(result);
   }
   let buffer;
   try {
-    buffer = await (0, import_promises.readFile)(filePath);
+    buffer = await promises.readFile(filePath);
   } catch (err) {
-    const result2 = {
+    const result = {
       success: false,
       output: "",
       error: err instanceof Error ? err.message : String(err)
     };
-    return JSON.stringify(result2);
+    return JSON.stringify(result);
   }
   if (isBinary(buffer)) {
-    const result2 = {
+    const result = {
       success: false,
       output: "",
       error: `Binary file not supported: ${filePath}`
     };
-    return JSON.stringify(result2);
+    return JSON.stringify(result);
   }
   const content = buffer.toString("utf8");
-  const allLines = content.split("\n");
-  if (allLines[allLines.length - 1] === "") {
-    allLines.pop();
-  }
-  const zeroBasedStart = startLine - 1;
-  const selectedLines = allLines.slice(zeroBasedStart, zeroBasedStart + limit);
-  const output = formatWithLineNumbers(selectedLines, startLine);
-  const totalLines = allLines.length;
-  const returnedLines = selectedLines.length;
-  const header = returnedLines < totalLines ? `[File: ${filePath} (lines ${startLine}-${startLine + returnedLines - 1} of ${totalLines})]
-` : `[File: ${filePath} (${totalLines} lines)]
-`;
-  const result = {
-    success: true,
-    output: header + output
-  };
-  return JSON.stringify(result);
+  return formatReadResult(filePath, content, startLine, limit);
 }
-var readTool = createZodFunctionTool(
-  "Read",
-  "Reads a file from the local filesystem.\n\nBy default, reads up to 2000 lines from the beginning of the file. You can optionally specify offset and limit for partial reads.\n\nResults are returned using cat -n format, with line numbers starting at 1.\n\nThe file_path parameter must be an absolute path, not a relative path.",
-  ReadSchema,
-  async (params) => {
-    return readFileTool(params);
-  }
-);
-
-// src/builtins/write-tool.ts
-var import_zod3 = require("zod");
-
-// src/builtins/atomic-file-write.ts
-var import_node_crypto = require("crypto");
-var import_promises2 = require("fs/promises");
-var import_node_path = require("path");
+function createReadTool(options = {}) {
+  return createZodFunctionTool(
+    "Read",
+    "Reads a file from the local filesystem.\n\nBy default, reads up to 2000 lines from the beginning of the file. You can optionally specify offset and limit for partial reads.\n\nResults are returned using cat -n format, with line numbers starting at 1.\n\nThe file_path parameter must be an absolute path, not a relative path.",
+    ReadSchema,
+    async (params) => {
+      return readFileTool(params, options);
+    }
+  );
+}
+var readTool = createReadTool();
 var TEMP_RANDOM_BYTES = 6;
 var PRESERVED_MODE_BITS = 4095;
 var MISSING_FILE_ERROR_CODE = "ENOENT";
 function createTempFilePath(filePath) {
-  const dir = (0, import_node_path.dirname)(filePath);
-  const name = (0, import_node_path.basename)(filePath);
-  const suffix = (0, import_node_crypto.randomBytes)(TEMP_RANDOM_BYTES).toString("hex");
-  return (0, import_node_path.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_promises2.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;
@@ -1059,31 +1308,35 @@ function hasErrorCode(error, code) {
   return "code" in error && error.code === code;
 }
 async function atomicWriteUtf8File(filePath, content) {
-  const dir = (0, import_node_path.dirname)(filePath);
-  await (0, import_promises2.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_promises2.writeFile)(tempFilePath, content, "utf8");
+    await promises.writeFile(tempFilePath, content, "utf8");
     if (existingMode !== void 0) {
-      await (0, import_promises2.chmod)(tempFilePath, existingMode);
+      await promises.chmod(tempFilePath, existingMode);
     }
-    await (0, import_promises2.rename)(tempFilePath, filePath);
+    await promises.rename(tempFilePath, filePath);
   } catch (error) {
-    await (0, import_promises2.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) {
+async function writeFileTool(args, options = {}) {
   const { filePath, content } = args;
   try {
-    await atomicWriteUtf8File(filePath, content);
+    if (options.sandboxClient) {
+      await options.sandboxClient.writeFile(filePath, content);
+    } else {
+      await atomicWriteUtf8File(filePath, content);
+    }
     const result = {
       success: true,
       output: `Written ${Buffer.byteLength(content, "utf8")} bytes to ${filePath}`
@@ -1098,31 +1351,30 @@ async function writeFileTool(args) {
     return JSON.stringify(result);
   }
 }
-var writeTool = createZodFunctionTool(
-  "Write",
-  "Writes a file to the local filesystem. This will overwrite an existing file if one exists.\n\nALWAYS prefer the Edit tool for modifying existing files \u2014 it only sends the diff. Only use this tool to create new files or for complete rewrites.\n\nNEVER create documentation files (*.md) or README files unless explicitly requested by the user.",
-  WriteSchema,
-  async (params) => {
-    return writeFileTool(params);
-  }
-);
-
-// src/builtins/edit-tool.ts
-var import_promises3 = 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(
+function createWriteTool(options = {}) {
+  return createZodFunctionTool(
+    "Write",
+    "Writes a file to the local filesystem. This will overwrite an existing file if one exists.\n\nALWAYS prefer the Edit tool for modifying existing files \u2014 it only sends the diff. Only use this tool to create new files or for complete rewrites.\n\nNEVER create documentation files (*.md) or README files unless explicitly requested by the user.",
+    WriteSchema,
+    async (params) => {
+      return writeFileTool(params, options);
+    }
+  );
+}
+var writeTool = createWriteTool();
+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"
   )
 });
-async function editFileTool(args) {
+async function editFileTool(args, options = {}) {
   const { filePath, oldString, newString, replaceAll = false } = args;
   let content;
   try {
-    content = await (0, import_promises3.readFile)(filePath, "utf8");
+    content = options.sandboxClient ? await options.sandboxClient.readFile(filePath) : await promises.readFile(filePath, "utf8");
   } catch (err) {
     const result2 = {
       success: false,
@@ -1154,7 +1406,11 @@ async function editFileTool(args) {
   }
   const updated = replaceAll ? content.split(oldString).join(newString) : content.slice(0, content.indexOf(oldString)) + newString + content.slice(content.indexOf(oldString) + oldString.length);
   try {
-    await atomicWriteUtf8File(filePath, updated);
+    if (options.sandboxClient) {
+      await options.sandboxClient.writeFile(filePath, updated);
+    } else {
+      await atomicWriteUtf8File(filePath, updated);
+    }
   } catch (err) {
     const result2 = {
       success: false,
@@ -1173,36 +1429,33 @@ async function editFileTool(args) {
   };
   return JSON.stringify(result);
 }
-var editTool = createZodFunctionTool(
-  "Edit",
-  "Performs exact string replacements in files.\n\nYou must use the Read tool at least once before editing. When editing text from Read output, preserve the exact indentation.\n\nThe edit will FAIL if old_string is not unique in the file. Either provide more surrounding context to make it unique, or use replace_all to change every instance.\n\nALWAYS prefer editing existing files over creating new ones.",
-  EditSchema,
-  async (params) => {
-    return editFileTool(params);
-  }
-);
-
-// src/builtins/glob-tool.ts
-var import_promises4 = require("fs/promises");
-var import_node_path2 = require("path");
-var import_fast_glob = __toESM(require("fast-glob"), 1);
-var import_zod5 = require("zod");
+function createEditTool(options = {}) {
+  return createZodFunctionTool(
+    "Edit",
+    "Performs exact string replacements in files.\n\nYou must use the Read tool at least once before editing. When editing text from Read output, preserve the exact indentation.\n\nThe edit will FAIL if old_string is not unique in the file. Either provide more surrounding context to make it unique, or use replace_all to change every instance.\n\nALWAYS prefer editing existing files over creating new ones.",
+    EditSchema,
+    async (params) => {
+      return editFileTool(params, options);
+    }
+  );
+}
+var editTool = createEditTool();
 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_path2.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,
@@ -1218,9 +1471,9 @@ async function globFileTool(args) {
   }
   const withMtime = await Promise.all(
     matches.map(async (p) => {
-      const absPath = (0, import_node_path2.resolve)(cwd, p);
+      const absPath = path.resolve(cwd, p);
       try {
-        const s = await (0, import_promises4.stat)(absPath);
+        const s = await promises.stat(absPath);
         return { path: p, mtime: s.mtimeMs };
       } catch {
         return { path: p, mtime: 0 };
@@ -1253,21 +1506,16 @@ var globTool = createZodFunctionTool(
     return globFileTool(params);
   }
 );
-
-// src/builtins/grep-tool.ts
-var import_promises5 = require("fs/promises");
-var import_node_path3 = 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'
   )
 });
@@ -1284,16 +1532,16 @@ async function collectFiles(dirPath, glob) {
   async function walk(current) {
     let entryNames;
     try {
-      entryNames = await (0, import_promises5.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_path3.join)(current, name);
+      const fullPath = path.join(current, name);
       let fileStat;
       try {
-        fileStat = await (0, import_promises5.stat)(fullPath);
+        fileStat = await promises.stat(fullPath);
       } catch {
         continue;
       }
@@ -1349,7 +1597,7 @@ async function grepFileTool(args) {
     contextLines = 0,
     outputMode = "files_with_matches"
   } = args;
-  const targetPath = searchPath ? (0, import_node_path3.resolve)(searchPath) : process.cwd();
+  const targetPath = searchPath ? path.resolve(searchPath) : process.cwd();
   let regex;
   try {
     regex = new RegExp(pattern);
@@ -1363,7 +1611,7 @@ async function grepFileTool(args) {
   }
   let targetStat;
   try {
-    targetStat = await (0, import_promises5.stat)(targetPath);
+    targetStat = await promises.stat(targetPath);
   } catch {
     const result2 = {
       success: false,
@@ -1382,7 +1630,7 @@ async function grepFileTool(args) {
   for (const filePath of files) {
     let content;
     try {
-      const buffer = await (0, import_promises5.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++) {
@@ -1413,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();
@@ -1481,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;
@@ -1545,21 +1787,27 @@ var webSearchTool = createZodFunctionTool(
   WebSearchSchema,
   async (params) => runWebSearch(params)
 );
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  FunctionTool,
-  OpenAPITool,
-  ToolRegistry,
-  bashTool,
-  createFunctionTool,
-  createOpenAPITool,
-  createZodFunctionTool,
-  editTool,
-  globTool,
-  grepTool,
-  readTool,
-  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;