@dexto/tools-filesystem 1.5.8 → 1.6.1

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

@@ -29,13 +29,26 @@ var import_write_file_tool = require("./write-file-tool.js");
 var import_filesystem_service = require("./filesystem-service.js");
 var import_core = require("@dexto/core");
 var import_core2 = require("@dexto/core");
-const createMockLogger = () => ({
-  debug: import_vitest.vi.fn(),
-  info: import_vitest.vi.fn(),
-  warn: import_vitest.vi.fn(),
-  error: import_vitest.vi.fn(),
-  createChild: import_vitest.vi.fn().mockReturnThis()
-});
+const createMockLogger = () => {
+  const logger = {
+    debug: import_vitest.vi.fn(),
+    silly: import_vitest.vi.fn(),
+    info: import_vitest.vi.fn(),
+    warn: import_vitest.vi.fn(),
+    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),
+    destroy: import_vitest.vi.fn(async () => void 0)
+  };
+  return logger;
+};
+function createToolContext(logger, overrides = {}) {
+  return { logger, ...overrides };
+}
 (0, import_vitest.describe)("write_file tool", () => {
   let mockLogger;
   let tempDir;
@@ -66,8 +79,38 @@ const createMockLogger = () => ({
     }
   });
   (0, import_vitest.describe)("File Modification Detection - Existing Files", () => {
+    (0, import_vitest.it)("should generate preview for existing files outside config-allowed roots (preview read only)", async () => {
+      const tool = (0, import_write_file_tool.createWriteFileTool)(async () => fileSystemService);
+      const rawExternalDir = await fs.mkdtemp(
+        path.join(os.tmpdir(), "dexto-write-outside-allowed-")
+      );
+      const externalDir = await fs.realpath(rawExternalDir);
+      const externalFile = path.join(externalDir, "external.txt");
+      try {
+        await fs.writeFile(externalFile, "original content");
+        const toolCallId = "preview-outside-roots";
+        const parsedInput = tool.inputSchema.parse({
+          file_path: externalFile,
+          content: "new content"
+        });
+        const preview = await tool.presentation.preview(
+          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 existing file is not modified between preview and execute", async () => {
-      const tool = (0, import_write_file_tool.createWriteFileTool)({ fileSystemService });
+      const tool = (0, import_write_file_tool.createWriteFileTool)(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "original content");
       const toolCallId = "test-call-123";
@@ -75,17 +118,29 @@ const createMockLogger = () => ({
         file_path: testFile,
         content: "new content"
       };
-      const preview = await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      const preview = await tool.presentation.preview(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       (0, import_vitest.expect)(preview).toBeDefined();
       (0, import_vitest.expect)(preview?.type).toBe("diff");
-      const result = await tool.execute(input, { toolCallId });
+      if (preview?.type === "diff") {
+        (0, import_vitest.expect)(preview.title).toBe("Update file");
+      } else {
+        import_vitest.expect.fail("Expected diff preview");
+      }
+      const result = await tool.execute(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       (0, import_vitest.expect)(result.success).toBe(true);
       (0, import_vitest.expect)(result.path).toBe(testFile);
       const content = await fs.readFile(testFile, "utf-8");
       (0, import_vitest.expect)(content).toBe("new content");
     });
     (0, import_vitest.it)("should fail when existing file is modified between preview and execute", async () => {
-      const tool = (0, import_write_file_tool.createWriteFileTool)({ fileSystemService });
+      const tool = (0, import_write_file_tool.createWriteFileTool)(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "original content");
       const toolCallId = "test-call-456";
@@ -93,10 +148,14 @@ const createMockLogger = () => ({
         file_path: testFile,
         content: "new content"
       };
-      await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      await tool.presentation.preview(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       await fs.writeFile(testFile, "user modified this");
       try {
-        await tool.execute(input, { toolCallId });
+        await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
         import_vitest.expect.fail("Should have thrown an error");
       } catch (error) {
         (0, import_vitest.expect)(error).toBeInstanceOf(import_core2.DextoRuntimeError);
@@ -108,7 +167,7 @@ const createMockLogger = () => ({
       (0, import_vitest.expect)(content).toBe("user modified this");
     });
     (0, import_vitest.it)("should fail when existing file is deleted between preview and execute", async () => {
-      const tool = (0, import_write_file_tool.createWriteFileTool)({ fileSystemService });
+      const tool = (0, import_write_file_tool.createWriteFileTool)(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "original content");
       const toolCallId = "test-call-deleted";
@@ -116,10 +175,14 @@ const createMockLogger = () => ({
         file_path: testFile,
         content: "new content"
       };
-      await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      await tool.presentation.preview(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       await fs.unlink(testFile);
       try {
-        await tool.execute(input, { toolCallId });
+        await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
         import_vitest.expect.fail("Should have thrown an error");
       } catch (error) {
         (0, import_vitest.expect)(error).toBeInstanceOf(import_core2.DextoRuntimeError);
@@ -131,35 +194,62 @@ const createMockLogger = () => ({
   });
   (0, import_vitest.describe)("File Modification Detection - New Files", () => {
     (0, import_vitest.it)("should succeed when creating new file that still does not exist", async () => {
-      const tool = (0, import_write_file_tool.createWriteFileTool)({ fileSystemService });
+      const tool = (0, import_write_file_tool.createWriteFileTool)(async () => fileSystemService);
       const testFile = path.join(tempDir, "new-file.txt");
       const toolCallId = "test-call-new";
       const input = {
         file_path: testFile,
         content: "brand new content"
       };
-      const preview = await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      const preview = await tool.presentation.preview(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       (0, import_vitest.expect)(preview).toBeDefined();
       (0, import_vitest.expect)(preview?.type).toBe("file");
-      (0, import_vitest.expect)(preview.operation).toBe("create");
-      const result = await tool.execute(input, { toolCallId });
+      if (preview?.type === "file") {
+        (0, import_vitest.expect)(preview.operation).toBe("create");
+        (0, import_vitest.expect)(preview.title).toBe("Create file");
+      } else {
+        import_vitest.expect.fail("Expected file preview");
+      }
+      const result = await tool.execute(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       (0, import_vitest.expect)(result.success).toBe(true);
+      const display = result._display;
+      if (display && typeof display === "object" && "type" in display) {
+        (0, import_vitest.expect)(display.type).toBe("file");
+        const fileDisplay = display;
+        (0, import_vitest.expect)(fileDisplay.title).toBe("Create file");
+        (0, import_vitest.expect)(fileDisplay.content).toBe("brand new content");
+      } else {
+        import_vitest.expect.fail("Expected result._display");
+      }
       const content = await fs.readFile(testFile, "utf-8");
       (0, import_vitest.expect)(content).toBe("brand new content");
     });
     (0, import_vitest.it)("should fail when file is created by someone else between preview and execute", async () => {
-      const tool = (0, import_write_file_tool.createWriteFileTool)({ fileSystemService });
+      const tool = (0, import_write_file_tool.createWriteFileTool)(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
       const testFile = path.join(tempDir, "race-condition.txt");
       const toolCallId = "test-call-race";
       const input = {
         file_path: testFile,
         content: "agent content"
       };
-      const preview = await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      const preview = await previewFn(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       (0, import_vitest.expect)(preview?.type).toBe("file");
       await fs.writeFile(testFile, "someone else created this");
       try {
-        await tool.execute(input, { toolCallId });
+        await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
         import_vitest.expect.fail("Should have thrown an error");
       } catch (error) {
         (0, import_vitest.expect)(error).toBeInstanceOf(import_core2.DextoRuntimeError);
@@ -173,7 +263,7 @@ const createMockLogger = () => ({
   });
   (0, import_vitest.describe)("Cache Cleanup", () => {
     (0, import_vitest.it)("should clean up hash cache after successful execution", async () => {
-      const tool = (0, import_write_file_tool.createWriteFileTool)({ fileSystemService });
+      const tool = (0, import_write_file_tool.createWriteFileTool)(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "original");
       const toolCallId = "test-call-cleanup";
@@ -181,20 +271,30 @@ const createMockLogger = () => ({
         file_path: testFile,
         content: "first write"
       };
-      await tool.generatePreview(input, { toolCallId });
-      await tool.execute(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      await tool.presentation.preview(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
+      await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
       const input2 = {
         file_path: testFile,
         content: "second write"
       };
-      await tool.generatePreview(input2, { toolCallId });
-      const result = await tool.execute(input2, { toolCallId });
+      const parsedInput2 = tool.inputSchema.parse(input2);
+      const previewFn2 = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn2).toBeDefined();
+      await previewFn2(parsedInput2, createToolContext(mockLogger, { toolCallId }));
+      const result = await tool.execute(
+        parsedInput2,
+        createToolContext(mockLogger, { toolCallId })
+      );
       (0, import_vitest.expect)(result.success).toBe(true);
       const content = await fs.readFile(testFile, "utf-8");
       (0, import_vitest.expect)(content).toBe("second write");
     });
     (0, import_vitest.it)("should clean up hash cache after failed execution", async () => {
-      const tool = (0, import_write_file_tool.createWriteFileTool)({ fileSystemService });
+      const tool = (0, import_write_file_tool.createWriteFileTool)(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "original");
       const toolCallId = "test-call-fail";
@@ -202,15 +302,21 @@ const createMockLogger = () => ({
         file_path: testFile,
         content: "new content"
       };
-      await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
+      await previewFn(parsedInput, createToolContext(mockLogger, { toolCallId }));
       await fs.writeFile(testFile, "modified");
       try {
-        await tool.execute(input, { toolCallId });
+        await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
       } catch {
       }
       await fs.writeFile(testFile, "reset content");
-      await tool.generatePreview(input, { toolCallId });
-      const result = await tool.execute(input, { toolCallId });
+      await previewFn(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      const result = await tool.execute(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       (0, import_vitest.expect)(result.success).toBe(true);
     });
   });

package/dist/write-file-tool.test.d.ts

@@ -1,2 +1,7 @@
-
-export {  }
+/**
+ * Write File Tool Tests
+ *
+ * Tests for the write_file tool including file modification detection.
+ */
+export {};
+//# sourceMappingURL=write-file-tool.test.d.ts.map

package/dist/write-file-tool.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-file-tool.test.d.ts","sourceRoot":"","sources":["../src/write-file-tool.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

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

@@ -6,13 +6,26 @@ import { createWriteFileTool } from "./write-file-tool.js";
 import { FileSystemService } from "./filesystem-service.js";
 import { ToolErrorCode } from "@dexto/core";
 import { DextoRuntimeError } from "@dexto/core";
-const createMockLogger = () => ({
-  debug: vi.fn(),
-  info: vi.fn(),
-  warn: vi.fn(),
-  error: vi.fn(),
-  createChild: vi.fn().mockReturnThis()
-});
+const createMockLogger = () => {
+  const logger = {
+    debug: vi.fn(),
+    silly: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    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),
+    destroy: vi.fn(async () => void 0)
+  };
+  return logger;
+};
+function createToolContext(logger, overrides = {}) {
+  return { logger, ...overrides };
+}
 describe("write_file tool", () => {
   let mockLogger;
   let tempDir;
@@ -43,8 +56,38 @@ describe("write_file tool", () => {
     }
   });
   describe("File Modification Detection - Existing Files", () => {
+    it("should generate preview for existing files outside config-allowed roots (preview read only)", async () => {
+      const tool = createWriteFileTool(async () => fileSystemService);
+      const rawExternalDir = await fs.mkdtemp(
+        path.join(os.tmpdir(), "dexto-write-outside-allowed-")
+      );
+      const externalDir = await fs.realpath(rawExternalDir);
+      const externalFile = path.join(externalDir, "external.txt");
+      try {
+        await fs.writeFile(externalFile, "original content");
+        const toolCallId = "preview-outside-roots";
+        const parsedInput = tool.inputSchema.parse({
+          file_path: externalFile,
+          content: "new content"
+        });
+        const preview = await tool.presentation.preview(
+          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 existing file is not modified between preview and execute", async () => {
-      const tool = createWriteFileTool({ fileSystemService });
+      const tool = createWriteFileTool(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "original content");
       const toolCallId = "test-call-123";
@@ -52,17 +95,29 @@ describe("write_file tool", () => {
         file_path: testFile,
         content: "new content"
       };
-      const preview = await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      const preview = await tool.presentation.preview(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       expect(preview).toBeDefined();
       expect(preview?.type).toBe("diff");
-      const result = await tool.execute(input, { toolCallId });
+      if (preview?.type === "diff") {
+        expect(preview.title).toBe("Update file");
+      } else {
+        expect.fail("Expected diff preview");
+      }
+      const result = await tool.execute(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       expect(result.success).toBe(true);
       expect(result.path).toBe(testFile);
       const content = await fs.readFile(testFile, "utf-8");
       expect(content).toBe("new content");
     });
     it("should fail when existing file is modified between preview and execute", async () => {
-      const tool = createWriteFileTool({ fileSystemService });
+      const tool = createWriteFileTool(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "original content");
       const toolCallId = "test-call-456";
@@ -70,10 +125,14 @@ describe("write_file tool", () => {
         file_path: testFile,
         content: "new content"
       };
-      await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      await tool.presentation.preview(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       await fs.writeFile(testFile, "user modified this");
       try {
-        await tool.execute(input, { toolCallId });
+        await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
         expect.fail("Should have thrown an error");
       } catch (error) {
         expect(error).toBeInstanceOf(DextoRuntimeError);
@@ -85,7 +144,7 @@ describe("write_file tool", () => {
       expect(content).toBe("user modified this");
     });
     it("should fail when existing file is deleted between preview and execute", async () => {
-      const tool = createWriteFileTool({ fileSystemService });
+      const tool = createWriteFileTool(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "original content");
       const toolCallId = "test-call-deleted";
@@ -93,10 +152,14 @@ describe("write_file tool", () => {
         file_path: testFile,
         content: "new content"
       };
-      await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      await tool.presentation.preview(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       await fs.unlink(testFile);
       try {
-        await tool.execute(input, { toolCallId });
+        await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
         expect.fail("Should have thrown an error");
       } catch (error) {
         expect(error).toBeInstanceOf(DextoRuntimeError);
@@ -108,35 +171,62 @@ describe("write_file tool", () => {
   });
   describe("File Modification Detection - New Files", () => {
     it("should succeed when creating new file that still does not exist", async () => {
-      const tool = createWriteFileTool({ fileSystemService });
+      const tool = createWriteFileTool(async () => fileSystemService);
       const testFile = path.join(tempDir, "new-file.txt");
       const toolCallId = "test-call-new";
       const input = {
         file_path: testFile,
         content: "brand new content"
       };
-      const preview = await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      const preview = await tool.presentation.preview(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       expect(preview).toBeDefined();
       expect(preview?.type).toBe("file");
-      expect(preview.operation).toBe("create");
-      const result = await tool.execute(input, { toolCallId });
+      if (preview?.type === "file") {
+        expect(preview.operation).toBe("create");
+        expect(preview.title).toBe("Create file");
+      } else {
+        expect.fail("Expected file preview");
+      }
+      const result = await tool.execute(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       expect(result.success).toBe(true);
+      const display = result._display;
+      if (display && typeof display === "object" && "type" in display) {
+        expect(display.type).toBe("file");
+        const fileDisplay = display;
+        expect(fileDisplay.title).toBe("Create file");
+        expect(fileDisplay.content).toBe("brand new content");
+      } else {
+        expect.fail("Expected result._display");
+      }
       const content = await fs.readFile(testFile, "utf-8");
       expect(content).toBe("brand new content");
     });
     it("should fail when file is created by someone else between preview and execute", async () => {
-      const tool = createWriteFileTool({ fileSystemService });
+      const tool = createWriteFileTool(async () => fileSystemService);
+      const previewFn = tool.presentation?.preview;
+      expect(previewFn).toBeDefined();
       const testFile = path.join(tempDir, "race-condition.txt");
       const toolCallId = "test-call-race";
       const input = {
         file_path: testFile,
         content: "agent content"
       };
-      const preview = await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      const preview = await previewFn(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       expect(preview?.type).toBe("file");
       await fs.writeFile(testFile, "someone else created this");
       try {
-        await tool.execute(input, { toolCallId });
+        await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
         expect.fail("Should have thrown an error");
       } catch (error) {
         expect(error).toBeInstanceOf(DextoRuntimeError);
@@ -150,7 +240,7 @@ describe("write_file tool", () => {
   });
   describe("Cache Cleanup", () => {
     it("should clean up hash cache after successful execution", async () => {
-      const tool = createWriteFileTool({ fileSystemService });
+      const tool = createWriteFileTool(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "original");
       const toolCallId = "test-call-cleanup";
@@ -158,20 +248,30 @@ describe("write_file tool", () => {
         file_path: testFile,
         content: "first write"
       };
-      await tool.generatePreview(input, { toolCallId });
-      await tool.execute(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      await tool.presentation.preview(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
+      await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
       const input2 = {
         file_path: testFile,
         content: "second write"
       };
-      await tool.generatePreview(input2, { toolCallId });
-      const result = await tool.execute(input2, { toolCallId });
+      const parsedInput2 = tool.inputSchema.parse(input2);
+      const previewFn2 = tool.presentation?.preview;
+      expect(previewFn2).toBeDefined();
+      await previewFn2(parsedInput2, createToolContext(mockLogger, { toolCallId }));
+      const result = await tool.execute(
+        parsedInput2,
+        createToolContext(mockLogger, { toolCallId })
+      );
       expect(result.success).toBe(true);
       const content = await fs.readFile(testFile, "utf-8");
       expect(content).toBe("second write");
     });
     it("should clean up hash cache after failed execution", async () => {
-      const tool = createWriteFileTool({ fileSystemService });
+      const tool = createWriteFileTool(async () => fileSystemService);
       const testFile = path.join(tempDir, "test.txt");
       await fs.writeFile(testFile, "original");
       const toolCallId = "test-call-fail";
@@ -179,15 +279,21 @@ describe("write_file tool", () => {
         file_path: testFile,
         content: "new content"
       };
-      await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      const previewFn = tool.presentation?.preview;
+      expect(previewFn).toBeDefined();
+      await previewFn(parsedInput, createToolContext(mockLogger, { toolCallId }));
       await fs.writeFile(testFile, "modified");
       try {
-        await tool.execute(input, { toolCallId });
+        await tool.execute(parsedInput, createToolContext(mockLogger, { toolCallId }));
       } catch {
       }
       await fs.writeFile(testFile, "reset content");
-      await tool.generatePreview(input, { toolCallId });
-      const result = await tool.execute(input, { toolCallId });
+      await previewFn(parsedInput, createToolContext(mockLogger, { toolCallId }));
+      const result = await tool.execute(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       expect(result.success).toBe(true);
     });
   });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dexto/tools-filesystem",
-  "version": "1.5.8",
-  "description": "FileSystem tools provider for Dexto agents",
+  "version": "1.6.1",
+  "description": "FileSystem tools factory for Dexto agents",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -22,7 +22,8 @@
     "glob": "^11.1.0",
     "safe-regex": "^2.1.1",
     "zod": "^3.25.0",
-    "@dexto/core": "1.5.8"
+    "@dexto/agent-config": "1.6.1",
+    "@dexto/core": "1.6.1"
   },
   "devDependencies": {
     "@types/diff": "^5.2.3",
@@ -35,7 +36,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "tsup",
+    "build": "tsup && node ../../scripts/clean-tsbuildinfo.mjs && tsc -b tsconfig.json --emitDeclarationOnly",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist"
   }

package/dist/directory-approval.integration.test.d.cts

@@ -1,2 +0,0 @@
-
-export {  }

package/dist/edit-file-tool.d.cts

@@ -1,17 +0,0 @@
-import { InternalTool } from '@dexto/core';
-import { FileToolOptions } from './file-tool-types.cjs';
-import './filesystem-service.cjs';
-import './types.cjs';
-
-/**
- * Edit File Tool
- *
- * Internal tool for editing files by replacing text (requires approval)
- */
-
-/**
- * Create the edit_file internal tool with directory approval support
- */
-declare function createEditFileTool(options: FileToolOptions): InternalTool;
-
-export { createEditFileTool };

package/dist/edit-file-tool.test.d.cts

@@ -1,2 +0,0 @@
-
-export {  }