ai-code-agents 0.1.0-beta.1

package/dist/index.cjs

@@ -0,0 +1,2688 @@
+"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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CopyFileResult: () => CopyFileResult,
+  CopyFileTool: () => CopyFileTool,
+  CopyFileToolInput: () => CopyFileToolInput,
+  CopyFileToolName: () => CopyFileToolName,
+  CopyFileToolOutput: () => CopyFileToolOutput,
+  DeleteFileResult: () => DeleteFileResult,
+  DeleteFileTool: () => DeleteFileTool,
+  DeleteFileToolInput: () => DeleteFileToolInput,
+  DeleteFileToolName: () => DeleteFileToolName,
+  DeleteFileToolOutput: () => DeleteFileToolOutput,
+  DockerEnvironment: () => DockerEnvironment,
+  DockerEnvironmentName: () => DockerEnvironmentName,
+  EditFileTool: () => EditFileTool,
+  EditFileToolInput: () => EditFileToolInput,
+  EditFileToolName: () => EditFileToolName,
+  EditFileToolOutput: () => EditFileToolOutput,
+  EnvironmentNames: () => EnvironmentNames,
+  EnvironmentToolNames: () => EnvironmentToolNames,
+  EnvironmentToolSafetyLevels: () => EnvironmentToolSafetyLevels,
+  GetProjectFileStructureTool: () => GetProjectFileStructureTool,
+  GetProjectFileStructureToolInput: () => GetProjectFileStructureToolInput,
+  GetProjectFileStructureToolName: () => GetProjectFileStructureToolName,
+  GetProjectFileStructureToolOutput: () => GetProjectFileStructureToolOutput,
+  GlobTool: () => GlobTool,
+  GlobToolInput: () => GlobToolInput,
+  GlobToolName: () => GlobToolName,
+  GlobToolOutput: () => GlobToolOutput,
+  ListDirectoryTool: () => ListDirectoryTool,
+  ListDirectoryToolInput: () => ListDirectoryToolInput,
+  ListDirectoryToolName: () => ListDirectoryToolName,
+  ListDirectoryToolOutput: () => ListDirectoryToolOutput,
+  MockFilesystemEnvironment: () => MockFilesystemEnvironment,
+  MockFilesystemEnvironmentName: () => MockFilesystemEnvironmentName,
+  MoveFileResult: () => MoveFileResult,
+  MoveFileTool: () => MoveFileTool,
+  MoveFileToolInput: () => MoveFileToolInput,
+  MoveFileToolName: () => MoveFileToolName,
+  MoveFileToolOutput: () => MoveFileToolOutput,
+  NodeFilesystemEnvironment: () => NodeFilesystemEnvironment,
+  NodeFilesystemEnvironmentName: () => NodeFilesystemEnvironmentName,
+  ReadFileResult: () => ReadFileResult,
+  ReadFileTool: () => ReadFileTool,
+  ReadFileToolInput: () => ReadFileToolInput,
+  ReadFileToolName: () => ReadFileToolName,
+  ReadFileToolOutput: () => ReadFileToolOutput,
+  ReadManyFilesTool: () => ReadManyFilesTool,
+  ReadManyFilesToolInput: () => ReadManyFilesToolInput,
+  ReadManyFilesToolName: () => ReadManyFilesToolName,
+  ReadManyFilesToolOutput: () => ReadManyFilesToolOutput,
+  RunCommandResult: () => RunCommandResult,
+  RunCommandTool: () => RunCommandTool,
+  RunCommandToolInput: () => RunCommandToolInput,
+  RunCommandToolName: () => RunCommandToolName,
+  RunCommandToolOutput: () => RunCommandToolOutput,
+  UnsafeLocalEnvironment: () => UnsafeLocalEnvironment,
+  UnsafeLocalEnvironmentName: () => UnsafeLocalEnvironmentName,
+  WriteFileResult: () => WriteFileResult,
+  WriteFileTool: () => WriteFileTool,
+  WriteFileToolInput: () => WriteFileToolInput,
+  WriteFileToolName: () => WriteFileToolName,
+  WriteFileToolOutput: () => WriteFileToolOutput,
+  createCodeAgent: () => createCodeAgent,
+  createEnvironment: () => createEnvironment,
+  createEnvironmentTool: () => createEnvironmentTool,
+  createToolsForEnvironment: () => createToolsForEnvironment,
+  createToolsForNamedEnvironment: () => createToolsForNamedEnvironment
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/environments/docker-environment.ts
+var import_node_child_process = require("child_process");
+
+// src/util/escape-command-arg.ts
+function escapeCommandArg(arg) {
+  if ("" === arg) {
+    return "''";
+  }
+  return `'${arg.replace(/'/g, "'\\''")}'`;
+}
+
+// src/util/validate-relative-path.ts
+var path = __toESM(require("path"), 1);
+function validateRelativePath(filePath) {
+  if (path.isAbsolute(filePath)) {
+    throw new Error("Absolute paths are not allowed.");
+  }
+  if (filePath.startsWith("~")) {
+    throw new Error('Paths starting with "~" are not allowed.');
+  }
+  if (filePath.includes("\0")) {
+    throw new Error("Paths must not contain null bytes.");
+  }
+  const normalizedPath = path.normalize(filePath);
+  if (normalizedPath.startsWith("..")) {
+    throw new Error("Path traversal is not allowed.");
+  }
+}
+
+// src/environments/filesystem-environment-base.ts
+var FilesystemEnvironmentBase = class {
+  _envConfig;
+  /**
+   * Constructs a new environment instance.
+   *
+   * @param config - Environment configuration.
+   */
+  constructor(config) {
+    this._envConfig = config;
+  }
+  /**
+   * Reads the content of a file at the specified path.
+   *
+   * @param path - The path to the file to read, relative to the project directory.
+   * @returns A promise that resolves to a ReadFileResult.
+   */
+  async readFile(path5) {
+    validateRelativePath(path5);
+    if (!await this.fileExists(path5)) {
+      throw new Error(`File not found: ${path5}`);
+    }
+    const content = await this.readFileContent(path5);
+    return {
+      path: path5,
+      content
+    };
+  }
+  /**
+   * Writes content to a file at the specified path.
+   *
+   * If a file is already present at the path, it will be overwritten.
+   *
+   * @param path - The path to the file to write, relative to the project directory.
+   * @param content - The content to write to the file.
+   * @returns A promise that resolves to a WriteFileResult.
+   */
+  async writeFile(path5, content) {
+    validateRelativePath(path5);
+    await this.writeFileContent(path5, content);
+    return {
+      path: path5,
+      message: "File written successfully."
+    };
+  }
+  /**
+   * Deletes a file at the specified path.
+   *
+   * @param path - The path to the file to delete, relative to the project directory.
+   * @returns A promise that resolves to a DeleteFileResult.
+   */
+  async deleteFile(path5) {
+    validateRelativePath(path5);
+    if (!await this.fileExists(path5)) {
+      return {
+        path: path5,
+        message: "File was already deleted."
+      };
+    }
+    await this.deleteFileContent(path5);
+    return {
+      path: path5,
+      message: "File deleted successfully."
+    };
+  }
+  /**
+   * Moves a file from a source path to a destination path.
+   *
+   * If a file is already present at the destination path, it will be overwritten.
+   *
+   * @param sourcePath - The path to the file to move.
+   * @param destinationPath - The path to move the file to.
+   * @returns A promise that resolves to a MoveFileResult.
+   */
+  async moveFile(sourcePath, destinationPath) {
+    validateRelativePath(sourcePath);
+    validateRelativePath(destinationPath);
+    if (!await this.fileExists(sourcePath)) {
+      throw new Error(`File not found: ${sourcePath}`);
+    }
+    await this.moveFileContent(sourcePath, destinationPath);
+    return {
+      sourcePath,
+      destinationPath,
+      message: "File moved successfully."
+    };
+  }
+  /**
+   * Copies a file from a source path to a destination path.
+   *
+   * If a file is already present at the destination path, it will be overwritten.
+   *
+   * @param sourcePath - The path to the file to copy.
+   * @param destinationPath - The path to copy the file to.
+   * @returns A promise that resolves to a CopyFileResult.
+   */
+  async copyFile(sourcePath, destinationPath) {
+    validateRelativePath(sourcePath);
+    validateRelativePath(destinationPath);
+    if (!await this.fileExists(sourcePath)) {
+      throw new Error(`File not found: ${sourcePath}`);
+    }
+    await this.copyFileContent(sourcePath, destinationPath);
+    return {
+      sourcePath,
+      destinationPath,
+      message: "File copied successfully."
+    };
+  }
+  /**
+   * Moves the content of a file from a source path to a destination path, relative to the project directory.
+   *
+   * When this method is called, it is guaranteed that the source file exists.
+   * This method unconditionally moves the content, even if a file already exists at the destination path.
+   *
+   * @param relativeSourcePath - The path to the file to move, relative to the project directory.
+   * @param relativeDestinationPath - The path to move the file to, relative to the project directory.
+   */
+  async moveFileContent(relativeSourcePath, relativeDestinationPath) {
+    const content = await this.readFileContent(relativeSourcePath);
+    this.writeFileContent(relativeDestinationPath, content);
+    this.deleteFileContent(relativeSourcePath);
+  }
+  /**
+   * Copies the content of a file from a source path to a destination path, relative to the project directory.
+   *
+   * When this method is called, it is guaranteed that the source file exists.
+   * This method unconditionally copies the content, even if a file already exists at the destination path.
+   *
+   * @param relativeSourcePath - The path to the file to copy, relative to the project directory.
+   * @param relativeDestinationPath - The path to copy the file to, relative to the project directory.
+   */
+  async copyFileContent(relativeSourcePath, relativeDestinationPath) {
+    const content = await this.readFileContent(relativeSourcePath);
+    this.writeFileContent(relativeDestinationPath, content);
+  }
+};
+
+// src/environments/command-line-environment-base.ts
+var CommandLineEnvironmentBase = class extends FilesystemEnvironmentBase {
+  /**
+   * Runs a CLI command in environment.
+   *
+   * @param command - The command to run.
+   * @returns A promise that resolves to a RunCommandResult.
+   */
+  async runCommand(command) {
+    const [exitCode, stdout, stderr] = await this.executeCommand(command);
+    return {
+      command,
+      exitCode,
+      stdout,
+      stderr
+    };
+  }
+};
+
+// src/environments/unix-environment-base.ts
+var UnixEnvironmentBase = class extends CommandLineEnvironmentBase {
+  /**
+   * Checks whether a file exists at the specified path relative to the project directory.
+   *
+   * @param relativePath - The path to the file to check, relative to the project directory.
+   * @returns True if the file exists, false otherwise.
+   */
+  async fileExists(relativePath) {
+    const command = `if [ -e ${escapeCommandArg(relativePath)} ]; then echo "yes"; else echo "no"; fi`;
+    const { exitCode, stdout } = await this.runCommand(command);
+    return exitCode === 0 && stdout.trim() === "yes";
+  }
+  /**
+   * Gets the content of a file at the specified path, relative to the project directory.
+   *
+   * When this method is called, it is guaranteed that the file exists.
+   *
+   * @param relativePath - The path to the file to read, relative to the project directory.
+   * @returns The content of the file.
+   */
+  async readFileContent(relativePath) {
+    const command = `cat ${escapeCommandArg(relativePath)}`;
+    const { exitCode, stdout } = await this.runCommand(command);
+    return exitCode === 0 ? stdout : "";
+  }
+  /**
+   * Writes content to a file at the specified path, relative to the project directory.
+   *
+   * This method unconditionally writes the content, even if a file already exists at the path, or if the file is new.
+   *
+   * @param relativePath - The path to the file to write, relative to the project directory.
+   * @param content - The content to write to the file.
+   */
+  async writeFileContent(relativePath, content) {
+    const command = `sh -c "echo ${escapeCommandArg(
+      content
+    )} > ${escapeCommandArg(relativePath)}"`;
+    const { exitCode, stderr } = await this.runCommand(command);
+    if (exitCode !== 0) {
+      throw new Error(`Failed to write file: ${stderr || "Unknown error"}`);
+    }
+  }
+  /**
+   * Deletes a file at the specified path, relative to the project directory.
+   *
+   * When this method is called, it is guaranteed that the file exists.
+   *
+   * @param relativePath - The path to the file to delete, relative to the project directory.
+   */
+  async deleteFileContent(relativePath) {
+    const command = `rm ${escapeCommandArg(relativePath)}`;
+    const { exitCode, stderr } = await this.runCommand(command);
+    if (exitCode !== 0) {
+      throw new Error(`Failed to delete file: ${stderr || "Unknown error"}`);
+    }
+  }
+  /**
+   * Moves the content of a file from a source path to a destination path, relative to the project directory.
+   *
+   * When this method is called, it is guaranteed that the source file exists.
+   * This method unconditionally moves the content, even if a file already exists at the destination path.
+   *
+   * @param relativeSourcePath - The path to the file to move, relative to the project directory.
+   * @param relativeDestinationPath - The path to move the file to, relative to the project directory.
+   */
+  async moveFileContent(relativeSourcePath, relativeDestinationPath) {
+    const command = `mv ${escapeCommandArg(relativeSourcePath)} ${escapeCommandArg(
+      relativeDestinationPath
+    )}`;
+    const { exitCode, stderr } = await this.runCommand(command);
+    if (exitCode !== 0) {
+      throw new Error(`Failed to move file: ${stderr || "Unknown error"}`);
+    }
+  }
+  /**
+   * Copies the content of a file from a source path to a destination path, relative to the project directory.
+   *
+   * When this method is called, it is guaranteed that the source file exists.
+   * This method unconditionally copies the content, even if a file already exists at the destination path.
+   *
+   * @param relativeSourcePath - The path to the file to copy, relative to the project directory.
+   * @param relativeDestinationPath - The path to copy the file to, relative to the project directory.
+   */
+  async copyFileContent(relativeSourcePath, relativeDestinationPath) {
+    const command = `cp ${escapeCommandArg(relativeSourcePath)} ${escapeCommandArg(
+      relativeDestinationPath
+    )}`;
+    const result = await this.runCommand(command);
+    if (result.exitCode !== 0) {
+      throw new Error(
+        `Failed to copy file: ${result.stderr || "Unknown error"}`
+      );
+    }
+  }
+};
+
+// src/environments/docker-environment.ts
+var DockerEnvironmentName = "docker";
+var DockerEnvironment = class extends UnixEnvironmentBase {
+  _commandPrefix;
+  /**
+   * Constructs a new environment instance.
+   *
+   * @param config - Environment configuration.
+   */
+  constructor(config) {
+    super(config);
+    const { directoryPath } = this._envConfig;
+    this._commandPrefix = directoryPath ? `cd ${escapeCommandArg(directoryPath)} && ` : "";
+  }
+  /**
+   * Gets the environment name.
+   *
+   * @returns The environment name.
+   */
+  get name() {
+    return DockerEnvironmentName;
+  }
+  /**
+   * Executes a command in the environment and returns the exit code, stdout, and stderr.
+   *
+   * @param command - The command to execute.
+   * @returns A promise that resolves to a tuple containing the exit code, stdout, and stderr.
+   */
+  async executeCommand(command) {
+    return new Promise((resolve) => {
+      (0, import_node_child_process.exec)(
+        `docker exec ${this._envConfig.containerId} ${this._commandPrefix}${command}`,
+        (error, stdout, stderr) => {
+          const exitCode = error ? error.code ?? 1 : 0;
+          resolve([exitCode, stdout, stderr]);
+        }
+      );
+    });
+  }
+};
+
+// src/environments/mock-filesystem-environment.ts
+var import_node_path = __toESM(require("path"), 1);
+var MockFilesystemEnvironmentName = "mock-filesystem";
+var MockFilesystemEnvironment = class extends FilesystemEnvironmentBase {
+  files;
+  _preparePath;
+  /**
+   * Constructs a new environment instance.
+   *
+   * @param config - Environment configuration.
+   */
+  constructor(config = {}) {
+    super(config);
+    const { initialFiles, directoryPath } = this._envConfig;
+    this.files = initialFiles ?? /* @__PURE__ */ new Map();
+    this._preparePath = directoryPath ? (filePath) => import_node_path.default.join(directoryPath, filePath) : (filePath) => filePath;
+  }
+  /**
+   * Gets the environment name.
+   *
+   * @returns The environment name.
+   */
+  get name() {
+    return MockFilesystemEnvironmentName;
+  }
+  /**
+   * Checks whether a file exists at the specified path relative to the project directory.
+   *
+   * @param relativePath - The path to the file to check, relative to the project directory.
+   * @returns True if the file exists, false otherwise.
+   */
+  async fileExists(relativePath) {
+    return this.files.has(this._preparePath(relativePath));
+  }
+  /**
+   * Gets the content of a file at the specified path, relative to the project directory.
+   *
+   * When this method is called, it is guaranteed that the file exists.
+   *
+   * @param relativePath - The path to the file to read, relative to the project directory.
+   * @returns The content of the file.
+   */
+  async readFileContent(relativePath) {
+    return this.files.get(this._preparePath(relativePath)) ?? "";
+  }
+  /**
+   * Writes content to a file at the specified path, relative to the project directory.
+   *
+   * This method unconditionally writes the content, even if a file already exists at the path, or if the file is new.
+   *
+   * @param relativePath - The path to the file to write, relative to the project directory.
+   * @param content - The content to write to the file.
+   */
+  async writeFileContent(relativePath, content) {
+    this.files.set(this._preparePath(relativePath), content);
+  }
+  /**
+   * Deletes a file at the specified path, relative to the project directory.
+   *
+   * @param relativePath - The path to the file to delete, relative to the project directory.
+   */
+  async deleteFileContent(relativePath) {
+    this.files.delete(this._preparePath(relativePath));
+  }
+};
+
+// src/environments/node-filesystem-environment.ts
+var import_promises = __toESM(require("fs/promises"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+var NodeFilesystemEnvironmentName = "node-filesystem";
+var NodeFilesystemEnvironment = class extends FilesystemEnvironmentBase {
+  /**
+   * Constructs a new NodeFilesystemEnvironment instance.
+   *
+   * @param config - Environment configuration including the mandatory directoryPath.
+   */
+  constructor(config) {
+    if (!config.directoryPath) {
+      throw new Error("The directory path must be provided");
+    }
+    super(config);
+  }
+  /**
+   * Gets the environment name.
+   *
+   * @returns The environment name.
+   */
+  get name() {
+    return NodeFilesystemEnvironmentName;
+  }
+  /**
+   * Checks whether a file exists at the specified path relative to the project directory.
+   *
+   * @param relativePath - The path to the file to check, relative to the project directory.
+   * @returns True if the file exists, false otherwise.
+   */
+  async fileExists(relativePath) {
+    const absolutePath = import_node_path2.default.join(this._envConfig.directoryPath, relativePath);
+    try {
+      await import_promises.default.stat(absolutePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Gets the content of a file at the specified path, relative to the project directory.
+   *
+   * When this method is called, it is guaranteed that the file exists.
+   *
+   * @param relativePath - The path to the file to read, relative to the project directory.
+   * @returns The content of the file.
+   */
+  async readFileContent(relativePath) {
+    const absolutePath = import_node_path2.default.join(this._envConfig.directoryPath, relativePath);
+    return import_promises.default.readFile(absolutePath, "utf-8");
+  }
+  /**
+   * Writes content to a file at the specified path, relative to the project directory.
+   *
+   * This method unconditionally writes the content, even if a file already exists at the path, or if the file is new.
+   *
+   * @param relativePath - The path to the file to write, relative to the project directory.
+   * @param content - The content to write to the file.
+   */
+  async writeFileContent(relativePath, content) {
+    const absolutePath = import_node_path2.default.join(this._envConfig.directoryPath, relativePath);
+    await import_promises.default.writeFile(absolutePath, content, "utf-8");
+  }
+  /**
+   * Deletes a file at the specified path, relative to the project directory.
+   *
+   * When this method is called, it is guaranteed that the file exists.
+   *
+   * @param relativePath - The path to the file to delete, relative to the project directory.
+   */
+  async deleteFileContent(relativePath) {
+    const absolutePath = import_node_path2.default.join(this._envConfig.directoryPath, relativePath);
+    await import_promises.default.rm(absolutePath);
+  }
+  /**
+   * Moves the content of a file from a source path to a destination path, relative to the project directory.
+   *
+   * When this method is called, it is guaranteed that the source file exists.
+   * This method unconditionally moves the content, even if a file already exists at the destination path.
+   *
+   * @param relativeSourcePath - The path to the file to move, relative to the project directory.
+   * @param relativeDestinationPath - The path to move the file to, relative to the project directory.
+   */
+  async moveFileContent(relativeSourcePath, relativeDestinationPath) {
+    const sourcePath = import_node_path2.default.join(
+      this._envConfig.directoryPath,
+      relativeSourcePath
+    );
+    const destinationPath = import_node_path2.default.join(
+      this._envConfig.directoryPath,
+      relativeDestinationPath
+    );
+    await import_promises.default.rename(sourcePath, destinationPath);
+  }
+};
+
+// src/environments/unsafe-local-environment.ts
+var import_node_child_process2 = require("child_process");
+var UnsafeLocalEnvironmentName = "unsafe-local";
+var UnsafeLocalEnvironment = class extends UnixEnvironmentBase {
+  _commandPrefix;
+  /**
+   * Constructs a new environment instance.
+   *
+   * @param config - Environment configuration.
+   */
+  constructor(config) {
+    const { directoryPath } = config;
+    if (!directoryPath) {
+      throw new Error("The directory path must be provided");
+    }
+    if (!directoryPath.startsWith("/")) {
+      throw new Error('The directory path must be absolute (start with "/")');
+    }
+    super(config);
+    this._commandPrefix = `cd ${escapeCommandArg(directoryPath)} && `;
+  }
+  /**
+   * Gets the environment name.
+   *
+   * @returns The environment name.
+   */
+  get name() {
+    return UnsafeLocalEnvironmentName;
+  }
+  /**
+   * Executes a command in the environment and returns the exit code, stdout, and stderr.
+   *
+   * @param command - The command to execute.
+   * @returns A promise that resolves to a tuple containing the exit code, stdout, and stderr.
+   */
+  async executeCommand(command) {
+    return new Promise((resolve) => {
+      (0, import_node_child_process2.exec)(`${this._commandPrefix}${command}`, (error, stdout, stderr) => {
+        const exitCode = error ? error.code ?? 1 : 0;
+        resolve([exitCode, stdout, stderr]);
+      });
+    });
+  }
+};
+
+// src/tools/copy-file-tool.ts
+var import_zod = require("zod");
+
+// src/types.ts
+var z = __toESM(require("zod"), 1);
+var ReadFileResult = z.object({
+  path: z.string().meta({
+    description: "The path to the file that was read."
+  }),
+  content: z.string().meta({
+    description: "The content of the file that was read."
+  })
+});
+var WriteFileResult = z.object({
+  path: z.string().meta({
+    description: "The path to the file that was written."
+  }),
+  message: z.string().meta({
+    description: "A message indicating the result of the write operation."
+  })
+});
+var DeleteFileResult = z.object({
+  path: z.string().meta({
+    description: "The path to the file that was deleted."
+  }),
+  message: z.string().meta({
+    description: "A message indicating the result of the delete operation."
+  })
+});
+var MoveFileResult = z.object({
+  sourcePath: z.string().meta({
+    description: "The original path of the file that was moved."
+  }),
+  destinationPath: z.string().meta({
+    description: "The new path of the file that was moved to."
+  }),
+  message: z.string().meta({
+    description: "A message indicating the result of the move operation."
+  })
+});
+var CopyFileResult = z.object({
+  sourcePath: z.string().meta({
+    description: "The original path of the file that was copied."
+  }),
+  destinationPath: z.string().meta({
+    description: "The new path of the file that was copied to."
+  }),
+  message: z.string().meta({
+    description: "A message indicating the result of the copy operation."
+  })
+});
+var RunCommandResult = z.object({
+  command: z.string().meta({
+    description: "The command that was executed."
+  }),
+  exitCode: z.number().meta({
+    description: "The exit code of the command."
+  }),
+  stdout: z.string().meta({
+    description: "The standard output of the command."
+  }),
+  stderr: z.string().meta({
+    description: "The standard error output of the command."
+  })
+});
+
+// src/tools/tool-base.ts
+var ToolBase = class {
+  _toolConfig;
+  _name;
+  _description;
+  _inputSchema;
+  _outputSchema;
+  _needsApproval;
+  /**
+   * Constructs a new tool instance.
+   *
+   * @param toolConfig - Optional tool config, can be used to override some defaults.
+   */
+  constructor(toolConfig) {
+    const {
+      name: defaultName,
+      description: defaultDescription,
+      inputSchema,
+      outputSchema,
+      needsApproval: defaultNeedsApproval
+    } = this.getMetadata();
+    this._name = toolConfig?.name || defaultName;
+    this._description = toolConfig?.description || defaultDescription;
+    this._inputSchema = inputSchema;
+    this._outputSchema = outputSchema;
+    this._needsApproval = toolConfig?.needsApproval !== void 0 ? toolConfig.needsApproval : defaultNeedsApproval;
+  }
+  /**
+   * Gets the tool name.
+   *
+   * @returns The tool name.
+   */
+  get name() {
+    return this._name;
+  }
+  /**
+   * Gets the tool description.
+   *
+   * @returns The tool description.
+   */
+  get description() {
+    return this._description;
+  }
+  /**
+   * Gets the input schema for the tool.
+   *
+   * @returns The input schema.
+   */
+  get inputSchema() {
+    return this._inputSchema;
+  }
+  /**
+   * Gets the input schema for the tool.
+   *
+   * @returns The input schema.
+   */
+  get outputSchema() {
+    return this._outputSchema;
+  }
+  /**
+   * Gets whether the tool needs approval before use.
+   *
+   * @returns True if the tool needs approval, false otherwise.
+   */
+  get needsApproval() {
+    return this._needsApproval;
+  }
+};
+
+// src/tools/environment-tool-base.ts
+var EnvironmentToolBase = class extends ToolBase {
+  _environment;
+  /**
+   * Constructs a new `EnvironmentToolBase` instance.
+   *
+   * @param environment - The execution environment to apply the tool in.
+   * @param toolConfig - Optional tool config, can be used to override some defaults.
+   */
+  constructor(environment, toolConfig) {
+    super(toolConfig);
+    this._environment = environment;
+  }
+  /**
+   * Gets the current execution environment for the tool.
+   *
+   * @returns The current execution environment.
+   */
+  get environment() {
+    return this._environment;
+  }
+  /**
+   * Executes the tool with the given input.
+   *
+   * @param input - The input for the tool.
+   * @param _options - Options from the tool call.
+   * @returns A promise that resolves to the tool execution result.
+   */
+  execute(input, _options) {
+    return this.executeForEnvironment(this._environment, input);
+  }
+};
+
+// src/tools/copy-file-tool.ts
+var CopyFileToolName = "copy_file";
+var CopyFileToolInput = import_zod.z.object({
+  sourcePath: import_zod.z.string().meta({
+    description: "The path to the file to copy, relative to the project directory."
+  }),
+  destinationPath: import_zod.z.string().meta({
+    description: "The path to the destination where the file should be copied, relative to the project directory. If the file already exists, it will be overwritten."
+  })
+});
+var CopyFileToolOutput = CopyFileResult;
+var CopyFileTool = class extends EnvironmentToolBase {
+  /**
+   * Returns the metadata for the tool.
+   *
+   * The name, description, and needsApproval properties are defaults which can be overridden in the constructor.
+   *
+   * @returns The tool metadata.
+   */
+  getMetadata() {
+    return {
+      name: CopyFileToolName,
+      description: "Copies a file from a source path to a destination path.",
+      inputSchema: CopyFileToolInput,
+      outputSchema: CopyFileToolOutput,
+      needsApproval: false
+    };
+  }
+  /**
+   * Executes the tool in the given execution environment with the given input.
+   *
+   * @param env - The execution environment to use.
+   * @param input - The input for the tool.
+   * @returns A promise that resolves to the tool execution result.
+   */
+  executeForEnvironment(env, input) {
+    return env.copyFile(input.sourcePath, input.destinationPath);
+  }
+  /**
+   * Converts the tool output to a format suitable for model consumption.
+   *
+   * @param output - The output from the tool execution.
+   * @returns The formatted tool result.
+   */
+  toModelOutput(output) {
+    return {
+      type: "text",
+      value: `File \`${output.sourcePath}\` copied successfully to \`${output.destinationPath}\`.`
+    };
+  }
+  /**
+   * Gets the examples for the tool.
+   *
+   * @returns The tool examples.
+   */
+  get examples() {
+    return [
+      {
+        input: {
+          sourcePath: "src/index.ts",
+          destinationPath: "index.ts"
+        },
+        output: "File `src/index.ts` copied successfully to `index.ts`."
+      }
+    ];
+  }
+};
+
+// src/tools/delete-file-tool.ts
+var import_zod2 = require("zod");
+var DeleteFileToolName = "delete_file";
+var DeleteFileToolInput = import_zod2.z.object({
+  path: import_zod2.z.string().meta({
+    description: "The path to the file to delete, relative to the project directory."
+  })
+});
+var DeleteFileToolOutput = DeleteFileResult;
+var DeleteFileTool = class extends EnvironmentToolBase {
+  /**
+   * Returns the metadata for the tool.
+   *
+   * The name, description, and needsApproval properties are defaults which can be overridden in the constructor.
+   *
+   * @returns The tool metadata.
+   */
+  getMetadata() {
+    return {
+      name: DeleteFileToolName,
+      description: "Deletes the file at the specified path.",
+      inputSchema: DeleteFileToolInput,
+      outputSchema: DeleteFileToolOutput,
+      needsApproval: true
+    };
+  }
+  /**
+   * Executes the tool in the given execution environment with the given input.
+   *
+   * @param env - The execution environment to use.
+   * @param input - The input for the tool.
+   * @returns A promise that resolves to the tool execution result.
+   */
+  executeForEnvironment(env, input) {
+    return env.deleteFile(input.path);
+  }
+  /**
+   * Converts the tool output to a format suitable for model consumption.
+   *
+   * @param output - The output from the tool execution.
+   * @returns The formatted tool result.
+   */
+  toModelOutput(output) {
+    return {
+      type: "text",
+      value: `File \`${output.path}\` deleted successfully.`
+    };
+  }
+  /**
+   * Gets the examples for the tool.
+   *
+   * @returns The tool examples.
+   */
+  get examples() {
+    return [
+      {
+        input: {
+          path: "src/components/Chart.tsx"
+        },
+        output: "File `src/components/Chart.tsx` deleted successfully."
+      }
+    ];
+  }
+};
+
+// src/tools/edit-file-tool.ts
+var import_zod3 = require("zod");
+var EditFileToolName = "edit_file";
+var EditFileToolInput = import_zod3.z.object({
+  path: import_zod3.z.string().meta({
+    description: "The path to the file to edit, relative to the project directory."
+  }),
+  oldString: import_zod3.z.string().meta({
+    description: "The exact string to replace in the file."
+  }),
+  newString: import_zod3.z.string().meta({
+    description: "The string to replace the old string with."
+  }),
+  replaceAll: import_zod3.z.boolean().optional().meta({
+    description: "Whether to replace all occurrences of the old string. Defaults to false."
+  })
+});
+var EditFileToolOutput = import_zod3.z.object({
+  path: import_zod3.z.string().meta({
+    description: "The path to the file that was edited."
+  }),
+  oldString: import_zod3.z.string().meta({
+    description: "The old string that was replaced."
+  }),
+  newString: import_zod3.z.string().meta({
+    description: "The new string that replaced the old string."
+  }),
+  replacements: import_zod3.z.number().meta({
+    description: "The number of replacements made."
+  }),
+  message: import_zod3.z.string().meta({
+    description: "A message indicating the result of the edit operation."
+  })
+});
+function escapeRegExp(string2) {
+  return string2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var EditFileTool = class extends EnvironmentToolBase {
+  /**
+   * Returns the metadata for the tool.
+   *
+   * The name, description, and needsApproval properties are defaults which can be overridden in the constructor.
+   *
+   * @returns The tool metadata.
+   */
+  getMetadata() {
+    return {
+      name: EditFileToolName,
+      description: "Edits a file by replacing strings.",
+      inputSchema: EditFileToolInput,
+      outputSchema: EditFileToolOutput,
+      needsApproval: true
+    };
+  }
+  /**
+   * Executes the tool in the given execution environment with the given input.
+   *
+   * @param env - The execution environment to use.
+   * @param input - The input for the tool.
+   * @returns A promise that resolves to the tool execution result.
+   */
+  async executeForEnvironment(env, input) {
+    const { path: path5, oldString, newString, replaceAll = false } = input;
+    const readResult = await env.readFile(path5);
+    let content = readResult.content;
+    let replacements = 0;
+    if (replaceAll) {
+      const escapedOldString = escapeRegExp(oldString);
+      const regex = new RegExp(escapedOldString, "g");
+      const matches = content.match(regex);
+      replacements = matches ? matches.length : 0;
+      content = content.replace(regex, newString);
+    } else {
+      const index = content.indexOf(oldString);
+      if (index !== -1) {
+        content = content.substring(0, index) + newString + content.substring(index + oldString.length);
+        replacements = 1;
+      }
+    }
+    await env.writeFile(path5, content);
+    const message = replacements > 0 ? `Successfully made ${replacements} replacement(s) in file.` : "No replacements made - old string not found.";
+    return {
+      path: path5,
+      oldString,
+      newString,
+      replacements,
+      message
+    };
+  }
+  /**
+   * Converts the tool output to a format suitable for model consumption.
+   *
+   * @param output - The output from the tool execution.
+   * @returns The formatted tool result.
+   */
+  toModelOutput(output) {
+    return {
+      type: "text",
+      value: `Edited file \`${output.path}\` with ${output.replacements} replacement(s).`
+    };
+  }
+  /**
+   * Gets the examples for the tool.
+   *
+   * @returns The tool examples.
+   */
+  get examples() {
+    return [
+      {
+        input: {
+          path: "src/example.ts",
+          oldString: 'console.log("hello");',
+          newString: 'console.log("world");',
+          replaceAll: false
+        },
+        output: {
+          path: "src/example.ts",
+          oldString: 'console.log("hello");',
+          newString: 'console.log("world");',
+          replacements: 1,
+          message: "Successfully made 1 replacement(s) in file."
+        }
+      },
+      {
+        input: {
+          path: "src/example.ts",
+          oldString: "var",
+          newString: "let",
+          replaceAll: true
+        },
+        output: {
+          path: "src/example.ts",
+          oldString: "var",
+          newString: "let",
+          replacements: 3,
+          message: "Successfully made 3 replacement(s) in file."
+        }
+      }
+    ];
+  }
+};
+
+// src/tools/get-project-file-structure-tool.ts
+var import_zod4 = require("zod");
+
+// src/util/build-tree-from-files.ts
+function renderTree(node, prefix = "") {
+  const entries = Object.keys(node).sort();
+  let result = "";
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    const isLast = i === entries.length - 1;
+    const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const nextPrefix = prefix + (isLast ? "    " : "\u2502   ");
+    result += prefix + connector + "**" + entry + "**\n";
+    if (Object.keys(node[entry]).length > 0) {
+      result += renderTree(node[entry], nextPrefix);
+    }
+  }
+  return result;
+}
+function buildTreeFromFiles(files) {
+  if (files.length === 0) {
+    return "";
+  }
+  const sortedFiles = [...files].sort();
+  const tree = {};
+  for (const file of sortedFiles) {
+    const parts = file.split("/");
+    let current = tree;
+    for (const part of parts) {
+      if (!current[part]) {
+        current[part] = {};
+      }
+      current = current[part];
+    }
+  }
+  return renderTree(tree).trim();
+}
+
+// src/tools/get-project-file-structure-tool.ts
+var GetProjectFileStructureToolName = "get_project_file_structure";
+var GetProjectFileStructureToolInput = import_zod4.z.object({
+  path: import_zod4.z.string().optional().meta({
+    description: 'Root path to list files from, relative to the project directory. Defaults to ".".'
+  }),
+  excludeGitIgnored: import_zod4.z.boolean().optional().meta({
+    description: "Whether to exclude files ignored by Git. Defaults to true."
+  })
+});
+var GetProjectFileStructureToolOutput = import_zod4.z.object({
+  files: import_zod4.z.array(import_zod4.z.string()).meta({
+    description: "List of all file paths found, relative to the root path."
+  }),
+  excludeGitIgnored: import_zod4.z.boolean().meta({
+    description: "Whether files ignored by Git were excluded."
+  })
+});
+var GetProjectFileStructureTool = class extends EnvironmentToolBase {
+  /**
+   * Returns the metadata for the tool.
+   *
+   * The name, description, and needsApproval properties are defaults which can be overridden in the constructor.
+   *
+   * @returns The tool metadata.
+   */
+  getMetadata() {
+    return {
+      name: GetProjectFileStructureToolName,
+      description: "Recursively lists all files in the project directory and formats them as a tree structure.",
+      inputSchema: GetProjectFileStructureToolInput,
+      outputSchema: GetProjectFileStructureToolOutput,
+      needsApproval: false
+    };
+  }
+  /**
+   * Executes the tool in the given execution environment with the given input.
+   *
+   * @param env - The execution environment to use.
+   * @param input - The input for the tool.
+   * @returns A promise that resolves to the tool execution result.
+   */
+  async executeForEnvironment(env, input) {
+    const { path: path5 = ".", excludeGitIgnored = true } = input;
+    const escapedPath = escapeCommandArg(path5);
+    let command = `find ${escapedPath} -type f`;
+    if (excludeGitIgnored) {
+      let gitIgnoredPaths = [];
+      try {
+        const { content: gitignoreContent } = await env.readFile(".gitignore");
+        gitIgnoredPaths = gitignoreContent.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+      } catch (_error) {
+      }
+      for (const gitIgnoredPath of gitIgnoredPaths) {
+        if (!gitIgnoredPath.endsWith("/")) {
+          const escapedPath2 = escapeCommandArg(`*/${gitIgnoredPath}/*`);
+          command += ` -not -name ${escapeCommandArg(gitIgnoredPath)} -not -path ${escapedPath2}`;
+        } else {
+          const escapedPath2 = escapeCommandArg(`*/${gitIgnoredPath}*`);
+          command += ` -not -path ${escapedPath2}`;
+        }
+      }
+    }
+    command += " | sort";
+    const { stdout, stderr, exitCode } = await env.runCommand(command);
+    if (exitCode !== 0) {
+      throw new Error(
+        `Failed to get project file structure with command "${command}": ${stderr}`
+      );
+    }
+    const files = stdout.split("\n").map((path6) => path6.trim()).filter(Boolean);
+    const trimInitialDotSlash = (path6) => path6.startsWith("./") ? path6.slice(2) : path6;
+    return {
+      files: files.map(trimInitialDotSlash),
+      excludeGitIgnored
+    };
+  }
+  /**
+   * Converts the tool output to a format suitable for model consumption.
+   *
+   * @param output - The output from the tool execution.
+   * @returns The formatted tool result.
+   */
+  toModelOutput(output) {
+    const tree = buildTreeFromFiles(output.files);
+    if (!tree) {
+      return {
+        type: "text",
+        value: "No files found."
+      };
+    }
+    return {
+      type: "text",
+      value: tree
+    };
+  }
+  /**
+   * Gets the examples for the tool.
+   *
+   * @returns The tool examples.
+   */
+  get examples() {
+    return [
+      {
+        input: {},
+        output: `\u251C\u2500\u2500 **src/**
+\u2502   \u251C\u2500\u2500 **components/**
+\u2502   \u2502   \u251C\u2500\u2500 **Button.js**
+\u2502   \u2502   \u2514\u2500\u2500 **Header.js**
+\u2502   \u2514\u2500\u2500 **index.js**
+\u251C\u2500\u2500 **tests/**
+\u2502   \u2514\u2500\u2500 **test_runner.py**
+\u251C\u2500\u2500 .gitignore
+\u251C\u2500\u2500 README.md
+\u2514\u2500\u2500 package.json`
+      }
+    ];
+  }
+};
+
+// src/tools/glob-tool.ts
+var import_zod5 = require("zod");
+
+// src/util/glob-to-reg-exp.ts
+function globToRegExp(glob) {
+  let reStr = "";
+  for (let i = 0; i < glob.length; i++) {
+    const char = glob[i];
+    switch (char) {
+      case "*":
+        if (glob[i + 1] === "*") {
+          if (glob[i + 2] === "/") {
+            reStr += "(?:.*\\/)?";
+            i += 2;
+          } else {
+            reStr += ".*";
+            i++;
+          }
+        } else {
+          reStr += "[^/]*";
+        }
+        break;
+      case "?":
+        reStr += "[^/]";
+        break;
+      // Escape characters with special meaning in regex.
+      case ".":
+      case "(":
+      case ")":
+      case "[":
+      case "]":
+      case "{":
+      case "}":
+      case "+":
+      case "^":
+      case "$":
+      case "|":
+      case "\\":
+        reStr += `\\${char}`;
+        break;
+      default:
+        reStr += char;
+    }
+  }
+  return new RegExp(`^${reStr}$`);
+}
+
+// src/tools/glob-tool.ts
+var GlobToolName = "glob";
+var GlobToolInput = import_zod5.z.object({
+  searchPattern: import_zod5.z.string().meta({
+    description: 'The glob pattern to search for, relative to the search path / project directory (e.g. "**/*.ts", "docs/*.md").'
+  }),
+  searchPath: import_zod5.z.string().optional().meta({
+    description: "The path to search within, relative to the project directory. Defaults to the project directory."
+  }),
+  excludeGitIgnored: import_zod5.z.boolean().optional().meta({
+    description: "Whether to exclude files ignored by Git. Defaults to true."
+  })
+});
+var GlobToolOutput = import_zod5.z.object({
+  searchPattern: import_zod5.z.string().meta({
+    description: "The glob pattern that was searched for."
+  }),
+  searchPath: import_zod5.z.string().meta({
+    description: "The path that was searched within."
+  }),
+  excludeGitIgnored: import_zod5.z.boolean().meta({
+    description: "Whether files ignored by Git were excluded."
+  }),
+  matchingPaths: import_zod5.z.array(import_zod5.z.string()).meta({
+    description: "The list of file paths that matched the glob search, relative to the project directory."
+  })
+});
+var GlobTool = class extends EnvironmentToolBase {
+  /**
+   * Returns the metadata for the tool.
+   *
+   * The name, description, and needsApproval properties are defaults which can be overridden in the constructor.
+   *
+   * @returns The tool metadata.
+   */
+  getMetadata() {
+    return {
+      name: GlobToolName,
+      description: "Runs a glob search to find matching file paths in the project.",
+      inputSchema: GlobToolInput,
+      outputSchema: GlobToolOutput,
+      needsApproval: false
+    };
+  }
+  /**
+   * Executes the tool in the given execution environment with the given input.
+   *
+   * @param env - The execution environment to use.
+   * @param input - The input for the tool.
+   * @returns A promise that resolves to the tool execution result.
+   */
+  async executeForEnvironment(env, input) {
+    const { searchPattern, searchPath = "", excludeGitIgnored = true } = input;
+    if (searchPattern.startsWith("/")) {
+      throw new Error(
+        "The search pattern must not start with a forward slash."
+      );
+    }
+    if (searchPath) {
+      validateRelativePath(searchPath);
+    }
+    const untrailingslashedSearchPath = searchPath === "" ? "." : searchPath.replace(/\/+$/, "");
+    const escapedSearchPath = escapeCommandArg(untrailingslashedSearchPath);
+    let command = `find ${escapedSearchPath} -type f`;
+    if (excludeGitIgnored) {
+      let gitIgnoredPaths = [];
+      try {
+        const { content: gitignoreContent } = await env.readFile(".gitignore");
+        gitIgnoredPaths = gitignoreContent.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+      } catch (_error) {
+      }
+      for (const gitIgnoredPath of gitIgnoredPaths) {
+        if (!gitIgnoredPath.endsWith("/")) {
+          const escapedPath = escapeCommandArg(`*/${gitIgnoredPath}/*`);
+          command += ` -not -name ${escapeCommandArg(gitIgnoredPath)} -not -path ${escapedPath}`;
+        } else {
+          const escapedPath = escapeCommandArg(`*/${gitIgnoredPath}*`);
+          command += ` -not -path ${escapedPath}`;
+        }
+      }
+    }
+    const { stdout, stderr, exitCode } = await env.runCommand(command);
+    if (exitCode !== 0) {
+      throw new Error(
+        `Failed to glob files with command "${command}": ${stderr}`
+      );
+    }
+    const matchingPaths = stdout.split("\n").map((path5) => path5.trim()).filter(Boolean);
+    const trimInitialDotSlash = (path5) => path5.startsWith("./") ? path5.slice(2) : path5;
+    if (searchPattern !== "" && searchPattern !== "**") {
+      const combinedPattern = `${untrailingslashedSearchPath}/${searchPattern}`;
+      const regExp = globToRegExp(combinedPattern);
+      const filteredMatchingPaths = matchingPaths.filter(
+        (path5) => regExp.test(path5)
+      );
+      return {
+        searchPattern,
+        searchPath,
+        excludeGitIgnored,
+        matchingPaths: filteredMatchingPaths.map(trimInitialDotSlash)
+      };
+    }
+    return {
+      searchPattern,
+      searchPath,
+      excludeGitIgnored,
+      matchingPaths: matchingPaths.map(trimInitialDotSlash)
+    };
+  }
+  /**
+   * Converts the tool output to a format suitable for model consumption.
+   *
+   * @param output - The output from the tool execution.
+   * @returns The formatted tool result.
+   */
+  toModelOutput(output) {
+    if (output.matchingPaths.length === 0) {
+      return {
+        type: "text",
+        value: "No matching files found."
+      };
+    }
+    const bulletPoints = output.matchingPaths.map((path5) => `- \`${path5}\``).join("\n");
+    return {
+      type: "text",
+      value: `Matching files:
+${bulletPoints}
+`
+    };
+  }
+  /**
+   * Gets the examples for the tool.
+   *
+   * @returns The tool examples.
+   */
+  get examples() {
+    return [
+      {
+        input: {
+          searchPattern: "src/**/*.tsx"
+        },
+        output: `Matching files:
+- \`src/app/page.tsx\`
+- \`src/components/chart.tsx\`
+- \`src/components/footer.tsx\`
+- \`src/components/header.tsx\`
+`
+      },
+      {
+        input: {
+          searchPattern: "*",
+          searchPath: "packages/my-project"
+        },
+        output: `Matching files:
+- \`packages/my-project/package.json\`
+- \`packages/my-project/README.md\`
+- \`packages/my-project/tsconfig.json\`
+- \`packages/my-project/vitest.config.ts\`
+`
+      }
+    ];
+  }
+};
+
+// src/tools/list-directory-tool.ts
+var import_zod6 = require("zod");
+var ListDirectoryToolName = "list_directory";
+var ListDirectoryToolInput = import_zod6.z.object({
+  path: import_zod6.z.string().meta({
+    description: "The directory path to list, relative to the project directory."
+  })
+});
+var ListDirectoryToolOutput = import_zod6.z.object({
+  path: import_zod6.z.string().meta({
+    description: "The directory path that was listed."
+  }),
+  files: import_zod6.z.array(import_zod6.z.string()).meta({
+    description: "List of files in the directory."
+  }),
+  directories: import_zod6.z.array(import_zod6.z.string()).meta({
+    description: "List of subdirectories in the directory."
+  })
+});
+var ListDirectoryTool = class extends EnvironmentToolBase {
+  /**
+   * Returns the metadata for the tool.
+   *
+   * The name, description, and needsApproval properties are defaults which can be overridden in the constructor.
+   *
+   * @returns The tool metadata.
+   */
+  getMetadata() {
+    return {
+      name: ListDirectoryToolName,
+      description: "Lists all files and directories in the specified directory, differentiating between files and directories. Non-recursive.",
+      inputSchema: ListDirectoryToolInput,
+      outputSchema: ListDirectoryToolOutput,
+      needsApproval: false
+    };
+  }
+  /**
+   * Executes the tool in the given execution environment with the given input.
+   *
+   * @param env - The execution environment to use.
+   * @param input - The input for the tool.
+   * @returns A promise that resolves to the tool execution result.
+   */
+  async executeForEnvironment(env, input) {
+    const escapedPath = escapeCommandArg(input.path);
+    const command = `ls -la ${escapedPath}`;
+    const { stdout, stderr, exitCode } = await env.runCommand(command);
+    if (exitCode !== 0) {
+      throw new Error(
+        `Failed to list directory "${input.path}" with command "${command}": ${stderr}`
+      );
+    }
+    const lines = stdout.split("\n").filter((line) => line.trim() !== "");
+    const files = [];
+    const directories = [];
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i].trim();
+      if (!line) continue;
+      const typeChar = line.charAt(0);
+      const parts = line.split(/\s+/);
+      const name = parts[parts.length - 1];
+      if (name === "." || name === "..") continue;
+      if (typeChar === "d") {
+        directories.push(name);
+      } else if (typeChar === "-") {
+        files.push(name);
+      }
+    }
+    return {
+      path: input.path,
+      files,
+      directories
+    };
+  }
+  /**
+   * Converts the tool output to a format suitable for model consumption.
+   *
+   * @param output - The output from the tool execution.
+   * @returns The formatted tool result.
+   */
+  toModelOutput(output) {
+    const formatEntries = (entries, type) => {
+      if (entries.length === 0) {
+        return `No ${type} found.`;
+      }
+      const bulletPoints = entries.map((name) => `- \`${name}\``).join("\n");
+      return `${type.charAt(0).toUpperCase() + type.slice(1)}:
+${bulletPoints}`;
+    };
+    const filesSection = formatEntries(output.files, "files");
+    const directoriesSection = formatEntries(output.directories, "directories");
+    return {
+      type: "text",
+      value: `Directory listing for \`${output.path}\`:
+
+${filesSection}
+
+${directoriesSection}`
+    };
+  }
+  /**
+   * Gets the examples for the tool.
+   *
+   * @returns The tool examples.
+   */
+  get examples() {
+    return [
+      {
+        input: {
+          path: "src"
+        },
+        output: `Directory listing for \`src\`:
+
+Files:
+- \`index.ts\`
+- \`utils.ts\`
+
+Directories:
+- \`components\`
+- \`hooks\``
+      }
+    ];
+  }
+};
+
+// src/tools/move-file-tool.ts
+var import_zod7 = require("zod");
+var MoveFileToolName = "move_file";
+var MoveFileToolInput = import_zod7.z.object({
+  sourcePath: import_zod7.z.string().meta({
+    description: "The path to the file to move, relative to the project directory."
+  }),
+  destinationPath: import_zod7.z.string().meta({
+    description: "The path to the destination where the file should be moved, relative to the project directory. If the file already exists, it will be overwritten."
+  })
+});
+var MoveFileToolOutput = MoveFileResult;
+var MoveFileTool = class extends EnvironmentToolBase {
+  /**
+   * Returns the metadata for the tool.
+   *
+   * The name, description, and needsApproval properties are defaults which can be overridden in the constructor.
+   *
+   * @returns The tool metadata.
+   */
+  getMetadata() {
+    return {
+      name: MoveFileToolName,
+      description: "Moves a file from a source path to a destination path.",
+      inputSchema: MoveFileToolInput,
+      outputSchema: MoveFileToolOutput,
+      needsApproval: false
+    };
+  }
+  /**
+   * Executes the tool in the given execution environment with the given input.
+   *
+   * @param env - The execution environment to use.
+   * @param input - The input for the tool.
+   * @returns A promise that resolves to the tool execution result.
+   */
+  executeForEnvironment(env, input) {
+    return env.moveFile(input.sourcePath, input.destinationPath);
+  }
+  /**
+   * Converts the tool output to a format suitable for model consumption.
+   *
+   * @param output - The output from the tool execution.
+   * @returns The formatted tool result.
+   */
+  toModelOutput(output) {
+    return {
+      type: "text",
+      value: `File \`${output.sourcePath}\` moved successfully to \`${output.destinationPath}\`.`
+    };
+  }
+  /**
+   * Gets the examples for the tool.
+   *
+   * @returns The tool examples.
+   */
+  get examples() {
+    return [
+      {
+        input: {
+          sourcePath: "src/lib/types.ts",
+          destinationPath: "lib/index.ts"
+        },
+        output: "File `src/lib/types.ts` moved successfully to `lib/index.ts`."
+      }
+    ];
+  }
+};
+
+// src/tools/read-file-tool.ts
+var import_zod8 = require("zod");
+
+// src/util/get-language-identifier-from-file-path.ts
+var import_node_path3 = __toESM(require("path"), 1);
+var jsLanguage = {
+  identifier: "javascript",
+  name: "JavaScript",
+  fileExtensions: ["js", "jsx"]
+};
+var tsLanguage = {
+  identifier: "typescript",
+  name: "TypeScript",
+  fileExtensions: ["ts", "tsx"]
+};
+var ymlLanguage = {
+  identifier: "yaml",
+  name: "YAML",
+  fileExtensions: ["yml", "yaml"]
+};
+var EXTENSION_TO_LANGUAGE = {
+  ts: tsLanguage,
+  tsx: tsLanguage,
+  js: jsLanguage,
+  jsx: jsLanguage,
+  py: {
+    identifier: "python",
+    name: "Python",
+    fileExtensions: ["py"]
+  },
+  java: {
+    identifier: "java",
+    name: "Java",
+    fileExtensions: ["java"]
+  },
+  c: {
+    identifier: "c",
+    name: "C",
+    fileExtensions: ["c"]
+  },
+  cpp: {
+    identifier: "cpp",
+    name: "C++",
+    fileExtensions: ["cpp"]
+  },
+  cs: {
+    identifier: "chsarp",
+    name: "C#",
+    fileExtensions: ["cs"]
+  },
+  go: {
+    identifier: "go",
+    name: "Go",
+    fileExtensions: ["go"]
+  },
+  rs: {
+    identifier: "rust",
+    name: "Rust",
+    fileExtensions: ["rs"]
+  },
+  php: {
+    identifier: "php",
+    name: "PHP",
+    fileExtensions: ["php"]
+  },
+  rb: {
+    identifier: "ruby",
+    name: "Ruby",
+    fileExtensions: ["rb"]
+  },
+  swift: {
+    identifier: "swift",
+    name: "Swift",
+    fileExtensions: ["swift"]
+  },
+  kt: {
+    identifier: "kotlin",
+    name: "Kotlin",
+    fileExtensions: ["kt"]
+  },
+  scala: {
+    identifier: "scala",
+    name: "Scala",
+    fileExtensions: ["scala"]
+  },
+  html: {
+    identifier: "html",
+    name: "HTML",
+    fileExtensions: ["html"]
+  },
+  css: {
+    identifier: "css",
+    name: "CSS",
+    fileExtensions: ["css"]
+  },
+  sass: {
+    identifier: "sass",
+    name: "Sass",
+    fileExtensions: ["sass"]
+  },
+  scss: {
+    identifier: "scss",
+    name: "SCSS",
+    fileExtensions: ["scss"]
+  },
+  less: {
+    identifier: "less",
+    name: "Less",
+    fileExtensions: ["less"]
+  },
+  json: {
+    identifier: "json",
+    name: "JSON",
+    fileExtensions: ["json"]
+  },
+  md: {
+    identifier: "markdown",
+    name: "Markdown",
+    fileExtensions: ["md"]
+  },
+  toml: {
+    identifier: "toml",
+    name: "TOML",
+    fileExtensions: ["toml"]
+  },
+  yml: ymlLanguage,
+  yaml: ymlLanguage,
+  xml: {
+    identifier: "xml",
+    name: "XML",
+    fileExtensions: ["xml"]
+  },
+  sql: {
+    identifier: "sql",
+    name: "SQL",
+    fileExtensions: ["sql"]
+  },
+  graphql: {
+    identifier: "graphql",
+    name: "GraphQL",
+    fileExtensions: ["graphql"]
+  },
+  sh: {
+    identifier: "bash",
+    name: "Shell",
+    fileExtensions: ["sh"]
+  },
+  ps1: {
+    identifier: "bash",
+    name: "PowerShell",
+    fileExtensions: ["ps1"]
+  }
+};
+function getLanguageFromFilePath(filePath) {
+  const extension = import_node_path3.default.extname(filePath).slice(1).toLowerCase() || "";
+  return EXTENSION_TO_LANGUAGE[extension];
+}
+function getLanguageIdentifierFromFilePath(filePath) {
+  const language = getLanguageFromFilePath(filePath);
+  return language ? language.identifier : "";
+}
+
+// src/tools/read-file-tool.ts
+var ReadFileToolName = "read_file";
+var ReadFileToolInput = import_zod8.z.object({
+  path: import_zod8.z.string().meta({
+    description: "The path to the file to read, relative to the project directory."
+  })
+});
+var ReadFileToolOutput = ReadFileResult;
+var formatModelResponse = (output) => {
+  const language = getLanguageIdentifierFromFilePath(output.path);
+  return `File: \`${output.path}\`
+Content:
+\`\`\`${language}
+${output.content}
+\`\`\`
+`;
+};
+var ReadFileTool = class extends EnvironmentToolBase {
+  /**
+   * Returns the metadata for the tool.
+   *
+   * The name, description, and needsApproval properties are defaults which can be overridden in the constructor.
+   *
+   * @returns The tool metadata.
+   */
+  getMetadata() {
+    return {
+      name: ReadFileToolName,
+      description: "Reads the content of a file at the specified path.",
+      inputSchema: ReadFileToolInput,
+      outputSchema: ReadFileToolOutput,
+      needsApproval: false
+    };
+  }
+  /**
+   * Executes the tool in the given execution environment with the given input.
+   *
+   * @param env - The execution environment to use.
+   * @param input - The input for the tool.
+   * @returns A promise that resolves to the tool execution result.
+   */
+  executeForEnvironment(env, input) {
+    return env.readFile(input.path);
+  }
+  /**
+   * Converts the tool output to a format suitable for model consumption.
+   *
+   * @param output - The output from the tool execution.
+   * @returns The formatted tool result.
+   */
+  toModelOutput(output) {
+    return {
+      type: "text",
+      value: formatModelResponse(output)
+    };
+  }
+  /**
+   * Gets the examples for the tool.
+   *
+   * @returns The tool examples.
+   */
+  get examples() {
+    const exampleContent = `import clsx from 'clsx';
+
+type LoaderProps = {
+  className?: string;
+};
+
+export function Loader(props: LoaderProps) {
+  const { className } = props;
+
+  return (
+    <div className={clsx('loader', className)}>
+      Loading\u2026
+    </div>
+  );
+}
+`;
+    return [
+      {
+        input: {
+          path: "src/components/Loader.tsx"
+        },
+        output: formatModelResponse({
+          path: "src/components/Loader.tsx",
+          content: exampleContent
+        })
+      }
+    ];
+  }
+};
+
+// src/tools/read-many-files-tool.ts
+var import_zod9 = require("zod");
+var ReadManyFilesToolName = "read_many_files";
+var ReadManyFilesToolInput = import_zod9.z.object({
+  paths: import_zod9.z.array(import_zod9.z.string()).meta({
+    description: "The paths to the files to read, relative to the project directory."
+  })
+});
+var ReadManyFilesToolOutput = import_zod9.z.record(import_zod9.z.string(), ReadFileResult);
+var formatModelResponse2 = (output) => {
+  const language = getLanguageIdentifierFromFilePath(output.path);
+  return `File: \`${output.path}\`
+Content:
+\`\`\`${language}
+${output.content}
+\`\`\`
+`;
+};
+var ReadManyFilesTool = class extends EnvironmentToolBase {
+  /**
+   * Returns the metadata for the tool.
+   *
+   * The name, description, and needsApproval properties are defaults which can be overridden in the constructor.
+   *
+   * @returns The tool metadata.
+   */
+  getMetadata() {
+    return {
+      name: ReadManyFilesToolName,
+      description: "Reads the contents of the files at the specified paths.",
+      inputSchema: ReadManyFilesToolInput,
+      outputSchema: ReadManyFilesToolOutput,
+      needsApproval: false
+    };
+  }
+  /**
+   * Executes the tool in the given execution environment with the given input.
+   *
+   * @param env - The execution environment to use.
+   * @param input - The input for the tool.
+   * @returns A promise that resolves to the tool execution result.
+   */
+  async executeForEnvironment(env, input) {
+    const results = await Promise.all(
+      input.paths.map((path5) => env.readFile(path5))
+    );
+    return results.reduce((acc, result) => {
+      acc[result.path] = result;
+      return acc;
+    }, {});
+  }
+  /**
+   * Converts the tool output to a format suitable for model consumption.
+   *
+   * @param output - The output from the tool execution.
+   * @returns The formatted tool result.
+   */
+  toModelOutput(output) {
+    const fileContentResponses = Object.values(output).map(
+      (fileResult) => formatModelResponse2(fileResult)
+    );
+    return {
+      type: "text",
+      value: fileContentResponses.join("\n")
+    };
+  }
+  /**
+   * Gets the examples for the tool.
+   *
+   * @returns The tool examples.
+   */
+  get examples() {
+    const exampleContent1 = `import clsx from 'clsx';
+
+type LoaderProps = {
+  className?: string;
+};
+
+export function Loader(props: LoaderProps) {
+  const { className } = props;
+
+  return (
+    <div className={clsx('loader', className)}>
+      Loading\u2026
+    </div>
+  );
+}
+`;
+    const exampleContent2 = `export function snakeCaseToCamelCase(snakeCase: string): string {
+  return snakeCase.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+`;
+    return [
+      {
+        input: {
+          paths: [
+            "src/components/Loader.tsx",
+            "src/util/snake-case-to-camel-case.ts"
+          ]
+        },
+        output: formatModelResponse2({
+          path: "src/components/Loader.tsx",
+          content: exampleContent1
+        }) + "\n" + formatModelResponse2({
+          path: "src/util/snake-case-to-camel-case.ts",
+          content: exampleContent2
+        })
+      }
+    ];
+  }
+};
+
+// src/tools/run-command-tool.ts
+var import_zod10 = require("zod");
+var RunCommandToolName = "run_command";
+var RunCommandToolInput = import_zod10.z.object({
+  command: import_zod10.z.string().meta({ description: "The CLI command to run, including all arguments." })
+});
+var RunCommandToolOutput = RunCommandResult;
+function formatCommandResultToModelResponse(output) {
+  const stdout = !output.stdout.trim() ? "(none)" : `
+\`\`\`
+${output.stdout}
+\`\`\``;
+  const stderr = !output.stderr.trim() ? "(none)" : `
+\`\`\`
+${output.stderr}
+\`\`\``;
+  return `Command: \`${output.command}\`
+Exit Code: ${output.exitCode}
+Output (stdout): ${stdout}
+Error Output (stderr): ${stderr}
+`;
+}
+var RunCommandTool = class extends EnvironmentToolBase {
+  /**
+   * Returns the metadata for the tool.
+   *
+   * The name, description, and needsApproval properties are defaults which can be overridden in the constructor.
+   *
+   * @returns The tool metadata.
+   */
+  getMetadata() {
+    return {
+      name: RunCommandToolName,
+      description: "Runs the specific CLI command.",
+      inputSchema: RunCommandToolInput,
+      outputSchema: RunCommandToolOutput,
+      needsApproval: true
+    };
+  }
+  /**
+   * Executes the tool in the given execution environment with the given input.
+   *
+   * @param env - The execution environment to use.
+   * @param input - The input for the tool.
+   * @returns A promise that resolves to the tool execution result.
+   */
+  executeForEnvironment(env, input) {
+    return env.runCommand(input.command);
+  }
+  /**
+   * Converts the tool output to a format suitable for model consumption.
+   *
+   * @param output - The output from the tool execution.
+   * @returns The formatted tool result.
+   */
+  toModelOutput(output) {
+    return {
+      type: "text",
+      value: formatCommandResultToModelResponse(output)
+    };
+  }
+  /**
+   * Gets the examples for the tool.
+   *
+   * @returns The tool examples.
+   */
+  get examples() {
+    const exampleGitOutput = `diff --git a/src/util/string-utils.ts b/src/util/string-utils.ts
+index 1836072..b13adef 100644
+--- a/src/util/string-utils.ts
++++ b/src/util/string-utils.ts
+@@ -1,3 +1,7 @@
+ export function snakeCaseToCamelCase(str: string): string {
+   return str.replace(/_([a-z])/g, (match, p1) => p1.toUpperCase());
+ }
++
++export function camelCaseToSnakeCase(str: string): string {
++  return str.replace(/([A-Z])/g, (match) => \`_\${match.toLowerCase()}\`);
++}
+`;
+    const exampleNpmOutput = `
+added 1 package, and changed 1 package in 2s
+
+156 packages are looking for funding
+  run \`npm fund\` for details`;
+    const exampleMkdirError = `mkdir: src/lib: No such file or directory
+`;
+    return [
+      {
+        input: {
+          command: "git --no-pager diff"
+        },
+        output: formatCommandResultToModelResponse({
+          command: "git --no-pager diff",
+          exitCode: 0,
+          stdout: exampleGitOutput,
+          stderr: ""
+        })
+      },
+      {
+        input: {
+          command: "npm install zod"
+        },
+        output: formatCommandResultToModelResponse({
+          command: "npm install zod",
+          exitCode: 0,
+          stdout: exampleNpmOutput,
+          stderr: ""
+        })
+      },
+      {
+        input: {
+          command: "mkdir src/lib/api"
+        },
+        output: formatCommandResultToModelResponse({
+          command: "mkdir src/lib/api",
+          exitCode: 1,
+          stdout: "",
+          stderr: exampleMkdirError
+        })
+      }
+    ];
+  }
+};
+
+// src/tools/write-file-tool.ts
+var import_zod11 = require("zod");
+var WriteFileToolName = "write_file";
+var WriteFileToolInput = import_zod11.z.object({
+  path: import_zod11.z.string().meta({
+    description: "The path to the file to write, relative to the project directory."
+  }),
+  content: import_zod11.z.string().meta({
+    description: "The content to write to the file. If the file already exists, the content will replace existing content."
+  })
+});
+var WriteFileToolOutput = WriteFileResult;
+var WriteFileTool = class extends EnvironmentToolBase {
+  /**
+   * Returns the metadata for the tool.
+   *
+   * The name, description, and needsApproval properties are defaults which can be overridden in the constructor.
+   *
+   * @returns The tool metadata.
+   */
+  getMetadata() {
+    return {
+      name: WriteFileToolName,
+      description: "Writes content to a file at the specified path.",
+      inputSchema: WriteFileToolInput,
+      outputSchema: WriteFileToolOutput,
+      needsApproval: false
+    };
+  }
+  /**
+   * Executes the tool in the given execution environment with the given input.
+   *
+   * @param env - The execution environment to use.
+   * @param input - The input for the tool.
+   * @returns A promise that resolves to the tool execution result.
+   */
+  executeForEnvironment(env, input) {
+    return env.writeFile(input.path, input.content);
+  }
+  /**
+   * Converts the tool output to a format suitable for model consumption.
+   *
+   * @param output - The output from the tool execution.
+   * @returns The formatted tool result.
+   */
+  toModelOutput(output) {
+    return {
+      type: "text",
+      value: `File \`${output.path}\` written successfully.`
+    };
+  }
+  /**
+   * Gets the examples for the tool.
+   *
+   * @returns The tool examples.
+   */
+  get examples() {
+    const exampleContent = `export function snakeCaseToCamelCase(snakeCase: string): string {
+  return snakeCase.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+`;
+    return [
+      {
+        input: {
+          path: "src/util/snake-case-to-camel-case.ts",
+          content: exampleContent
+        },
+        output: "File `src/util/snake-case-to-camel-case.ts` written successfully."
+      }
+    ];
+  }
+};
+
+// src/agent-creators.ts
+var import_ai = require("ai");
+
+// src/tools/submit-tool.ts
+var import_zod12 = require("zod");
+var SubmitToolName = "submit";
+var SubmitToolInput = import_zod12.z.object({});
+var SubmitToolOutput = import_zod12.z.object({});
+var SubmitTool = class extends ToolBase {
+  /**
+   * Returns the metadata for the tool.
+   *
+   * The name, description, and needsApproval properties are defaults which can be overridden in the constructor.
+   *
+   * @returns The tool metadata.
+   */
+  getMetadata() {
+    return {
+      name: SubmitToolName,
+      description: "Submits the current task, indicating that it is completed.",
+      inputSchema: SubmitToolInput,
+      outputSchema: SubmitToolOutput,
+      needsApproval: false
+    };
+  }
+  /**
+   * Executes the tool with the given input.
+   *
+   * @param _ - The input for the tool. Unused.
+   * @param __ - Options from the tool call. Unused.
+   * @returns A promise that resolves to the tool execution result.
+   */
+  async execute(_, __) {
+    return {};
+  }
+  /**
+   * Converts the tool output to a format suitable for model consumption.
+   *
+   * @param _ - The output from the tool execution. Unused.
+   * @returns The formatted tool result.
+   */
+  toModelOutput(_) {
+    return {
+      type: "text",
+      value: `Task submitted successfully.`
+    };
+  }
+  /**
+   * Gets the examples for the tool.
+   *
+   * @returns The tool examples.
+   */
+  get examples() {
+    return [];
+  }
+};
+
+// src/instructions.ts
+function getAdditionalInstructions(config) {
+  const { maxSteps, allowSubmit, tools } = config;
+  const exampleSections = [];
+  for (const [toolName, tool] of Object.entries(tools)) {
+    if ("examples" in tool && Array.isArray(tool.examples) && tool.examples.length > 0) {
+      let toolSection = `### Tool: \`${toolName}\`
+
+`;
+      for (const example of tool.examples) {
+        toolSection += formatExampleForInstructions(toolName, example);
+      }
+      exampleSections.push(toolSection.trim());
+    }
+  }
+  const workflowGuidelines = [
+    /*
+     * If there are examples, the tool information is already mentioned in a separate Tool Examples section.
+     * Therefore the line below is only relevant if there are no examples.
+     */
+    ...!exampleSections.length ? [
+      "You have access to several tools to assist you in completing your task."
+    ] : [],
+    "You must issue tool calls to complete your task. Do not engage with the user directly.",
+    ...allowSubmit ? [
+      `Once you think you have completed your task, call the \`${SubmitToolName}\` tool to submit your results.`
+    ] : [],
+    `You have a maximum of ${maxSteps} steps to complete your task.`
+  ];
+  const importantWorkflowGuidelines = `## Important Workflow Guidelines
+
+${workflowGuidelines.map((line) => `- ${line}`).join("\n")}
+
+Remember, you don't get to ask the user any clarifying questions, just use the tools available to complete your task. You're on your own now.
+`;
+  if (exampleSections.length) {
+    return `## Tool Examples
+
+You have access to several tools to assist you in completing your task. Here are some examples of how to use them:
+
+${exampleSections.join("\n\n")}
+
+` + importantWorkflowGuidelines;
+  }
+  return importantWorkflowGuidelines;
+}
+function formatExampleForInstructions(toolName, example) {
+  const input = typeof example.input === "undefined" ? "" : typeof example.input === "string" || typeof example.input === "number" ? example.input : JSON.stringify(example.input, null, 2);
+  const output = typeof example.output === "undefined" ? "" : typeof example.output === "string" || typeof example.output === "number" ? example.output : JSON.stringify(example.output, null, 2);
+  if (output === "") {
+    return `<example>
+<tool_call>
+${toolName}(${input})
+</tool_call>
+</example>`;
+  }
+  return `<example>
+<tool_call>
+${toolName}(${input})
+</tool_call>
+<tool_response>
+${output}
+</tool_response>
+</example>`;
+}
+
+// src/tool-creators.ts
+var availableEnvironmentTools = {
+  [ReadFileToolName]: ReadFileTool,
+  [WriteFileToolName]: WriteFileTool,
+  [DeleteFileToolName]: DeleteFileTool,
+  [EditFileToolName]: EditFileTool,
+  [MoveFileToolName]: MoveFileTool,
+  [CopyFileToolName]: CopyFileTool,
+  [ReadManyFilesToolName]: ReadManyFilesTool,
+  [GetProjectFileStructureToolName]: GetProjectFileStructureTool,
+  [GlobToolName]: GlobTool,
+  [ListDirectoryToolName]: ListDirectoryTool,
+  [RunCommandToolName]: RunCommandTool
+};
+var cliOnlyTools = [
+  GetProjectFileStructureToolName,
+  GlobToolName,
+  ListDirectoryToolName,
+  RunCommandToolName
+];
+var readonlyTools = [
+  ReadFileToolName,
+  ReadManyFilesToolName,
+  GetProjectFileStructureToolName,
+  GlobToolName,
+  ListDirectoryToolName
+];
+var dangerousTools = [
+  DeleteFileToolName,
+  RunCommandToolName
+];
+var EnvironmentToolSafetyLevels = [
+  "readonly",
+  "basic",
+  "all"
+];
+var EnvironmentToolNames = Object.keys(
+  availableEnvironmentTools
+);
+function createEnvironmentTool(toolName, environment, config) {
+  if (!(toolName in availableEnvironmentTools)) {
+    throw new Error(`Unsupported environment: ${toolName}`);
+  }
+  const EnvironmentToolClass = availableEnvironmentTools[toolName];
+  return new EnvironmentToolClass(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    environment,
+    config
+  );
+}
+function createToolsForEnvironment(environment, toolsDefinition = "all") {
+  const sanitizedToolsDefinition = sanitizeToolsDefinition(toolsDefinition);
+  const isCliEnvironment = "runCommand" in environment;
+  const tools = {};
+  for (const toolDefinition of sanitizedToolsDefinition) {
+    const actualToolName = toolDefinition.toolName;
+    if (!isCliEnvironment && cliOnlyTools.includes(actualToolName)) {
+      throw new Error(
+        `The "${actualToolName}" tool can only be used with command-line environments.`
+      );
+    }
+    const toolNameToUse = toolDefinition.toolConfig?.name || toolDefinition.toolName;
+    let toolConfig;
+    if (toolDefinition.toolConfig) {
+      toolConfig = toolDefinition.toolConfig;
+    }
+    if (toolNameToUse in tools) {
+      throw new Error(
+        `Multiple tools named "${toolNameToUse}" are provided - make sure tool names are unique.`
+      );
+    }
+    tools[toolNameToUse] = createEnvironmentTool(
+      actualToolName,
+      isCliEnvironment ? environment : environment,
+      toolConfig
+    );
+  }
+  return tools;
+}
+function createToolsForNamedEnvironment(environmentName, environment, toolsDefinition = "all") {
+  const sanitizedToolsDefinition = sanitizeToolsDefinition(toolsDefinition);
+  const toolsDefinitionWithEnvironmentName = sanitizedToolsDefinition.map(
+    (toolDefinition) => {
+      if (toolDefinition.toolConfig) {
+        const toolNameToUse = toolDefinition.toolConfig.name || toolDefinition.toolName;
+        return {
+          toolName: toolDefinition.toolName,
+          toolConfig: {
+            ...toolDefinition.toolConfig,
+            name: `${toolNameToUse}_in_${environmentName}`
+          }
+        };
+      }
+      return {
+        toolName: toolDefinition.toolName,
+        toolConfig: {
+          name: `${toolDefinition.toolName}_in_${environmentName}`
+        }
+      };
+    }
+  );
+  return createToolsForEnvironment(
+    environment,
+    toolsDefinitionWithEnvironmentName
+  );
+}
+function sanitizeToolsDefinition(toolsDefinition) {
+  if (typeof toolsDefinition === "string") {
+    switch (toolsDefinition) {
+      case "readonly":
+        toolsDefinition = readonlyTools;
+        break;
+      case "basic":
+        toolsDefinition = EnvironmentToolNames.filter(
+          (toolName) => !dangerousTools.includes(toolName)
+        );
+        break;
+      default:
+        toolsDefinition = [...EnvironmentToolNames];
+    }
+  }
+  return toolsDefinition.map((tool) => {
+    if (typeof tool === "string") {
+      return { toolName: tool };
+    }
+    return tool;
+  });
+}
+
+// src/util/get-step-log.ts
+function getStepLog(stepResult) {
+  const { content } = stepResult;
+  let logEntry = "";
+  content.forEach((part) => {
+    logEntry += part.type;
+    if ("toolName" in part && "toolCallId" in part && part.toolCallId) {
+      logEntry += ` (${part.toolName}, ID ${part.toolCallId})`;
+    } else if ("toolName" in part) {
+      logEntry += ` (${part.toolName})`;
+    }
+    logEntry += ": ";
+    if (part.type === "tool-call" && "input" in part) {
+      logEntry += typeof part.input === "string" ? part.input : JSON.stringify(part.input);
+    } else if (part.type === "tool-result" && "output" in part) {
+      logEntry += typeof part.output === "string" ? part.output : JSON.stringify(part.output);
+    } else if (part.type === "tool-error" && "error" in part) {
+      logEntry += typeof part.error === "object" && part.error !== null && "message" in part.error ? part.error.message : String(part.error);
+    } else if (part.type === "text" && "text" in part) {
+      logEntry += part.text;
+    }
+    logEntry += "\n";
+  });
+  return logEntry.trim();
+}
+
+// src/agent-creators.ts
+function createCodeAgent(agentConfig) {
+  const {
+    maxSteps,
+    allowSubmit,
+    logStep,
+    omitAdditionalInstructions,
+    tools: originalTools,
+    stopWhen: originalStopWhen,
+    prepareStep: originalPrepareStep,
+    system: originalSystemInstruction,
+    ...remainingConfig
+  } = agentConfig;
+  let agentSettings;
+  let environmentTools;
+  if ("environments" in remainingConfig) {
+    const { environments, environmentToolsDefinition, ...agentSettingsInput } = remainingConfig;
+    agentSettings = { ...agentSettingsInput };
+    environmentTools = {};
+    for (const [environmentName, environment] of Object.entries(environments)) {
+      if (!(environmentName in environmentToolsDefinition)) {
+        throw new Error(
+          `No tools definition provided for environment "${environmentName}". Please provide a tools definition for each environment.`
+        );
+      }
+      const environmentTools2 = createToolsForNamedEnvironment(
+        environmentName,
+        environment,
+        environmentToolsDefinition[environmentName]
+      );
+      for (const [toolName, tool] of Object.entries(environmentTools2)) {
+        if (toolName in environmentTools2) {
+          throw new Error(
+            `Tool name conflict: The tool name "${toolName}" from environment "${environmentName}" is already used by another environment's tools.`
+          );
+        }
+        environmentTools2[toolName] = tool;
+      }
+    }
+  } else if ("environment" in remainingConfig) {
+    const { environment, environmentToolsDefinition, ...agentSettingsInput } = remainingConfig;
+    agentSettings = { ...agentSettingsInput };
+    environmentTools = createToolsForEnvironment(
+      environment,
+      environmentToolsDefinition
+    );
+  } else {
+    agentSettings = { ...remainingConfig };
+  }
+  const tools = environmentTools && originalTools ? mergeTools(environmentTools, originalTools) : originalTools || environmentTools || {};
+  if (allowSubmit) {
+    if (SubmitToolName in tools) {
+      throw new Error(
+        `Tool name conflict: The Submit tool name "${SubmitToolName}" is already used by another tool.`
+      );
+    }
+    tools[SubmitToolName] = new SubmitTool();
+  }
+  if (Object.keys(tools).length > 0) {
+    agentSettings.tools = tools;
+  }
+  let stepCount = 0;
+  const prepareStep = logStep ? (prepareStepInput) => {
+    const { steps } = prepareStepInput;
+    if (steps.length > 0) {
+      stepCount += 1;
+      const stepLog = getStepLog(steps[steps.length - 1]);
+      logStep(`=== Step ${stepCount} ===
+${stepLog}`, stepCount - 1);
+    }
+    if (originalPrepareStep) {
+      return originalPrepareStep(prepareStepInput);
+    }
+    return void 0;
+  } : originalPrepareStep;
+  const stopWhenCondition = allowSubmit ? [(0, import_ai.stepCountIs)(maxSteps), (0, import_ai.hasToolCall)(SubmitToolName)] : (0, import_ai.stepCountIs)(maxSteps);
+  const stopWhen = originalStopWhen ? mergeStopWhen(originalStopWhen, stopWhenCondition) : stopWhenCondition;
+  const system = !omitAdditionalInstructions ? mergeSystemInstructions(
+    originalSystemInstruction,
+    getAdditionalInstructions({ maxSteps, allowSubmit, tools })
+  ) : originalSystemInstruction;
+  return new import_ai.Experimental_Agent({
+    ...agentSettings,
+    system,
+    prepareStep,
+    stopWhen
+  });
+}
+function mergeTools(baseTools, additionalTools) {
+  const tools = { ...baseTools };
+  for (const [toolName, tool] of Object.entries(additionalTools)) {
+    if (toolName in tools) {
+      throw new Error(
+        `Tool name conflict: The additional tool name "${toolName}" is already used by the code environment tools.`
+      );
+    }
+    tools[toolName] = tool;
+  }
+  return tools;
+}
+function mergeStopWhen(baseStopWhen, additionalStopWhen) {
+  if (Array.isArray(baseStopWhen)) {
+    if (Array.isArray(additionalStopWhen)) {
+      return [...baseStopWhen, ...additionalStopWhen];
+    }
+    return [...baseStopWhen, additionalStopWhen];
+  }
+  if (Array.isArray(additionalStopWhen)) {
+    return [baseStopWhen, ...additionalStopWhen];
+  }
+  return [baseStopWhen, additionalStopWhen];
+}
+function mergeSystemInstructions(baseSystem, additionalInstructions) {
+  if (baseSystem) {
+    return `${baseSystem.trimEnd()}
+
+${additionalInstructions}`;
+  }
+  return additionalInstructions;
+}
+
+// src/environment-creators.ts
+var availableEnvironments = {
+  [UnsafeLocalEnvironmentName]: UnsafeLocalEnvironment,
+  [DockerEnvironmentName]: DockerEnvironment,
+  [MockFilesystemEnvironmentName]: MockFilesystemEnvironment,
+  [NodeFilesystemEnvironmentName]: NodeFilesystemEnvironment
+};
+var EnvironmentNames = Object.keys(
+  availableEnvironments
+);
+function createEnvironment(environmentName, config) {
+  if (!(environmentName in availableEnvironments)) {
+    throw new Error(`Unsupported environment: ${environmentName}`);
+  }
+  const EnvironmentClass = availableEnvironments[environmentName];
+  return new EnvironmentClass(config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CopyFileResult,
+  CopyFileTool,
+  CopyFileToolInput,
+  CopyFileToolName,
+  CopyFileToolOutput,
+  DeleteFileResult,
+  DeleteFileTool,
+  DeleteFileToolInput,
+  DeleteFileToolName,
+  DeleteFileToolOutput,
+  DockerEnvironment,
+  DockerEnvironmentName,
+  EditFileTool,
+  EditFileToolInput,
+  EditFileToolName,
+  EditFileToolOutput,
+  EnvironmentNames,
+  EnvironmentToolNames,
+  EnvironmentToolSafetyLevels,
+  GetProjectFileStructureTool,
+  GetProjectFileStructureToolInput,
+  GetProjectFileStructureToolName,
+  GetProjectFileStructureToolOutput,
+  GlobTool,
+  GlobToolInput,
+  GlobToolName,
+  GlobToolOutput,
+  ListDirectoryTool,
+  ListDirectoryToolInput,
+  ListDirectoryToolName,
+  ListDirectoryToolOutput,
+  MockFilesystemEnvironment,
+  MockFilesystemEnvironmentName,
+  MoveFileResult,
+  MoveFileTool,
+  MoveFileToolInput,
+  MoveFileToolName,
+  MoveFileToolOutput,
+  NodeFilesystemEnvironment,
+  NodeFilesystemEnvironmentName,
+  ReadFileResult,
+  ReadFileTool,
+  ReadFileToolInput,
+  ReadFileToolName,
+  ReadFileToolOutput,
+  ReadManyFilesTool,
+  ReadManyFilesToolInput,
+  ReadManyFilesToolName,
+  ReadManyFilesToolOutput,
+  RunCommandResult,
+  RunCommandTool,
+  RunCommandToolInput,
+  RunCommandToolName,
+  RunCommandToolOutput,
+  UnsafeLocalEnvironment,
+  UnsafeLocalEnvironmentName,
+  WriteFileResult,
+  WriteFileTool,
+  WriteFileToolInput,
+  WriteFileToolName,
+  WriteFileToolOutput,
+  createCodeAgent,
+  createEnvironment,
+  createEnvironmentTool,
+  createToolsForEnvironment,
+  createToolsForNamedEnvironment
+});
+//# sourceMappingURL=index.cjs.map