@agentforge/tools 0.16.77 → 0.16.78

package/README.md

@@ -204,6 +204,27 @@ Tools for file system operations.
 - **`pathRelative`** - Get relative path
 - **`pathNormalize`** - Normalize paths
 
+#### Filesystem Confinement
+
+The standalone filesystem tool exports are intentionally powerful for trusted local automation. For model-exposed tools, configure a shared policy on the factory functions so every file and directory operation uses the same allowed roots and symlink checks:
+
+```typescript
+import {
+  createDirectoryOperationTools,
+  createFileOperationTools,
+  createFileSystemPolicy,
+} from '@agentforge/tools';
+
+const policy = createFileSystemPolicy({
+  workspaceRoot: process.cwd(),
+});
+
+const safeFileTools = createFileOperationTools({ policy });
+const safeDirectoryTools = createDirectoryOperationTools({ policy });
+```
+
+The policy rejects `..` traversal, resolved symlink escapes, paths outside configured roots, and recursive deletion of a configured root. Use `allowedRoots` for multiple roots. Keep the default unrestricted exports for trusted local automation only; `allowOutsideRoots: true` is an explicit privileged opt-out when a configured factory must access the wider host filesystem. The `file-exists` tool preserves its legacy result shape for successful and missing-path checks, while policy violations return `{ success: false, error }`. Detailed `directory-list` results use non-following `lstat` metadata for symlink entries under both default and confined policies.
+
 ### Utility Tools (22 tools)
 
 General utility tools for common operations.

package/dist/index.cjs

@@ -16,7 +16,7 @@ var events = require('events');
 var stream = require('stream');
 var crypto = require('crypto');
 var fs = require('fs');
-var path7 = require('path');
+var path = require('path');
 var dateFns = require('date-fns');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -43,7 +43,7 @@ var net__default = /*#__PURE__*/_interopDefault(net);
 var axios13__default = /*#__PURE__*/_interopDefault(axios13);
 var cheerio__namespace = /*#__PURE__*/_interopNamespace(cheerio);
 var neo4j__default = /*#__PURE__*/_interopDefault(neo4j);
-var path7__namespace = /*#__PURE__*/_interopNamespace(path7);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
@@ -698,7 +698,7 @@ function isRetryableError(error) {
   return false;
 }
 function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 async function retryWithBackoff(fn, config = DEFAULT_RETRY_CONFIG) {
   let lastError;
@@ -2207,8 +2207,8 @@ var objectOmitSchema = zod.z.object({
 });
 
 // src/data/transformer/tools/shared.ts
-function getNestedValue(value, path12) {
-  return path12.split(".").reduce((current, key) => {
+function getNestedValue(value, path13) {
+  return path13.split(".").reduce((current, key) => {
     if (current == null) {
       return void 0;
     }
@@ -2598,7 +2598,7 @@ function isRetryableError2(error) {
   return false;
 }
 function sleep2(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 async function retryWithBackoff2(fn, config = DEFAULT_RETRY_CONFIG2) {
   let lastError;
@@ -3497,16 +3497,16 @@ function formatRelationship(rel) {
     properties: formatValue(rel.properties)
   };
 }
-function formatPath(path12) {
+function formatPath(path13) {
   return {
-    start: formatNode(path12.start),
-    end: formatNode(path12.end),
-    segments: path12.segments.map((segment) => ({
+    start: formatNode(path13.start),
+    end: formatNode(path13.end),
+    segments: path13.segments.map((segment) => ({
       start: formatNode(segment.start),
       relationship: formatRelationship(segment.relationship),
       end: formatNode(segment.end)
     })),
-    length: path12.length
+    length: path13.length
   };
 }
 function formatResults(records) {
@@ -5683,8 +5683,8 @@ function toBatchErrorMessage(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function delayBatchRetry(ms) {
-  return new Promise((resolve2) => {
-    setTimeout(resolve2, ms);
+  return new Promise((resolve3) => {
+    setTimeout(resolve3, ms);
   });
 }
 
@@ -6110,7 +6110,7 @@ function withTransactionTimeout(operation, timeoutMs, onTimeout) {
   if (!timeoutMs) {
     return operation;
   }
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     let timedOut = false;
     const timer = setTimeout(() => {
       timedOut = true;
@@ -6122,7 +6122,7 @@ function withTransactionTimeout(operation, timeoutMs, onTimeout) {
         return;
       }
       clearTimeout(timer);
-      resolve2(result);
+      resolve3(result);
     }).catch((error) => {
       if (timedOut) {
         return;
@@ -9355,11 +9355,135 @@ var fileDeleteSchema = zod.z.object({
 var fileExistsSchema = zod.z.object({
   path: zod.z.string().describe("Path to check")
 });
-function createFileReaderTool(defaultEncoding = "utf8") {
+var FileSystemPolicyError = class extends Error {
+  constructor(message, operation, inputPath) {
+    super(message);
+    this.operation = operation;
+    this.inputPath = inputPath;
+    this.name = "FileSystemPolicyError";
+  }
+  code = "FILE_SYSTEM_POLICY_VIOLATION";
+};
+function containsTraversal(inputPath) {
+  return inputPath.split(/[\\/]+/).includes("..");
+}
+function isWithinRoot(root, target) {
+  const relative4 = path__namespace.relative(root, target);
+  return relative4 === "" || !relative4.startsWith(`..${path__namespace.sep}`) && relative4 !== ".." && !path__namespace.isAbsolute(relative4);
+}
+async function resolveWithMissingTail(inputPath) {
+  let currentPath = inputPath;
+  const missingSegments = [];
+  while (true) {
+    try {
+      const resolvedPath = await fs.promises.realpath(currentPath);
+      return path__namespace.join(resolvedPath, ...missingSegments);
+    } catch (error) {
+      const code = error.code;
+      if (code !== "ENOENT" && code !== "ENOTDIR") {
+        throw error;
+      }
+      const parentPath = path__namespace.dirname(currentPath);
+      if (parentPath === currentPath) {
+        throw error;
+      }
+      missingSegments.unshift(path__namespace.basename(currentPath));
+      currentPath = parentPath;
+    }
+  }
+}
+var FileSystemPolicy = class {
+  allowedRoots;
+  allowOutsideRoots;
+  allowRootDeletion;
+  baseDirectory;
+  constructor(options = {}) {
+    const configuredRoots = [
+      ...options.allowedRoots ?? [],
+      ...options.workspaceRoot ? [options.workspaceRoot] : []
+    ];
+    this.allowedRoots = [...new Set(configuredRoots.map((root) => path__namespace.resolve(root)))];
+    this.baseDirectory = path__namespace.resolve(options.workspaceRoot ?? process.cwd());
+    this.allowOutsideRoots = options.allowOutsideRoots ?? this.allowedRoots.length === 0;
+    this.allowRootDeletion = options.allowRootDeletion ?? this.allowOutsideRoots;
+  }
+  async resolvePath(inputPath, operation) {
+    const { resolvedPath } = await this.resolvePathWithRoots(inputPath, operation);
+    return resolvedPath;
+  }
+  async resolveDeletePath(inputPath, recursive) {
+    const { resolvedPath, resolvedRoots } = await this.resolvePathWithRoots(inputPath, "directory deletion");
+    if (recursive && !this.allowRootDeletion && resolvedRoots.some((root) => root === resolvedPath)) {
+      throw new FileSystemPolicyError(
+        "Filesystem policy blocked directory deletion: recursive deletion of an allowed root is not permitted",
+        "directory deletion",
+        inputPath
+      );
+    }
+    return resolvedPath;
+  }
+  async resolvePathWithRoots(inputPath, operation) {
+    const absolutePath = path__namespace.resolve(this.baseDirectory, inputPath);
+    if (this.allowOutsideRoots) {
+      return { resolvedPath: absolutePath, resolvedRoots: [] };
+    }
+    if (containsTraversal(inputPath)) {
+      throw new FileSystemPolicyError(
+        `Filesystem policy blocked ${operation}: path traversal is not allowed`,
+        operation,
+        inputPath
+      );
+    }
+    let resolvedPath;
+    try {
+      resolvedPath = await resolveWithMissingTail(absolutePath);
+    } catch {
+      throw new FileSystemPolicyError(
+        `Filesystem policy could not resolve ${operation} path`,
+        operation,
+        inputPath
+      );
+    }
+    const resolvedRoots = await this.resolveRoots(operation, inputPath);
+    if (!resolvedRoots.some((root) => isWithinRoot(root, resolvedPath))) {
+      throw new FileSystemPolicyError(
+        `Filesystem policy blocked ${operation}: path is outside the allowed roots`,
+        operation,
+        inputPath
+      );
+    }
+    return { resolvedPath, resolvedRoots };
+  }
+  async resolveRoots(operation, inputPath) {
+    try {
+      return await Promise.all(this.allowedRoots.map((root) => fs.promises.realpath(root)));
+    } catch {
+      throw new FileSystemPolicyError(
+        `Filesystem policy could not resolve an allowed root for ${operation}`,
+        operation,
+        inputPath
+      );
+    }
+  }
+};
+var DEFAULT_FILE_SYSTEM_POLICY = new FileSystemPolicy();
+function createFileSystemPolicy(options = {}) {
+  return new FileSystemPolicy(options);
+}
+function resolveFileSystemPolicy(policy) {
+  if (!policy) {
+    return DEFAULT_FILE_SYSTEM_POLICY;
+  }
+  return policy instanceof FileSystemPolicy ? policy : createFileSystemPolicy(policy);
+}
+
+// src/file/operations/tools/file-reader.ts
+function createFileReaderTool(defaultEncoding = "utf8", policy = DEFAULT_FILE_SYSTEM_POLICY) {
   return core.toolBuilder().name("file-reader").description("Read the contents of a file from the file system. Supports text and binary files with various encodings.").category(core.ToolCategory.FILE_SYSTEM).tags(["file", "read", "io", "filesystem"]).schema(fileReaderSchema).implementSafe(async (input) => {
     const encoding = input.encoding || defaultEncoding;
-    const content = await fs.promises.readFile(input.path, encoding);
-    const stats = await fs.promises.stat(input.path);
+    const safePath = await policy.resolvePath(input.path, "file read");
+    const content = await fs.promises.readFile(safePath, encoding);
+    const stats = await fs.promises.stat(safePath);
     return {
       content,
       size: stats.size,
@@ -9368,16 +9492,17 @@ function createFileReaderTool(defaultEncoding = "utf8") {
     };
   }).build();
 }
-function createFileWriterTool(defaultEncoding = "utf8", createDirsDefault = false) {
+function createFileWriterTool(defaultEncoding = "utf8", createDirsDefault = false, policy = DEFAULT_FILE_SYSTEM_POLICY) {
   return core.toolBuilder().name("file-writer").description("Write content to a file. Creates the file if it doesn't exist, or overwrites it if it does.").category(core.ToolCategory.FILE_SYSTEM).tags(["file", "write", "io", "filesystem"]).schema(fileWriterSchema).implementSafe(async (input) => {
     const encoding = input.encoding || defaultEncoding;
     const createDirs = input.createDirs ?? createDirsDefault;
+    const safePath = await policy.resolvePath(input.path, "file write");
     if (createDirs) {
-      const dir = path7__namespace.dirname(input.path);
+      const dir = path__namespace.dirname(safePath);
       await fs.promises.mkdir(dir, { recursive: true });
     }
-    await fs.promises.writeFile(input.path, input.content, encoding);
-    const stats = await fs.promises.stat(input.path);
+    await fs.promises.writeFile(safePath, input.content, encoding);
+    const stats = await fs.promises.stat(safePath);
     return {
       path: input.path,
       size: stats.size,
@@ -9385,31 +9510,34 @@ function createFileWriterTool(defaultEncoding = "utf8", createDirsDefault = fals
     };
   }).build();
 }
-function createFileAppendTool(defaultEncoding = "utf8") {
+function createFileAppendTool(defaultEncoding = "utf8", policy = DEFAULT_FILE_SYSTEM_POLICY) {
   return core.toolBuilder().name("file-append").description("Append content to the end of a file. Creates the file if it doesn't exist.").category(core.ToolCategory.FILE_SYSTEM).tags(["file", "append", "io", "filesystem"]).schema(fileAppendSchema).implementSafe(async (input) => {
     const encoding = input.encoding || defaultEncoding;
-    await fs.promises.appendFile(input.path, input.content, encoding);
-    const stats = await fs.promises.stat(input.path);
+    const safePath = await policy.resolvePath(input.path, "file append");
+    await fs.promises.appendFile(safePath, input.content, encoding);
+    const stats = await fs.promises.stat(safePath);
     return {
       path: input.path,
       size: stats.size
     };
   }).build();
 }
-function createFileDeleteTool() {
+function createFileDeleteTool(policy = DEFAULT_FILE_SYSTEM_POLICY) {
   return core.toolBuilder().name("file-delete").description("Delete a file from the file system. Returns an error if the file doesn't exist.").category(core.ToolCategory.FILE_SYSTEM).tags(["file", "delete", "remove", "filesystem"]).schema(fileDeleteSchema).implementSafe(async (input) => {
-    await fs.promises.unlink(input.path);
+    const safePath = await policy.resolvePath(input.path, "file deletion");
+    await fs.promises.unlink(safePath);
     return {
       path: input.path,
       message: "File deleted successfully"
     };
   }).build();
 }
-function createFileExistsTool() {
+function createFileExistsTool(policy = DEFAULT_FILE_SYSTEM_POLICY) {
   return core.toolBuilder().name("file-exists").description("Check if a file or directory exists at the specified path.").category(core.ToolCategory.FILE_SYSTEM).tags(["file", "exists", "check", "filesystem"]).schema(fileExistsSchema).implement(async (input) => {
     try {
-      await fs.promises.access(input.path);
-      const stats = await fs.promises.stat(input.path);
+      const safePath = await policy.resolvePath(input.path, "file existence check");
+      await fs.promises.access(safePath);
+      const stats = await fs.promises.stat(safePath);
       return {
         exists: true,
         path: input.path,
@@ -9418,7 +9546,13 @@ function createFileExistsTool() {
         size: stats.size,
         modified: stats.mtime.toISOString()
       };
-    } catch {
+    } catch (error) {
+      if (error instanceof FileSystemPolicyError) {
+        return {
+          success: false,
+          error: error.message
+        };
+      }
       return {
         exists: false,
         path: input.path
@@ -9443,14 +9577,16 @@ var fileOperationTools = [
 function createFileOperationTools(config = {}) {
   const {
     defaultEncoding = "utf8",
-    createDirsDefault = false
+    createDirsDefault = false,
+    policy: policyInput
   } = config;
+  const policy = resolveFileSystemPolicy(policyInput);
   return [
-    createFileReaderTool(defaultEncoding),
-    createFileWriterTool(defaultEncoding, createDirsDefault),
-    createFileAppendTool(defaultEncoding),
-    createFileDeleteTool(),
-    createFileExistsTool()
+    createFileReaderTool(defaultEncoding, policy),
+    createFileWriterTool(defaultEncoding, createDirsDefault, policy),
+    createFileAppendTool(defaultEncoding, policy),
+    createFileDeleteTool(policy),
+    createFileExistsTool(policy)
   ];
 }
 var directoryListSchema = zod.z.object({
@@ -9473,21 +9609,23 @@ var fileSearchSchema = zod.z.object({
   recursive: zod.z.boolean().default(true).describe("Search in subdirectories"),
   caseSensitive: zod.z.boolean().default(false).describe("Case-sensitive pattern matching")
 });
-function createDirectoryListTool(defaultRecursive = false, defaultIncludeDetails = false) {
+function createDirectoryListTool(defaultRecursive = false, defaultIncludeDetails = false, policy = DEFAULT_FILE_SYSTEM_POLICY) {
   return core.toolBuilder().name("directory-list").description("List all files and directories in a directory. Can optionally include file details and filter by extension.").category(core.ToolCategory.FILE_SYSTEM).tags(["directory", "list", "files", "filesystem"]).schema(directoryListSchema).implementSafe(async (input) => {
+    const safePath = await policy.resolvePath(input.path, "directory listing");
+    const includeDetails = input.includeDetails ?? defaultIncludeDetails;
     const listFiles = async (dir, recursive2) => {
       const entries = await fs.promises.readdir(dir, { withFileTypes: true });
       const files2 = [];
       for (const entry of entries) {
-        const fullPath = path7__namespace.join(dir, entry.name);
-        const relativePath = path7__namespace.relative(input.path, fullPath);
+        const fullPath = path__namespace.join(dir, entry.name);
+        const relativePath = path__namespace.relative(safePath, fullPath);
         if (input.extension && !entry.name.endsWith(input.extension)) {
           if (!entry.isDirectory() || !recursive2) {
             continue;
           }
         }
-        if (input.includeDetails) {
-          const stats = await fs.promises.stat(fullPath);
+        if (includeDetails) {
+          const stats = await fs.promises.lstat(fullPath);
           files2.push({
             name: entry.name,
             path: relativePath,
@@ -9513,7 +9651,7 @@ function createDirectoryListTool(defaultRecursive = false, defaultIncludeDetails
       return files2;
     };
     const recursive = input.recursive ?? defaultRecursive;
-    const files = await listFiles(input.path, recursive);
+    const files = await listFiles(safePath, recursive);
     return {
       path: input.path,
       files,
@@ -9521,37 +9659,40 @@ function createDirectoryListTool(defaultRecursive = false, defaultIncludeDetails
     };
   }).build();
 }
-function createDirectoryCreateTool(defaultRecursive = true) {
+function createDirectoryCreateTool(defaultRecursive = true, policy = DEFAULT_FILE_SYSTEM_POLICY) {
   return core.toolBuilder().name("directory-create").description("Create a new directory. Can optionally create parent directories if they don't exist.").category(core.ToolCategory.FILE_SYSTEM).tags(["directory", "create", "mkdir", "filesystem"]).schema(directoryCreateSchema).implementSafe(async (input) => {
     const recursive = input.recursive ?? defaultRecursive;
-    await fs.promises.mkdir(input.path, { recursive });
+    const safePath = await policy.resolvePath(input.path, "directory creation");
+    await fs.promises.mkdir(safePath, { recursive });
     return {
       path: input.path,
       message: "Directory created successfully"
     };
   }).build();
 }
-function createDirectoryDeleteTool(defaultRecursive = false) {
+function createDirectoryDeleteTool(defaultRecursive = false, policy = DEFAULT_FILE_SYSTEM_POLICY) {
   return core.toolBuilder().name("directory-delete").description("Delete a directory. Can optionally delete non-empty directories recursively.").category(core.ToolCategory.FILE_SYSTEM).tags(["directory", "delete", "remove", "filesystem"]).schema(directoryDeleteSchema).implementSafe(async (input) => {
     const recursive = input.recursive ?? defaultRecursive;
-    await fs.promises.rm(input.path, { recursive, force: false });
+    const safePath = await policy.resolveDeletePath(input.path, recursive);
+    await fs.promises.rm(safePath, { recursive, force: false });
     return {
       path: input.path,
       message: "Directory deleted successfully"
     };
   }).build();
 }
-function createFileSearchTool(defaultRecursive = true, defaultCaseSensitive = false) {
+function createFileSearchTool(defaultRecursive = true, defaultCaseSensitive = false, policy = DEFAULT_FILE_SYSTEM_POLICY) {
   return core.toolBuilder().name("file-search").description("Search for files by name pattern in a directory. Supports wildcards and recursive search.").category(core.ToolCategory.FILE_SYSTEM).tags(["file", "search", "find", "filesystem"]).schema(fileSearchSchema).implementSafe(async (input) => {
     const recursive = input.recursive ?? defaultRecursive;
     const caseSensitive = input.caseSensitive ?? defaultCaseSensitive;
+    const safeDirectory = await policy.resolvePath(input.directory, "file search");
     const searchFiles = async (dir) => {
       const entries = await fs.promises.readdir(dir, { withFileTypes: true });
       const matches2 = [];
       const regexPattern = input.pattern.replace(/\./g, "\\.").replace(/\*/g, ".*");
       const regex = new RegExp(`^${regexPattern}$`, caseSensitive ? "" : "i");
       for (const entry of entries) {
-        const fullPath = path7__namespace.join(dir, entry.name);
+        const fullPath = path__namespace.join(dir, entry.name);
         if (entry.isFile() && regex.test(entry.name)) {
           matches2.push(fullPath);
         }
@@ -9562,7 +9703,7 @@ function createFileSearchTool(defaultRecursive = true, defaultCaseSensitive = fa
       }
       return matches2;
     };
-    const matches = await searchFiles(input.directory);
+    const matches = await searchFiles(safeDirectory);
     return {
       directory: input.directory,
       pattern: input.pattern,
@@ -9587,15 +9728,17 @@ function createDirectoryOperationTools(config = {}) {
   const {
     defaultRecursive = false,
     defaultIncludeDetails = false,
-    defaultCaseSensitive = false
+    defaultCaseSensitive = false,
+    policy: policyInput
   } = config;
+  const policy = resolveFileSystemPolicy(policyInput);
   return [
-    createDirectoryListTool(defaultRecursive, defaultIncludeDetails),
-    createDirectoryCreateTool(true),
+    createDirectoryListTool(defaultRecursive, defaultIncludeDetails, policy),
+    createDirectoryCreateTool(true, policy),
     // Always default to true for create
-    createDirectoryDeleteTool(false),
+    createDirectoryDeleteTool(false, policy),
     // Always default to false for delete (safety)
-    createFileSearchTool(defaultRecursive, defaultCaseSensitive)
+    createFileSearchTool(defaultRecursive, defaultCaseSensitive, policy)
   ];
 }
 var pathJoinSchema = zod.z.object({
@@ -9626,7 +9769,7 @@ var pathNormalizeSchema = zod.z.object({
 });
 function createPathJoinTool() {
   return core.toolBuilder().name("path-join").description("Join multiple path segments into a single path. Handles platform-specific separators.").category(core.ToolCategory.FILE_SYSTEM).tags(["path", "join", "filesystem"]).schema(pathJoinSchema).implement(async (input) => {
-    const joined = path7__namespace.join(...input.segments);
+    const joined = path__namespace.join(...input.segments);
     return {
       path: joined,
       segments: input.segments
@@ -9635,59 +9778,59 @@ function createPathJoinTool() {
 }
 function createPathResolveTool() {
   return core.toolBuilder().name("path-resolve").description("Resolve a sequence of paths into an absolute path. Resolves relative paths from the current working directory.").category(core.ToolCategory.FILE_SYSTEM).tags(["path", "resolve", "absolute", "filesystem"]).schema(pathResolveSchema).implement(async (input) => {
-    const resolved = path7__namespace.resolve(...input.paths);
+    const resolved = path__namespace.resolve(...input.paths);
     return {
       path: resolved,
-      isAbsolute: path7__namespace.isAbsolute(resolved)
+      isAbsolute: path__namespace.isAbsolute(resolved)
     };
   }).build();
 }
 function createPathParseTool() {
   return core.toolBuilder().name("path-parse").description("Parse a file path into its components (directory, filename, extension, etc.).").category(core.ToolCategory.FILE_SYSTEM).tags(["path", "parse", "filesystem"]).schema(pathParseSchema).implement(async (input) => {
-    const parsed = path7__namespace.parse(input.path);
+    const parsed = path__namespace.parse(input.path);
     return {
       root: parsed.root,
       dir: parsed.dir,
       base: parsed.base,
       name: parsed.name,
       ext: parsed.ext,
-      isAbsolute: path7__namespace.isAbsolute(input.path)
+      isAbsolute: path__namespace.isAbsolute(input.path)
     };
   }).build();
 }
 function createPathBasenameTool() {
   return core.toolBuilder().name("path-basename").description("Get the last portion of a path (filename with extension). Optionally remove the extension.").category(core.ToolCategory.FILE_SYSTEM).tags(["path", "basename", "filename", "filesystem"]).schema(pathBasenameSchema).implement(async (input) => {
-    const basename4 = input.removeExtension ? path7__namespace.basename(input.path, path7__namespace.extname(input.path)) : path7__namespace.basename(input.path);
+    const basename5 = input.removeExtension ? path__namespace.basename(input.path, path__namespace.extname(input.path)) : path__namespace.basename(input.path);
     return {
-      basename: basename4,
-      extension: path7__namespace.extname(input.path)
+      basename: basename5,
+      extension: path__namespace.extname(input.path)
     };
   }).build();
 }
 function createPathDirnameTool() {
   return core.toolBuilder().name("path-dirname").description("Get the directory name of a path (everything except the last portion).").category(core.ToolCategory.FILE_SYSTEM).tags(["path", "dirname", "directory", "filesystem"]).schema(pathDirnameSchema).implement(async (input) => {
-    const dirname3 = path7__namespace.dirname(input.path);
+    const dirname4 = path__namespace.dirname(input.path);
     return {
-      dirname: dirname3,
-      basename: path7__namespace.basename(input.path)
+      dirname: dirname4,
+      basename: path__namespace.basename(input.path)
     };
   }).build();
 }
 function createPathExtensionTool() {
   return core.toolBuilder().name("path-extension").description('Get the file extension from a path (including the dot, e.g., ".txt").').category(core.ToolCategory.FILE_SYSTEM).tags(["path", "extension", "ext", "filesystem"]).schema(pathExtensionSchema).implement(async (input) => {
-    const ext = path7__namespace.extname(input.path);
+    const ext = path__namespace.extname(input.path);
     return {
       extension: ext,
       hasExtension: ext.length > 0,
-      filename: path7__namespace.basename(input.path, ext)
+      filename: path__namespace.basename(input.path, ext)
     };
   }).build();
 }
 function createPathRelativeTool() {
   return core.toolBuilder().name("path-relative").description("Get the relative path from one path to another.").category(core.ToolCategory.FILE_SYSTEM).tags(["path", "relative", "filesystem"]).schema(pathRelativeSchema).implement(async (input) => {
-    const relative3 = path7__namespace.relative(input.from, input.to);
+    const relative4 = path__namespace.relative(input.from, input.to);
     return {
-      relativePath: relative3,
+      relativePath: relative4,
       from: input.from,
       to: input.to
     };
@@ -9695,7 +9838,7 @@ function createPathRelativeTool() {
 }
 function createPathNormalizeTool() {
   return core.toolBuilder().name("path-normalize").description('Normalize a path by resolving ".." and "." segments and removing duplicate separators.').category(core.ToolCategory.FILE_SYSTEM).tags(["path", "normalize", "filesystem"]).schema(pathNormalizeSchema).implement(async (input) => {
-    const normalized = path7__namespace.normalize(input.path);
+    const normalized = path__namespace.normalize(input.path);
     return {
       normalized,
       original: input.path
@@ -10604,6 +10747,7 @@ exports.CurrentDateTimeSchema = CurrentDateTimeSchema;
 exports.DEFAULT_BATCH_SIZE = DEFAULT_BATCH_SIZE;
 exports.DEFAULT_CHUNK_SIZE = DEFAULT_CHUNK_SIZE;
 exports.DEFAULT_DESTINATION_POLICY = DEFAULT_DESTINATION_POLICY;
+exports.DEFAULT_FILE_SYSTEM_POLICY = DEFAULT_FILE_SYSTEM_POLICY;
 exports.DEFAULT_RETRY_CONFIG = DEFAULT_RETRY_CONFIG2;
 exports.DateArithmeticSchema = DateArithmeticSchema;
 exports.DateComparisonSchema = DateComparisonSchema;
@@ -10613,6 +10757,8 @@ exports.DestinationPolicyError = DestinationPolicyError;
 exports.DuckDuckGoProvider = DuckDuckGoProvider;
 exports.EmailValidatorSchema = EmailValidatorSchema;
 exports.EmbeddingManager = EmbeddingManager;
+exports.FileSystemPolicy = FileSystemPolicy;
+exports.FileSystemPolicyError = FileSystemPolicyError;
 exports.HttpMethod = HttpMethod;
 exports.IpValidatorSchema = IpValidatorSchema;
 exports.MAX_BATCH_SIZE = MAX_BATCH_SIZE;
@@ -10686,6 +10832,7 @@ exports.createFileExistsTool = createFileExistsTool;
 exports.createFileOperationTools = createFileOperationTools;
 exports.createFileReaderTool = createFileReaderTool;
 exports.createFileSearchTool = createFileSearchTool;
+exports.createFileSystemPolicy = createFileSystemPolicy;
 exports.createFileWriterTool = createFileWriterTool;
 exports.createHtmlParserTool = createHtmlParserTool;
 exports.createHtmlParserTools = createHtmlParserTools;
@@ -10894,6 +11041,7 @@ exports.relationalQuery = relationalQuery;
 exports.relationalSelect = relationalSelect;
 exports.relationalUpdate = relationalUpdate;
 exports.requestWithDestinationPolicy = requestWithDestinationPolicy;
+exports.resolveFileSystemPolicy = resolveFileSystemPolicy;
 exports.retryWithBackoff = retryWithBackoff2;
 exports.scraperTools = scraperTools;
 exports.searchConfluence = searchConfluence;