ai-code-agents 0.1.0-beta.1 → 0.2.0

package/dist/index.cjs

@@ -30,12 +30,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // 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,
@@ -57,20 +55,22 @@ __export(index_exports, {
   GlobToolInput: () => GlobToolInput,
   GlobToolName: () => GlobToolName,
   GlobToolOutput: () => GlobToolOutput,
+  GrepTool: () => GrepTool,
+  GrepToolInput: () => GrepToolInput,
+  GrepToolName: () => GrepToolName,
+  GrepToolOutput: () => GrepToolOutput,
   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,
@@ -79,19 +79,23 @@ __export(index_exports, {
   ReadManyFilesToolInput: () => ReadManyFilesToolInput,
   ReadManyFilesToolName: () => ReadManyFilesToolName,
   ReadManyFilesToolOutput: () => ReadManyFilesToolOutput,
-  RunCommandResult: () => RunCommandResult,
   RunCommandTool: () => RunCommandTool,
   RunCommandToolInput: () => RunCommandToolInput,
   RunCommandToolName: () => RunCommandToolName,
   RunCommandToolOutput: () => RunCommandToolOutput,
+  SubmitTool: () => SubmitTool,
+  SubmitToolInput: () => SubmitToolInput,
+  SubmitToolName: () => SubmitToolName,
+  SubmitToolOutput: () => SubmitToolOutput,
   UnsafeLocalEnvironment: () => UnsafeLocalEnvironment,
   UnsafeLocalEnvironmentName: () => UnsafeLocalEnvironmentName,
-  WriteFileResult: () => WriteFileResult,
   WriteFileTool: () => WriteFileTool,
   WriteFileToolInput: () => WriteFileToolInput,
   WriteFileToolName: () => WriteFileToolName,
   WriteFileToolOutput: () => WriteFileToolOutput,
   createCodeAgent: () => createCodeAgent,
+  createCodeAgentSettings: () => createCodeAgentSettings,
+  createCodeAgentTools: () => createCodeAgentTools,
   createEnvironment: () => createEnvironment,
   createEnvironmentTool: () => createEnvironmentTool,
   createToolsForEnvironment: () => createToolsForEnvironment,
@@ -101,290 +105,17 @@ module.exports = __toCommonJS(index_exports);
 
 // src/environments/docker-environment.ts
 var import_node_child_process = require("child_process");
+var import_environment_utils = require("@ai-code-agents/environment-utils");
 
-// 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/util/escape-command.ts
+function escapeCommand(command) {
+  const escaped = command.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return `"${escaped}"`;
 }
 
-// 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 {
+var DockerEnvironment = class extends import_environment_utils.UnixEnvironmentBase {
   _commandPrefix;
   /**
    * Constructs a new environment instance.
@@ -394,7 +125,7 @@ var DockerEnvironment = class extends UnixEnvironmentBase {
   constructor(config) {
     super(config);
     const { directoryPath } = this._envConfig;
-    this._commandPrefix = directoryPath ? `cd ${escapeCommandArg(directoryPath)} && ` : "";
+    this._commandPrefix = directoryPath ? `cd ${(0, import_environment_utils.escapeCommandArg)(directoryPath)} && ` : "";
   }
   /**
    * Gets the environment name.
@@ -413,7 +144,7 @@ var DockerEnvironment = class extends UnixEnvironmentBase {
   async executeCommand(command) {
     return new Promise((resolve) => {
       (0, import_node_child_process.exec)(
-        `docker exec ${this._envConfig.containerId} ${this._commandPrefix}${command}`,
+        `docker exec ${this._envConfig.containerId} sh -c ${escapeCommand(this._commandPrefix + command)}`,
         (error, stdout, stderr) => {
           const exitCode = error ? error.code ?? 1 : 0;
           resolve([exitCode, stdout, stderr]);
@@ -425,8 +156,9 @@ var DockerEnvironment = class extends UnixEnvironmentBase {
 
 // src/environments/mock-filesystem-environment.ts
 var import_node_path = __toESM(require("path"), 1);
+var import_environment_utils2 = require("@ai-code-agents/environment-utils");
 var MockFilesystemEnvironmentName = "mock-filesystem";
-var MockFilesystemEnvironment = class extends FilesystemEnvironmentBase {
+var MockFilesystemEnvironment = class extends import_environment_utils2.FilesystemEnvironmentBase {
   files;
   _preparePath;
   /**
@@ -437,7 +169,7 @@ var MockFilesystemEnvironment = class extends FilesystemEnvironmentBase {
   constructor(config = {}) {
     super(config);
     const { initialFiles, directoryPath } = this._envConfig;
-    this.files = initialFiles ?? /* @__PURE__ */ new Map();
+    this.files = initialFiles ? new Map(Object.entries(initialFiles)) : /* @__PURE__ */ new Map();
     this._preparePath = directoryPath ? (filePath) => import_node_path.default.join(directoryPath, filePath) : (filePath) => filePath;
   }
   /**
@@ -492,8 +224,9 @@ var MockFilesystemEnvironment = class extends FilesystemEnvironmentBase {
 // src/environments/node-filesystem-environment.ts
 var import_promises = __toESM(require("fs/promises"), 1);
 var import_node_path2 = __toESM(require("path"), 1);
+var import_environment_utils3 = require("@ai-code-agents/environment-utils");
 var NodeFilesystemEnvironmentName = "node-filesystem";
-var NodeFilesystemEnvironment = class extends FilesystemEnvironmentBase {
+var NodeFilesystemEnvironment = class extends import_environment_utils3.FilesystemEnvironmentBase {
   /**
    * Constructs a new NodeFilesystemEnvironment instance.
    *
@@ -587,8 +320,9 @@ var NodeFilesystemEnvironment = class extends FilesystemEnvironmentBase {
 
 // src/environments/unsafe-local-environment.ts
 var import_node_child_process2 = require("child_process");
+var import_environment_utils4 = require("@ai-code-agents/environment-utils");
 var UnsafeLocalEnvironmentName = "unsafe-local";
-var UnsafeLocalEnvironment = class extends UnixEnvironmentBase {
+var UnsafeLocalEnvironment = class extends import_environment_utils4.UnixEnvironmentBase {
   _commandPrefix;
   /**
    * Constructs a new environment instance.
@@ -604,7 +338,7 @@ var UnsafeLocalEnvironment = class extends UnixEnvironmentBase {
       throw new Error('The directory path must be absolute (start with "/")');
     }
     super(config);
-    this._commandPrefix = `cd ${escapeCommandArg(directoryPath)} && `;
+    this._commandPrefix = `cd ${(0, import_environment_utils4.escapeCommandArg)(directoryPath)} && `;
   }
   /**
    * Gets the environment name.
@@ -632,173 +366,7 @@ var UnsafeLocalEnvironment = class extends UnixEnvironmentBase {
 
 // 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 import_environment_utils5 = require("@ai-code-agents/environment-utils");
 var CopyFileToolName = "copy_file";
 var CopyFileToolInput = import_zod.z.object({
   sourcePath: import_zod.z.string().meta({
@@ -808,8 +376,8 @@ var CopyFileToolInput = import_zod.z.object({
     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 {
+var CopyFileToolOutput = import_environment_utils5.CopyFileResult;
+var CopyFileTool = class extends import_environment_utils5.EnvironmentToolBase {
   /**
    * Returns the metadata for the tool.
    *
@@ -839,10 +407,11 @@ var CopyFileTool = class extends EnvironmentToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param output - The output from the tool execution.
+   * @param options - The tool result, including the output from the tool execution.
    * @returns The formatted tool result.
    */
-  toModelOutput(output) {
+  toModelOutput(options) {
+    const { output } = options;
     return {
       type: "text",
       value: `File \`${output.sourcePath}\` copied successfully to \`${output.destinationPath}\`.`
@@ -868,14 +437,15 @@ var CopyFileTool = class extends EnvironmentToolBase {
 
 // src/tools/delete-file-tool.ts
 var import_zod2 = require("zod");
+var import_environment_utils6 = require("@ai-code-agents/environment-utils");
 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 {
+var DeleteFileToolOutput = import_environment_utils6.DeleteFileResult;
+var DeleteFileTool = class extends import_environment_utils6.EnvironmentToolBase {
   /**
    * Returns the metadata for the tool.
    *
@@ -905,10 +475,11 @@ var DeleteFileTool = class extends EnvironmentToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param output - The output from the tool execution.
+   * @param options - The tool result, including the output from the tool execution.
    * @returns The formatted tool result.
    */
-  toModelOutput(output) {
+  toModelOutput(options) {
+    const { output } = options;
     return {
       type: "text",
       value: `File \`${output.path}\` deleted successfully.`
@@ -933,6 +504,7 @@ var DeleteFileTool = class extends EnvironmentToolBase {
 
 // src/tools/edit-file-tool.ts
 var import_zod3 = require("zod");
+var import_environment_utils7 = require("@ai-code-agents/environment-utils");
 var EditFileToolName = "edit_file";
 var EditFileToolInput = import_zod3.z.object({
   path: import_zod3.z.string().meta({
@@ -965,10 +537,10 @@ var EditFileToolOutput = import_zod3.z.object({
     description: "A message indicating the result of the edit operation."
   })
 });
-function escapeRegExp(string2) {
-  return string2.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-var EditFileTool = class extends EnvironmentToolBase {
+var EditFileTool = class extends import_environment_utils7.EnvironmentToolBase {
   /**
    * Returns the metadata for the tool.
    *
@@ -1023,10 +595,11 @@ var EditFileTool = class extends EnvironmentToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param output - The output from the tool execution.
+   * @param options - The tool result, including the output from the tool execution.
    * @returns The formatted tool result.
    */
-  toModelOutput(output) {
+  toModelOutput(options) {
+    const { output } = options;
     return {
       type: "text",
       value: `Edited file \`${output.path}\` with ${output.replacements} replacement(s).`
@@ -1075,6 +648,7 @@ var EditFileTool = class extends EnvironmentToolBase {
 
 // src/tools/get-project-file-structure-tool.ts
 var import_zod4 = require("zod");
+var import_environment_utils9 = require("@ai-code-agents/environment-utils");
 
 // src/util/build-tree-from-files.ts
 function renderTree(node, prefix = "") {
@@ -1111,6 +685,91 @@ function buildTreeFromFiles(files) {
   return renderTree(tree).trim();
 }
 
+// src/util/get-gitignored-paths.ts
+var import_node_path3 = __toESM(require("path"), 1);
+var import_environment_utils8 = require("@ai-code-agents/environment-utils");
+async function getGitIgnoredPaths(env) {
+  const gitignorePath = await getClosestGitIgnorePath(env);
+  if (!gitignorePath) {
+    return [];
+  }
+  const { stdout: pwd } = await env.runCommand("pwd");
+  const currentDir = pwd.trim();
+  const gitignoreDir = import_node_path3.default.dirname(gitignorePath);
+  try {
+    const { stdout, exitCode } = await env.runCommand(
+      `cat ${(0, import_environment_utils8.escapeCommandArg)(gitignorePath)}`
+    );
+    if (exitCode !== 0) {
+      return [];
+    }
+    const rawRules = stdout.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+    const relPath = import_node_path3.default.relative(gitignoreDir, currentDir);
+    if (relPath === "") {
+      return rawRules.map(
+        (rule) => rule.startsWith("/") ? rule.slice(1) : rule
+      );
+    }
+    const relPathSegments = relPath.split(import_node_path3.default.sep);
+    const sanitizedRules = [];
+    for (const rule of rawRules) {
+      const isAnchored = rule.startsWith("/") || rule.includes("/") && rule.indexOf("/") !== rule.length - 1;
+      if (!isAnchored || rule.startsWith("**/")) {
+        sanitizedRules.push(rule.startsWith("**/") ? rule.slice(3) : rule);
+        continue;
+      }
+      const normalizedRule = rule.startsWith("/") ? rule.slice(1) : rule;
+      const cleanRule = normalizedRule.endsWith("/") ? normalizedRule.slice(0, -1) : normalizedRule;
+      const ruleSegments = cleanRule.split("/");
+      let matches = true;
+      let i = 0;
+      for (; i < relPathSegments.length; i++) {
+        if (i >= ruleSegments.length) {
+          sanitizedRules.push(".");
+          matches = false;
+          break;
+        }
+        if (!matchSegment(ruleSegments[i], relPathSegments[i])) {
+          matches = false;
+          break;
+        }
+      }
+      if (matches) {
+        const remaining = ruleSegments.slice(i).join("/");
+        if (remaining) {
+          sanitizedRules.push(
+            normalizedRule.endsWith("/") && !remaining.endsWith("/") ? `${remaining}/` : remaining
+          );
+        } else {
+          sanitizedRules.push(".");
+        }
+      }
+    }
+    return [...new Set(sanitizedRules)];
+  } catch (_error) {
+    return [];
+  }
+}
+function matchSegment(pattern, segment) {
+  if (pattern === "*") {
+    return true;
+  }
+  if (pattern === segment) {
+    return true;
+  }
+  if (pattern.includes("*") || pattern.includes("?")) {
+    const regexStr = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+    const regex = new RegExp(`^${regexStr}$`);
+    return regex.test(segment);
+  }
+  return false;
+}
+async function getClosestGitIgnorePath(env) {
+  const command = 'd=$PWD; while [ -n "$d" ] && [ ! -f "$d/.gitignore" ]; do d=${d%/*}; done; [ -f "$d/.gitignore" ] && echo "$d/.gitignore"';
+  const { stdout } = await env.runCommand(command);
+  return stdout.trim();
+}
+
 // src/tools/get-project-file-structure-tool.ts
 var GetProjectFileStructureToolName = "get_project_file_structure";
 var GetProjectFileStructureToolInput = import_zod4.z.object({
@@ -1129,7 +788,7 @@ var GetProjectFileStructureToolOutput = import_zod4.z.object({
     description: "Whether files ignored by Git were excluded."
   })
 });
-var GetProjectFileStructureTool = class extends EnvironmentToolBase {
+var GetProjectFileStructureTool = class extends import_environment_utils9.EnvironmentToolBase {
   /**
    * Returns the metadata for the tool.
    *
@@ -1155,21 +814,16 @@ var GetProjectFileStructureTool = class extends EnvironmentToolBase {
    */
   async executeForEnvironment(env, input) {
     const { path: path5 = ".", excludeGitIgnored = true } = input;
-    const escapedPath = escapeCommandArg(path5);
+    const escapedPath = (0, import_environment_utils9.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) {
-      }
+      const gitIgnoredPaths = await getGitIgnoredPaths(env);
       for (const gitIgnoredPath of gitIgnoredPaths) {
         if (!gitIgnoredPath.endsWith("/")) {
-          const escapedPath2 = escapeCommandArg(`*/${gitIgnoredPath}/*`);
-          command += ` -not -name ${escapeCommandArg(gitIgnoredPath)} -not -path ${escapedPath2}`;
+          const escapedPath2 = (0, import_environment_utils9.escapeCommandArg)(`*/${gitIgnoredPath}/*`);
+          command += ` -not -name ${(0, import_environment_utils9.escapeCommandArg)(gitIgnoredPath)} -not -path ${escapedPath2}`;
         } else {
-          const escapedPath2 = escapeCommandArg(`*/${gitIgnoredPath}*`);
+          const escapedPath2 = (0, import_environment_utils9.escapeCommandArg)(`*/${gitIgnoredPath}*`);
           command += ` -not -path ${escapedPath2}`;
         }
       }
@@ -1191,10 +845,11 @@ var GetProjectFileStructureTool = class extends EnvironmentToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param output - The output from the tool execution.
+   * @param options - The tool result, including the output from the tool execution.
    * @returns The formatted tool result.
    */
-  toModelOutput(output) {
+  toModelOutput(options) {
+    const { output } = options;
     const tree = buildTreeFromFiles(output.files);
     if (!tree) {
       return {
@@ -1233,6 +888,7 @@ var GetProjectFileStructureTool = class extends EnvironmentToolBase {
 
 // src/tools/glob-tool.ts
 var import_zod5 = require("zod");
+var import_environment_utils10 = require("@ai-code-agents/environment-utils");
 
 // src/util/glob-to-reg-exp.ts
 function globToRegExp(glob) {
@@ -1305,7 +961,7 @@ var GlobToolOutput = import_zod5.z.object({
     description: "The list of file paths that matched the glob search, relative to the project directory."
   })
 });
-var GlobTool = class extends EnvironmentToolBase {
+var GlobTool = class extends import_environment_utils10.EnvironmentToolBase {
   /**
    * Returns the metadata for the tool.
    *
@@ -1337,24 +993,19 @@ var GlobTool = class extends EnvironmentToolBase {
       );
     }
     if (searchPath) {
-      validateRelativePath(searchPath);
+      (0, import_environment_utils10.validateRelativePath)(searchPath);
     }
     const untrailingslashedSearchPath = searchPath === "" ? "." : searchPath.replace(/\/+$/, "");
-    const escapedSearchPath = escapeCommandArg(untrailingslashedSearchPath);
+    const escapedSearchPath = (0, import_environment_utils10.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) {
-      }
+      const gitIgnoredPaths = await getGitIgnoredPaths(env);
       for (const gitIgnoredPath of gitIgnoredPaths) {
         if (!gitIgnoredPath.endsWith("/")) {
-          const escapedPath = escapeCommandArg(`*/${gitIgnoredPath}/*`);
-          command += ` -not -name ${escapeCommandArg(gitIgnoredPath)} -not -path ${escapedPath}`;
+          const escapedPath = (0, import_environment_utils10.escapeCommandArg)(`*/${gitIgnoredPath}/*`);
+          command += ` -not -name ${(0, import_environment_utils10.escapeCommandArg)(gitIgnoredPath)} -not -path ${escapedPath}`;
         } else {
-          const escapedPath = escapeCommandArg(`*/${gitIgnoredPath}*`);
+          const escapedPath = (0, import_environment_utils10.escapeCommandArg)(`*/${gitIgnoredPath}*`);
           command += ` -not -path ${escapedPath}`;
         }
       }
@@ -1390,10 +1041,11 @@ var GlobTool = class extends EnvironmentToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param output - The output from the tool execution.
+   * @param options - The tool result, including the output from the tool execution.
    * @returns The formatted tool result.
    */
-  toModelOutput(output) {
+  toModelOutput(options) {
+    const { output } = options;
     if (output.matchingPaths.length === 0) {
       return {
         type: "text",
@@ -1442,26 +1094,287 @@ ${bulletPoints}
   }
 };
 
-// src/tools/list-directory-tool.ts
+// src/tools/grep-tool.ts
 var import_zod6 = require("zod");
-var ListDirectoryToolName = "list_directory";
-var ListDirectoryToolInput = import_zod6.z.object({
+var import_environment_utils11 = require("@ai-code-agents/environment-utils");
+var GrepToolName = "grep";
+var GrepToolInput = import_zod6.z.object({
+  regexpPattern: import_zod6.z.string().meta({
+    description: "The regular expression pattern to search for in file contents."
+  }),
+  searchPattern: import_zod6.z.string().optional().meta({
+    description: 'The glob pattern to filter which files are searched (e.g. "**/*.ts"). If omitted, searches all files.'
+  }),
+  searchPath: import_zod6.z.string().optional().meta({
+    description: "The path to search within, relative to the project directory. Defaults to the project directory."
+  }),
+  contextLines: import_zod6.z.number().int().nonnegative().optional().meta({
+    description: "The number of context lines to include before and after each match."
+  })
+});
+var GrepMatch = import_zod6.z.object({
   path: import_zod6.z.string().meta({
+    description: "The path to the file containing the match, relative to the project directory."
+  }),
+  lineNumber: import_zod6.z.number().int().meta({
+    description: "The line number of the match (1-based)."
+  }),
+  line: import_zod6.z.string().meta({
+    description: "The content of the matching line."
+  }),
+  beforeContext: import_zod6.z.array(import_zod6.z.string()).optional().meta({
+    description: "Lines of context before the match."
+  }),
+  afterContext: import_zod6.z.array(import_zod6.z.string()).optional().meta({
+    description: "Lines of context after the match."
+  })
+});
+var GrepToolOutput = import_zod6.z.object({
+  regexpPattern: import_zod6.z.string().meta({
+    description: "The regular expression pattern that was searched for."
+  }),
+  searchPattern: import_zod6.z.string().optional().meta({
+    description: "The glob pattern used to filter files."
+  }),
+  searchPath: import_zod6.z.string().optional().meta({
+    description: "The path that was searched within."
+  }),
+  contextLines: import_zod6.z.number().optional().meta({
+    description: "The number of context lines included."
+  }),
+  matches: import_zod6.z.array(GrepMatch).meta({
+    description: "The list of matches found."
+  })
+});
+var GrepTool = class extends import_environment_utils11.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: GrepToolName,
+      description: "Searches for a regular expression pattern within the content of files in the project.",
+      inputSchema: GrepToolInput,
+      outputSchema: GrepToolOutput,
+      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 {
+      regexpPattern,
+      searchPattern,
+      searchPath = "",
+      contextLines = 0
+    } = input;
+    if (searchPath) {
+      (0, import_environment_utils11.validateRelativePath)(searchPath);
+    }
+    const globTool = new GlobTool(env);
+    const globResult = await globTool.execute(
+      {
+        searchPattern: searchPattern || "**/*",
+        searchPath
+      },
+      {}
+    );
+    const filesToSearch = globResult.matchingPaths;
+    if (filesToSearch.length === 0) {
+      return {
+        regexpPattern,
+        searchPattern,
+        searchPath,
+        contextLines,
+        matches: []
+      };
+    }
+    const BATCH_SIZE = 50;
+    const matches = [];
+    for (let i = 0; i < filesToSearch.length; i += BATCH_SIZE) {
+      const batch = filesToSearch.slice(i, i + BATCH_SIZE);
+      const escapedFilePaths = batch.map(import_environment_utils11.escapeCommandArg).join(" ");
+      const command = `grep -n -H -I -E ${(0, import_environment_utils11.escapeCommandArg)(regexpPattern)} ${escapedFilePaths}`;
+      const { stdout, exitCode } = await env.runCommand(command);
+      if (exitCode > 1) {
+        throw new Error(`Failed to execute grep command "${command}".`);
+      }
+      if (stdout) {
+        const lines = stdout.split("\n");
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          const firstColonIndex = line.indexOf(":");
+          if (firstColonIndex === -1) continue;
+          const secondColonIndex = line.indexOf(":", firstColonIndex + 1);
+          if (secondColonIndex === -1) continue;
+          const filePath = line.substring(0, firstColonIndex);
+          const lineNumberStr = line.substring(
+            firstColonIndex + 1,
+            secondColonIndex
+          );
+          const content = line.substring(secondColonIndex + 1);
+          const lineNumber = parseInt(lineNumberStr, 10);
+          if (isNaN(lineNumber)) continue;
+          matches.push({
+            path: filePath,
+            lineNumber,
+            line: content
+          });
+        }
+      }
+    }
+    if (contextLines > 0 && matches.length > 0) {
+      const matchesByFile = /* @__PURE__ */ new Map();
+      for (const match of matches) {
+        if (!matchesByFile.has(match.path)) {
+          matchesByFile.set(match.path, []);
+        }
+        matchesByFile.get(match.path).push(match);
+      }
+      for (const [filePath, fileMatches] of matchesByFile) {
+        try {
+          const { content } = await env.readFile(filePath);
+          const lines = content.split("\n");
+          for (const match of fileMatches) {
+            const lineIndex = match.lineNumber - 1;
+            const start = Math.max(0, lineIndex - contextLines);
+            const end = Math.min(lines.length, lineIndex + contextLines + 1);
+            match.beforeContext = lines.slice(start, lineIndex);
+            match.afterContext = lines.slice(lineIndex + 1, end);
+          }
+        } catch (_error) {
+        }
+      }
+    }
+    return {
+      regexpPattern,
+      searchPattern,
+      searchPath,
+      contextLines,
+      matches
+    };
+  }
+  /**
+   * Converts the tool output to a format suitable for model consumption.
+   *
+   * @param options - The tool result, including the output from the tool execution.
+   * @returns The formatted tool result.
+   */
+  toModelOutput(options) {
+    const { output } = options;
+    if (output.matches.length === 0) {
+      return {
+        type: "text",
+        value: "No matches found."
+      };
+    }
+    let result = `Found ${output.matches.length} matches:
+`;
+    const matchesByFile = /* @__PURE__ */ new Map();
+    for (const match of output.matches) {
+      if (!matchesByFile.has(match.path)) {
+        matchesByFile.set(match.path, []);
+      }
+      matchesByFile.get(match.path).push(match);
+    }
+    for (const [filePath, matches] of matchesByFile) {
+      result += `
+File: ${filePath}
+`;
+      for (const match of matches) {
+        if (match.beforeContext && match.beforeContext.length > 0) {
+          match.beforeContext.forEach((line, idx) => {
+            result += `  ${match.lineNumber - match.beforeContext.length + idx}: ${line}
+`;
+          });
+        }
+        result += `> ${match.lineNumber}: ${match.line}
+`;
+        if (match.afterContext && match.afterContext.length > 0) {
+          match.afterContext.forEach((line, idx) => {
+            result += `  ${match.lineNumber + 1 + idx}: ${line}
+`;
+          });
+        }
+        if (output.contextLines && output.contextLines > 0) {
+          result += "---\n";
+        }
+      }
+    }
+    return {
+      type: "text",
+      value: result
+    };
+  }
+  /**
+   * Gets the examples for the tool.
+   *
+   * @returns The tool examples.
+   */
+  get examples() {
+    return [
+      {
+        input: {
+          regexpPattern: "interface.*Tool",
+          searchPattern: "src/**/*.ts"
+        },
+        output: `Found 2 matches:
+
+File: src/types.ts
+> 120: export interface ToolInterface<ToolInputType, ToolOutputType> {
+> 135: export interface EnvironmentToolInterface<
+
+File: src/tools/tool-base.ts
+> 10: export abstract class ToolBase<
+`
+      },
+      {
+        input: {
+          regexpPattern: "TODO",
+          contextLines: 1
+        },
+        output: `Found 1 matches:
+
+File: src/index.ts
+  10: // Some code before
+> 11: // TODO: Implement feature X
+  12: // Some code after
+`
+      }
+    ];
+  }
+};
+
+// src/tools/list-directory-tool.ts
+var import_zod7 = require("zod");
+var import_environment_utils12 = require("@ai-code-agents/environment-utils");
+var ListDirectoryToolName = "list_directory";
+var ListDirectoryToolInput = import_zod7.z.object({
+  path: import_zod7.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({
+var ListDirectoryToolOutput = import_zod7.z.object({
+  path: import_zod7.z.string().meta({
     description: "The directory path that was listed."
   }),
-  files: import_zod6.z.array(import_zod6.z.string()).meta({
+  files: import_zod7.z.array(import_zod7.z.string()).meta({
     description: "List of files in the directory."
   }),
-  directories: import_zod6.z.array(import_zod6.z.string()).meta({
+  directories: import_zod7.z.array(import_zod7.z.string()).meta({
     description: "List of subdirectories in the directory."
   })
 });
-var ListDirectoryTool = class extends EnvironmentToolBase {
+var ListDirectoryTool = class extends import_environment_utils12.EnvironmentToolBase {
   /**
    * Returns the metadata for the tool.
    *
@@ -1486,7 +1399,7 @@ var ListDirectoryTool = class extends EnvironmentToolBase {
    * @returns A promise that resolves to the tool execution result.
    */
   async executeForEnvironment(env, input) {
-    const escapedPath = escapeCommandArg(input.path);
+    const escapedPath = (0, import_environment_utils12.escapeCommandArg)(input.path);
     const command = `ls -la ${escapedPath}`;
     const { stdout, stderr, exitCode } = await env.runCommand(command);
     if (exitCode !== 0) {
@@ -1519,10 +1432,11 @@ var ListDirectoryTool = class extends EnvironmentToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param output - The output from the tool execution.
+   * @param options - The tool result, including the output from the tool execution.
    * @returns The formatted tool result.
    */
-  toModelOutput(output) {
+  toModelOutput(options) {
+    const { output } = options;
     const formatEntries = (entries, type) => {
       if (entries.length === 0) {
         return `No ${type} found.`;
@@ -1568,18 +1482,19 @@ Directories:
 };
 
 // src/tools/move-file-tool.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
+var import_environment_utils13 = require("@ai-code-agents/environment-utils");
 var MoveFileToolName = "move_file";
-var MoveFileToolInput = import_zod7.z.object({
-  sourcePath: import_zod7.z.string().meta({
+var MoveFileToolInput = import_zod8.z.object({
+  sourcePath: import_zod8.z.string().meta({
     description: "The path to the file to move, relative to the project directory."
   }),
-  destinationPath: import_zod7.z.string().meta({
+  destinationPath: import_zod8.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 {
+var MoveFileToolOutput = import_environment_utils13.MoveFileResult;
+var MoveFileTool = class extends import_environment_utils13.EnvironmentToolBase {
   /**
    * Returns the metadata for the tool.
    *
@@ -1609,10 +1524,11 @@ var MoveFileTool = class extends EnvironmentToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param output - The output from the tool execution.
+   * @param options - The tool result, including the output from the tool execution.
    * @returns The formatted tool result.
    */
-  toModelOutput(output) {
+  toModelOutput(options) {
+    const { output } = options;
     return {
       type: "text",
       value: `File \`${output.sourcePath}\` moved successfully to \`${output.destinationPath}\`.`
@@ -1637,10 +1553,11 @@ var MoveFileTool = class extends EnvironmentToolBase {
 };
 
 // src/tools/read-file-tool.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
+var import_environment_utils14 = require("@ai-code-agents/environment-utils");
 
 // src/util/get-language-identifier-from-file-path.ts
-var import_node_path3 = __toESM(require("path"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
 var jsLanguage = {
   identifier: "javascript",
   name: "JavaScript",
@@ -1790,7 +1707,7 @@ var EXTENSION_TO_LANGUAGE = {
   }
 };
 function getLanguageFromFilePath(filePath) {
-  const extension = import_node_path3.default.extname(filePath).slice(1).toLowerCase() || "";
+  const extension = import_node_path4.default.extname(filePath).slice(1).toLowerCase() || "";
   return EXTENSION_TO_LANGUAGE[extension];
 }
 function getLanguageIdentifierFromFilePath(filePath) {
@@ -1800,12 +1717,12 @@ function getLanguageIdentifierFromFilePath(filePath) {
 
 // src/tools/read-file-tool.ts
 var ReadFileToolName = "read_file";
-var ReadFileToolInput = import_zod8.z.object({
-  path: import_zod8.z.string().meta({
+var ReadFileToolInput = import_zod9.z.object({
+  path: import_zod9.z.string().meta({
     description: "The path to the file to read, relative to the project directory."
   })
 });
-var ReadFileToolOutput = ReadFileResult;
+var ReadFileToolOutput = import_environment_utils14.ReadFileResult;
 var formatModelResponse = (output) => {
   const language = getLanguageIdentifierFromFilePath(output.path);
   return `File: \`${output.path}\`
@@ -1815,7 +1732,7 @@ ${output.content}
 \`\`\`
 `;
 };
-var ReadFileTool = class extends EnvironmentToolBase {
+var ReadFileTool = class extends import_environment_utils14.EnvironmentToolBase {
   /**
    * Returns the metadata for the tool.
    *
@@ -1845,10 +1762,11 @@ var ReadFileTool = class extends EnvironmentToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param output - The output from the tool execution.
+   * @param options - The tool result, including the output from the tool execution.
    * @returns The formatted tool result.
    */
-  toModelOutput(output) {
+  toModelOutput(options) {
+    const { output } = options;
     return {
       type: "text",
       value: formatModelResponse(output)
@@ -1891,14 +1809,15 @@ export function Loader(props: LoaderProps) {
 };
 
 // src/tools/read-many-files-tool.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
+var import_environment_utils15 = require("@ai-code-agents/environment-utils");
 var ReadManyFilesToolName = "read_many_files";
-var ReadManyFilesToolInput = import_zod9.z.object({
-  paths: import_zod9.z.array(import_zod9.z.string()).meta({
+var ReadManyFilesToolInput = import_zod10.z.object({
+  paths: import_zod10.z.array(import_zod10.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 ReadManyFilesToolOutput = import_zod10.z.record(import_zod10.z.string(), import_environment_utils15.ReadFileResult);
 var formatModelResponse2 = (output) => {
   const language = getLanguageIdentifierFromFilePath(output.path);
   return `File: \`${output.path}\`
@@ -1908,7 +1827,7 @@ ${output.content}
 \`\`\`
 `;
 };
-var ReadManyFilesTool = class extends EnvironmentToolBase {
+var ReadManyFilesTool = class extends import_environment_utils15.EnvironmentToolBase {
   /**
    * Returns the metadata for the tool.
    *
@@ -1944,10 +1863,11 @@ var ReadManyFilesTool = class extends EnvironmentToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param output - The output from the tool execution.
+   * @param options - The tool result, including the output from the tool execution.
    * @returns The formatted tool result.
    */
-  toModelOutput(output) {
+  toModelOutput(options) {
+    const { output } = options;
     const fileContentResponses = Object.values(output).map(
       (fileResult) => formatModelResponse2(fileResult)
     );
@@ -2003,12 +1923,13 @@ export function Loader(props: LoaderProps) {
 };
 
 // src/tools/run-command-tool.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
+var import_environment_utils16 = require("@ai-code-agents/environment-utils");
 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 RunCommandToolInput = import_zod11.z.object({
+  command: import_zod11.z.string().meta({ description: "The CLI command to run, including all arguments." })
 });
-var RunCommandToolOutput = RunCommandResult;
+var RunCommandToolOutput = import_environment_utils16.RunCommandResult;
 function formatCommandResultToModelResponse(output) {
   const stdout = !output.stdout.trim() ? "(none)" : `
 \`\`\`
@@ -2024,7 +1945,7 @@ Output (stdout): ${stdout}
 Error Output (stderr): ${stderr}
 `;
 }
-var RunCommandTool = class extends EnvironmentToolBase {
+var RunCommandTool = class extends import_environment_utils16.EnvironmentToolBase {
   /**
    * Returns the metadata for the tool.
    *
@@ -2054,10 +1975,11 @@ var RunCommandTool = class extends EnvironmentToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param output - The output from the tool execution.
+   * @param options - The tool result, including the output from the tool execution.
    * @returns The formatted tool result.
    */
-  toModelOutput(output) {
+  toModelOutput(options) {
+    const { output } = options;
     return {
       type: "text",
       value: formatCommandResultToModelResponse(output)
@@ -2128,18 +2050,19 @@ added 1 package, and changed 1 package in 2s
 };
 
 // src/tools/write-file-tool.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
+var import_environment_utils17 = require("@ai-code-agents/environment-utils");
 var WriteFileToolName = "write_file";
-var WriteFileToolInput = import_zod11.z.object({
-  path: import_zod11.z.string().meta({
+var WriteFileToolInput = import_zod12.z.object({
+  path: import_zod12.z.string().meta({
     description: "The path to the file to write, relative to the project directory."
   }),
-  content: import_zod11.z.string().meta({
+  content: import_zod12.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 {
+var WriteFileToolOutput = import_environment_utils17.WriteFileResult;
+var WriteFileTool = class extends import_environment_utils17.EnvironmentToolBase {
   /**
    * Returns the metadata for the tool.
    *
@@ -2169,10 +2092,11 @@ var WriteFileTool = class extends EnvironmentToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param output - The output from the tool execution.
+   * @param options - The tool result, including the output from the tool execution.
    * @returns The formatted tool result.
    */
-  toModelOutput(output) {
+  toModelOutput(options) {
+    const { output } = options;
     return {
       type: "text",
       value: `File \`${output.path}\` written successfully.`
@@ -2200,15 +2124,13 @@ var WriteFileTool = class extends EnvironmentToolBase {
   }
 };
 
-// src/agent-creators.ts
-var import_ai = require("ai");
-
 // src/tools/submit-tool.ts
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
+var import_environment_utils18 = require("@ai-code-agents/environment-utils");
 var SubmitToolName = "submit";
-var SubmitToolInput = import_zod12.z.object({});
-var SubmitToolOutput = import_zod12.z.object({});
-var SubmitTool = class extends ToolBase {
+var SubmitToolInput = import_zod13.z.object({});
+var SubmitToolOutput = import_zod13.z.object({});
+var SubmitTool = class extends import_environment_utils18.ToolBase {
   /**
    * Returns the metadata for the tool.
    *
@@ -2229,7 +2151,7 @@ var SubmitTool = class extends ToolBase {
    * Executes the tool with the given input.
    *
    * @param _ - The input for the tool. Unused.
-   * @param __ - Options from the tool call. Unused.
+   * @param __ - Options for the tool execution. Unused.
    * @returns A promise that resolves to the tool execution result.
    */
   async execute(_, __) {
@@ -2238,7 +2160,7 @@ var SubmitTool = class extends ToolBase {
   /**
    * Converts the tool output to a format suitable for model consumption.
    *
-   * @param _ - The output from the tool execution. Unused.
+   * @param _ - The tool result, including the output from the tool execution. Unused.
    * @returns The formatted tool result.
    */
   toModelOutput(_) {
@@ -2257,13 +2179,19 @@ var SubmitTool = class extends ToolBase {
   }
 };
 
+// src/agent-creators.ts
+var import_ai = require("ai");
+
 // src/instructions.ts
 function getAdditionalInstructions(config) {
   const { maxSteps, allowSubmit, tools } = config;
-  const exampleSections = [];
+  const exampleSections = [
+    "# Tool Examples",
+    "You have access to several tools to assist you in completing your task. Here are some examples of how to use them:"
+  ];
   for (const [toolName, tool] of Object.entries(tools)) {
     if ("examples" in tool && Array.isArray(tool.examples) && tool.examples.length > 0) {
-      let toolSection = `### Tool: \`${toolName}\`
+      let toolSection = `## Tool: \`${toolName}\`
 
 `;
       for (const example of tool.examples) {
@@ -2272,40 +2200,48 @@ function getAdditionalInstructions(config) {
       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.
+  const constraintSections = ["# Behavioral Guidelines"];
+  const constraintsByType = getCodeAgentConstraints({ maxSteps, allowSubmit });
+  if (constraintsByType.must && constraintsByType.must.length > 0) {
+    let constraintSection = "## You MUST:\n\n";
+    for (const constraint of constraintsByType.must) {
+      constraintSection += `- ${constraint}
 `;
-  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;
+    }
+    constraintSections.push(constraintSection.trim());
+  }
+  if (constraintsByType.must_not && constraintsByType.must_not.length > 0) {
+    let constraintSection = "## You MUST NOT:\n\n";
+    for (const constraint of constraintsByType.must_not) {
+      constraintSection += `- ${constraint}
+`;
+    }
+    constraintSections.push(constraintSection.trim());
+  }
+  if (constraintsByType.should && constraintsByType.should.length > 0) {
+    let constraintSection = "## You SHOULD:\n\n";
+    for (const constraint of constraintsByType.should) {
+      constraintSection += `- ${constraint}
+`;
+    }
+    constraintSections.push(constraintSection.trim());
+  }
+  if (constraintsByType.should_not && constraintsByType.should_not.length > 0) {
+    let constraintSection = "## You SHOULD NOT:\n\n";
+    for (const constraint of constraintsByType.should_not) {
+      constraintSection += `- ${constraint}
+`;
+    }
+    constraintSections.push(constraintSection.trim());
   }
-  return importantWorkflowGuidelines;
+  const finalReminder = getCodeAgentFinalReminder();
+  return [...exampleSections, ...constraintSections, finalReminder].join(
+    "\n\n"
+  );
 }
 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);
+  const input = formatValueForExample(example.input);
+  const output = formatValueForExample(example.output);
   if (output === "") {
     return `<example>
 <tool_call>
@@ -2322,8 +2258,40 @@ ${output}
 </tool_response>
 </example>`;
 }
+function formatValueForExample(value) {
+  if (typeof value === "undefined") {
+    return "";
+  }
+  if (typeof value === "string") {
+    return `"${value}"`;
+  }
+  if (typeof value === "number") {
+    return value.toString();
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  return JSON.stringify(value, null, 2);
+}
+function getCodeAgentConstraints(config) {
+  const { maxSteps, allowSubmit } = config;
+  return {
+    must: [
+      "Always issue tool calls to complete your task",
+      ...allowSubmit ? [
+        `Call the \`${SubmitToolName}\` tool once you think you have completed your task, to submit your results`
+      ] : [],
+      `Complete your task within ${maxSteps} steps`
+    ],
+    must_not: ["Engage with the user directly"]
+  };
+}
+function getCodeAgentFinalReminder() {
+  return "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.";
+}
 
 // src/tool-creators.ts
+var import_environment_utils19 = require("@ai-code-agents/environment-utils");
 var availableEnvironmentTools = {
   [ReadFileToolName]: ReadFileTool,
   [WriteFileToolName]: WriteFileTool,
@@ -2334,12 +2302,14 @@ var availableEnvironmentTools = {
   [ReadManyFilesToolName]: ReadManyFilesTool,
   [GetProjectFileStructureToolName]: GetProjectFileStructureTool,
   [GlobToolName]: GlobTool,
+  [GrepToolName]: GrepTool,
   [ListDirectoryToolName]: ListDirectoryTool,
   [RunCommandToolName]: RunCommandTool
 };
 var cliOnlyTools = [
   GetProjectFileStructureToolName,
   GlobToolName,
+  GrepToolName,
   ListDirectoryToolName,
   RunCommandToolName
 ];
@@ -2348,6 +2318,7 @@ var readonlyTools = [
   ReadManyFilesToolName,
   GetProjectFileStructureToolName,
   GlobToolName,
+  GrepToolName,
   ListDirectoryToolName
 ];
 var dangerousTools = [
@@ -2375,7 +2346,7 @@ function createEnvironmentTool(toolName, environment, config) {
 }
 function createToolsForEnvironment(environment, toolsDefinition = "all") {
   const sanitizedToolsDefinition = sanitizeToolsDefinition(toolsDefinition);
-  const isCliEnvironment = "runCommand" in environment;
+  const isCliEnvironment = (0, import_environment_utils19.isCommandLine)(environment);
   const tools = {};
   for (const toolDefinition of sanitizedToolsDefinition) {
     const actualToolName = toolDefinition.toolName;
@@ -2396,7 +2367,7 @@ function createToolsForEnvironment(environment, toolsDefinition = "all") {
     }
     tools[toolNameToUse] = createEnvironmentTool(
       actualToolName,
-      isCliEnvironment ? environment : environment,
+      environment,
       toolConfig
     );
   }
@@ -2452,6 +2423,54 @@ function sanitizeToolsDefinition(toolsDefinition) {
   });
 }
 
+// src/util/truncate.ts
+function truncateString(str) {
+  const lines = str.split("\n");
+  while (lines.length > 0 && lines[lines.length - 1] === "") {
+    lines.pop();
+  }
+  const isMultiline = lines.length > 1;
+  if (isMultiline) {
+    if (lines.length > 5) {
+      const truncatedLines = lines.slice(0, 5).join("\n");
+      const moreLines = lines.length - 5;
+      const lineSuffix = moreLines === 1 ? "line" : "lines";
+      return `${truncatedLines}
+...(${moreLines} more ${lineSuffix})`;
+    }
+    return lines.join("\n");
+  }
+  const singleLine = lines[0] || "";
+  if (singleLine.length > 300) {
+    const moreChars = singleLine.length - 300;
+    return `${singleLine.slice(0, 300)}...(${moreChars} more characters)`;
+  }
+  return singleLine;
+}
+function truncateObject(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (typeof value === "string") {
+      result[key] = truncateString(value);
+    } else if (Array.isArray(value)) {
+      result[key] = value.map((item) => {
+        if (typeof item === "string") {
+          return truncateString(item);
+        }
+        if (typeof item === "object" && item !== null) {
+          return truncateObject(item);
+        }
+        return item;
+      });
+    } else if (typeof value === "object" && value !== null) {
+      result[key] = truncateObject(value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+
 // src/util/get-step-log.ts
 function getStepLog(stepResult) {
   const { content } = stepResult;
@@ -2465,13 +2484,17 @@ function getStepLog(stepResult) {
     }
     logEntry += ": ";
     if (part.type === "tool-call" && "input" in part) {
-      logEntry += typeof part.input === "string" ? part.input : JSON.stringify(part.input);
+      logEntry += typeof part.input === "string" ? truncateString(part.input) : part.input === null || part.input === void 0 ? String(part.input) : JSON.stringify(
+        truncateObject(part.input)
+      );
     } else if (part.type === "tool-result" && "output" in part) {
-      logEntry += typeof part.output === "string" ? part.output : JSON.stringify(part.output);
+      logEntry += typeof part.output === "string" ? truncateString(part.output) : part.output === null || part.output === void 0 ? String(part.output) : JSON.stringify(
+        truncateObject(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 += truncateString(part.text);
     }
     logEntry += "\n";
   });
@@ -2480,6 +2503,9 @@ function getStepLog(stepResult) {
 
 // src/agent-creators.ts
 function createCodeAgent(agentConfig) {
+  return new import_ai.ToolLoopAgent(createCodeAgentSettings(agentConfig));
+}
+function createCodeAgentSettings(agentConfig) {
   const {
     maxSteps,
     allowSubmit,
@@ -2488,46 +2514,29 @@ function createCodeAgent(agentConfig) {
     tools: originalTools,
     stopWhen: originalStopWhen,
     prepareStep: originalPrepareStep,
-    system: originalSystemInstruction,
+    instructions: originalSystemInstruction,
     ...remainingConfig
   } = agentConfig;
   let agentSettings;
-  let environmentTools;
+  let tools;
   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;
-      }
-    }
+    tools = createCodeAgentTools(
+      { environments, environmentToolsDefinition },
+      originalTools
+    );
   } else if ("environment" in remainingConfig) {
     const { environment, environmentToolsDefinition, ...agentSettingsInput } = remainingConfig;
     agentSettings = { ...agentSettingsInput };
-    environmentTools = createToolsForEnvironment(
-      environment,
-      environmentToolsDefinition
+    tools = createCodeAgentTools(
+      { environment, environmentToolsDefinition },
+      originalTools
     );
   } else {
     agentSettings = { ...remainingConfig };
+    tools = originalTools || {};
   }
-  const tools = environmentTools && originalTools ? mergeTools(environmentTools, originalTools) : originalTools || environmentTools || {};
   if (allowSubmit) {
     if (SubmitToolName in tools) {
       throw new Error(
@@ -2555,16 +2564,54 @@ ${stepLog}`, stepCount - 1);
   } : 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(
+  const instructions = !omitAdditionalInstructions ? mergeSystemInstructions(
     originalSystemInstruction,
     getAdditionalInstructions({ maxSteps, allowSubmit, tools })
   ) : originalSystemInstruction;
-  return new import_ai.Experimental_Agent({
+  return {
     ...agentSettings,
-    system,
+    instructions,
     prepareStep,
     stopWhen
-  });
+  };
+}
+function createCodeAgentTools(agentToolsConfig, originalTools) {
+  if ("environments" in agentToolsConfig) {
+    const { environments, environmentToolsDefinition } = agentToolsConfig;
+    const 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 envTools = createToolsForNamedEnvironment(
+        environmentName,
+        environment,
+        environmentToolsDefinition[environmentName]
+      );
+      for (const [toolName, tool] of Object.entries(envTools)) {
+        if (toolName in environmentTools) {
+          throw new Error(
+            `Tool name conflict: The tool name "${toolName}" from environment "${environmentName}" is already used by another environment's tools.`
+          );
+        }
+        environmentTools[toolName] = tool;
+      }
+    }
+    return originalTools ? mergeTools(environmentTools, originalTools) : environmentTools;
+  }
+  if ("environment" in agentToolsConfig) {
+    const { environment, environmentToolsDefinition } = agentToolsConfig;
+    const environmentTools = createToolsForEnvironment(
+      environment,
+      environmentToolsDefinition
+    );
+    return originalTools ? mergeTools(environmentTools, originalTools) : environmentTools;
+  }
+  throw new Error(
+    'No environments provided in agent tools configuration. Please provide either "environment" or "environments".'
+  );
 }
 function mergeTools(baseTools, additionalTools) {
   const tools = { ...baseTools };
@@ -2590,9 +2637,26 @@ function mergeStopWhen(baseStopWhen, additionalStopWhen) {
   }
   return [baseStopWhen, additionalStopWhen];
 }
-function mergeSystemInstructions(baseSystem, additionalInstructions) {
-  if (baseSystem) {
-    return `${baseSystem.trimEnd()}
+function mergeSystemInstructions(baseInstructions, additionalInstructions) {
+  if (baseInstructions) {
+    if (Array.isArray(baseInstructions)) {
+      return [
+        ...baseInstructions,
+        {
+          role: "system",
+          content: additionalInstructions
+        }
+      ];
+    }
+    if (typeof baseInstructions === "object") {
+      return {
+        ...baseInstructions,
+        content: `${baseInstructions.content.trimEnd()}
+
+${additionalInstructions}`
+      };
+    }
+    return `${baseInstructions.trimEnd()}
 
 ${additionalInstructions}`;
   }
@@ -2618,12 +2682,10 @@ function createEnvironment(environmentName, config) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  CopyFileResult,
   CopyFileTool,
   CopyFileToolInput,
   CopyFileToolName,
   CopyFileToolOutput,
-  DeleteFileResult,
   DeleteFileTool,
   DeleteFileToolInput,
   DeleteFileToolName,
@@ -2645,20 +2707,22 @@ function createEnvironment(environmentName, config) {
   GlobToolInput,
   GlobToolName,
   GlobToolOutput,
+  GrepTool,
+  GrepToolInput,
+  GrepToolName,
+  GrepToolOutput,
   ListDirectoryTool,
   ListDirectoryToolInput,
   ListDirectoryToolName,
   ListDirectoryToolOutput,
   MockFilesystemEnvironment,
   MockFilesystemEnvironmentName,
-  MoveFileResult,
   MoveFileTool,
   MoveFileToolInput,
   MoveFileToolName,
   MoveFileToolOutput,
   NodeFilesystemEnvironment,
   NodeFilesystemEnvironmentName,
-  ReadFileResult,
   ReadFileTool,
   ReadFileToolInput,
   ReadFileToolName,
@@ -2667,19 +2731,23 @@ function createEnvironment(environmentName, config) {
   ReadManyFilesToolInput,
   ReadManyFilesToolName,
   ReadManyFilesToolOutput,
-  RunCommandResult,
   RunCommandTool,
   RunCommandToolInput,
   RunCommandToolName,
   RunCommandToolOutput,
+  SubmitTool,
+  SubmitToolInput,
+  SubmitToolName,
+  SubmitToolOutput,
   UnsafeLocalEnvironment,
   UnsafeLocalEnvironmentName,
-  WriteFileResult,
   WriteFileTool,
   WriteFileToolInput,
   WriteFileToolName,
   WriteFileToolOutput,
   createCodeAgent,
+  createCodeAgentSettings,
+  createCodeAgentTools,
   createEnvironment,
   createEnvironmentTool,
   createToolsForEnvironment,