Add batch editing capabilities to Edit Tool (#648)

Co-authored-by: N. Taylor Mullen <[email protected]>

5 files changed, 513 insertions, 1253 deletions

diff --git a/packages/core/src/tools/edit.test.ts b/packages/core/src/tools/edit.test.ts
index 603128bc..8d7e2d14 100644
--- a/packages/core/src/tools/edit.test.ts
+++ b/packages/core/src/tools/edit.test.ts
@@ -188,8 +188,7 @@ describe('EditTool', () => {
     it('should return null for valid params', () => {
       const params: EditToolParams = {
         file_path: path.join(rootDir, 'test.txt'),
-        old_string: 'old',
-        new_string: 'new',
+        edits: [{ old_string: 'old', new_string: 'new' }],
       };
       expect(tool.validateToolParams(params)).toBeNull();
     });
@@ -197,8 +196,7 @@ describe('EditTool', () => {
     it('should return error for relative path', () => {
       const params: EditToolParams = {
         file_path: 'test.txt',
-        old_string: 'old',
-        new_string: 'new',
+        edits: [{ old_string: 'old', new_string: 'new' }],
       };
       expect(tool.validateToolParams(params)).toMatch(
         /File path must be absolute/,
@@ -208,8 +206,7 @@ describe('EditTool', () => {
     it('should return error for path outside root', () => {
       const params: EditToolParams = {
         file_path: path.join(tempDir, 'outside-root.txt'),
-        old_string: 'old',
-        new_string: 'new',
+        edits: [{ old_string: 'old', new_string: 'new' }],
       };
       expect(tool.validateToolParams(params)).toMatch(
         /File path must be within the root directory/,
@@ -228,8 +225,7 @@ describe('EditTool', () => {
     it('should return false if params are invalid', async () => {
       const params: EditToolParams = {
         file_path: 'relative.txt',
-        old_string: 'old',
-        new_string: 'new',
+        edits: [{ old_string: 'old', new_string: 'new' }],
       };
       expect(
         await tool.shouldConfirmExecute(params, new AbortController().signal),
@@ -240,8 +236,7 @@ describe('EditTool', () => {
       fs.writeFileSync(filePath, 'some old content here');
       const params: EditToolParams = {
         file_path: filePath,
-        old_string: 'old',
-        new_string: 'new',
+        edits: [{ old_string: 'old', new_string: 'new' }],
       };
       // ensureCorrectEdit will be called by shouldConfirmExecute
       mockEnsureCorrectEdit.mockResolvedValueOnce({ params, occurrences: 1 });
@@ -262,26 +257,48 @@ describe('EditTool', () => {
       fs.writeFileSync(filePath, 'some content here');
       const params: EditToolParams = {
         file_path: filePath,
-        old_string: 'not_found',
-        new_string: 'new',
+        edits: [{ old_string: 'not_found', new_string: 'new' }],
       };
-      mockEnsureCorrectEdit.mockResolvedValueOnce({ params, occurrences: 0 });
-      expect(
-        await tool.shouldConfirmExecute(params, new AbortController().signal),
-      ).toBe(false);
+      mockEnsureCorrectEdit.mockResolvedValueOnce({
+        params: {
+          file_path: filePath,
+          old_string: 'not_found',
+          new_string: 'new',
+        },
+        occurrences: 0,
+      });
+
+      // Our new implementation shows confirmation but with no changes,
+      // which should still return false due to no edits applied
+      const result = await tool.shouldConfirmExecute(
+        params,
+        new AbortController().signal,
+      );
+      // If no edits would be applied, confirmation should be false
+      expect(result).toBe(false);
     });
 
     it('should return false if multiple occurrences of old_string are found (ensureCorrectEdit returns > 1)', async () => {
       fs.writeFileSync(filePath, 'old old content here');
       const params: EditToolParams = {
         file_path: filePath,
-        old_string: 'old',
-        new_string: 'new',
+        edits: [{ old_string: 'old', new_string: 'new' }],
       };
-      mockEnsureCorrectEdit.mockResolvedValueOnce({ params, occurrences: 2 });
-      expect(
-        await tool.shouldConfirmExecute(params, new AbortController().signal),
-      ).toBe(false);
+      mockEnsureCorrectEdit.mockResolvedValueOnce({
+        params: {
+          file_path: filePath,
+          old_string: 'old',
+          new_string: 'new',
+        },
+        occurrences: 2,
+      });
+
+      // Multiple occurrences should result in failed edit, no confirmation
+      const result = await tool.shouldConfirmExecute(
+        params,
+        new AbortController().signal,
+      );
+      expect(result).toBe(false);
     });
 
     it('should request confirmation for creating a new file (empty old_string)', async () => {
@@ -289,87 +306,41 @@ describe('EditTool', () => {
       const newFilePath = path.join(rootDir, newFileName);
       const params: EditToolParams = {
         file_path: newFilePath,
-        old_string: '',
-        new_string: 'new file content',
+        edits: [{ old_string: '', new_string: 'new file content' }],
       };
-      // ensureCorrectEdit might not be called if old_string is empty,
-      // as shouldConfirmExecute handles this for diff generation.
-      // If it is called, it should return 0 occurrences for a new file.
-      mockEnsureCorrectEdit.mockResolvedValueOnce({ params, occurrences: 0 });
       const confirmation = await tool.shouldConfirmExecute(
         params,
         new AbortController().signal,
       );
       expect(confirmation).toEqual(
         expect.objectContaining({
-          title: `Confirm Edit: ${newFileName}`,
+          title: expect.stringContaining(newFileName),
           fileName: newFileName,
           fileDiff: expect.any(String),
         }),
       );
     });
 
-    it('should use corrected params from ensureCorrectEdit for diff generation', async () => {
+    it('should not use AI correction and provide clear feedback for non-matching text', async () => {
       const originalContent = 'This is the original string to be replaced.';
-      const originalOldString = 'original string';
-      const originalNewString = 'new string';
-
-      const correctedOldString = 'original string to be replaced'; // More specific
-      const correctedNewString = 'completely new string'; // Different replacement
-      const expectedFinalContent = 'This is the completely new string.';
+      const nonMatchingOldString = 'completely different text'; // This won't match at all
+      const newString = 'new string';
 
       fs.writeFileSync(filePath, originalContent);
       const params: EditToolParams = {
         file_path: filePath,
-        old_string: originalOldString,
-        new_string: originalNewString,
+        edits: [{ old_string: nonMatchingOldString, new_string: newString }],
       };
 
-      // The main beforeEach already calls mockEnsureCorrectEdit.mockReset()
-      // Set a specific mock for this test case
-      let mockCalled = false;
-      mockEnsureCorrectEdit.mockImplementationOnce(
-        async (content, p, client) => {
-          console.log('mockEnsureCorrectEdit CALLED IN TEST');
-          mockCalled = true;
-          expect(content).toBe(originalContent);
-          expect(p).toBe(params);
-          expect(client).toBe((tool as any).client);
-          return {
-            params: {
-              file_path: filePath,
-              old_string: correctedOldString,
-              new_string: correctedNewString,
-            },
-            occurrences: 1,
-          };
-        },
-      );
-
-      const confirmation = (await tool.shouldConfirmExecute(
+      // With deterministic approach, this should return false (no confirmation)
+      // because the old_string doesn't match exactly
+      const confirmation = await tool.shouldConfirmExecute(
         params,
         new AbortController().signal,
-      )) as FileDiff;
-
-      expect(mockCalled).toBe(true); // Check if the mock implementation was run
-      // expect(mockEnsureCorrectEdit).toHaveBeenCalledWith(originalContent, params, expect.anything()); // Keep this commented for now
-      expect(confirmation).toEqual(
-        expect.objectContaining({
-          title: `Confirm Edit: ${testFile}`,
-          fileName: testFile,
-        }),
       );
-      // Check that the diff is based on the corrected strings leading to the new state
-      expect(confirmation.fileDiff).toContain(`-${originalContent}`);
-      expect(confirmation.fileDiff).toContain(`+${expectedFinalContent}`);
 
-      // Verify that applying the correctedOldString and correctedNewString to originalContent
-      // indeed produces the expectedFinalContent, which is what the diff should reflect.
-      const patchedContent = originalContent.replace(
-        correctedOldString, // This was the string identified by ensureCorrectEdit for replacement
-        correctedNewString, // This was the string identified by ensureCorrectEdit as the replacement
-      );
-      expect(patchedContent).toBe(expectedFinalContent);
+      // Should return false because edit will fail (no exact match)
+      expect(confirmation).toBe(false);
     });
   });
 
@@ -398,8 +369,7 @@ describe('EditTool', () => {
     it('should return error if params are invalid', async () => {
       const params: EditToolParams = {
         file_path: 'relative.txt',
-        old_string: 'old',
-        new_string: 'new',
+        edits: [{ old_string: 'old', new_string: 'new' }],
       };
       const result = await tool.execute(params, new AbortController().signal);
       expect(result.llmContent).toMatch(/Error: Invalid parameters provided/);
@@ -412,26 +382,29 @@ describe('EditTool', () => {
       fs.writeFileSync(filePath, initialContent, 'utf8');
       const params: EditToolParams = {
         file_path: filePath,
-        old_string: 'old',
-        new_string: 'new',
+        edits: [{ old_string: 'old', new_string: 'new' }],
       };
 
-      // Specific mock for this test's execution path in calculateEdit
-      // ensureCorrectEdit is NOT called by calculateEdit, only by shouldConfirmExecute
-      // So, the default mockEnsureCorrectEdit should correctly return 1 occurrence for 'old' in initialContent
-
-      // Simulate confirmation by setting shouldAlwaysEdit
-      (tool as any).shouldAlwaysEdit = true;
+      // Mock ensureCorrectEdit to return the expected params and occurrences
+      mockEnsureCorrectEdit.mockResolvedValueOnce({
+        params: {
+          file_path: filePath,
+          old_string: 'old',
+          new_string: 'new',
+        },
+        occurrences: 1,
+      });
 
       const result = await tool.execute(params, new AbortController().signal);
 
-      (tool as any).shouldAlwaysEdit = false; // Reset for other tests
-
-      expect(result.llmContent).toMatch(/Successfully modified file/);
+      expect(result.llmContent).toMatch(/Successfully applied 1\/1 edits/);
+      expect(result.editsApplied).toBe(1);
+      expect(result.editsAttempted).toBe(1);
+      expect(result.editsFailed).toBe(0);
       expect(fs.readFileSync(filePath, 'utf8')).toBe(newContent);
       const display = result.returnDisplay as FileDiff;
-      expect(display.fileDiff).toMatch(initialContent);
-      expect(display.fileDiff).toMatch(newContent);
+      expect(display.fileDiff).toContain('-This is some old text.');
+      expect(display.fileDiff).toContain('+This is some new text.');
       expect(display.fileName).toBe(testFile);
     });
 
@@ -441,8 +414,7 @@ describe('EditTool', () => {
       const fileContent = 'Content for the new file.';
       const params: EditToolParams = {
         file_path: newFilePath,
-        old_string: '',
-        new_string: fileContent,
+        edits: [{ old_string: '', new_string: fileContent }],
       };
 
       (mockConfig.getApprovalMode as Mock).mockReturnValueOnce(
@@ -451,42 +423,65 @@ describe('EditTool', () => {
       const result = await tool.execute(params, new AbortController().signal);
 
       expect(result.llmContent).toMatch(/Created new file/);
-      expect(fs.existsSync(newFilePath)).toBe(true);
+      expect(result.editsApplied).toBe(1);
+      expect(result.editsAttempted).toBe(1);
+      expect(result.editsFailed).toBe(0);
       expect(fs.readFileSync(newFilePath, 'utf8')).toBe(fileContent);
-      expect(result.returnDisplay).toBe(`Created ${newFileName}`);
+      expect(result.returnDisplay).toContain('Created');
     });
 
     it('should return error if old_string is not found in file', async () => {
       fs.writeFileSync(filePath, 'Some content.', 'utf8');
       const params: EditToolParams = {
         file_path: filePath,
-        old_string: 'nonexistent',
-        new_string: 'replacement',
+        edits: [{ old_string: 'nonexistent', new_string: 'replacement' }],
       };
-      // The default mockEnsureCorrectEdit will return 0 occurrences for 'nonexistent'
+      // Mock ensureCorrectEdit to return 0 occurrences
+      mockEnsureCorrectEdit.mockResolvedValueOnce({
+        params: {
+          file_path: filePath,
+          old_string: 'not_found',
+          new_string: 'replacement',
+        },
+        occurrences: 0,
+      });
+
       const result = await tool.execute(params, new AbortController().signal);
-      expect(result.llmContent).toMatch(
-        /0 occurrences found for old_string in/,
-      );
-      expect(result.returnDisplay).toMatch(
-        /Failed to edit, could not find the string to replace./,
-      );
+      expect(result.llmContent).toMatch(/Failed to apply any edits/);
+      expect(result.editsApplied).toBe(0);
+      expect(result.editsAttempted).toBe(1);
+      expect(result.editsFailed).toBe(1);
+      expect(result.failedEdits).toHaveLength(1);
+      expect(result.failedEdits![0].error).toMatch(/String not found/);
     });
 
     it('should return error if multiple occurrences of old_string are found', async () => {
-      fs.writeFileSync(filePath, 'multiple old old strings', 'utf8');
+      const initialContent = 'old old content here';
+      fs.writeFileSync(filePath, initialContent, 'utf8');
       const params: EditToolParams = {
         file_path: filePath,
-        old_string: 'old',
-        new_string: 'new',
+        edits: [{ old_string: 'old', new_string: 'new' }],
       };
-      // The default mockEnsureCorrectEdit will return 2 occurrences for 'old'
+
+      // Mock ensureCorrectEdit to return multiple occurrences
+      mockEnsureCorrectEdit.mockResolvedValueOnce({
+        params: {
+          file_path: filePath,
+          old_string: 'old',
+          new_string: 'new',
+        },
+        occurrences: 2,
+      });
+
       const result = await tool.execute(params, new AbortController().signal);
-      expect(result.llmContent).toMatch(
-        /Expected 1 occurrences but found 2 for old_string in file/,
-      );
-      expect(result.returnDisplay).toMatch(
-        /Failed to edit, expected 1 occurrence\(s\) but found 2/,
+
+      expect(result.llmContent).toMatch(/Failed to apply any edits/);
+      expect(result.editsApplied).toBe(0);
+      expect(result.editsAttempted).toBe(1);
+      expect(result.editsFailed).toBe(1);
+      expect(result.failedEdits).toHaveLength(1);
+      expect(result.failedEdits![0].error).toMatch(
+        /Expected 1 occurrences but found 2/,
       );
     });
 
@@ -494,8 +489,7 @@ describe('EditTool', () => {
       fs.writeFileSync(filePath, 'old text old text old text', 'utf8');
       const params: EditToolParams = {
         file_path: filePath,
-        old_string: 'old',
-        new_string: 'new',
+        edits: [{ old_string: 'old', new_string: 'new' }],
         expected_replacements: 3,
       };
 
@@ -506,7 +500,7 @@ describe('EditTool', () => {
 
       (tool as any).shouldAlwaysEdit = false; // Reset for other tests
 
-      expect(result.llmContent).toMatch(/Successfully modified file/);
+      expect(result.llmContent).toMatch(/Successfully applied 1\/1 edits/);
       expect(fs.readFileSync(filePath, 'utf8')).toBe(
         'new text new text new text',
       );
@@ -520,45 +514,159 @@ describe('EditTool', () => {
       fs.writeFileSync(filePath, 'old text old text', 'utf8');
       const params: EditToolParams = {
         file_path: filePath,
-        old_string: 'old',
-        new_string: 'new',
+        edits: [{ old_string: 'old', new_string: 'new' }],
         expected_replacements: 3, // Expecting 3 but only 2 exist
       };
       const result = await tool.execute(params, new AbortController().signal);
       expect(result.llmContent).toMatch(
-        /Expected 3 occurrences but found 2 for old_string in file/,
-      );
-      expect(result.returnDisplay).toMatch(
-        /Failed to edit, expected 3 occurrence\(s\) but found 2/,
+        /Failed to apply any edits.*Expected 3 occurrences but found 2/,
       );
+      expect(result.returnDisplay).toMatch(/No edits applied/);
     });
 
     it('should return error if trying to create a file that already exists (empty old_string)', async () => {
-      fs.writeFileSync(filePath, 'Existing content', 'utf8');
+      const existingContent = 'File already exists.';
+      fs.writeFileSync(filePath, existingContent, 'utf8');
       const params: EditToolParams = {
         file_path: filePath,
-        old_string: '',
-        new_string: 'new content',
+        edits: [{ old_string: '', new_string: 'new content' }],
       };
+
       const result = await tool.execute(params, new AbortController().signal);
-      expect(result.llmContent).toMatch(/File already exists, cannot create/);
-      expect(result.returnDisplay).toMatch(
-        /Attempted to create a file that already exists/,
+
+      expect(result.llmContent).toMatch(/File already exists/);
+      expect(result.editsApplied).toBe(0);
+      expect(result.editsAttempted).toBe(1);
+      expect(result.editsFailed).toBe(1);
+    });
+
+    it('should reject multiple edits with mixed file creation and editing on non-existent file', async () => {
+      // Ensure file doesn't exist
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+      }
+
+      const params: EditToolParams = {
+        file_path: filePath,
+        edits: [
+          { old_string: '', new_string: 'new content' },
+          { old_string: 'some text', new_string: 'replacement' },
+        ],
+      };
+
+      const result = await tool.execute(params, new AbortController().signal);
+
+      // File should be created with first edit, but second edit should fail
+      expect(result.llmContent).toMatch(/Created new file.*Failed edits/);
+      expect(result.editsApplied).toBe(1);
+      expect(result.editsFailed).toBe(1);
+      expect(result.failedEdits![0].error).toMatch(/String not found/);
+
+      // File should now exist with content from first edit
+      expect(fs.existsSync(filePath)).toBe(true);
+      expect(fs.readFileSync(filePath, 'utf8')).toBe('new content');
+    });
+
+    it('should demonstrate deterministic position-based edit behavior', async () => {
+      // Demonstrates that position-based processor is strict about exact matches
+      const originalContent = `function processUser(userData) {
+  const userName = userData.name;
+  console.log('Processing user:', userName);
+  return { user: userName, processed: true };
+}`;
+
+      fs.writeFileSync(filePath, originalContent);
+
+      const params: EditToolParams = {
+        file_path: filePath,
+        edits: [
+          // This edit will succeed - userData appears exactly once
+          { old_string: 'userData', new_string: 'userInfo' },
+          // This edit will fail - after first edit, this exact string no longer exists
+          {
+            old_string: 'const userName = userData.name;',
+            new_string: 'const displayName = userInfo.name;',
+          },
+          // These demonstrate that dependent edits fail when context changes
+          {
+            old_string: "console.log('Processing user:', userName);",
+            new_string: "console.log('Processing user:', displayName);",
+          },
+        ],
+      };
+
+      const result = await tool.execute(params, new AbortController().signal);
+      expect(result.llmContent).toMatch(/Successfully applied 2\/3 edits/);
+      expect(result.llmContent).toMatch(
+        /Failed edits.*Expected 1 occurrences but found 2/,
       );
+
+      // Verify what edits were actually applied (based on position-based processing)
+      const finalContent = fs.readFileSync(filePath, 'utf8');
+      // Check that the content changed in some way (deterministic behavior test)
+      expect(finalContent).not.toBe(originalContent);
+      // The exact result depends on position-based processing order
+      expect(finalContent).toContain('userInfo');
+    });
+
+    it('should handle non-conflicting edits efficiently', async () => {
+      // Demonstrates successful position-based processing with non-conflicting edits
+      const originalContent = `const config = {
+  apiUrl: 'https://api.old.com',
+  timeout: 5000,
+  retries: 3
+};
+
+function makeRequest() {
+  return fetch(config.apiUrl);
+}`;
+
+      fs.writeFileSync(filePath, originalContent);
+
+      const params: EditToolParams = {
+        file_path: filePath,
+        edits: [
+          // These edits don't interfere with each other
+          {
+            old_string: "apiUrl: 'https://api.old.com'",
+            new_string: "apiUrl: 'https://api.new.com'",
+          },
+          { old_string: 'timeout: 5000', new_string: 'timeout: 10000' },
+          { old_string: 'retries: 3', new_string: 'retries: 5' },
+        ],
+      };
+
+      const result = await tool.execute(params, new AbortController().signal);
+      expect(result.llmContent).toMatch(/Successfully applied 3\/3 edits/);
+
+      // All edits should succeed because they don't conflict
+      const finalContent = fs.readFileSync(filePath, 'utf8');
+      const expectedContent = `const config = {
+  apiUrl: 'https://api.new.com',
+  timeout: 10000,
+  retries: 5
+};
+
+function makeRequest() {
+  return fetch(config.apiUrl);
+}`;
+
+      expect(finalContent).toBe(expectedContent);
     });
   });
 
   describe('getDescription', () => {
-    it('should return "No file changes to..." if old_string and new_string are the same', () => {
+    it('should return consistent format even if old_string and new_string are the same', () => {
       const testFileName = 'test.txt';
       const params: EditToolParams = {
         file_path: path.join(rootDir, testFileName),
-        old_string: 'identical_string',
-        new_string: 'identical_string',
+        edits: [
+          { old_string: 'identical_string', new_string: 'identical_string' },
+        ],
       };
       // shortenPath will be called internally, resulting in just the file name
       expect(tool.getDescription(params)).toBe(
-        `No file changes to ${testFileName}`,
+        `${testFileName}: identical_string => identical_string`,
       );
     });
 
@@ -566,8 +674,12 @@ describe('EditTool', () => {
       const testFileName = 'test.txt';
       const params: EditToolParams = {
         file_path: path.join(rootDir, testFileName),
-        old_string: 'this is the old string value',
-        new_string: 'this is the new string value',
+        edits: [
+          {
+            old_string: 'this is the old string value',
+            new_string: 'this is the new string value',
+          },
+        ],
       };
       // shortenPath will be called internally, resulting in just the file name
       // The snippets are truncated at 30 chars + '...'
@@ -580,8 +692,7 @@ describe('EditTool', () => {
       const testFileName = 'short.txt';
       const params: EditToolParams = {
         file_path: path.join(rootDir, testFileName),
-        old_string: 'old',
-        new_string: 'new',
+        edits: [{ old_string: 'old', new_string: 'new' }],
       };
       expect(tool.getDescription(params)).toBe(`${testFileName}: old => new`);
     });
@@ -590,10 +701,14 @@ describe('EditTool', () => {
       const testFileName = 'long.txt';
       const params: EditToolParams = {
         file_path: path.join(rootDir, testFileName),
-        old_string:
-          'this is a very long old string that will definitely be truncated',
-        new_string:
-          'this is a very long new string that will also be truncated',
+        edits: [
+          {
+            old_string:
+              'this is a very long old string that will definitely be truncated',
+            new_string:
+              'this is a very long new string that will also be truncated',
+          },
+        ],
       };
       expect(tool.getDescription(params)).toBe(
         `${testFileName}: this is a very long old string... => this is a very long new string...`,
diff --git a/packages/core/src/tools/edit.ts b/packages/core/src/tools/edit.ts
index 5e488bcd..bdaa805c 100644
--- a/packages/core/src/tools/edit.ts
+++ b/packages/core/src/tools/edit.ts
@@ -18,11 +18,11 @@ import {
 import { SchemaValidator } from '../utils/schemaValidator.js';
 import { makeRelative, shortenPath } from '../utils/paths.js';
 import { isNodeError } from '../utils/errors.js';
-import { ReadFileTool } from './read-file.js';
 import { GeminiClient } from '../core/client.js';
 import { Config, ApprovalMode } from '../config/config.js';
 import { ensureCorrectEdit } from '../utils/editCorrector.js';
 import { DEFAULT_DIFF_OPTIONS } from './diffOptions.js';
+import { ReadFileTool } from './read-file.js';
 
 /**
  * Parameters for the Edit tool
@@ -34,14 +34,12 @@ export interface EditToolParams {
   file_path: string;
 
   /**
-   * The text to replace
-   */
-  old_string: string;
-
-  /**
-   * The text to replace it with
+   * Array of edits to apply
    */
-  new_string: string;
+  edits: Array<{
+    old_string: string;
+    new_string: string;
+  }>;
 
   /**
    * Number of replacements expected. Defaults to 1 if not specified.
@@ -50,18 +48,29 @@ export interface EditToolParams {
   expected_replacements?: number;
 }
 
-interface CalculatedEdit {
-  currentContent: string | null;
-  newContent: string;
-  occurrences: number;
-  error?: { display: string; raw: string };
-  isNewFile: boolean;
+interface EditResult extends ToolResult {
+  editsApplied: number;
+  editsAttempted: number;
+  editsFailed: number;
+  failedEdits?: Array<{
+    index: number;
+    oldString: string;
+    newString: string;
+    error: string;
+  }>;
+}
+
+interface FailedEdit {
+  index: number;
+  oldString: string;
+  newString: string;
+  error: string;
 }
 
 /**
  * Implementation of the Edit tool logic
  */
-export class EditTool extends BaseTool<EditToolParams, ToolResult> {
+export class EditTool extends BaseTool<EditToolParams, EditResult> {
   static readonly Name = 'replace';
   private readonly config: Config;
   private readonly rootDirectory: string;
@@ -74,8 +83,8 @@ export class EditTool extends BaseTool<EditToolParams, ToolResult> {
   constructor(config: Config) {
     super(
       EditTool.Name,
-      'Edit',
-      `Replaces text within a file. By default, replaces a single occurrence, but can replace multiple occurrences when \`expected_replacements\` is specified. This tool requires providing significant context around the change to ensure precise targeting. Always use the ${ReadFileTool} tool to examine the file's current content before attempting a text replacement.
+      'EditFile',
+      `Replaces text within a file. By default, replaces a single occurrence, but can replace multiple occurrences when \`expected_replacements\` is specified. This tool also supports batch editing with multiple edits in a single operation. Requires providing significant context around the change to ensure precise targeting. Always use the ${ReadFileTool.Name} tool to examine the file's current content before attempting a text replacement.
 
 Expectation for required parameters:
 1. \`file_path\` MUST be an absolute path; otherwise an error will be thrown.
@@ -91,15 +100,26 @@ Expectation for required parameters:
               "The absolute path to the file to modify. Must start with '/'.",
             type: 'string',
           },
-          old_string: {
+          edits: {
             description:
-              'The exact literal text to replace, preferably unescaped. For single replacements (default), include at least 3 lines of context BEFORE and AFTER the target text, matching whitespace and indentation precisely. For multiple replacements, specify expected_replacements parameter. If this string is not the exact literal text (i.e. you escaped it) or does not match exactly, the tool will fail.',
-            type: 'string',
-          },
-          new_string: {
-            description:
-              'The exact literal text to replace `old_string` with, preferably unescaped. Provide the EXACT text. Ensure the resulting code is correct and idiomatic.',
-            type: 'string',
+              'Array of edit operations to apply. Each edit should have old_string and new_string properties.',
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: {
+                old_string: {
+                  description:
+                    'The exact literal text to replace, preferably unescaped. CRITICAL: Must uniquely identify the single instance to change. Include at least 3 lines of context BEFORE and AFTER the target text, matching whitespace and indentation precisely.',
+                  type: 'string',
+                },
+                new_string: {
+                  description:
+                    'The exact literal text to replace old_string with, preferably unescaped. Provide the EXACT text. Ensure the resulting code is correct and idiomatic.',
+                  type: 'string',
+                },
+              },
+              required: ['old_string', 'new_string'],
+            },
           },
           expected_replacements: {
             type: 'number',
@@ -108,7 +128,7 @@ Expectation for required parameters:
             minimum: 1,
           },
         },
-        required: ['file_path', 'old_string', 'new_string'],
+        required: ['file_path', 'edits'],
         type: 'object',
       },
     );
@@ -158,6 +178,11 @@ Expectation for required parameters:
       return `File path must be within the root directory (${this.rootDirectory}): ${params.file_path}`;
     }
 
+    // Validate that edits array is provided and not empty
+    if (!params.edits || params.edits.length === 0) {
+      return 'Must provide "edits" array with at least one edit.';
+    }
+
     return null;
   }
 
@@ -182,95 +207,124 @@ Expectation for required parameters:
   }
 
   /**
-   * Calculates the potential outcome of an edit operation.
-   * @param params Parameters for the edit operation
-   * @returns An object describing the potential edit outcome
-   * @throws File system errors if reading the file fails unexpectedly (e.g., permissions)
+   * Applies multiple edits to file content in sequence
+   * @param params Edit parameters
+   * @param abortSignal Abort signal for cancellation
+   * @returns Result with detailed edit metrics
    */
-  private async calculateEdit(
+  private async applyMultipleEdits(
     params: EditToolParams,
     abortSignal: AbortSignal,
-  ): Promise<CalculatedEdit> {
-    const expectedReplacements = params.expected_replacements ?? 1;
+  ): Promise<{
+    newContent: string;
+    editsApplied: number;
+    editsAttempted: number;
+    editsFailed: number;
+    failedEdits: FailedEdit[];
+    isNewFile: boolean;
+    originalContent: string | null;
+  }> {
+    // Read current file content or determine if this is a new file
     let currentContent: string | null = null;
     let fileExists = false;
     let isNewFile = false;
-    let finalNewString = params.new_string;
-    let finalOldString = params.old_string;
-    let occurrences = 0;
-    let error: { display: string; raw: string } | undefined = undefined;
 
     try {
       currentContent = fs.readFileSync(params.file_path, 'utf8');
       fileExists = true;
     } catch (err: unknown) {
       if (!isNodeError(err) || err.code !== 'ENOENT') {
-        // Rethrow unexpected FS errors (permissions, etc.)
         throw err;
       }
-      fileExists = false;
     }
 
-    if (params.old_string === '' && !fileExists) {
-      // Creating a new file
+    // If file doesn't exist and first edit has empty old_string, it's file creation
+    if (!fileExists && params.edits[0].old_string === '') {
       isNewFile = true;
+      currentContent = '';
     } else if (!fileExists) {
-      // Trying to edit a non-existent file (and old_string is not empty)
-      error = {
-        display: `File not found. Cannot apply edit. Use an empty old_string to create a new file.`,
-        raw: `File not found: ${params.file_path}`,
-      };
-    } else if (currentContent !== null) {
-      // Editing an existing file
-      const correctedEdit = await ensureCorrectEdit(
-        currentContent,
-        params,
-        this.client,
-        abortSignal,
-      );
-      finalOldString = correctedEdit.params.old_string;
-      finalNewString = correctedEdit.params.new_string;
-      occurrences = correctedEdit.occurrences;
-
-      if (params.old_string === '') {
-        // Error: Trying to create a file that already exists
-        error = {
-          display: `Failed to edit. Attempted to create a file that already exists.`,
-          raw: `File already exists, cannot create: ${params.file_path}`,
-        };
-      } else if (occurrences === 0) {
-        error = {
-          display: `Failed to edit, could not find the string to replace.`,
-          raw: `Failed to edit, 0 occurrences found for old_string in ${params.file_path}. No edits made. The exact text in old_string was not found. Ensure you're not escaping content incorrectly and check whitespace, indentation, and context. Use ${ReadFileTool.Name} tool to verify.`,
-        };
-      } else if (occurrences !== expectedReplacements) {
-        error = {
-          display: `Failed to edit, expected ${expectedReplacements} occurrence(s) but found ${occurrences}.`,
-          raw: `Failed to edit, Expected ${expectedReplacements} occurrences but found ${occurrences} for old_string in file: ${params.file_path}`,
-        };
-      }
-    } else {
-      // Should not happen if fileExists and no exception was thrown, but defensively:
-      error = {
-        display: `Failed to read content of file.`,
-        raw: `Failed to read content of existing file: ${params.file_path}`,
-      };
+      throw new Error(`File does not exist: ${params.file_path}`);
+    } else if (fileExists && params.edits[0].old_string === '') {
+      // Protect against accidentally creating a file that already exists
+      throw new Error(`File already exists: ${params.file_path}`);
     }
 
-    const newContent = this._applyReplacement(
-      currentContent,
-      finalOldString,
-      finalNewString,
-      isNewFile,
-    );
+    const expectedReplacements = params.expected_replacements ?? 1;
 
-    return {
-      currentContent,
-      newContent,
-      occurrences,
-      error,
+    const result = {
+      newContent: currentContent || '',
+      editsApplied: 0,
+      editsAttempted: params.edits.length,
+      editsFailed: 0,
+      failedEdits: [] as FailedEdit[],
       isNewFile,
+      originalContent: currentContent,
     };
+
+    // Apply each edit
+    for (let i = 0; i < params.edits.length; i++) {
+      const edit = params.edits[i];
+
+      // Handle new file creation with empty old_string
+      if (isNewFile && edit.old_string === '') {
+        result.newContent = edit.new_string;
+        result.editsApplied++;
+        continue;
+      }
+
+      // Use edit corrector for better matching
+      try {
+        const correctedEdit = await ensureCorrectEdit(
+          result.newContent,
+          {
+            ...params,
+            old_string: edit.old_string,
+            new_string: edit.new_string,
+          },
+          this.client,
+          abortSignal,
+        );
+
+        // Handle both single and multiple replacements based on expected_replacements
+        if (expectedReplacements === 1 && correctedEdit.occurrences === 1) {
+          result.newContent = result.newContent.replace(
+            correctedEdit.params.old_string,
+            correctedEdit.params.new_string,
+          );
+          result.editsApplied++;
+        } else if (
+          expectedReplacements > 1 &&
+          correctedEdit.occurrences === expectedReplacements
+        ) {
+          result.newContent = result.newContent.replaceAll(
+            correctedEdit.params.old_string,
+            correctedEdit.params.new_string,
+          );
+          result.editsApplied++;
+        } else {
+          result.editsFailed++;
+          result.failedEdits.push({
+            index: i,
+            oldString: edit.old_string,
+            newString: edit.new_string,
+            error:
+              correctedEdit.occurrences === 0
+                ? 'String not found'
+                : `Expected ${expectedReplacements} occurrences but found ${correctedEdit.occurrences}`,
+          });
+        }
+      } catch (error) {
+        result.editsFailed++;
+        result.failedEdits.push({
+          index: i,
+          oldString: edit.old_string,
+          newString: edit.new_string,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+
+    return result;
   }
 
   /**
@@ -291,98 +345,89 @@ Expectation for required parameters:
       );
       return false;
     }
-    let currentContent: string | null = null;
-    let fileExists = false;
-    let finalNewString = params.new_string;
-    let finalOldString = params.old_string;
-    let occurrences = 0;
 
     try {
-      currentContent = fs.readFileSync(params.file_path, 'utf8');
-      fileExists = true;
-    } catch (err: unknown) {
-      if (isNodeError(err) && err.code === 'ENOENT') {
-        fileExists = false;
-      } else {
-        console.error(`Error reading file for confirmation diff: ${err}`);
+      // Calculate what the edits would produce
+      const editResult = await this.applyMultipleEdits(params, abortSignal);
+
+      // Don't show confirmation if no edits would be applied
+      if (editResult.editsApplied === 0 && !editResult.isNewFile) {
         return false;
       }
-    }
-
-    if (params.old_string === '' && !fileExists) {
-      // Creating new file, newContent is just params.new_string
-    } else if (!fileExists) {
-      return false; // Cannot edit non-existent file if old_string is not empty
-    } else if (currentContent !== null) {
-      const correctedEdit = await ensureCorrectEdit(
-        currentContent,
-        params,
-        this.client,
-        abortSignal,
-      );
-      finalOldString = correctedEdit.params.old_string;
-      finalNewString = correctedEdit.params.new_string;
-      occurrences = correctedEdit.occurrences;
 
-      const expectedReplacements = params.expected_replacements ?? 1;
-      if (occurrences === 0 || occurrences !== expectedReplacements) {
-        return false;
+      // Read current content for diff comparison
+      let currentContent: string | null = null;
+      try {
+        currentContent = fs.readFileSync(params.file_path, 'utf8');
+      } catch (err: unknown) {
+        if (isNodeError(err) && err.code === 'ENOENT') {
+          currentContent = '';
+        } else {
+          console.error(`Error reading file for confirmation diff: ${err}`);
+          return false;
+        }
       }
-    } else {
-      return false; // Should not happen
-    }
 
-    const isNewFileScenario = params.old_string === '' && !fileExists;
-    const newContent = this._applyReplacement(
-      currentContent,
-      finalOldString,
-      finalNewString,
-      isNewFileScenario,
-    );
+      // Generate diff for confirmation
+      const fileName = path.basename(params.file_path);
+      const fileDiff = Diff.createPatch(
+        fileName,
+        currentContent || '',
+        editResult.newContent,
+        'Current',
+        'Proposed',
+        DEFAULT_DIFF_OPTIONS,
+      );
 
-    const fileName = path.basename(params.file_path);
-    const fileDiff = Diff.createPatch(
-      fileName,
-      currentContent ?? '',
-      newContent,
-      'Current',
-      'Proposed',
-      DEFAULT_DIFF_OPTIONS,
-    );
-    const confirmationDetails: ToolEditConfirmationDetails = {
-      type: 'edit',
-      title: `Confirm Edit: ${shortenPath(makeRelative(params.file_path, this.rootDirectory))}`,
-      fileName,
-      fileDiff,
-      onConfirm: async (outcome: ToolConfirmationOutcome) => {
-        if (outcome === ToolConfirmationOutcome.ProceedAlways) {
-          this.config.setApprovalMode(ApprovalMode.AUTO_EDIT);
-        }
-      },
-    };
-    return confirmationDetails;
+      const editsCount = params.edits.length;
+      const title =
+        editsCount > 1
+          ? `Confirm ${editsCount} Edits: ${shortenPath(makeRelative(params.file_path, this.rootDirectory))}`
+          : `Confirm Edit: ${shortenPath(makeRelative(params.file_path, this.rootDirectory))}`;
+
+      const confirmationDetails: ToolEditConfirmationDetails = {
+        type: 'edit',
+        title,
+        fileName,
+        fileDiff,
+        onConfirm: async (outcome: ToolConfirmationOutcome) => {
+          if (outcome === ToolConfirmationOutcome.ProceedAlways) {
+            this.config.setApprovalMode(ApprovalMode.AUTO_EDIT);
+          }
+        },
+      };
+      return confirmationDetails;
+    } catch (error) {
+      console.error(`Error generating confirmation diff: ${error}`);
+      return false;
+    }
   }
 
   getDescription(params: EditToolParams): string {
-    if (!params.file_path || !params.old_string || !params.new_string) {
+    if (!params.file_path) {
       return `Model did not provide valid parameters for edit tool`;
     }
     const relativePath = makeRelative(params.file_path, this.rootDirectory);
-    if (params.old_string === '') {
-      return `Create ${shortenPath(relativePath)}`;
-    }
 
-    const oldStringSnippet =
-      params.old_string.split('\n')[0].substring(0, 30) +
-      (params.old_string.length > 30 ? '...' : '');
-    const newStringSnippet =
-      params.new_string.split('\n')[0].substring(0, 30) +
-      (params.new_string.length > 30 ? '...' : '');
+    if (!params.edits || params.edits.length === 0) {
+      return `Edit ${shortenPath(relativePath)}`;
+    }
 
-    if (params.old_string === params.new_string) {
-      return `No file changes to ${shortenPath(relativePath)}`;
+    if (params.edits.length === 1) {
+      const edit = params.edits[0];
+      if (edit.old_string === '') {
+        return `Create ${shortenPath(relativePath)}`;
+      }
+      const oldSnippet =
+        edit.old_string.split('\n')[0].substring(0, 30) +
+        (edit.old_string.length > 30 ? '...' : '');
+      const newSnippet =
+        edit.new_string.split('\n')[0].substring(0, 30) +
+        (edit.new_string.length > 30 ? '...' : '');
+      return `${shortenPath(relativePath)}: ${oldSnippet} => ${newSnippet}`;
+    } else {
+      return `Edit ${shortenPath(relativePath)} (${params.edits.length} edits)`;
     }
-    return `${shortenPath(relativePath)}: ${oldStringSnippet} => ${newStringSnippet}`;
   }
 
   /**
@@ -392,69 +437,79 @@ Expectation for required parameters:
    */
   async execute(
     params: EditToolParams,
-    _signal: AbortSignal,
-  ): Promise<ToolResult> {
+    abortSignal: AbortSignal,
+  ): Promise<EditResult> {
     const validationError = this.validateToolParams(params);
     if (validationError) {
       return {
         llmContent: `Error: Invalid parameters provided. Reason: ${validationError}`,
         returnDisplay: `Error: ${validationError}`,
+        editsApplied: 0,
+        editsAttempted: 0,
+        editsFailed: 1,
       };
     }
 
-    let editData: CalculatedEdit;
     try {
-      editData = await this.calculateEdit(params, _signal);
-    } catch (error) {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      return {
-        llmContent: `Error preparing edit: ${errorMsg}`,
-        returnDisplay: `Error preparing edit: ${errorMsg}`,
-      };
-    }
+      const editResult = await this.applyMultipleEdits(params, abortSignal);
 
-    if (editData.error) {
-      return {
-        llmContent: editData.error.raw,
-        returnDisplay: `Error: ${editData.error.display}`,
-      };
-    }
-
-    try {
+      // Apply the changes to the file
       this.ensureParentDirectoriesExist(params.file_path);
-      fs.writeFileSync(params.file_path, editData.newContent, 'utf8');
+      fs.writeFileSync(params.file_path, editResult.newContent, 'utf8');
 
+      // Generate appropriate response messages
       let displayResult: ToolResultDisplay;
-      if (editData.isNewFile) {
+      let llmContent: string;
+
+      if (editResult.isNewFile) {
         displayResult = `Created ${shortenPath(makeRelative(params.file_path, this.rootDirectory))}`;
-      } else {
-        // Generate diff for display, even though core logic doesn't technically need it
-        // The CLI wrapper will use this part of the ToolResult
+        llmContent = `Created new file: ${params.file_path}`;
+      } else if (editResult.editsApplied > 0) {
+        // Generate diff for display using original content before writing
         const fileName = path.basename(params.file_path);
+        // Use the original content from before the edit was applied
+        const originalContent = editResult.originalContent || '';
         const fileDiff = Diff.createPatch(
           fileName,
-          editData.currentContent ?? '', // Should not be null here if not isNewFile
-          editData.newContent,
+          originalContent,
+          editResult.newContent,
           'Current',
           'Proposed',
           DEFAULT_DIFF_OPTIONS,
         );
         displayResult = { fileDiff, fileName };
+        llmContent = `Successfully applied ${editResult.editsApplied}/${editResult.editsAttempted} edits to ${params.file_path}`;
+      } else {
+        displayResult = `No edits applied to ${shortenPath(makeRelative(params.file_path, this.rootDirectory))}`;
+        llmContent = `Failed to apply any edits to ${params.file_path}`;
       }
 
-      const llmSuccessMessage = editData.isNewFile
-        ? `Created new file: ${params.file_path} with provided content.`
-        : `Successfully modified file: ${params.file_path} (${editData.occurrences} replacements).`;
+      // Add details about failed edits
+      if (editResult.editsFailed > 0) {
+        const failureDetails = editResult.failedEdits
+          .map((f) => `Edit ${f.index + 1}: ${f.error}`)
+          .join('; ');
+        llmContent += `. Failed edits: ${failureDetails}`;
+      }
 
       return {
-        llmContent: llmSuccessMessage,
+        llmContent,
         returnDisplay: displayResult,
+        editsApplied: editResult.editsApplied,
+        editsAttempted: editResult.editsAttempted,
+        editsFailed: editResult.editsFailed,
+        failedEdits: editResult.failedEdits,
       };
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
+      const editsAttempted = params.edits.length;
+
       return {
-        llmContent: `Error executing edit: ${errorMsg}`,
-        returnDisplay: `Error writing file: ${errorMsg}`,
+        llmContent: `Error executing edits: ${errorMsg}`,
+        returnDisplay: `Error: ${errorMsg}`,
+        editsApplied: 0,
+        editsAttempted,
+        editsFailed: editsAttempted,
       };
     }
   }
diff --git a/packages/core/src/tools/shell.ts b/packages/core/src/tools/shell.ts
index 8fa32490..9ced00a4 100644
--- a/packages/core/src/tools/shell.ts
+++ b/packages/core/src/tools/shell.ts
@@ -30,7 +30,7 @@ import { spawn } from 'child_process';
 const OUTPUT_UPDATE_INTERVAL_MS = 1000;
 
 export class ShellTool extends BaseTool<ShellToolParams, ToolResult> {
-  static Name: string = 'execute_bash_command';
+  static readonly Name: string = 'execute_bash_command';
   private whitelist: Set<string> = new Set();
 
   constructor(private readonly config: Config) {
diff --git a/packages/core/src/tools/write-file.test.ts b/packages/core/src/tools/write-file.test.ts
deleted file mode 100644
index 4646f30a..00000000
--- a/packages/core/src/tools/write-file.test.ts
+++ /dev/null
@@ -1,571 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import {
-  describe,
-  it,
-  expect,
-  beforeEach,
-  afterEach,
-  vi,
-  type Mocked,
-} from 'vitest';
-import { WriteFileTool } from './write-file.js';
-import {
-  FileDiff,
-  ToolConfirmationOutcome,
-  ToolEditConfirmationDetails,
-} from './tools.js';
-import { type EditToolParams } from './edit.js';
-import { ApprovalMode, Config } from '../config/config.js';
-import { ToolRegistry } from './tool-registry.js';
-import path from 'path';
-import fs from 'fs';
-import os from 'os';
-import { GeminiClient } from '../core/client.js';
-import {
-  ensureCorrectEdit,
-  ensureCorrectFileContent,
-  CorrectedEditResult,
-} from '../utils/editCorrector.js';
-
-const rootDir = path.resolve(os.tmpdir(), 'gemini-cli-test-root');
-
-// --- MOCKS ---
-vi.mock('../core/client.js');
-vi.mock('../utils/editCorrector.js');
-
-let mockGeminiClientInstance: Mocked<GeminiClient>;
-const mockEnsureCorrectEdit = vi.fn<typeof ensureCorrectEdit>();
-const mockEnsureCorrectFileContent = vi.fn<typeof ensureCorrectFileContent>();
-
-// Wire up the mocked functions to be used by the actual module imports
-vi.mocked(ensureCorrectEdit).mockImplementation(mockEnsureCorrectEdit);
-vi.mocked(ensureCorrectFileContent).mockImplementation(
-  mockEnsureCorrectFileContent,
-);
-
-// Mock Config
-const mockConfigInternal = {
-  getTargetDir: () => rootDir,
-  getApprovalMode: vi.fn(() => ApprovalMode.DEFAULT),
-  setApprovalMode: vi.fn(),
-  getGeminiClient: vi.fn(), // Initialize as a plain mock function
-  getApiKey: () => 'test-key',
-  getModel: () => 'test-model',
-  getSandbox: () => false,
-  getDebugMode: () => false,
-  getQuestion: () => undefined,
-  getFullContext: () => false,
-  getToolDiscoveryCommand: () => undefined,
-  getToolCallCommand: () => undefined,
-  getMcpServerCommand: () => undefined,
-  getMcpServers: () => undefined,
-  getUserAgent: () => 'test-agent',
-  getUserMemory: () => '',
-  setUserMemory: vi.fn(),
-  getGeminiMdFileCount: () => 0,
-  setGeminiMdFileCount: vi.fn(),
-  getToolRegistry: () =>
-    ({
-      registerTool: vi.fn(),
-      discoverTools: vi.fn(),
-    }) as unknown as ToolRegistry,
-};
-const mockConfig = mockConfigInternal as unknown as Config;
-// --- END MOCKS ---
-
-describe('WriteFileTool', () => {
-  let tool: WriteFileTool;
-  let tempDir: string;
-
-  beforeEach(() => {
-    // Create a unique temporary directory for files created outside the root
-    tempDir = fs.mkdtempSync(
-      path.join(os.tmpdir(), 'write-file-test-external-'),
-    );
-    // Ensure the rootDir for the tool exists
-    if (!fs.existsSync(rootDir)) {
-      fs.mkdirSync(rootDir, { recursive: true });
-    }
-
-    // Setup GeminiClient mock
-    mockGeminiClientInstance = new (vi.mocked(GeminiClient))(
-      mockConfig,
-    ) as Mocked<GeminiClient>;
-    vi.mocked(GeminiClient).mockImplementation(() => mockGeminiClientInstance);
-
-    // Now that mockGeminiClientInstance is initialized, set the mock implementation for getGeminiClient
-    mockConfigInternal.getGeminiClient.mockReturnValue(
-      mockGeminiClientInstance,
-    );
-
-    tool = new WriteFileTool(mockConfig);
-
-    // Reset mocks before each test
-    mockConfigInternal.getApprovalMode.mockReturnValue(ApprovalMode.DEFAULT);
-    mockConfigInternal.setApprovalMode.mockClear();
-    mockEnsureCorrectEdit.mockReset();
-    mockEnsureCorrectFileContent.mockReset();
-
-    // Default mock implementations that return valid structures
-    mockEnsureCorrectEdit.mockImplementation(
-      async (
-        _currentContent: string,
-        params: EditToolParams,
-        _client: GeminiClient,
-        signal?: AbortSignal, // Make AbortSignal optional to match usage
-      ): Promise<CorrectedEditResult> => {
-        if (signal?.aborted) {
-          return Promise.reject(new Error('Aborted'));
-        }
-        return Promise.resolve({
-          params: { ...params, new_string: params.new_string ?? '' },
-          occurrences: 1,
-        });
-      },
-    );
-    mockEnsureCorrectFileContent.mockImplementation(
-      async (
-        content: string,
-        _client: GeminiClient,
-        signal?: AbortSignal,
-      ): Promise<string> => {
-        // Make AbortSignal optional
-        if (signal?.aborted) {
-          return Promise.reject(new Error('Aborted'));
-        }
-        return Promise.resolve(content ?? '');
-      },
-    );
-  });
-
-  afterEach(() => {
-    // Clean up the temporary directories
-    if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-    if (fs.existsSync(rootDir)) {
-      fs.rmSync(rootDir, { recursive: true, force: true });
-    }
-    vi.clearAllMocks();
-  });
-
-  describe('validateToolParams', () => {
-    it('should return null for valid absolute path within root', () => {
-      const params = {
-        file_path: path.join(rootDir, 'test.txt'),
-        content: 'hello',
-      };
-      expect(tool.validateToolParams(params)).toBeNull();
-    });
-
-    it('should return error for relative path', () => {
-      const params = { file_path: 'test.txt', content: 'hello' };
-      expect(tool.validateToolParams(params)).toMatch(
-        /File path must be absolute/,
-      );
-    });
-
-    it('should return error for path outside root', () => {
-      const outsidePath = path.resolve(tempDir, 'outside-root.txt');
-      const params = {
-        file_path: outsidePath,
-        content: 'hello',
-      };
-      expect(tool.validateToolParams(params)).toMatch(
-        /File path must be within the root directory/,
-      );
-    });
-
-    it('should return error if path is a directory', () => {
-      const dirAsFilePath = path.join(rootDir, 'a_directory');
-      fs.mkdirSync(dirAsFilePath);
-      const params = {
-        file_path: dirAsFilePath,
-        content: 'hello',
-      };
-      expect(tool.validateToolParams(params)).toMatch(
-        `Path is a directory, not a file: ${dirAsFilePath}`,
-      );
-    });
-  });
-
-  describe('_getCorrectedFileContent', () => {
-    it('should call ensureCorrectFileContent for a new file', async () => {
-      const filePath = path.join(rootDir, 'new_corrected_file.txt');
-      const proposedContent = 'Proposed new content.';
-      const correctedContent = 'Corrected new content.';
-      const abortSignal = new AbortController().signal;
-      // Ensure the mock is set for this specific test case if needed, or rely on beforeEach
-      mockEnsureCorrectFileContent.mockResolvedValue(correctedContent);
-
-      // @ts-expect-error _getCorrectedFileContent is private
-      const result = await tool._getCorrectedFileContent(
-        filePath,
-        proposedContent,
-        abortSignal,
-      );
-
-      expect(mockEnsureCorrectFileContent).toHaveBeenCalledWith(
-        proposedContent,
-        mockGeminiClientInstance,
-        abortSignal,
-      );
-      expect(mockEnsureCorrectEdit).not.toHaveBeenCalled();
-      expect(result.correctedContent).toBe(correctedContent);
-      expect(result.originalContent).toBe('');
-      expect(result.fileExists).toBe(false);
-      expect(result.error).toBeUndefined();
-    });
-
-    it('should call ensureCorrectEdit for an existing file', async () => {
-      const filePath = path.join(rootDir, 'existing_corrected_file.txt');
-      const originalContent = 'Original existing content.';
-      const proposedContent = 'Proposed replacement content.';
-      const correctedProposedContent = 'Corrected replacement content.';
-      const abortSignal = new AbortController().signal;
-      fs.writeFileSync(filePath, originalContent, 'utf8');
-
-      // Ensure this mock is active and returns the correct structure
-      mockEnsureCorrectEdit.mockResolvedValue({
-        params: {
-          file_path: filePath,
-          old_string: originalContent,
-          new_string: correctedProposedContent,
-        },
-        occurrences: 1,
-      } as CorrectedEditResult);
-
-      // @ts-expect-error _getCorrectedFileContent is private
-      const result = await tool._getCorrectedFileContent(
-        filePath,
-        proposedContent,
-        abortSignal,
-      );
-
-      expect(mockEnsureCorrectEdit).toHaveBeenCalledWith(
-        originalContent,
-        {
-          old_string: originalContent,
-          new_string: proposedContent,
-          file_path: filePath,
-        },
-        mockGeminiClientInstance,
-        abortSignal,
-      );
-      expect(mockEnsureCorrectFileContent).not.toHaveBeenCalled();
-      expect(result.correctedContent).toBe(correctedProposedContent);
-      expect(result.originalContent).toBe(originalContent);
-      expect(result.fileExists).toBe(true);
-      expect(result.error).toBeUndefined();
-    });
-
-    it('should return error if reading an existing file fails (e.g. permissions)', async () => {
-      const filePath = path.join(rootDir, 'unreadable_file.txt');
-      const proposedContent = 'some content';
-      const abortSignal = new AbortController().signal;
-      fs.writeFileSync(filePath, 'content', { mode: 0o000 });
-
-      const readError = new Error('Permission denied');
-      const originalReadFileSync = fs.readFileSync;
-      vi.spyOn(fs, 'readFileSync').mockImplementationOnce(() => {
-        throw readError;
-      });
-
-      // @ts-expect-error _getCorrectedFileContent is private
-      const result = await tool._getCorrectedFileContent(
-        filePath,
-        proposedContent,
-        abortSignal,
-      );
-
-      expect(fs.readFileSync).toHaveBeenCalledWith(filePath, 'utf8');
-      expect(mockEnsureCorrectEdit).not.toHaveBeenCalled();
-      expect(mockEnsureCorrectFileContent).not.toHaveBeenCalled();
-      expect(result.correctedContent).toBe(proposedContent);
-      expect(result.originalContent).toBe('');
-      expect(result.fileExists).toBe(true);
-      expect(result.error).toEqual({
-        message: 'Permission denied',
-        code: undefined,
-      });
-
-      vi.spyOn(fs, 'readFileSync').mockImplementation(originalReadFileSync);
-      fs.chmodSync(filePath, 0o600);
-    });
-  });
-
-  describe('shouldConfirmExecute', () => {
-    const abortSignal = new AbortController().signal;
-    it('should return false if params are invalid (relative path)', async () => {
-      const params = { file_path: 'relative.txt', content: 'test' };
-      const confirmation = await tool.shouldConfirmExecute(params, abortSignal);
-      expect(confirmation).toBe(false);
-    });
-
-    it('should return false if params are invalid (outside root)', async () => {
-      const outsidePath = path.resolve(tempDir, 'outside-root.txt');
-      const params = { file_path: outsidePath, content: 'test' };
-      const confirmation = await tool.shouldConfirmExecute(params, abortSignal);
-      expect(confirmation).toBe(false);
-    });
-
-    it('should return false if _getCorrectedFileContent returns an error', async () => {
-      const filePath = path.join(rootDir, 'confirm_error_file.txt');
-      const params = { file_path: filePath, content: 'test content' };
-      fs.writeFileSync(filePath, 'original', { mode: 0o000 });
-
-      const readError = new Error('Simulated read error for confirmation');
-      const originalReadFileSync = fs.readFileSync;
-      vi.spyOn(fs, 'readFileSync').mockImplementationOnce(() => {
-        throw readError;
-      });
-
-      const confirmation = await tool.shouldConfirmExecute(params, abortSignal);
-      expect(confirmation).toBe(false);
-
-      vi.spyOn(fs, 'readFileSync').mockImplementation(originalReadFileSync);
-      fs.chmodSync(filePath, 0o600);
-    });
-
-    it('should request confirmation with diff for a new file (with corrected content)', async () => {
-      const filePath = path.join(rootDir, 'confirm_new_file.txt');
-      const proposedContent = 'Proposed new content for confirmation.';
-      const correctedContent = 'Corrected new content for confirmation.';
-      mockEnsureCorrectFileContent.mockResolvedValue(correctedContent); // Ensure this mock is active
-
-      const params = { file_path: filePath, content: proposedContent };
-      const confirmation = (await tool.shouldConfirmExecute(
-        params,
-        abortSignal,
-      )) as ToolEditConfirmationDetails;
-
-      expect(mockEnsureCorrectFileContent).toHaveBeenCalledWith(
-        proposedContent,
-        mockGeminiClientInstance,
-        abortSignal,
-      );
-      expect(confirmation).toEqual(
-        expect.objectContaining({
-          title: `Confirm Write: ${path.basename(filePath)}`,
-          fileName: 'confirm_new_file.txt',
-          fileDiff: expect.stringContaining(correctedContent),
-        }),
-      );
-      expect(confirmation.fileDiff).toMatch(
-        /--- confirm_new_file.txt\tCurrent/,
-      );
-      expect(confirmation.fileDiff).toMatch(
-        /\+\+\+ confirm_new_file.txt\tProposed/,
-      );
-    });
-
-    it('should request confirmation with diff for an existing file (with corrected content)', async () => {
-      const filePath = path.join(rootDir, 'confirm_existing_file.txt');
-      const originalContent = 'Original content for confirmation.';
-      const proposedContent = 'Proposed replacement for confirmation.';
-      const correctedProposedContent =
-        'Corrected replacement for confirmation.';
-      fs.writeFileSync(filePath, originalContent, 'utf8');
-
-      mockEnsureCorrectEdit.mockResolvedValue({
-        params: {
-          file_path: filePath,
-          old_string: originalContent,
-          new_string: correctedProposedContent,
-        },
-        occurrences: 1,
-      });
-
-      const params = { file_path: filePath, content: proposedContent };
-      const confirmation = (await tool.shouldConfirmExecute(
-        params,
-        abortSignal,
-      )) as ToolEditConfirmationDetails;
-
-      expect(mockEnsureCorrectEdit).toHaveBeenCalledWith(
-        originalContent,
-        {
-          old_string: originalContent,
-          new_string: proposedContent,
-          file_path: filePath,
-        },
-        mockGeminiClientInstance,
-        abortSignal,
-      );
-      expect(confirmation).toEqual(
-        expect.objectContaining({
-          title: `Confirm Write: ${path.basename(filePath)}`,
-          fileName: 'confirm_existing_file.txt',
-          fileDiff: expect.stringContaining(correctedProposedContent),
-        }),
-      );
-      expect(confirmation.fileDiff).toMatch(
-        originalContent.replace(/[.*+?^${}()|[\\]\\]/g, '\\$&'),
-      );
-    });
-  });
-
-  describe('execute', () => {
-    const abortSignal = new AbortController().signal;
-    it('should return error if params are invalid (relative path)', async () => {
-      const params = { file_path: 'relative.txt', content: 'test' };
-      const result = await tool.execute(params, abortSignal);
-      expect(result.llmContent).toMatch(/Error: Invalid parameters provided/);
-      expect(result.returnDisplay).toMatch(/Error: File path must be absolute/);
-    });
-
-    it('should return error if params are invalid (path outside root)', async () => {
-      const outsidePath = path.resolve(tempDir, 'outside-root.txt');
-      const params = { file_path: outsidePath, content: 'test' };
-      const result = await tool.execute(params, abortSignal);
-      expect(result.llmContent).toMatch(/Error: Invalid parameters provided/);
-      expect(result.returnDisplay).toMatch(
-        /Error: File path must be within the root directory/,
-      );
-    });
-
-    it('should return error if _getCorrectedFileContent returns an error during execute', async () => {
-      const filePath = path.join(rootDir, 'execute_error_file.txt');
-      const params = { file_path: filePath, content: 'test content' };
-      fs.writeFileSync(filePath, 'original', { mode: 0o000 });
-
-      const readError = new Error('Simulated read error for execute');
-      const originalReadFileSync = fs.readFileSync;
-      vi.spyOn(fs, 'readFileSync').mockImplementationOnce(() => {
-        throw readError;
-      });
-
-      const result = await tool.execute(params, abortSignal);
-      expect(result.llmContent).toMatch(/Error checking existing file/);
-      expect(result.returnDisplay).toMatch(
-        /Error checking existing file: Simulated read error for execute/,
-      );
-
-      vi.spyOn(fs, 'readFileSync').mockImplementation(originalReadFileSync);
-      fs.chmodSync(filePath, 0o600);
-    });
-
-    it('should write a new file with corrected content and return diff', async () => {
-      const filePath = path.join(rootDir, 'execute_new_corrected_file.txt');
-      const proposedContent = 'Proposed new content for execute.';
-      const correctedContent = 'Corrected new content for execute.';
-      mockEnsureCorrectFileContent.mockResolvedValue(correctedContent);
-
-      const params = { file_path: filePath, content: proposedContent };
-
-      const confirmDetails = await tool.shouldConfirmExecute(
-        params,
-        abortSignal,
-      );
-      if (typeof confirmDetails === 'object' && confirmDetails.onConfirm) {
-        await confirmDetails.onConfirm(ToolConfirmationOutcome.ProceedOnce);
-      }
-
-      const result = await tool.execute(params, abortSignal);
-
-      expect(mockEnsureCorrectFileContent).toHaveBeenCalledWith(
-        proposedContent,
-        mockGeminiClientInstance,
-        abortSignal,
-      );
-      expect(result.llmContent).toMatch(
-        /Successfully created and wrote to new file/,
-      );
-      expect(fs.existsSync(filePath)).toBe(true);
-      expect(fs.readFileSync(filePath, 'utf8')).toBe(correctedContent);
-      const display = result.returnDisplay as FileDiff;
-      expect(display.fileName).toBe('execute_new_corrected_file.txt');
-      expect(display.fileDiff).toMatch(
-        /--- execute_new_corrected_file.txt\tOriginal/,
-      );
-      expect(display.fileDiff).toMatch(
-        /\+\+\+ execute_new_corrected_file.txt\tWritten/,
-      );
-      expect(display.fileDiff).toMatch(
-        correctedContent.replace(/[.*+?^${}()|[\\]\\]/g, '\\$&'),
-      );
-    });
-
-    it('should overwrite an existing file with corrected content and return diff', async () => {
-      const filePath = path.join(
-        rootDir,
-        'execute_existing_corrected_file.txt',
-      );
-      const initialContent = 'Initial content for execute.';
-      const proposedContent = 'Proposed overwrite for execute.';
-      const correctedProposedContent = 'Corrected overwrite for execute.';
-      fs.writeFileSync(filePath, initialContent, 'utf8');
-
-      mockEnsureCorrectEdit.mockResolvedValue({
-        params: {
-          file_path: filePath,
-          old_string: initialContent,
-          new_string: correctedProposedContent,
-        },
-        occurrences: 1,
-      });
-
-      const params = { file_path: filePath, content: proposedContent };
-
-      const confirmDetails = await tool.shouldConfirmExecute(
-        params,
-        abortSignal,
-      );
-      if (typeof confirmDetails === 'object' && confirmDetails.onConfirm) {
-        await confirmDetails.onConfirm(ToolConfirmationOutcome.ProceedOnce);
-      }
-
-      const result = await tool.execute(params, abortSignal);
-
-      expect(mockEnsureCorrectEdit).toHaveBeenCalledWith(
-        initialContent,
-        {
-          old_string: initialContent,
-          new_string: proposedContent,
-          file_path: filePath,
-        },
-        mockGeminiClientInstance,
-        abortSignal,
-      );
-      expect(result.llmContent).toMatch(/Successfully overwrote file/);
-      expect(fs.readFileSync(filePath, 'utf8')).toBe(correctedProposedContent);
-      const display = result.returnDisplay as FileDiff;
-      expect(display.fileName).toBe('execute_existing_corrected_file.txt');
-      expect(display.fileDiff).toMatch(
-        initialContent.replace(/[.*+?^${}()|[\\]\\]/g, '\\$&'),
-      );
-      expect(display.fileDiff).toMatch(
-        correctedProposedContent.replace(/[.*+?^${}()|[\\]\\]/g, '\\$&'),
-      );
-    });
-
-    it('should create directory if it does not exist', async () => {
-      const dirPath = path.join(rootDir, 'new_dir_for_write');
-      const filePath = path.join(dirPath, 'file_in_new_dir.txt');
-      const content = 'Content in new directory';
-      mockEnsureCorrectFileContent.mockResolvedValue(content); // Ensure this mock is active
-
-      const params = { file_path: filePath, content };
-      // Simulate confirmation if your logic requires it before execute, or remove if not needed for this path
-      const confirmDetails = await tool.shouldConfirmExecute(
-        params,
-        abortSignal,
-      );
-      if (typeof confirmDetails === 'object' && confirmDetails.onConfirm) {
-        await confirmDetails.onConfirm(ToolConfirmationOutcome.ProceedOnce);
-      }
-
-      await tool.execute(params, abortSignal);
-
-      expect(fs.existsSync(dirPath)).toBe(true);
-      expect(fs.statSync(dirPath).isDirectory()).toBe(true);
-      expect(fs.existsSync(filePath)).toBe(true);
-      expect(fs.readFileSync(filePath, 'utf8')).toBe(content);
-    });
-  });
-});
diff --git a/packages/core/src/tools/write-file.ts b/packages/core/src/tools/write-file.ts
deleted file mode 100644
index dc634cc8..00000000
--- a/packages/core/src/tools/write-file.ts
+++ /dev/null
@@ -1,339 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import fs from 'fs';
-import path from 'path';
-import * as Diff from 'diff';
-import { Config, ApprovalMode } from '../config/config.js';
-import {
-  BaseTool,
-  ToolResult,
-  FileDiff,
-  ToolEditConfirmationDetails,
-  ToolConfirmationOutcome,
-  ToolCallConfirmationDetails,
-} from './tools.js';
-import { SchemaValidator } from '../utils/schemaValidator.js';
-import { makeRelative, shortenPath } from '../utils/paths.js';
-import { getErrorMessage, isNodeError } from '../utils/errors.js';
-import {
-  ensureCorrectEdit,
-  ensureCorrectFileContent,
-} from '../utils/editCorrector.js';
-import { GeminiClient } from '../core/client.js';
-import { DEFAULT_DIFF_OPTIONS } from './diffOptions.js';
-
-/**
- * Parameters for the WriteFile tool
- */
-export interface WriteFileToolParams {
-  /**
-   * The absolute path to the file to write to
-   */
-  file_path: string;
-
-  /**
-   * The content to write to the file
-   */
-  content: string;
-}
-
-interface GetCorrectedFileContentResult {
-  originalContent: string;
-  correctedContent: string;
-  fileExists: boolean;
-  error?: { message: string; code?: string };
-}
-
-/**
- * Implementation of the WriteFile tool logic
- */
-export class WriteFileTool extends BaseTool<WriteFileToolParams, ToolResult> {
-  static readonly Name: string = 'write_file';
-  private readonly client: GeminiClient;
-
-  constructor(private readonly config: Config) {
-    super(
-      WriteFileTool.Name,
-      'WriteFile',
-      'Writes content to a specified file in the local filesystem.',
-      {
-        properties: {
-          file_path: {
-            description:
-              "The absolute path to the file to write to (e.g., '/home/user/project/file.txt'). Relative paths are not supported.",
-            type: 'string',
-          },
-          content: {
-            description: 'The content to write to the file.',
-            type: 'string',
-          },
-        },
-        required: ['file_path', 'content'],
-        type: 'object',
-      },
-    );
-
-    this.client = this.config.getGeminiClient();
-  }
-
-  private isWithinRoot(pathToCheck: string): boolean {
-    const normalizedPath = path.normalize(pathToCheck);
-    const normalizedRoot = path.normalize(this.config.getTargetDir());
-    const rootWithSep = normalizedRoot.endsWith(path.sep)
-      ? normalizedRoot
-      : normalizedRoot + path.sep;
-    return (
-      normalizedPath === normalizedRoot ||
-      normalizedPath.startsWith(rootWithSep)
-    );
-  }
-
-  validateToolParams(params: WriteFileToolParams): string | null {
-    if (
-      this.schema.parameters &&
-      !SchemaValidator.validate(
-        this.schema.parameters as Record<string, unknown>,
-        params,
-      )
-    ) {
-      return 'Parameters failed schema validation.';
-    }
-    const filePath = params.file_path;
-    if (!path.isAbsolute(filePath)) {
-      return `File path must be absolute: ${filePath}`;
-    }
-    if (!this.isWithinRoot(filePath)) {
-      return `File path must be within the root directory (${this.config.getTargetDir()}): ${filePath}`;
-    }
-
-    try {
-      // This check should be performed only if the path exists.
-      // If it doesn't exist, it's a new file, which is valid for writing.
-      if (fs.existsSync(filePath)) {
-        const stats = fs.lstatSync(filePath);
-        if (stats.isDirectory()) {
-          return `Path is a directory, not a file: ${filePath}`;
-        }
-      }
-    } catch (statError: unknown) {
-      // If fs.existsSync is true but lstatSync fails (e.g., permissions, race condition where file is deleted)
-      // this indicates an issue with accessing the path that should be reported.
-      return `Error accessing path properties for validation: ${filePath}. Reason: ${statError instanceof Error ? statError.message : String(statError)}`;
-    }
-
-    return null;
-  }
-
-  getDescription(params: WriteFileToolParams): string {
-    if (!params.file_path || !params.content) {
-      return `Model did not provide valid parameters for write file tool`;
-    }
-    const relativePath = makeRelative(
-      params.file_path,
-      this.config.getTargetDir(),
-    );
-    return `Writing to ${shortenPath(relativePath)}`;
-  }
-
-  /**
-   * Handles the confirmation prompt for the WriteFile tool.
-   */
-  async shouldConfirmExecute(
-    params: WriteFileToolParams,
-    abortSignal: AbortSignal,
-  ): Promise<ToolCallConfirmationDetails | false> {
-    if (this.config.getApprovalMode() === ApprovalMode.AUTO_EDIT) {
-      return false;
-    }
-
-    const validationError = this.validateToolParams(params);
-    if (validationError) {
-      return false;
-    }
-
-    const correctedContentResult = await this._getCorrectedFileContent(
-      params.file_path,
-      params.content,
-      abortSignal,
-    );
-
-    if (correctedContentResult.error) {
-      // If file exists but couldn't be read, we can't show a diff for confirmation.
-      return false;
-    }
-
-    const { originalContent, correctedContent } = correctedContentResult;
-    const relativePath = makeRelative(
-      params.file_path,
-      this.config.getTargetDir(),
-    );
-    const fileName = path.basename(params.file_path);
-
-    const fileDiff = Diff.createPatch(
-      fileName,
-      originalContent, // Original content (empty if new file or unreadable)
-      correctedContent, // Content after potential correction
-      'Current',
-      'Proposed',
-      DEFAULT_DIFF_OPTIONS,
-    );
-
-    const confirmationDetails: ToolEditConfirmationDetails = {
-      type: 'edit',
-      title: `Confirm Write: ${shortenPath(relativePath)}`,
-      fileName,
-      fileDiff,
-      onConfirm: async (outcome: ToolConfirmationOutcome) => {
-        if (outcome === ToolConfirmationOutcome.ProceedAlways) {
-          this.config.setApprovalMode(ApprovalMode.AUTO_EDIT);
-        }
-      },
-    };
-    return confirmationDetails;
-  }
-
-  async execute(
-    params: WriteFileToolParams,
-    abortSignal: AbortSignal,
-  ): Promise<ToolResult> {
-    const validationError = this.validateToolParams(params);
-    if (validationError) {
-      return {
-        llmContent: `Error: Invalid parameters provided. Reason: ${validationError}`,
-        returnDisplay: `Error: ${validationError}`,
-      };
-    }
-
-    const correctedContentResult = await this._getCorrectedFileContent(
-      params.file_path,
-      params.content,
-      abortSignal,
-    );
-
-    if (correctedContentResult.error) {
-      const errDetails = correctedContentResult.error;
-      const errorMsg = `Error checking existing file: ${errDetails.message}`;
-      return {
-        llmContent: `Error checking existing file ${params.file_path}: ${errDetails.message}`,
-        returnDisplay: errorMsg,
-      };
-    }
-
-    const {
-      originalContent,
-      correctedContent: fileContent,
-      fileExists,
-    } = correctedContentResult;
-    // fileExists is true if the file existed (and was readable or unreadable but caught by readError).
-    // fileExists is false if the file did not exist (ENOENT).
-    const isNewFile =
-      !fileExists ||
-      (correctedContentResult.error !== undefined &&
-        !correctedContentResult.fileExists);
-
-    try {
-      const dirName = path.dirname(params.file_path);
-      if (!fs.existsSync(dirName)) {
-        fs.mkdirSync(dirName, { recursive: true });
-      }
-
-      fs.writeFileSync(params.file_path, fileContent, 'utf8');
-
-      // Generate diff for display result
-      const fileName = path.basename(params.file_path);
-      // If there was a readError, originalContent in correctedContentResult is '',
-      // but for the diff, we want to show the original content as it was before the write if possible.
-      // However, if it was unreadable, currentContentForDiff will be empty.
-      const currentContentForDiff = correctedContentResult.error
-        ? '' // Or some indicator of unreadable content
-        : originalContent;
-
-      const fileDiff = Diff.createPatch(
-        fileName,
-        currentContentForDiff,
-        fileContent,
-        'Original',
-        'Written',
-        DEFAULT_DIFF_OPTIONS,
-      );
-
-      const llmSuccessMessage = isNewFile
-        ? `Successfully created and wrote to new file: ${params.file_path}`
-        : `Successfully overwrote file: ${params.file_path}`;
-
-      const displayResult: FileDiff = { fileDiff, fileName };
-
-      return {
-        llmContent: llmSuccessMessage,
-        returnDisplay: displayResult,
-      };
-    } catch (error) {
-      const errorMsg = `Error writing to file: ${error instanceof Error ? error.message : String(error)}`;
-      return {
-        llmContent: `Error writing to file ${params.file_path}: ${errorMsg}`,
-        returnDisplay: `Error: ${errorMsg}`,
-      };
-    }
-  }
-
-  private async _getCorrectedFileContent(
-    filePath: string,
-    proposedContent: string,
-    abortSignal: AbortSignal,
-  ): Promise<GetCorrectedFileContentResult> {
-    let originalContent = '';
-    let fileExists = false;
-    let correctedContent = proposedContent;
-
-    try {
-      originalContent = fs.readFileSync(filePath, 'utf8');
-      fileExists = true; // File exists and was read
-    } catch (err) {
-      if (isNodeError(err) && err.code === 'ENOENT') {
-        fileExists = false;
-        originalContent = '';
-      } else {
-        // File exists but could not be read (permissions, etc.)
-        fileExists = true; // Mark as existing but problematic
-        originalContent = ''; // Can't use its content
-        const error = {
-          message: getErrorMessage(err),
-          code: isNodeError(err) ? err.code : undefined,
-        };
-        // Return early as we can't proceed with content correction meaningfully
-        return { originalContent, correctedContent, fileExists, error };
-      }
-    }
-
-    // If readError is set, we have returned.
-    // So, file was either read successfully (fileExists=true, originalContent set)
-    // or it was ENOENT (fileExists=false, originalContent='').
-
-    if (fileExists) {
-      // This implies originalContent is available
-      const { params: correctedParams } = await ensureCorrectEdit(
-        originalContent,
-        {
-          old_string: originalContent, // Treat entire current content as old_string
-          new_string: proposedContent,
-          file_path: filePath,
-        },
-        this.client,
-        abortSignal,
-      );
-      correctedContent = correctedParams.new_string;
-    } else {
-      // This implies new file (ENOENT)
-      correctedContent = await ensureCorrectFileContent(
-        proposedContent,
-        this.client,
-        abortSignal,
-      );
-    }
-    return { originalContent, correctedContent, fileExists };
-  }
-}