@dexto/tools-filesystem 1.5.8 → 1.6.0

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

@@ -29,13 +29,25 @@ 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),
+    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;
@@ -67,7 +79,7 @@ const createMockLogger = () => ({
   });
   (0, import_vitest.describe)("File Modification Detection - Existing Files", () => {
     (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 +87,24 @@ 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.generatePreview(
+        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 });
+      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 +112,11 @@ const createMockLogger = () => ({
         file_path: testFile,
         content: "new content"
       };
-      await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      await tool.generatePreview(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 +128,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 +136,11 @@ const createMockLogger = () => ({
         file_path: testFile,
         content: "new content"
       };
-      await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      await tool.generatePreview(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 +152,46 @@ 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.generatePreview(
+        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 });
+      const result = await tool.execute(
+        parsedInput,
+        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("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 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 tool.generatePreview(
+        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 +205,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 +213,28 @@ 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.generatePreview(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);
+      await tool.generatePreview(
+        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 +242,19 @@ const createMockLogger = () => ({
         file_path: testFile,
         content: "new content"
       };
-      await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      await tool.generatePreview(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 tool.generatePreview(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,25 @@ 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),
+    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;
@@ -44,7 +56,7 @@ describe("write_file tool", () => {
   });
   describe("File Modification Detection - Existing Files", () => {
     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 +64,24 @@ 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.generatePreview(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       expect(preview).toBeDefined();
       expect(preview?.type).toBe("diff");
-      const result = await tool.execute(input, { toolCallId });
+      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 +89,11 @@ describe("write_file tool", () => {
         file_path: testFile,
         content: "new content"
       };
-      await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      await tool.generatePreview(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 +105,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 +113,11 @@ describe("write_file tool", () => {
         file_path: testFile,
         content: "new content"
       };
-      await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      await tool.generatePreview(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 +129,46 @@ 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.generatePreview(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       expect(preview).toBeDefined();
       expect(preview?.type).toBe("file");
       expect(preview.operation).toBe("create");
-      const result = await tool.execute(input, { toolCallId });
+      const result = await tool.execute(
+        parsedInput,
+        createToolContext(mockLogger, { toolCallId })
+      );
       expect(result.success).toBe(true);
       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 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 tool.generatePreview(
+        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 +182,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 +190,28 @@ 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.generatePreview(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);
+      await tool.generatePreview(
+        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 +219,19 @@ describe("write_file tool", () => {
         file_path: testFile,
         content: "new content"
       };
-      await tool.generatePreview(input, { toolCallId });
+      const parsedInput = tool.inputSchema.parse(input);
+      await tool.generatePreview(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 tool.generatePreview(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.0",
+  "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.0",
+    "@dexto/core": "1.6.0"
   },
   "devDependencies": {
     "@types/diff": "^5.2.3",

package/dist/tool-provider.cjs

@@ -1,123 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var tool_provider_exports = {};
-__export(tool_provider_exports, {
-  fileSystemToolsProvider: () => fileSystemToolsProvider
-});
-module.exports = __toCommonJS(tool_provider_exports);
-var import_zod = require("zod");
-var import_filesystem_service = require("./filesystem-service.js");
-var import_read_file_tool = require("./read-file-tool.js");
-var import_write_file_tool = require("./write-file-tool.js");
-var import_edit_file_tool = require("./edit-file-tool.js");
-var import_glob_files_tool = require("./glob-files-tool.js");
-var import_grep_content_tool = require("./grep-content-tool.js");
-const DEFAULT_ALLOWED_PATHS = ["."];
-const DEFAULT_BLOCKED_PATHS = [".git", "node_modules/.bin", ".env"];
-const DEFAULT_BLOCKED_EXTENSIONS = [".exe", ".dll", ".so"];
-const DEFAULT_MAX_FILE_SIZE = 10 * 1024 * 1024;
-const DEFAULT_ENABLE_BACKUPS = false;
-const DEFAULT_BACKUP_RETENTION_DAYS = 7;
-const FILESYSTEM_TOOL_NAMES = [
-  "read_file",
-  "write_file",
-  "edit_file",
-  "glob_files",
-  "grep_content"
-];
-const FileSystemToolsConfigSchema = import_zod.z.object({
-  type: import_zod.z.literal("filesystem-tools"),
-  allowedPaths: import_zod.z.array(import_zod.z.string()).default(DEFAULT_ALLOWED_PATHS).describe("List of allowed base paths for file operations"),
-  blockedPaths: import_zod.z.array(import_zod.z.string()).default(DEFAULT_BLOCKED_PATHS).describe("List of blocked paths to exclude from operations"),
-  blockedExtensions: import_zod.z.array(import_zod.z.string()).default(DEFAULT_BLOCKED_EXTENSIONS).describe("List of blocked file extensions"),
-  maxFileSize: import_zod.z.number().int().positive().default(DEFAULT_MAX_FILE_SIZE).describe(
-    `Maximum file size in bytes (default: ${DEFAULT_MAX_FILE_SIZE / 1024 / 1024}MB)`
-  ),
-  workingDirectory: import_zod.z.string().optional().describe("Working directory for file operations (defaults to process.cwd())"),
-  enableBackups: import_zod.z.boolean().default(DEFAULT_ENABLE_BACKUPS).describe("Enable automatic backups of modified files"),
-  backupPath: import_zod.z.string().optional().describe("Absolute path for storing file backups (if enableBackups is true)"),
-  backupRetentionDays: import_zod.z.number().int().positive().default(DEFAULT_BACKUP_RETENTION_DAYS).describe(
-    `Number of days to retain backup files (default: ${DEFAULT_BACKUP_RETENTION_DAYS})`
-  ),
-  enabledTools: import_zod.z.array(import_zod.z.enum(FILESYSTEM_TOOL_NAMES)).optional().describe(
-    `Subset of tools to enable. If not specified, all tools are enabled. Available: ${FILESYSTEM_TOOL_NAMES.join(", ")}`
-  )
-}).strict();
-const fileSystemToolsProvider = {
-  type: "filesystem-tools",
-  configSchema: FileSystemToolsConfigSchema,
-  create: (config, context) => {
-    const { logger, services } = context;
-    logger.debug("Creating FileSystemService for filesystem tools");
-    const fileSystemService = new import_filesystem_service.FileSystemService(
-      {
-        allowedPaths: config.allowedPaths,
-        blockedPaths: config.blockedPaths,
-        blockedExtensions: config.blockedExtensions,
-        maxFileSize: config.maxFileSize,
-        workingDirectory: config.workingDirectory || process.cwd(),
-        enableBackups: config.enableBackups,
-        backupPath: config.backupPath,
-        backupRetentionDays: config.backupRetentionDays
-      },
-      logger
-    );
-    fileSystemService.initialize().catch((error) => {
-      logger.error(`Failed to initialize FileSystemService: ${error.message}`);
-    });
-    logger.debug("FileSystemService created - initialization will complete on first tool use");
-    const approvalManager = services?.approvalManager;
-    if (approvalManager) {
-      const approvalChecker = (filePath) => {
-        return approvalManager.isDirectoryApproved(filePath);
-      };
-      fileSystemService.setDirectoryApprovalChecker(approvalChecker);
-      logger.debug("Directory approval checker configured for FileSystemService");
-    }
-    const directoryApproval = approvalManager ? {
-      isSessionApproved: (filePath) => approvalManager.isDirectorySessionApproved(filePath),
-      addApproved: (directory, type) => approvalManager.addApprovedDirectory(directory, type)
-    } : void 0;
-    const fileToolOptions = {
-      fileSystemService,
-      directoryApproval
-    };
-    const toolCreators = {
-      read_file: () => (0, import_read_file_tool.createReadFileTool)(fileToolOptions),
-      write_file: () => (0, import_write_file_tool.createWriteFileTool)(fileToolOptions),
-      edit_file: () => (0, import_edit_file_tool.createEditFileTool)(fileToolOptions),
-      glob_files: () => (0, import_glob_files_tool.createGlobFilesTool)(fileToolOptions),
-      grep_content: () => (0, import_grep_content_tool.createGrepContentTool)(fileToolOptions)
-    };
-    const toolsToCreate = config.enabledTools ?? FILESYSTEM_TOOL_NAMES;
-    if (config.enabledTools) {
-      logger.debug(`Creating subset of filesystem tools: ${toolsToCreate.join(", ")}`);
-    }
-    return toolsToCreate.map((toolName) => toolCreators[toolName]());
-  },
-  metadata: {
-    displayName: "FileSystem Tools",
-    description: "File system operations (read, write, edit, glob, grep)",
-    category: "filesystem"
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  fileSystemToolsProvider
-});