@dexto/tools-filesystem 1.6.0 → 1.6.2

package/dist/edit-file-tool.cjs

@@ -45,6 +45,7 @@ function generateDiffPreview(filePath, originalContent, newContent) {
   const deletions = (unified.match(/^-[^-]/gm) || []).length;
   return {
     type: "diff",
+    title: "Update file",
     unified,
     filename: filePath,
     additions,
@@ -54,67 +55,88 @@ function generateDiffPreview(filePath, originalContent, newContent) {
 function createEditFileTool(getFileSystemService) {
   return (0, import_core.defineTool)({
     id: "edit_file",
-    displayName: "Update",
     aliases: ["edit"],
     description: "Edit a file by replacing text. By default, old_string must be unique in the file (will error if found multiple times). Set replace_all=true to replace all occurrences. Automatically creates backup before editing. Requires approval. Returns success status, path, number of changes made, and backup path.",
     inputSchema: EditFileInputSchema,
     ...(0, import_directory_approval.createDirectoryAccessApprovalHandlers)({
       toolName: "edit_file",
       operation: "edit",
+      inputSchema: EditFileInputSchema,
       getFileSystemService,
       resolvePaths: (input, fileSystemService) => (0, import_directory_approval.resolveFilePath)(fileSystemService.getWorkingDirectory(), input.file_path)
     }),
-    /**
-     * Generate preview for approval UI - shows diff without modifying file
-     * Throws ToolError.validationFailed() for validation errors (file not found, string not found)
-     * Stores content hash for change detection in execute phase.
-     */
-    async generatePreview(input, context) {
-      const { file_path, old_string, new_string, replace_all } = input;
-      const resolvedFileSystemService = await getFileSystemService(context);
-      const { path: resolvedPath } = (0, import_directory_approval.resolveFilePath)(
-        resolvedFileSystemService.getWorkingDirectory(),
-        file_path
-      );
-      try {
-        const originalFile = await resolvedFileSystemService.readFile(resolvedPath);
-        const originalContent = originalFile.content;
-        if (context.toolCallId) {
-          previewContentHashCache.set(
-            context.toolCallId,
-            computeContentHash(originalContent)
-          );
-        }
-        if (!replace_all) {
-          const occurrences = originalContent.split(old_string).length - 1;
-          if (occurrences > 1) {
+    presentation: {
+      describeHeader: (input) => (0, import_core.createLocalToolCallHeader)({
+        title: "Update",
+        argsText: (0, import_core.truncateForHeader)(input.file_path, 140)
+      }),
+      /**
+       * Generate preview for approval UI - shows diff without modifying file
+       * Throws ToolError.validationFailed() for validation errors (file not found, string not found)
+       * Stores content hash for change detection in execute phase.
+       */
+      preview: async (input, context) => {
+        const { file_path, old_string, new_string, replace_all } = input;
+        const resolvedFileSystemService = await getFileSystemService(context);
+        const { path: resolvedPath } = (0, import_directory_approval.resolveFilePath)(
+          resolvedFileSystemService.getWorkingDirectory(),
+          file_path
+        );
+        try {
+          let originalContent;
+          try {
+            const originalFile = await resolvedFileSystemService.readFile(resolvedPath);
+            originalContent = originalFile.content;
+          } catch (error) {
+            if (error instanceof import_core.DextoRuntimeError && error.code === import_error_codes.FileSystemErrorCode.INVALID_PATH) {
+              const originalFile = await resolvedFileSystemService.readFileForToolPreview(
+                resolvedPath
+              );
+              originalContent = originalFile.content;
+            } else {
+              throw error;
+            }
+          }
+          if (context.toolCallId) {
+            previewContentHashCache.set(
+              context.toolCallId,
+              computeContentHash(originalContent)
+            );
+          }
+          if (!replace_all) {
+            const occurrences = originalContent.split(old_string).length - 1;
+            if (occurrences > 1) {
+              throw import_core.ToolError.validationFailed(
+                "edit_file",
+                `String found ${occurrences} times in file. Set replace_all=true to replace all, or provide more context to make old_string unique.`,
+                { file_path: resolvedPath, occurrences }
+              );
+            }
+          }
+          const newContent = replace_all ? originalContent.split(old_string).join(new_string) : originalContent.replace(old_string, new_string);
+          if (originalContent === newContent) {
             throw import_core.ToolError.validationFailed(
               "edit_file",
-              `String found ${occurrences} times in file. Set replace_all=true to replace all, or provide more context to make old_string unique.`,
-              { file_path: resolvedPath, occurrences }
+              `String not found in file: "${old_string.slice(0, 50)}${old_string.length > 50 ? "..." : ""}"`,
+              {
+                file_path: resolvedPath,
+                old_string_preview: old_string.slice(0, 100)
+              }
             );
           }
+          return generateDiffPreview(resolvedPath, originalContent, newContent);
+        } catch (error) {
+          if (error instanceof import_core.DextoRuntimeError && error.code === import_core.ToolErrorCode.VALIDATION_FAILED) {
+            throw error;
+          }
+          if (error instanceof import_core.DextoRuntimeError) {
+            throw import_core.ToolError.validationFailed("edit_file", error.message, {
+              file_path: resolvedPath,
+              originalErrorCode: error.code
+            });
+          }
+          return null;
         }
-        const newContent = replace_all ? originalContent.split(old_string).join(new_string) : originalContent.replace(old_string, new_string);
-        if (originalContent === newContent) {
-          throw import_core.ToolError.validationFailed(
-            "edit_file",
-            `String not found in file: "${old_string.slice(0, 50)}${old_string.length > 50 ? "..." : ""}"`,
-            { file_path: resolvedPath, old_string_preview: old_string.slice(0, 100) }
-          );
-        }
-        return generateDiffPreview(resolvedPath, originalContent, newContent);
-      } catch (error) {
-        if (error instanceof import_core.DextoRuntimeError && error.code === import_core.ToolErrorCode.VALIDATION_FAILED) {
-          throw error;
-        }
-        if (error instanceof import_core.DextoRuntimeError) {
-          throw import_core.ToolError.validationFailed("edit_file", error.message, {
-            file_path: resolvedPath,
-            originalErrorCode: error.code
-          });
-        }
-        return null;
       }
     },
     async execute(input, context) {

package/dist/edit-file-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"edit-file-tool.d.ts","sourceRoot":"","sources":["../src/edit-file-tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAE9D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAkBpE,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;EAaZ,CAAC;AAyBd;;GAEG;AACH,wBAAgB,kBAAkB,CAC9B,oBAAoB,EAAE,uBAAuB,GAC9C,IAAI,CAAC,OAAO,mBAAmB,CAAC,CAgKlC"}
+{"version":3,"file":"edit-file-tool.d.ts","sourceRoot":"","sources":["../src/edit-file-tool.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAE9D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAkBpE,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;;;EAaZ,CAAC;AA0Bd;;GAEG;AACH,wBAAgB,kBAAkB,CAC9B,oBAAoB,EAAE,uBAAuB,GAC9C,IAAI,CAAC,OAAO,mBAAmB,CAAC,CA2LlC"}

package/dist/edit-file-tool.js

@@ -1,7 +1,14 @@
 import { createHash } from "node:crypto";
 import { z } from "zod";
 import { createPatch } from "diff";
-import { DextoRuntimeError, ToolError, ToolErrorCode, defineTool } from "@dexto/core";
+import {
+  createLocalToolCallHeader,
+  DextoRuntimeError,
+  ToolError,
+  ToolErrorCode,
+  defineTool,
+  truncateForHeader
+} from "@dexto/core";
 import { FileSystemErrorCode } from "./error-codes.js";
 import { createDirectoryAccessApprovalHandlers, resolveFilePath } from "./directory-approval.js";
 const previewContentHashCache = /* @__PURE__ */ new Map();
@@ -22,6 +29,7 @@ function generateDiffPreview(filePath, originalContent, newContent) {
   const deletions = (unified.match(/^-[^-]/gm) || []).length;
   return {
     type: "diff",
+    title: "Update file",
     unified,
     filename: filePath,
     additions,
@@ -31,67 +39,88 @@ function generateDiffPreview(filePath, originalContent, newContent) {
 function createEditFileTool(getFileSystemService) {
   return defineTool({
     id: "edit_file",
-    displayName: "Update",
     aliases: ["edit"],
     description: "Edit a file by replacing text. By default, old_string must be unique in the file (will error if found multiple times). Set replace_all=true to replace all occurrences. Automatically creates backup before editing. Requires approval. Returns success status, path, number of changes made, and backup path.",
     inputSchema: EditFileInputSchema,
     ...createDirectoryAccessApprovalHandlers({
       toolName: "edit_file",
       operation: "edit",
+      inputSchema: EditFileInputSchema,
       getFileSystemService,
       resolvePaths: (input, fileSystemService) => resolveFilePath(fileSystemService.getWorkingDirectory(), input.file_path)
     }),
-    /**
-     * Generate preview for approval UI - shows diff without modifying file
-     * Throws ToolError.validationFailed() for validation errors (file not found, string not found)
-     * Stores content hash for change detection in execute phase.
-     */
-    async generatePreview(input, context) {
-      const { file_path, old_string, new_string, replace_all } = input;
-      const resolvedFileSystemService = await getFileSystemService(context);
-      const { path: resolvedPath } = resolveFilePath(
-        resolvedFileSystemService.getWorkingDirectory(),
-        file_path
-      );
-      try {
-        const originalFile = await resolvedFileSystemService.readFile(resolvedPath);
-        const originalContent = originalFile.content;
-        if (context.toolCallId) {
-          previewContentHashCache.set(
-            context.toolCallId,
-            computeContentHash(originalContent)
-          );
-        }
-        if (!replace_all) {
-          const occurrences = originalContent.split(old_string).length - 1;
-          if (occurrences > 1) {
+    presentation: {
+      describeHeader: (input) => createLocalToolCallHeader({
+        title: "Update",
+        argsText: truncateForHeader(input.file_path, 140)
+      }),
+      /**
+       * Generate preview for approval UI - shows diff without modifying file
+       * Throws ToolError.validationFailed() for validation errors (file not found, string not found)
+       * Stores content hash for change detection in execute phase.
+       */
+      preview: async (input, context) => {
+        const { file_path, old_string, new_string, replace_all } = input;
+        const resolvedFileSystemService = await getFileSystemService(context);
+        const { path: resolvedPath } = resolveFilePath(
+          resolvedFileSystemService.getWorkingDirectory(),
+          file_path
+        );
+        try {
+          let originalContent;
+          try {
+            const originalFile = await resolvedFileSystemService.readFile(resolvedPath);
+            originalContent = originalFile.content;
+          } catch (error) {
+            if (error instanceof DextoRuntimeError && error.code === FileSystemErrorCode.INVALID_PATH) {
+              const originalFile = await resolvedFileSystemService.readFileForToolPreview(
+                resolvedPath
+              );
+              originalContent = originalFile.content;
+            } else {
+              throw error;
+            }
+          }
+          if (context.toolCallId) {
+            previewContentHashCache.set(
+              context.toolCallId,
+              computeContentHash(originalContent)
+            );
+          }
+          if (!replace_all) {
+            const occurrences = originalContent.split(old_string).length - 1;
+            if (occurrences > 1) {
+              throw ToolError.validationFailed(
+                "edit_file",
+                `String found ${occurrences} times in file. Set replace_all=true to replace all, or provide more context to make old_string unique.`,
+                { file_path: resolvedPath, occurrences }
+              );
+            }
+          }
+          const newContent = replace_all ? originalContent.split(old_string).join(new_string) : originalContent.replace(old_string, new_string);
+          if (originalContent === newContent) {
             throw ToolError.validationFailed(
               "edit_file",
-              `String found ${occurrences} times in file. Set replace_all=true to replace all, or provide more context to make old_string unique.`,
-              { file_path: resolvedPath, occurrences }
+              `String not found in file: "${old_string.slice(0, 50)}${old_string.length > 50 ? "..." : ""}"`,
+              {
+                file_path: resolvedPath,
+                old_string_preview: old_string.slice(0, 100)
+              }
             );
           }
+          return generateDiffPreview(resolvedPath, originalContent, newContent);
+        } catch (error) {
+          if (error instanceof DextoRuntimeError && error.code === ToolErrorCode.VALIDATION_FAILED) {
+            throw error;
+          }
+          if (error instanceof DextoRuntimeError) {
+            throw ToolError.validationFailed("edit_file", error.message, {
+              file_path: resolvedPath,
+              originalErrorCode: error.code
+            });
+          }
+          return null;
         }
-        const newContent = replace_all ? originalContent.split(old_string).join(new_string) : originalContent.replace(old_string, new_string);
-        if (originalContent === newContent) {
-          throw ToolError.validationFailed(
-            "edit_file",
-            `String not found in file: "${old_string.slice(0, 50)}${old_string.length > 50 ? "..." : ""}"`,
-            { file_path: resolvedPath, old_string_preview: old_string.slice(0, 100) }
-          );
-        }
-        return generateDiffPreview(resolvedPath, originalContent, newContent);
-      } catch (error) {
-        if (error instanceof DextoRuntimeError && error.code === ToolErrorCode.VALIDATION_FAILED) {
-          throw error;
-        }
-        if (error instanceof DextoRuntimeError) {
-          throw ToolError.validationFailed("edit_file", error.message, {
-            file_path: resolvedPath,
-            originalErrorCode: error.code
-          });
-        }
-        return null;
       }
     },
     async execute(input, context) {

package/dist/edit-file-tool.test.cjs

@@ -38,6 +38,7 @@ const createMockLogger = () => {
     error: import_vitest.vi.fn(),
     trackException: import_vitest.vi.fn(),
     createChild: import_vitest.vi.fn(() => logger),
+    createFileOnlyChild: import_vitest.vi.fn(() => logger),
     setLevel: import_vitest.vi.fn(),
     getLevel: import_vitest.vi.fn(() => "debug"),
     getLogFilePath: import_vitest.vi.fn(() => null),
@@ -78,8 +79,43 @@ function createToolContext(logger, overrides = {}) {
     }
   });
   (0, import_vitest.describe)("File Modification Detection", () => {
+    (0, import_vitest.it)("should generate preview for files outside config-allowed roots (preview read only)", async () => {
+      const tool = (0, import_edit_file_tool.createEditFileTool)(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
+      const rawExternalDir = await fs.mkdtemp(
+        path.join(os.tmpdir(), "dexto-edit-outside-allowed-")
+      );
+      const externalDir = await fs.realpath(rawExternalDir);
+      const externalFile = path.join(externalDir, "external.txt");
+      try {
+        await fs.writeFile(externalFile, "hello world");
+        const toolCallId = "preview-outside-roots";
+        const parsedInput = tool.inputSchema.parse({
+          file_path: externalFile,
+          old_string: "world",
+          new_string: "universe"
+        });
+        const preview = await previewFn(
+          parsedInput,
+          createToolContext(mockLogger, { toolCallId })
+        );
+        (0, import_vitest.expect)(preview).toBeDefined();
+        (0, import_vitest.expect)(preview?.type).toBe("diff");
+        if (preview?.type === "diff") {
+          (0, import_vitest.expect)(preview.title).toBe("Update file");
+          (0, import_vitest.expect)(preview.filename).toBe(externalFile);
+        } else {
+          import_vitest.expect.fail("Expected diff preview");
+        }
+      } finally {
+        await fs.rm(externalDir, { recursive: true, force: true });
+      }
+    });
     (0, import_vitest.it)("should succeed when file is not modified between preview and execute", async () => {
       const tool = (0, import_edit_file_tool.createEditFileTool)(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-123";
@@ -89,7 +125,7 @@ function createToolContext(logger, overrides = {}) {
         new_string: "universe"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      const preview = await tool.generatePreview(
+      const preview = await previewFn(
         parsedInput,
         createToolContext(mockLogger, { toolCallId })
       );
@@ -105,6 +141,8 @@ function createToolContext(logger, overrides = {}) {
     });
     (0, import_vitest.it)("should fail when file is modified between preview and execute", async () => {
       const tool = (0, import_edit_file_tool.createEditFileTool)(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-456";
@@ -114,7 +152,7 @@ function createToolContext(logger, overrides = {}) {
         new_string: "universe"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      const preview = await tool.generatePreview(
+      const preview = await previewFn(
         parsedInput,
         createToolContext(mockLogger, { toolCallId })
       );
@@ -134,6 +172,8 @@ function createToolContext(logger, overrides = {}) {
     });
     (0, import_vitest.it)("should detect file modification with correct error code", async () => {
       const tool = (0, import_edit_file_tool.createEditFileTool)(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-789";
@@ -143,7 +183,7 @@ function createToolContext(logger, overrides = {}) {
         new_string: "universe"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      await previewFn(parsedInput, createToolContext(mockLogger, { toolCallId }));
       await fs.writeFile(testFile, "hello world modified");
       try {
         await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
@@ -161,6 +201,8 @@ function createToolContext(logger, overrides = {}) {
     });
     (0, import_vitest.it)("should work without toolCallId (no modification check)", async () => {
       const tool = (0, import_edit_file_tool.createEditFileTool)(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const input = {
@@ -169,7 +211,7 @@ function createToolContext(logger, overrides = {}) {
         new_string: "universe"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      await tool.generatePreview(parsedInput, createToolContext(mockLogger));
+      await previewFn(parsedInput, createToolContext(mockLogger));
       await fs.writeFile(testFile, "hello world changed");
       try {
         await tool.execute(parsedInput, createToolContext(mockLogger));
@@ -182,6 +224,8 @@ function createToolContext(logger, overrides = {}) {
     });
     (0, import_vitest.it)("should clean up hash cache after successful execution", async () => {
       const tool = (0, import_edit_file_tool.createEditFileTool)(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-cleanup";
@@ -191,7 +235,7 @@ function createToolContext(logger, overrides = {}) {
         new_string: "universe"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      await previewFn(parsedInput, createToolContext(mockLogger, { toolCallId }));
       await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
       const input2 = {
         file_path: testFile,
@@ -199,10 +243,7 @@ function createToolContext(logger, overrides = {}) {
         new_string: "galaxy"
       };
       const parsedInput2 = tool.inputSchema.parse(input2);
-      await tool.generatePreview(
-        parsedInput2,
-        createToolContext(mockLogger, { toolCallId })
-      );
+      await previewFn(parsedInput2, createToolContext(mockLogger, { toolCallId }));
       const result = await tool.execute(
         parsedInput2,
         createToolContext(mockLogger, { toolCallId })
@@ -213,6 +254,8 @@ function createToolContext(logger, overrides = {}) {
     });
     (0, import_vitest.it)("should clean up hash cache after failed execution", async () => {
       const tool = (0, import_edit_file_tool.createEditFileTool)(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-fail-cleanup";
@@ -222,14 +265,14 @@ function createToolContext(logger, overrides = {}) {
         new_string: "universe"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      await previewFn(parsedInput, createToolContext(mockLogger, { toolCallId }));
       await fs.writeFile(testFile, "hello world modified");
       try {
         await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
       } catch {
       }
       await fs.writeFile(testFile, "hello world");
-      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      await previewFn(parsedInput, createToolContext(mockLogger, { toolCallId }));
       const result = await tool.execute(
         parsedInput,
         createToolContext(mockLogger, { toolCallId })

package/dist/edit-file-tool.test.js

@@ -15,6 +15,7 @@ const createMockLogger = () => {
     error: vi.fn(),
     trackException: vi.fn(),
     createChild: vi.fn(() => logger),
+    createFileOnlyChild: vi.fn(() => logger),
     setLevel: vi.fn(),
     getLevel: vi.fn(() => "debug"),
     getLogFilePath: vi.fn(() => null),
@@ -55,8 +56,43 @@ describe("edit_file tool", () => {
     }
   });
   describe("File Modification Detection", () => {
+    it("should generate preview for files outside config-allowed roots (preview read only)", async () => {
+      const tool = createEditFileTool(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      expect(previewFn).toBeDefined();
+      const rawExternalDir = await fs.mkdtemp(
+        path.join(os.tmpdir(), "dexto-edit-outside-allowed-")
+      );
+      const externalDir = await fs.realpath(rawExternalDir);
+      const externalFile = path.join(externalDir, "external.txt");
+      try {
+        await fs.writeFile(externalFile, "hello world");
+        const toolCallId = "preview-outside-roots";
+        const parsedInput = tool.inputSchema.parse({
+          file_path: externalFile,
+          old_string: "world",
+          new_string: "universe"
+        });
+        const preview = await previewFn(
+          parsedInput,
+          createToolContext(mockLogger, { toolCallId })
+        );
+        expect(preview).toBeDefined();
+        expect(preview?.type).toBe("diff");
+        if (preview?.type === "diff") {
+          expect(preview.title).toBe("Update file");
+          expect(preview.filename).toBe(externalFile);
+        } else {
+          expect.fail("Expected diff preview");
+        }
+      } finally {
+        await fs.rm(externalDir, { recursive: true, force: true });
+      }
+    });
     it("should succeed when file is not modified between preview and execute", async () => {
       const tool = createEditFileTool(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      expect(previewFn).toBeDefined();
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-123";
@@ -66,7 +102,7 @@ describe("edit_file tool", () => {
         new_string: "universe"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      const preview = await tool.generatePreview(
+      const preview = await previewFn(
         parsedInput,
         createToolContext(mockLogger, { toolCallId })
       );
@@ -82,6 +118,8 @@ describe("edit_file tool", () => {
     });
     it("should fail when file is modified between preview and execute", async () => {
       const tool = createEditFileTool(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      expect(previewFn).toBeDefined();
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-456";
@@ -91,7 +129,7 @@ describe("edit_file tool", () => {
         new_string: "universe"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      const preview = await tool.generatePreview(
+      const preview = await previewFn(
         parsedInput,
         createToolContext(mockLogger, { toolCallId })
       );
@@ -111,6 +149,8 @@ describe("edit_file tool", () => {
     });
     it("should detect file modification with correct error code", async () => {
       const tool = createEditFileTool(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      expect(previewFn).toBeDefined();
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-789";
@@ -120,7 +160,7 @@ describe("edit_file tool", () => {
         new_string: "universe"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      await previewFn(parsedInput, createToolContext(mockLogger, { toolCallId }));
       await fs.writeFile(testFile, "hello world modified");
       try {
         await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
@@ -138,6 +178,8 @@ describe("edit_file tool", () => {
     });
     it("should work without toolCallId (no modification check)", async () => {
       const tool = createEditFileTool(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      expect(previewFn).toBeDefined();
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const input = {
@@ -146,7 +188,7 @@ describe("edit_file tool", () => {
         new_string: "universe"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      await tool.generatePreview(parsedInput, createToolContext(mockLogger));
+      await previewFn(parsedInput, createToolContext(mockLogger));
       await fs.writeFile(testFile, "hello world changed");
       try {
         await tool.execute(parsedInput, createToolContext(mockLogger));
@@ -159,6 +201,8 @@ describe("edit_file tool", () => {
     });
     it("should clean up hash cache after successful execution", async () => {
       const tool = createEditFileTool(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      expect(previewFn).toBeDefined();
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-cleanup";
@@ -168,7 +212,7 @@ describe("edit_file tool", () => {
         new_string: "universe"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      await previewFn(parsedInput, createToolContext(mockLogger, { toolCallId }));
       await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
       const input2 = {
         file_path: testFile,
@@ -176,10 +220,7 @@ describe("edit_file tool", () => {
         new_string: "galaxy"
       };
       const parsedInput2 = tool.inputSchema.parse(input2);
-      await tool.generatePreview(
-        parsedInput2,
-        createToolContext(mockLogger, { toolCallId })
-      );
+      await previewFn(parsedInput2, createToolContext(mockLogger, { toolCallId }));
       const result = await tool.execute(
         parsedInput2,
         createToolContext(mockLogger, { toolCallId })
@@ -190,6 +231,8 @@ describe("edit_file tool", () => {
     });
     it("should clean up hash cache after failed execution", async () => {
       const tool = createEditFileTool(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      expect(previewFn).toBeDefined();
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "hello world");
       const toolCallId = "test-call-fail-cleanup";
@@ -199,14 +242,14 @@ describe("edit_file tool", () => {
         new_string: "universe"
       };
       const parsedInput = tool.inputSchema.parse(input);
-      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      await previewFn(parsedInput, createToolContext(mockLogger, { toolCallId }));
       await fs.writeFile(testFile, "hello world modified");
       try {
         await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
       } catch {
       }
       await fs.writeFile(testFile, "hello world");
-      await tool.generatePreview(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      await previewFn(parsedInput, createToolContext(mockLogger, { toolCallId }));
       const result = await tool.execute(
         parsedInput,
         createToolContext(mockLogger, { toolCallId })

package/dist/error-codes.cjs

@@ -34,7 +34,11 @@ var FileSystemErrorCode = /* @__PURE__ */ ((FileSystemErrorCode2) => {
   FileSystemErrorCode2["FILE_TOO_LARGE"] = "FILESYSTEM_FILE_TOO_LARGE";
   FileSystemErrorCode2["TOO_MANY_RESULTS"] = "FILESYSTEM_TOO_MANY_RESULTS";
   FileSystemErrorCode2["READ_FAILED"] = "FILESYSTEM_READ_FAILED";
+  FileSystemErrorCode2["LIST_FAILED"] = "FILESYSTEM_LIST_FAILED";
   FileSystemErrorCode2["WRITE_FAILED"] = "FILESYSTEM_WRITE_FAILED";
+  FileSystemErrorCode2["CREATE_DIR_FAILED"] = "FILESYSTEM_CREATE_DIR_FAILED";
+  FileSystemErrorCode2["DELETE_FAILED"] = "FILESYSTEM_DELETE_FAILED";
+  FileSystemErrorCode2["RENAME_FAILED"] = "FILESYSTEM_RENAME_FAILED";
   FileSystemErrorCode2["BACKUP_FAILED"] = "FILESYSTEM_BACKUP_FAILED";
   FileSystemErrorCode2["EDIT_FAILED"] = "FILESYSTEM_EDIT_FAILED";
   FileSystemErrorCode2["STRING_NOT_UNIQUE"] = "FILESYSTEM_STRING_NOT_UNIQUE";