bashkit 0.3.1 → 0.3.2

package/dist/workflow.js

@@ -15,11 +15,726 @@ var __toESM = (mod, isNodeMode, target) => {
       });
   return to;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-// src/workflow.ts
+// src/tools/read.ts
+var exports_read = {};
+__export(exports_read, {
+  readInputSchema: () => readInputSchema,
+  createReadTool: () => createReadTool,
+  READ_DESCRIPTION: () => READ_DESCRIPTION
+});
 import { tool, zodSchema } from "ai";
 import { z } from "zod";
+function createReadTool(sandbox, config) {
+  return tool({
+    description: READ_DESCRIPTION,
+    inputSchema: zodSchema(readInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
+    execute: async ({
+      file_path,
+      offset,
+      limit
+    }) => {
+      if (config?.allowedPaths) {
+        const isAllowed = config.allowedPaths.some((allowed) => file_path.startsWith(allowed));
+        if (!isAllowed) {
+          return { error: `Path not allowed: ${file_path}` };
+        }
+      }
+      try {
+        const exists = await sandbox.fileExists(file_path);
+        if (!exists) {
+          return { error: `Path not found: ${file_path}` };
+        }
+        const isDir = await sandbox.isDirectory(file_path);
+        if (isDir) {
+          const entries = await sandbox.readDir(file_path);
+          return {
+            type: "directory",
+            entries,
+            count: entries.length
+          };
+        }
+        const content = await sandbox.readFile(file_path);
+        const nullByteIndex = content.indexOf("\x00");
+        if (nullByteIndex !== -1 && nullByteIndex < 1000) {
+          const ext = file_path.split(".").pop()?.toLowerCase();
+          const binaryExtensions = [
+            "pdf",
+            "png",
+            "jpg",
+            "jpeg",
+            "gif",
+            "zip",
+            "tar",
+            "gz",
+            "exe",
+            "bin",
+            "so",
+            "dylib"
+          ];
+          if (binaryExtensions.includes(ext || "")) {
+            return {
+              error: `Cannot read binary file: ${file_path} (file exists, ${content.length} bytes). Use appropriate tools to process ${ext?.toUpperCase()} files (e.g., Python scripts for PDFs).`
+            };
+          }
+        }
+        const allLines = content.split(`
+`);
+        const totalLines = allLines.length;
+        const maxLinesWithoutLimit = config?.maxFileSize || 500;
+        if (!limit && totalLines > maxLinesWithoutLimit) {
+          return {
+            error: `File is large (${totalLines} lines). Use 'offset' and 'limit' to read in chunks. Example: offset=1, limit=100 for first 100 lines.`
+          };
+        }
+        const startLine = offset ? offset - 1 : 0;
+        const endLine = limit ? startLine + limit : allLines.length;
+        const selectedLines = allLines.slice(startLine, endLine);
+        const lines = selectedLines.map((line, i) => ({
+          line_number: startLine + i + 1,
+          content: line
+        }));
+        return {
+          type: "text",
+          content: selectedLines.join(`
+`),
+          lines,
+          total_lines: totalLines
+        };
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+var readInputSchema, READ_DESCRIPTION = `Reads a file from the local filesystem. You can access any file directly by using this tool.
+Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
+
+Usage:
+- The file_path parameter must be an absolute path, not a relative path
+- By default, it reads up to 500 lines starting from the beginning of the file
+- You can optionally specify a line offset and limit (especially handy for long files)
+- Results are returned with line numbers starting at 1
+- This tool can only read text files, not binary files (images, PDFs, etc.)
+- This tool can only read files, not directories. To read a directory, use an ls command via the Bash tool.
+- It is always better to speculatively read multiple potentially useful files in parallel
+- If you read a file that exists but has empty contents you will receive a warning in place of file contents`;
+var init_read = __esm(() => {
+  readInputSchema = z.object({
+    file_path: z.string().describe("Absolute path to file or directory"),
+    offset: z.number().optional().describe("Line number to start reading from (1-indexed)"),
+    limit: z.number().optional().describe("Maximum number of lines to read")
+  });
+});
+
+// src/tools/write.ts
+var exports_write = {};
+__export(exports_write, {
+  writeInputSchema: () => writeInputSchema,
+  createWriteTool: () => createWriteTool,
+  WRITE_DESCRIPTION: () => WRITE_DESCRIPTION
+});
+import { tool as tool2, zodSchema as zodSchema2 } from "ai";
+import { z as z2 } from "zod";
+function createWriteTool(sandbox, config) {
+  return tool2({
+    description: WRITE_DESCRIPTION,
+    inputSchema: zodSchema2(writeInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
+    execute: async ({
+      file_path,
+      content
+    }) => {
+      const byteLength = Buffer.byteLength(content, "utf-8");
+      if (config?.maxFileSize && byteLength > config.maxFileSize) {
+        return {
+          error: `File content exceeds maximum size of ${config.maxFileSize} bytes (got ${byteLength})`
+        };
+      }
+      if (config?.allowedPaths) {
+        const isAllowed = config.allowedPaths.some((allowed) => file_path.startsWith(allowed));
+        if (!isAllowed) {
+          return { error: `Path not allowed: ${file_path}` };
+        }
+      }
+      try {
+        await sandbox.writeFile(file_path, content);
+        return {
+          message: `Successfully wrote to ${file_path}`,
+          bytes_written: byteLength,
+          file_path
+        };
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+var writeInputSchema, WRITE_DESCRIPTION = `Writes content to a file on the filesystem.
+
+**Important guidelines:**
+- This tool will overwrite existing files at the provided path
+- If modifying an existing file, you MUST use the Read tool first to read the file's contents
+- ALWAYS prefer editing existing files over creating new ones
+- NEVER proactively create documentation files (*.md) or README files unless explicitly requested
+- The file_path must be an absolute path, not relative
+
+**When to use Write vs Edit:**
+- Use Write for creating new files or completely replacing file contents
+- Use Edit for making targeted changes to existing files (preferred for modifications)`;
+var init_write = __esm(() => {
+  writeInputSchema = z2.object({
+    file_path: z2.string().describe("Path to the file to write"),
+    content: z2.string().describe("Content to write to the file")
+  });
+});
+
+// src/tools/edit.ts
+var exports_edit = {};
+__export(exports_edit, {
+  editInputSchema: () => editInputSchema,
+  createEditTool: () => createEditTool,
+  EDIT_DESCRIPTION: () => EDIT_DESCRIPTION
+});
+import { tool as tool3, zodSchema as zodSchema3 } from "ai";
+import { z as z3 } from "zod";
+function createEditTool(sandbox, config) {
+  return tool3({
+    description: EDIT_DESCRIPTION,
+    inputSchema: zodSchema3(editInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
+    execute: async ({
+      file_path,
+      old_string,
+      new_string,
+      replace_all = false
+    }) => {
+      if (old_string === new_string) {
+        return { error: "old_string and new_string must be different" };
+      }
+      if (config?.allowedPaths) {
+        const isAllowed = config.allowedPaths.some((allowed) => file_path.startsWith(allowed));
+        if (!isAllowed) {
+          return { error: `Path not allowed: ${file_path}` };
+        }
+      }
+      try {
+        const exists = await sandbox.fileExists(file_path);
+        if (!exists) {
+          return { error: `File not found: ${file_path}` };
+        }
+        const content = await sandbox.readFile(file_path);
+        const occurrences = content.split(old_string).length - 1;
+        if (occurrences === 0) {
+          return { error: `String not found in file: "${old_string}"` };
+        }
+        if (!replace_all && occurrences > 1) {
+          return {
+            error: `String appears ${occurrences} times in file. Use replace_all=true to replace all, or provide a more unique string.`
+          };
+        }
+        let newContent;
+        let replacements;
+        if (replace_all) {
+          newContent = content.split(old_string).join(new_string);
+          replacements = occurrences;
+        } else {
+          newContent = content.replace(old_string, new_string);
+          replacements = 1;
+        }
+        await sandbox.writeFile(file_path, newContent);
+        return {
+          message: `Successfully edited ${file_path}`,
+          file_path,
+          replacements
+        };
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+var editInputSchema, EDIT_DESCRIPTION = `Performs exact string replacements in files.
+
+**Important guidelines:**
+- You MUST use the Read tool first before editing any file
+- Preserve exact indentation (tabs/spaces) when replacing text
+- The old_string must be unique in the file, or the edit will fail
+- If old_string appears multiple times, either provide more context to make it unique, or use replace_all=true
+
+**Parameters:**
+- old_string: The exact text to find and replace (must match exactly, including whitespace)
+- new_string: The replacement text (must be different from old_string)
+- replace_all: Set to true to replace all occurrences (useful for renaming variables)
+
+**When to use:**
+- Making targeted changes to existing files
+- Renaming variables or functions (with replace_all=true)
+- Updating specific sections`;
+var init_edit = __esm(() => {
+  editInputSchema = z3.object({
+    file_path: z3.string().describe("The absolute path to the file to modify"),
+    old_string: z3.string().describe("The text to replace"),
+    new_string: z3.string().describe("The text to replace it with (must be different from old_string)"),
+    replace_all: z3.boolean().optional().describe("Replace all occurrences of old_string (default false)")
+  });
+});
+
+// src/tools/bash.ts
+var exports_bash = {};
+__export(exports_bash, {
+  createBashTool: () => createBashTool,
+  bashInputSchema: () => bashInputSchema,
+  BASH_DESCRIPTION: () => BASH_DESCRIPTION
+});
+import { tool as tool4, zodSchema as zodSchema4 } from "ai";
+import { z as z4 } from "zod";
+function createBashTool(sandbox, config) {
+  const maxOutputLength = config?.maxOutputLength ?? 30000;
+  const defaultTimeout = config?.timeout ?? 120000;
+  return tool4({
+    description: BASH_DESCRIPTION,
+    inputSchema: zodSchema4(bashInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
+    execute: async ({
+      command,
+      timeout,
+      description: _description,
+      run_in_background: _run_in_background
+    }) => {
+      if (config?.blockedCommands) {
+        for (const blocked of config.blockedCommands) {
+          if (command.includes(blocked)) {
+            return {
+              error: `Command blocked: contains '${blocked}'`
+            };
+          }
+        }
+      }
+      try {
+        const effectiveTimeout = Math.min(timeout ?? defaultTimeout, 600000);
+        const result = await sandbox.exec(command, {
+          timeout: effectiveTimeout
+        });
+        let stdout = result.stdout;
+        let stderr = result.stderr;
+        if (stdout.length > maxOutputLength) {
+          stdout = stdout.slice(0, maxOutputLength) + `
+[output truncated, ${stdout.length - maxOutputLength} chars omitted]`;
+        }
+        if (stderr.length > maxOutputLength) {
+          stderr = stderr.slice(0, maxOutputLength) + `
+[output truncated, ${stderr.length - maxOutputLength} chars omitted]`;
+        }
+        return {
+          stdout,
+          stderr,
+          exit_code: result.exitCode,
+          interrupted: result.interrupted,
+          duration_ms: result.durationMs
+        };
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+var bashInputSchema, BASH_DESCRIPTION = `Executes a bash command in a persistent shell session with optional timeout.
+
+IMPORTANT: For file operations (reading, writing, editing, searching, finding files) - use the specialized tools instead of bash commands.
+
+Before executing the command, please follow these steps:
+
+1. Directory Verification:
+   - If the command will create new directories or files, first use \`ls\` to verify the parent directory exists and is the correct location
+   - For example, before running "mkdir foo/bar", first use \`ls foo\` to check that "foo" exists
+
+2. Command Execution:
+   - Always quote file paths that contain spaces with double quotes (e.g., cd "/path/with spaces")
+   - Examples of proper quoting:
+     - cd "/Users/name/My Documents" (correct)
+     - cd /Users/name/My Documents (incorrect - will fail)
+   - After ensuring proper quoting, execute the command
+
+Usage notes:
+  - The command argument is required
+  - You can specify an optional timeout in milliseconds (max 600000ms / 10 minutes). Default is 120000ms (2 minutes).
+  - It is very helpful if you write a clear, concise description of what this command does in 5-10 words
+  - If the output exceeds 30000 characters, output will be truncated
+  - Avoid using \`find\`, \`grep\`, \`cat\`, \`head\`, \`tail\`, \`sed\`, \`awk\`, or \`echo\` commands. Instead, use dedicated tools:
+    - File search: Use Glob (NOT find or ls)
+    - Content search: Use Grep (NOT grep or rg)
+    - Read files: Use Read (NOT cat/head/tail)
+    - Edit files: Use Edit (NOT sed/awk)
+    - Write files: Use Write (NOT echo >/cat <<EOF)
+  - When issuing multiple commands:
+    - If commands are independent, make multiple Bash tool calls in parallel
+    - If commands depend on each other, use '&&' to chain them (e.g., \`git add . && git commit -m "message"\`)
+    - Use ';' only when you need sequential execution but don't care if earlier commands fail
+    - DO NOT use newlines to separate commands
+  - Try to maintain your current working directory by using absolute paths and avoiding \`cd\``;
+var init_bash = __esm(() => {
+  bashInputSchema = z4.object({
+    command: z4.string().describe("The command to execute"),
+    timeout: z4.number().optional().describe("Optional timeout in milliseconds (max 600000)"),
+    description: z4.string().optional().describe("Clear, concise description of what this command does in 5-10 words"),
+    run_in_background: z4.boolean().optional().describe("Set to true to run this command in the background")
+  });
+});
+
+// src/tools/glob.ts
+var exports_glob = {};
+__export(exports_glob, {
+  globInputSchema: () => globInputSchema,
+  createGlobTool: () => createGlobTool,
+  GLOB_DESCRIPTION: () => GLOB_DESCRIPTION
+});
+import { tool as tool5, zodSchema as zodSchema5 } from "ai";
+import { z as z5 } from "zod";
+function createGlobTool(sandbox, config) {
+  return tool5({
+    description: GLOB_DESCRIPTION,
+    inputSchema: zodSchema5(globInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
+    execute: async ({
+      pattern,
+      path
+    }) => {
+      const searchPath = path || ".";
+      if (config?.allowedPaths) {
+        const isAllowed = config.allowedPaths.some((allowed) => searchPath.startsWith(allowed));
+        if (!isAllowed) {
+          return { error: `Path not allowed: ${searchPath}` };
+        }
+      }
+      try {
+        const result = await sandbox.exec(`find ${searchPath} -type f -name "${pattern}" 2>/dev/null | head -1000`, { timeout: config?.timeout });
+        if (result.exitCode !== 0 && result.stderr) {
+          return { error: result.stderr };
+        }
+        const matches = result.stdout.split(`
+`).filter(Boolean).map((p) => p.trim());
+        return {
+          matches,
+          count: matches.length,
+          search_path: searchPath
+        };
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+var globInputSchema, GLOB_DESCRIPTION = `
+- Fast file pattern matching tool that works with any codebase size
+- Supports glob patterns like "**/*.js" or "src/**/*.ts"
+- Returns matching file paths sorted by modification time
+- Use this tool when you need to find files by name patterns
+- When you are doing an open ended search that may require multiple rounds of globbing and grepping, use the Task tool instead
+- It is always better to speculatively perform multiple searches in parallel if they are potentially useful
+`;
+var init_glob = __esm(() => {
+  globInputSchema = z5.object({
+    pattern: z5.string().describe('Glob pattern to match files (e.g., "**/*.ts", "src/**/*.js", "*.md")'),
+    path: z5.string().optional().describe("Directory to search in (defaults to working directory)")
+  });
+});
+
+// src/tools/grep.ts
+var exports_grep = {};
+__export(exports_grep, {
+  grepInputSchema: () => grepInputSchema,
+  createGrepTool: () => createGrepTool,
+  GREP_DESCRIPTION: () => GREP_DESCRIPTION
+});
+import { tool as tool6, zodSchema as zodSchema6 } from "ai";
+import { z as z6 } from "zod";
+function createGrepTool(sandbox, config) {
+  return tool6({
+    description: GREP_DESCRIPTION,
+    inputSchema: zodSchema6(grepInputSchema),
+    strict: config?.strict,
+    needsApproval: config?.needsApproval,
+    providerOptions: config?.providerOptions,
+    execute: async (input) => {
+      const {
+        pattern,
+        path,
+        glob,
+        type,
+        output_mode = "files_with_matches",
+        "-i": caseInsensitive,
+        "-B": beforeContext,
+        "-A": afterContext,
+        "-C": context,
+        head_limit,
+        offset = 0,
+        multiline
+      } = input;
+      const searchPath = path || ".";
+      if (config?.allowedPaths) {
+        const isAllowed = config.allowedPaths.some((allowed) => searchPath.startsWith(allowed));
+        if (!isAllowed) {
+          return { error: `Path not allowed: ${searchPath}` };
+        }
+      }
+      try {
+        if (!sandbox.rgPath) {
+          return {
+            error: "Ripgrep not available. Call ensureSandboxTools(sandbox) before using Grep with remote sandboxes."
+          };
+        }
+        const cmd = buildRipgrepCommand({
+          rgPath: sandbox.rgPath,
+          pattern,
+          searchPath,
+          output_mode,
+          caseInsensitive,
+          beforeContext,
+          afterContext,
+          context,
+          glob,
+          type,
+          multiline
+        });
+        const result = await sandbox.exec(cmd, { timeout: config?.timeout });
+        if (output_mode === "files_with_matches") {
+          return parseFilesOutput(result.stdout);
+        } else if (output_mode === "count") {
+          return parseCountOutput(result.stdout);
+        } else {
+          return parseContentOutput(result.stdout, head_limit, offset);
+        }
+      } catch (error) {
+        return {
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+      }
+    }
+  });
+}
+function buildRipgrepCommand(opts) {
+  const flags = ["--json"];
+  if (opts.caseInsensitive)
+    flags.push("-i");
+  if (opts.multiline)
+    flags.push("-U", "--multiline-dotall");
+  if (opts.output_mode === "content") {
+    if (opts.context) {
+      flags.push(`-C ${opts.context}`);
+    } else {
+      if (opts.beforeContext)
+        flags.push(`-B ${opts.beforeContext}`);
+      if (opts.afterContext)
+        flags.push(`-A ${opts.afterContext}`);
+    }
+  }
+  if (opts.glob)
+    flags.push(`-g "${opts.glob}"`);
+  if (opts.type)
+    flags.push(`-t ${opts.type}`);
+  const flagStr = flags.join(" ");
+  return `${opts.rgPath} ${flagStr} "${opts.pattern}" ${opts.searchPath} 2>/dev/null`;
+}
+function parseFilesOutput(stdout) {
+  const files = new Set;
+  for (const line of stdout.split(`
+`).filter(Boolean)) {
+    try {
+      const msg = JSON.parse(line);
+      if (msg.type === "begin") {
+        const data = msg.data;
+        files.add(data.path.text);
+      }
+    } catch {}
+  }
+  return {
+    files: Array.from(files),
+    count: files.size
+  };
+}
+function parseCountOutput(stdout) {
+  const counts = new Map;
+  for (const line of stdout.split(`
+`).filter(Boolean)) {
+    try {
+      const msg = JSON.parse(line);
+      if (msg.type === "end") {
+        const data = msg.data;
+        counts.set(data.path.text, data.stats.matches);
+      }
+    } catch {}
+  }
+  const countsArray = Array.from(counts.entries()).map(([file, count]) => ({
+    file,
+    count
+  }));
+  const total = countsArray.reduce((sum, c) => sum + c.count, 0);
+  return {
+    counts: countsArray,
+    total
+  };
+}
+function parseContentOutput(stdout, head_limit, offset = 0) {
+  const fileData = new Map;
+  for (const line of stdout.split(`
+`).filter(Boolean)) {
+    try {
+      const msg = JSON.parse(line);
+      if (msg.type === "begin") {
+        const data = msg.data;
+        fileData.set(data.path.text, { matches: [], contexts: [] });
+      } else if (msg.type === "context") {
+        const data = msg.data;
+        const fd = fileData.get(data.path.text);
+        if (fd) {
+          fd.contexts.push({
+            line_number: data.line_number,
+            text: data.lines.text.replace(/\n$/, "")
+          });
+        }
+      } else if (msg.type === "match") {
+        const data = msg.data;
+        const fd = fileData.get(data.path.text);
+        if (fd) {
+          fd.matches.push({
+            line_number: data.line_number,
+            text: data.lines.text.replace(/\n$/, "")
+          });
+        }
+      }
+    } catch {}
+  }
+  const allMatches = [];
+  for (const [file, { matches, contexts }] of fileData) {
+    matches.sort((a, b) => a.line_number - b.line_number);
+    contexts.sort((a, b) => a.line_number - b.line_number);
+    const matchContexts = new Map;
+    for (const match of matches) {
+      matchContexts.set(match.line_number, { before: [], after: [] });
+    }
+    for (const ctx of contexts) {
+      let bestMatch = null;
+      let bestDistance = Infinity;
+      let isBefore = false;
+      for (const match of matches) {
+        const distance = Math.abs(ctx.line_number - match.line_number);
+        if (distance < bestDistance) {
+          bestDistance = distance;
+          bestMatch = match;
+          isBefore = ctx.line_number < match.line_number;
+        }
+      }
+      if (bestMatch) {
+        const mc = matchContexts.get(bestMatch.line_number);
+        if (mc) {
+          if (isBefore) {
+            mc.before.push(ctx.text);
+          } else {
+            mc.after.push(ctx.text);
+          }
+        }
+      }
+    }
+    for (const match of matches) {
+      const mc = matchContexts.get(match.line_number);
+      allMatches.push({
+        file,
+        line_number: match.line_number,
+        line: match.text,
+        before_context: mc?.before ?? [],
+        after_context: mc?.after ?? []
+      });
+    }
+  }
+  const grepMatches = allMatches.map((m) => ({
+    file: m.file,
+    line_number: m.line_number,
+    line: m.line,
+    before_context: m.before_context.length > 0 ? m.before_context : undefined,
+    after_context: m.after_context.length > 0 ? m.after_context : undefined
+  }));
+  let result = grepMatches;
+  if (offset > 0) {
+    result = result.slice(offset);
+  }
+  if (head_limit && head_limit > 0) {
+    result = result.slice(0, head_limit);
+  }
+  return {
+    matches: result,
+    total_matches: result.length
+  };
+}
+var grepInputSchema, GREP_DESCRIPTION = `A powerful content search tool built on ripgrep with regex support.
+
+**Usage:**
+- ALWAYS use Grep for search tasks. NEVER invoke \`grep\` or \`rg\` as a Bash command.
+- Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+")
+- Filter files with glob parameter (e.g., "*.js", "**/*.tsx") or type parameter (e.g., "js", "py", "rust")
+
+**Output modes:**
+- "content": Shows matching lines with optional context
+- "files_with_matches": Shows only file paths (default)
+- "count": Shows match counts per file
+
+**Context options (content mode only):**
+- -B: Lines to show before each match
+- -A: Lines to show after each match
+- -C: Lines to show before and after each match
+
+**Pagination:**
+- Use offset to skip results (useful for pagination)
+- Use head_limit to limit total results returned`;
+var init_grep = __esm(() => {
+  grepInputSchema = z6.object({
+    pattern: z6.string().describe("The regular expression pattern to search for in file contents"),
+    path: z6.string().optional().describe("File or directory to search in (defaults to cwd)"),
+    glob: z6.string().optional().describe('Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}")'),
+    type: z6.string().optional().describe('File type to search (e.g. "js", "py", "rust")'),
+    output_mode: z6.enum(["content", "files_with_matches", "count"]).optional().describe('Output mode: "content" shows matching lines, "files_with_matches" shows file paths (default), "count" shows match counts'),
+    "-i": z6.boolean().optional().describe("Case insensitive search"),
+    "-n": z6.boolean().optional().describe("Show line numbers in output. Requires output_mode: 'content'. Defaults to true."),
+    "-B": z6.number().optional().describe("Number of lines to show before each match. Requires output_mode: 'content'."),
+    "-A": z6.number().optional().describe("Number of lines to show after each match. Requires output_mode: 'content'."),
+    "-C": z6.number().optional().describe("Number of lines to show before and after each match. Requires output_mode: 'content'."),
+    head_limit: z6.number().optional().describe("Limit output to first N lines/entries. Works across all output modes. Defaults to 0 (unlimited)."),
+    offset: z6.number().optional().describe("Skip first N lines/entries before applying head_limit. Works across all output modes. Defaults to 0."),
+    multiline: z6.boolean().optional().describe("Enable multiline mode where patterns can span lines. Default: false.")
+  });
+});
 
 // src/sandbox/lazy-singleton.ts
 function createLazySingleton(factory) {
@@ -37,19 +752,33 @@ function createLazySingleton(factory) {
   };
 }
 
+// src/sandbox/ripgrep.ts
+async function getBundledRgPath() {
+  try {
+    const { rgPath } = await import("@vscode/ripgrep");
+    return rgPath;
+  } catch {
+    return;
+  }
+}
+function getBundledRgPathSync() {
+  try {
+    const { rgPath } = __require("@vscode/ripgrep");
+    return rgPath;
+  } catch {
+    return;
+  }
+}
+
 // src/sandbox/ensure-tools.ts
-import { rgPath as bundledRgPath } from "@vscode/ripgrep";
-var RIPGREP_VERSION = "14.1.0";
-var ARCH_MAP = {
-  x86_64: "x86_64-unknown-linux-musl",
-  aarch64: "aarch64-unknown-linux-gnu",
-  arm64: "aarch64-unknown-linux-gnu"
-};
 async function ensureSandboxTools(sandbox) {
-  const bundledCheck = await sandbox.exec(`test -x "${bundledRgPath}" && echo found`);
-  if (bundledCheck.stdout.includes("found")) {
-    sandbox.rgPath = bundledRgPath;
-    return;
+  const bundledRgPath = await getBundledRgPath();
+  if (bundledRgPath) {
+    const bundledCheck = await sandbox.exec(`test -x "${bundledRgPath}" && echo found`);
+    if (bundledCheck.stdout.includes("found")) {
+      sandbox.rgPath = bundledRgPath;
+      return;
+    }
   }
   const tmpCheck = await sandbox.exec("test -x /tmp/rg && echo found");
   if (tmpCheck.stdout.includes("found")) {
@@ -79,8 +808,20 @@ async function ensureSandboxTools(sandbox) {
   }
   sandbox.rgPath = "/tmp/rg";
 }
+var RIPGREP_VERSION = "14.1.0", ARCH_MAP;
+var init_ensure_tools = __esm(() => {
+  ARCH_MAP = {
+    x86_64: "x86_64-unknown-linux-musl",
+    aarch64: "aarch64-unknown-linux-gnu",
+    arm64: "aarch64-unknown-linux-gnu"
+  };
+});
 
 // src/sandbox/e2b.ts
+var exports_e2b = {};
+__export(exports_e2b, {
+  createE2BSandbox: () => createE2BSandbox
+});
 async function createE2BSandbox(config = {}) {
   let sandboxId = config.sandboxId;
   const workingDirectory = config.cwd || "/home/user";
@@ -199,255 +940,107 @@ async function createE2BSandbox(config = {}) {
   }
   return sandboxObj;
 }
-
-// src/workflow.ts
-async function reconnectSandbox(sandboxId, apiKey) {
-  return createE2BSandbox({
-    sandboxId,
-    apiKey,
-    ensureTools: false
-  });
-}
-var readInputSchema = z.object({
-  file_path: z.string().describe("Absolute path to file or directory"),
-  offset: z.number().optional().describe("Line number to start reading from (1-indexed)"),
-  limit: z.number().optional().describe("Maximum number of lines to read")
+var init_e2b = __esm(() => {
+  init_ensure_tools();
 });
-var READ_DESCRIPTION = `Reads a file from the sandbox filesystem.
 
-Usage:
-- The file_path parameter must be an absolute path
-- By default, reads up to 500 lines from the beginning
-- Use offset and limit for large files
-- Returns line numbers starting at 1`;
-var writeInputSchema = z.object({
-  file_path: z.string().describe("Absolute path to the file to write"),
-  content: z.string().describe("Content to write to the file")
-});
-var WRITE_DESCRIPTION = `Writes content to a file in the sandbox filesystem.
-Creates parent directories if they don't exist.`;
-var editInputSchema = z.object({
-  file_path: z.string().describe("Absolute path to the file to edit"),
-  old_string: z.string().describe("The exact string to find and replace"),
-  new_string: z.string().describe("The string to replace it with")
-});
-var EDIT_DESCRIPTION = `Makes a targeted edit to a file by replacing old_string with new_string.
-The old_string must match exactly (including whitespace and indentation).`;
-var bashInputSchema = z.object({
-  command: z.string().describe("The bash command to execute"),
-  description: z.string().optional().describe("Brief description of what this command does"),
-  timeout: z.number().optional().describe("Timeout in milliseconds (default: 120000)")
-});
-var BASH_DESCRIPTION = `Executes a bash command in the sandbox.
-Use for git, npm, system commands, etc.`;
-var globInputSchema = z.object({
-  pattern: z.string().describe('Glob pattern (e.g., "**/*.ts", "src/**/*.json")'),
-  path: z.string().optional().describe("Directory to search in")
-});
-var GLOB_DESCRIPTION = `Finds files matching a glob pattern.
-Returns list of matching file paths.`;
-var grepInputSchema = z.object({
-  pattern: z.string().describe("Regex pattern to search for"),
-  path: z.string().optional().describe("File or directory to search in"),
-  glob: z.string().optional().describe('Glob pattern to filter files (e.g., "*.ts")'),
-  output_mode: z.enum(["content", "files_with_matches", "count"]).optional().describe("Output mode (default: files_with_matches)")
-});
-var GREP_DESCRIPTION = `Searches for a regex pattern in files.
-Returns matching lines with file paths and line numbers.`;
-async function executeRead(sandbox, params, config) {
-  const { file_path, offset, limit } = params;
-  if (config?.allowedPaths) {
-    const isAllowed = config.allowedPaths.some((allowed) => file_path.startsWith(allowed));
-    if (!isAllowed) {
-      return { error: `Path not allowed: ${file_path}` };
-    }
-  }
-  try {
-    const exists = await sandbox.fileExists(file_path);
-    if (!exists) {
-      return { error: `Path not found: ${file_path}` };
-    }
-    const isDir = await sandbox.isDirectory(file_path);
-    if (isDir) {
-      const entries = await sandbox.readDir(file_path);
-      return { type: "directory", entries, count: entries.length };
-    }
-    const content = await sandbox.readFile(file_path);
-    const allLines = content.split(`
-`);
-    const totalLines = allLines.length;
-    const maxLinesWithoutLimit = config?.maxFileSize || 500;
-    if (!limit && totalLines > maxLinesWithoutLimit) {
-      return {
-        error: `File is large (${totalLines} lines). Use 'offset' and 'limit' to read in chunks.`
-      };
-    }
-    const startLine = offset ? offset - 1 : 0;
-    const endLine = limit ? startLine + limit : allLines.length;
-    const selectedLines = allLines.slice(startLine, endLine);
-    const lines = selectedLines.map((line, i) => ({
-      line_number: startLine + i + 1,
-      content: line
-    }));
-    return {
-      type: "text",
-      content: selectedLines.join(`
-`),
-      lines,
-      total_lines: totalLines
-    };
-  } catch (error) {
-    return { error: error instanceof Error ? error.message : "Unknown error" };
-  }
-}
-async function executeWrite(sandbox, params) {
-  const { file_path, content } = params;
-  try {
-    const dir = file_path.split("/").slice(0, -1).join("/");
-    if (dir) {
-      await sandbox.exec(`mkdir -p "${dir}"`);
-    }
-    await sandbox.writeFile(file_path, content);
-    return { success: true, path: file_path, bytes_written: content.length };
-  } catch (error) {
-    return { error: error instanceof Error ? error.message : "Unknown error" };
-  }
-}
-async function executeEdit(sandbox, params) {
-  const { file_path, old_string, new_string } = params;
-  try {
-    const content = await sandbox.readFile(file_path);
-    if (!content.includes(old_string)) {
-      return { error: `old_string not found in file: ${file_path}` };
-    }
-    const newContent = content.replace(old_string, new_string);
-    await sandbox.writeFile(file_path, newContent);
-    return { success: true, path: file_path };
-  } catch (error) {
-    return { error: error instanceof Error ? error.message : "Unknown error" };
-  }
-}
-async function executeBash(sandbox, params, config) {
-  const { command, timeout } = params;
-  if (config?.blockedCommands) {
-    const isBlocked = config.blockedCommands.some((blocked) => command.includes(blocked));
-    if (isBlocked) {
-      return { error: `Command blocked by security policy` };
-    }
-  }
-  try {
-    const result = await sandbox.exec(command, {
-      timeout: timeout || config?.timeout || 120000
-    });
-    return {
-      stdout: result.stdout,
-      stderr: result.stderr,
-      exit_code: result.exitCode,
-      duration_ms: result.durationMs
-    };
-  } catch (error) {
-    return { error: error instanceof Error ? error.message : "Unknown error" };
-  }
-}
-async function executeGlob(sandbox, params) {
-  const { pattern, path } = params;
-  const searchPath = path || ".";
-  try {
-    const result = await sandbox.exec(`find ${searchPath} -type f -name "${pattern.replace(/\*\*/g, "*")}" 2>/dev/null | head -200`);
-    const files = result.stdout.split(`
-`).filter(Boolean);
-    return { files, count: files.length };
-  } catch (error) {
-    return { error: error instanceof Error ? error.message : "Unknown error" };
-  }
-}
-async function executeGrep(sandbox, params) {
-  const { pattern, path, glob, output_mode } = params;
-  const searchPath = path || ".";
-  const mode = output_mode || "files_with_matches";
-  try {
-    let cmd;
-    const rgPath = sandbox.rgPath || "rg";
-    if (mode === "files_with_matches") {
-      cmd = `${rgPath} -l "${pattern}" ${searchPath}`;
-    } else if (mode === "count") {
-      cmd = `${rgPath} -c "${pattern}" ${searchPath}`;
-    } else {
-      cmd = `${rgPath} -n "${pattern}" ${searchPath}`;
-    }
-    if (glob) {
-      cmd += ` --glob "${glob}"`;
-    }
-    cmd += " 2>/dev/null | head -100";
-    const result = await sandbox.exec(cmd);
-    const lines = result.stdout.split(`
-`).filter(Boolean);
-    if (mode === "files_with_matches") {
-      return { files: lines, count: lines.length };
-    } else if (mode === "count") {
-      return { matches: lines };
-    } else {
-      return { content: result.stdout, match_count: lines.length };
-    }
-  } catch (error) {
-    return { error: error instanceof Error ? error.message : "Unknown error" };
-  }
-}
+// src/workflow.ts
+init_read();
+init_write();
+init_edit();
+init_bash();
+init_glob();
+init_grep();
+import { tool as tool7, zodSchema as zodSchema7 } from "ai";
 function createDurableAgentTools(sandboxId, config) {
   const toolsConfig = config?.tools || {};
+  const _sandboxId = sandboxId;
+  const _apiKey = config?.apiKey;
+  const _readConfig = toolsConfig.Read;
+  const _bashConfig = toolsConfig.Bash;
   const tools = {
-    Read: tool({
+    Read: tool7({
       description: READ_DESCRIPTION,
-      inputSchema: zodSchema(readInputSchema),
-      execute: async (params) => {
+      inputSchema: zodSchema7(readInputSchema),
+      execute: async function readFile(params, options) {
         "use step";
-        const sandbox = await reconnectSandbox(sandboxId, config?.apiKey);
-        return executeRead(sandbox, params, toolsConfig.Read);
+        const { createReadTool: createReadTool2 } = await Promise.resolve().then(() => (init_read(), exports_read));
+        const { createE2BSandbox: createE2BSandbox2 } = await Promise.resolve().then(() => (init_e2b(), exports_e2b));
+        const sandbox = await createE2BSandbox2({ sandboxId: _sandboxId, apiKey: _apiKey, ensureTools: false });
+        const readTool = createReadTool2(sandbox, _readConfig);
+        if (!readTool.execute)
+          throw new Error("Read tool missing execute");
+        return readTool.execute(params, options);
       }
     }),
-    Write: tool({
+    Write: tool7({
       description: WRITE_DESCRIPTION,
-      inputSchema: zodSchema(writeInputSchema),
-      execute: async (params) => {
+      inputSchema: zodSchema7(writeInputSchema),
+      execute: async function writeFile(params, options) {
         "use step";
-        const sandbox = await reconnectSandbox(sandboxId, config?.apiKey);
-        return executeWrite(sandbox, params);
+        const { createWriteTool: createWriteTool2 } = await Promise.resolve().then(() => (init_write(), exports_write));
+        const { createE2BSandbox: createE2BSandbox2 } = await Promise.resolve().then(() => (init_e2b(), exports_e2b));
+        const sandbox = await createE2BSandbox2({ sandboxId: _sandboxId, apiKey: _apiKey, ensureTools: false });
+        const writeTool = createWriteTool2(sandbox);
+        if (!writeTool.execute)
+          throw new Error("Write tool missing execute");
+        return writeTool.execute(params, options);
       }
     }),
-    Edit: tool({
+    Edit: tool7({
       description: EDIT_DESCRIPTION,
-      inputSchema: zodSchema(editInputSchema),
-      execute: async (params) => {
+      inputSchema: zodSchema7(editInputSchema),
+      execute: async function editFile(params, options) {
         "use step";
-        const sandbox = await reconnectSandbox(sandboxId, config?.apiKey);
-        return executeEdit(sandbox, params);
+        const { createEditTool: createEditTool2 } = await Promise.resolve().then(() => (init_edit(), exports_edit));
+        const { createE2BSandbox: createE2BSandbox2 } = await Promise.resolve().then(() => (init_e2b(), exports_e2b));
+        const sandbox = await createE2BSandbox2({ sandboxId: _sandboxId, apiKey: _apiKey, ensureTools: false });
+        const editTool = createEditTool2(sandbox);
+        if (!editTool.execute)
+          throw new Error("Edit tool missing execute");
+        return editTool.execute(params, options);
       }
     }),
-    Bash: tool({
+    Bash: tool7({
       description: BASH_DESCRIPTION,
-      inputSchema: zodSchema(bashInputSchema),
-      execute: async (params) => {
+      inputSchema: zodSchema7(bashInputSchema),
+      execute: async function runBash(params, options) {
         "use step";
-        const sandbox = await reconnectSandbox(sandboxId, config?.apiKey);
-        return executeBash(sandbox, params, toolsConfig.Bash);
+        const { createBashTool: createBashTool2 } = await Promise.resolve().then(() => (init_bash(), exports_bash));
+        const { createE2BSandbox: createE2BSandbox2 } = await Promise.resolve().then(() => (init_e2b(), exports_e2b));
+        const sandbox = await createE2BSandbox2({ sandboxId: _sandboxId, apiKey: _apiKey, ensureTools: false });
+        const bashTool = createBashTool2(sandbox, _bashConfig);
+        if (!bashTool.execute)
+          throw new Error("Bash tool missing execute");
+        return bashTool.execute(params, options);
       }
     }),
-    Glob: tool({
+    Glob: tool7({
       description: GLOB_DESCRIPTION,
-      inputSchema: zodSchema(globInputSchema),
-      execute: async (params) => {
+      inputSchema: zodSchema7(globInputSchema),
+      execute: async function globFiles(params, options) {
         "use step";
-        const sandbox = await reconnectSandbox(sandboxId, config?.apiKey);
-        return executeGlob(sandbox, params);
+        const { createGlobTool: createGlobTool2 } = await Promise.resolve().then(() => (init_glob(), exports_glob));
+        const { createE2BSandbox: createE2BSandbox2 } = await Promise.resolve().then(() => (init_e2b(), exports_e2b));
+        const sandbox = await createE2BSandbox2({ sandboxId: _sandboxId, apiKey: _apiKey, ensureTools: false });
+        const globTool = createGlobTool2(sandbox);
+        if (!globTool.execute)
+          throw new Error("Glob tool missing execute");
+        return globTool.execute(params, options);
       }
     }),
-    Grep: tool({
+    Grep: tool7({
       description: GREP_DESCRIPTION,
-      inputSchema: zodSchema(grepInputSchema),
-      execute: async (params) => {
+      inputSchema: zodSchema7(grepInputSchema),
+      execute: async function grepSearch(params, options) {
         "use step";
-        const sandbox = await reconnectSandbox(sandboxId, config?.apiKey);
-        return executeGrep(sandbox, params);
+        const { createGrepTool: createGrepTool2 } = await Promise.resolve().then(() => (init_grep(), exports_grep));
+        const { createE2BSandbox: createE2BSandbox2 } = await Promise.resolve().then(() => (init_e2b(), exports_e2b));
+        const sandbox = await createE2BSandbox2({ sandboxId: _sandboxId, apiKey: _apiKey, ensureTools: false });
+        const grepTool = createGrepTool2(sandbox);
+        if (!grepTool.execute)
+          throw new Error("Grep tool missing execute");
+        return grepTool.execute(params, options);
       }
     })
   };