@agentforge/tools 0.16.77 → 0.16.79

package/dist/index.js

@@ -14,7 +14,7 @@ import { EventEmitter } from 'events';
 import { Readable } from 'stream';
 import { createHash, randomUUID } from 'crypto';
 import { promises } from 'fs';
-import * as path7 from 'path';
+import * as path from 'path';
 import { format, parse as parse$1, isValid, add, sub, differenceInDays, differenceInHours, differenceInMinutes, isAfter, isBefore } from 'date-fns';
 
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
@@ -670,7 +670,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;
@@ -2179,8 +2179,8 @@ var objectOmitSchema = 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;
     }
@@ -2570,7 +2570,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;
@@ -3469,16 +3469,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) {
@@ -5655,8 +5655,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);
   });
 }
 
@@ -6082,7 +6082,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;
@@ -6094,7 +6094,7 @@ function withTransactionTimeout(operation, timeoutMs, onTimeout) {
         return;
       }
       clearTimeout(timer);
-      resolve2(result);
+      resolve3(result);
     }).catch((error) => {
       if (timedOut) {
         return;
@@ -9327,11 +9327,135 @@ var fileDeleteSchema = z.object({
 var fileExistsSchema = z.object({
   path: 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.relative(root, target);
+  return relative4 === "" || !relative4.startsWith(`..${path.sep}`) && relative4 !== ".." && !path.isAbsolute(relative4);
+}
+async function resolveWithMissingTail(inputPath) {
+  let currentPath = inputPath;
+  const missingSegments = [];
+  while (true) {
+    try {
+      const resolvedPath = await promises.realpath(currentPath);
+      return path.join(resolvedPath, ...missingSegments);
+    } catch (error) {
+      const code = error.code;
+      if (code !== "ENOENT" && code !== "ENOTDIR") {
+        throw error;
+      }
+      const parentPath = path.dirname(currentPath);
+      if (parentPath === currentPath) {
+        throw error;
+      }
+      missingSegments.unshift(path.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.resolve(root)))];
+    this.baseDirectory = path.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.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) => 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 toolBuilder().name("file-reader").description("Read the contents of a file from the file system. Supports text and binary files with various encodings.").category(ToolCategory.FILE_SYSTEM).tags(["file", "read", "io", "filesystem"]).schema(fileReaderSchema).implementSafe(async (input) => {
     const encoding = input.encoding || defaultEncoding;
-    const content = await promises.readFile(input.path, encoding);
-    const stats = await promises.stat(input.path);
+    const safePath = await policy.resolvePath(input.path, "file read");
+    const content = await promises.readFile(safePath, encoding);
+    const stats = await promises.stat(safePath);
     return {
       content,
       size: stats.size,
@@ -9340,16 +9464,17 @@ function createFileReaderTool(defaultEncoding = "utf8") {
     };
   }).build();
 }
-function createFileWriterTool(defaultEncoding = "utf8", createDirsDefault = false) {
+function createFileWriterTool(defaultEncoding = "utf8", createDirsDefault = false, policy = DEFAULT_FILE_SYSTEM_POLICY) {
   return 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(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.dirname(input.path);
+      const dir = path.dirname(safePath);
       await promises.mkdir(dir, { recursive: true });
     }
-    await promises.writeFile(input.path, input.content, encoding);
-    const stats = await promises.stat(input.path);
+    await promises.writeFile(safePath, input.content, encoding);
+    const stats = await promises.stat(safePath);
     return {
       path: input.path,
       size: stats.size,
@@ -9357,31 +9482,34 @@ function createFileWriterTool(defaultEncoding = "utf8", createDirsDefault = fals
     };
   }).build();
 }
-function createFileAppendTool(defaultEncoding = "utf8") {
+function createFileAppendTool(defaultEncoding = "utf8", policy = DEFAULT_FILE_SYSTEM_POLICY) {
   return toolBuilder().name("file-append").description("Append content to the end of a file. Creates the file if it doesn't exist.").category(ToolCategory.FILE_SYSTEM).tags(["file", "append", "io", "filesystem"]).schema(fileAppendSchema).implementSafe(async (input) => {
     const encoding = input.encoding || defaultEncoding;
-    await promises.appendFile(input.path, input.content, encoding);
-    const stats = await promises.stat(input.path);
+    const safePath = await policy.resolvePath(input.path, "file append");
+    await promises.appendFile(safePath, input.content, encoding);
+    const stats = await promises.stat(safePath);
     return {
       path: input.path,
       size: stats.size
     };
   }).build();
 }
-function createFileDeleteTool() {
+function createFileDeleteTool(policy = DEFAULT_FILE_SYSTEM_POLICY) {
   return toolBuilder().name("file-delete").description("Delete a file from the file system. Returns an error if the file doesn't exist.").category(ToolCategory.FILE_SYSTEM).tags(["file", "delete", "remove", "filesystem"]).schema(fileDeleteSchema).implementSafe(async (input) => {
-    await promises.unlink(input.path);
+    const safePath = await policy.resolvePath(input.path, "file deletion");
+    await promises.unlink(safePath);
     return {
       path: input.path,
       message: "File deleted successfully"
     };
   }).build();
 }
-function createFileExistsTool() {
+function createFileExistsTool(policy = DEFAULT_FILE_SYSTEM_POLICY) {
   return toolBuilder().name("file-exists").description("Check if a file or directory exists at the specified path.").category(ToolCategory.FILE_SYSTEM).tags(["file", "exists", "check", "filesystem"]).schema(fileExistsSchema).implement(async (input) => {
     try {
-      await promises.access(input.path);
-      const stats = await promises.stat(input.path);
+      const safePath = await policy.resolvePath(input.path, "file existence check");
+      await promises.access(safePath);
+      const stats = await promises.stat(safePath);
       return {
         exists: true,
         path: input.path,
@@ -9390,7 +9518,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
@@ -9415,14 +9549,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 = z.object({
@@ -9445,21 +9581,23 @@ var fileSearchSchema = z.object({
   recursive: z.boolean().default(true).describe("Search in subdirectories"),
   caseSensitive: 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 toolBuilder().name("directory-list").description("List all files and directories in a directory. Can optionally include file details and filter by extension.").category(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 promises.readdir(dir, { withFileTypes: true });
       const files2 = [];
       for (const entry of entries) {
-        const fullPath = path7.join(dir, entry.name);
-        const relativePath = path7.relative(input.path, fullPath);
+        const fullPath = path.join(dir, entry.name);
+        const relativePath = path.relative(safePath, fullPath);
         if (input.extension && !entry.name.endsWith(input.extension)) {
           if (!entry.isDirectory() || !recursive2) {
             continue;
           }
         }
-        if (input.includeDetails) {
-          const stats = await promises.stat(fullPath);
+        if (includeDetails) {
+          const stats = await promises.lstat(fullPath);
           files2.push({
             name: entry.name,
             path: relativePath,
@@ -9485,7 +9623,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,
@@ -9493,37 +9631,40 @@ function createDirectoryListTool(defaultRecursive = false, defaultIncludeDetails
     };
   }).build();
 }
-function createDirectoryCreateTool(defaultRecursive = true) {
+function createDirectoryCreateTool(defaultRecursive = true, policy = DEFAULT_FILE_SYSTEM_POLICY) {
   return toolBuilder().name("directory-create").description("Create a new directory. Can optionally create parent directories if they don't exist.").category(ToolCategory.FILE_SYSTEM).tags(["directory", "create", "mkdir", "filesystem"]).schema(directoryCreateSchema).implementSafe(async (input) => {
     const recursive = input.recursive ?? defaultRecursive;
-    await promises.mkdir(input.path, { recursive });
+    const safePath = await policy.resolvePath(input.path, "directory creation");
+    await 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 toolBuilder().name("directory-delete").description("Delete a directory. Can optionally delete non-empty directories recursively.").category(ToolCategory.FILE_SYSTEM).tags(["directory", "delete", "remove", "filesystem"]).schema(directoryDeleteSchema).implementSafe(async (input) => {
     const recursive = input.recursive ?? defaultRecursive;
-    await promises.rm(input.path, { recursive, force: false });
+    const safePath = await policy.resolveDeletePath(input.path, recursive);
+    await 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 toolBuilder().name("file-search").description("Search for files by name pattern in a directory. Supports wildcards and recursive search.").category(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 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.join(dir, entry.name);
+        const fullPath = path.join(dir, entry.name);
         if (entry.isFile() && regex.test(entry.name)) {
           matches2.push(fullPath);
         }
@@ -9534,7 +9675,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,
@@ -9559,15 +9700,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 = z.object({
@@ -9598,7 +9741,7 @@ var pathNormalizeSchema = z.object({
 });
 function createPathJoinTool() {
   return toolBuilder().name("path-join").description("Join multiple path segments into a single path. Handles platform-specific separators.").category(ToolCategory.FILE_SYSTEM).tags(["path", "join", "filesystem"]).schema(pathJoinSchema).implement(async (input) => {
-    const joined = path7.join(...input.segments);
+    const joined = path.join(...input.segments);
     return {
       path: joined,
       segments: input.segments
@@ -9607,59 +9750,59 @@ function createPathJoinTool() {
 }
 function createPathResolveTool() {
   return toolBuilder().name("path-resolve").description("Resolve a sequence of paths into an absolute path. Resolves relative paths from the current working directory.").category(ToolCategory.FILE_SYSTEM).tags(["path", "resolve", "absolute", "filesystem"]).schema(pathResolveSchema).implement(async (input) => {
-    const resolved = path7.resolve(...input.paths);
+    const resolved = path.resolve(...input.paths);
     return {
       path: resolved,
-      isAbsolute: path7.isAbsolute(resolved)
+      isAbsolute: path.isAbsolute(resolved)
     };
   }).build();
 }
 function createPathParseTool() {
   return toolBuilder().name("path-parse").description("Parse a file path into its components (directory, filename, extension, etc.).").category(ToolCategory.FILE_SYSTEM).tags(["path", "parse", "filesystem"]).schema(pathParseSchema).implement(async (input) => {
-    const parsed = path7.parse(input.path);
+    const parsed = path.parse(input.path);
     return {
       root: parsed.root,
       dir: parsed.dir,
       base: parsed.base,
       name: parsed.name,
       ext: parsed.ext,
-      isAbsolute: path7.isAbsolute(input.path)
+      isAbsolute: path.isAbsolute(input.path)
     };
   }).build();
 }
 function createPathBasenameTool() {
   return toolBuilder().name("path-basename").description("Get the last portion of a path (filename with extension). Optionally remove the extension.").category(ToolCategory.FILE_SYSTEM).tags(["path", "basename", "filename", "filesystem"]).schema(pathBasenameSchema).implement(async (input) => {
-    const basename4 = input.removeExtension ? path7.basename(input.path, path7.extname(input.path)) : path7.basename(input.path);
+    const basename5 = input.removeExtension ? path.basename(input.path, path.extname(input.path)) : path.basename(input.path);
     return {
-      basename: basename4,
-      extension: path7.extname(input.path)
+      basename: basename5,
+      extension: path.extname(input.path)
     };
   }).build();
 }
 function createPathDirnameTool() {
   return toolBuilder().name("path-dirname").description("Get the directory name of a path (everything except the last portion).").category(ToolCategory.FILE_SYSTEM).tags(["path", "dirname", "directory", "filesystem"]).schema(pathDirnameSchema).implement(async (input) => {
-    const dirname3 = path7.dirname(input.path);
+    const dirname4 = path.dirname(input.path);
     return {
-      dirname: dirname3,
-      basename: path7.basename(input.path)
+      dirname: dirname4,
+      basename: path.basename(input.path)
     };
   }).build();
 }
 function createPathExtensionTool() {
   return toolBuilder().name("path-extension").description('Get the file extension from a path (including the dot, e.g., ".txt").').category(ToolCategory.FILE_SYSTEM).tags(["path", "extension", "ext", "filesystem"]).schema(pathExtensionSchema).implement(async (input) => {
-    const ext = path7.extname(input.path);
+    const ext = path.extname(input.path);
     return {
       extension: ext,
       hasExtension: ext.length > 0,
-      filename: path7.basename(input.path, ext)
+      filename: path.basename(input.path, ext)
     };
   }).build();
 }
 function createPathRelativeTool() {
   return toolBuilder().name("path-relative").description("Get the relative path from one path to another.").category(ToolCategory.FILE_SYSTEM).tags(["path", "relative", "filesystem"]).schema(pathRelativeSchema).implement(async (input) => {
-    const relative3 = path7.relative(input.from, input.to);
+    const relative4 = path.relative(input.from, input.to);
     return {
-      relativePath: relative3,
+      relativePath: relative4,
       from: input.from,
       to: input.to
     };
@@ -9667,7 +9810,7 @@ function createPathRelativeTool() {
 }
 function createPathNormalizeTool() {
   return toolBuilder().name("path-normalize").description('Normalize a path by resolving ".." and "." segments and removing duplicate separators.').category(ToolCategory.FILE_SYSTEM).tags(["path", "normalize", "filesystem"]).schema(pathNormalizeSchema).implement(async (input) => {
-    const normalized = path7.normalize(input.path);
+    const normalized = path.normalize(input.path);
     return {
       normalized,
       original: input.path
@@ -10567,6 +10710,6 @@ function createAskHumanTool() {
 }
 var askHumanTool = createAskHumanTool();
 
-export { AskHumanInputSchema, CalculatorSchema, ConnectionManager, ConnectionState, CreditCardValidatorSchema, CurrentDateTimeSchema, DEFAULT_BATCH_SIZE, DEFAULT_CHUNK_SIZE, DEFAULT_DESTINATION_POLICY, DEFAULT_RETRY_CONFIG2 as DEFAULT_RETRY_CONFIG, DateArithmeticSchema, DateComparisonSchema, DateDifferenceSchema, DateFormatterSchema, DestinationPolicyError, DuckDuckGoProvider, EmailValidatorSchema, EmbeddingManager, HttpMethod, IpValidatorSchema, MAX_BATCH_SIZE, MathFunctionsSchema, MissingPeerDependencyError, OpenAIEmbeddingProvider, PhoneValidatorSchema, RandomNumberSchema, SchemaInspector, SerperProvider, StatisticsSchema, StringCaseConverterSchema, StringJoinSchema, StringLengthSchema, StringReplaceSchema, StringSplitSchema, StringSubstringSchema, StringTrimSchema, UrlValidatorSimpleSchema, UuidValidatorSchema, archiveConfluencePage, arrayFilter, arrayFilterSchema, arrayGroupBy, arrayGroupBySchema, arrayMap, arrayMapSchema, arraySort, arraySortSchema, askHumanTool, assertDestinationAllowed, benchmarkBatchExecution, benchmarkStreamingSelectMemory, buildDeleteQuery, buildInsertQuery, buildSelectQuery, buildUpdateQuery, calculator, checkPeerDependency, confluenceTools, createArrayFilterTool, createArrayGroupByTool, createArrayMapTool, createArraySortTool, createAskHumanTool, createCalculatorTool, createConfluencePage, createConfluenceTools, createCreditCardValidatorTool, createCsvGeneratorTool, createCsvParserTool, createCsvToJsonTool, createCsvTools, createCurrentDateTimeTool, createDateArithmeticTool, createDateComparisonTool, createDateDifferenceTool, createDateFormatterTool, createDateTimeTools, createDirectoryCreateTool, createDirectoryDeleteTool, createDirectoryListTool, createDirectoryOperationTools, createDuckDuckGoProvider, createEmailValidatorTool, createExtractImagesTool, createExtractLinksTool, createFileAppendTool, createFileDeleteTool, createFileExistsTool, createFileOperationTools, createFileReaderTool, createFileSearchTool, createFileWriterTool, createHtmlParserTool, createHtmlParserTools, createHttpTools, createIpValidatorTool, createJsonMergeTool, createJsonParserTool, createJsonQueryTool, createJsonStringifyTool, createJsonToCsvTool, createJsonToXmlTool, createJsonTools, createJsonValidatorTool, createMathFunctionsTool, createMathOperationTools, createNeo4jCreateNodeWithEmbeddingTool, createNeo4jFindNodesTool, createNeo4jGetSchemaTool, createNeo4jQueryTool, createNeo4jTools, createNeo4jTraverseTool, createNeo4jVectorSearchTool, createNeo4jVectorSearchWithEmbeddingTool, createObjectOmitTool, createObjectPickTool, createPathBasenameTool, createPathDirnameTool, createPathExtensionTool, createPathJoinTool, createPathNormalizeTool, createPathParseTool, createPathRelativeTool, createPathResolveTool, createPathUtilityTools, createPhoneValidatorTool, createRandomNumberTool, createScraperTools, createSelectReadableStream, createSerperProvider, createSlackTools, createStatisticsTool, createStringCaseConverterTool, createStringJoinTool, createStringLengthTool, createStringReplaceTool, createStringSplitTool, createStringSubstringTool, createStringTrimTool, createStringUtilityTools, createTransformerTools, createUrlBuilderTool, createUrlQueryParserTool, createUrlValidatorSimpleTool, createUrlValidatorTool, createUrlValidatorTools, createUuidValidatorTool, createValidationTools, createWebScraperTool, createXmlGeneratorTool, createXmlParserTool, createXmlToJsonTool, createXmlTools, creditCardValidator, csvGenerator, csvGeneratorSchema, csvParser, csvParserSchema, csvToJson, csvToJsonSchema, csvTools, currentDateTime, dateArithmetic, dateComparison, dateDifference, dateFormatter, dateTimeTools, diffSchemas, directoryCreate, directoryCreateSchema, directoryDelete, directoryDeleteSchema, directoryList, directoryListSchema, directoryOperationTools, emailValidator, embeddingManager, executeBatchedTask, executeQuery2 as executeQuery, executeStreamingSelect, exportSchemaToJson, extractImages, extractImagesSchema, extractLinks, extractLinksSchema, fileAppend, fileAppendSchema, fileDelete, fileDeleteSchema, fileExists, fileExistsSchema, fileOperationTools, fileReader, fileReaderSchema, fileSearch, fileSearchSchema, fileWriter, fileWriterSchema, generateBatchEmbeddings, generateEmbedding, getCohereApiKey, getConfluencePage, getEmbeddingModel, getEmbeddingProvider, getHuggingFaceApiKey, getInstallationInstructions, getOllamaBaseUrl, getOpenAIApiKey, getPeerDependencyName, getSlackChannels, getSlackMessages, getSpacePages, getVendorTypeMap, getVoyageApiKey, htmlParser, htmlParserSchema, htmlParserTools, httpClient, httpGet, httpGetSchema, httpPost, httpPostSchema, httpRequestSchema, httpTools, importSchemaFromJson, initializeEmbeddings, initializeEmbeddingsWithConfig, initializeFromEnv, initializeNeo4jTools, ipValidator, isRetryableError2 as isRetryableError, jsonMerge, jsonMergeSchema, jsonParser, jsonParserSchema, jsonQuery, jsonQuerySchema, jsonStringify, jsonStringifySchema, jsonToCsv, jsonToCsvSchema, jsonToXml, jsonToXmlSchema, jsonTools, jsonValidator, jsonValidatorSchema, listConfluenceSpaces, mapColumnType, mapSchemaTypes, mathFunctions, mathOperationTools, neo4jCoreTools, neo4jCreateNodeWithEmbedding, neo4jCreateNodeWithEmbeddingSchema, neo4jFindNodes, neo4jFindNodesSchema, neo4jGetSchema, neo4jGetSchemaSchema, neo4jPool, neo4jQuery, neo4jQuerySchema, neo4jTools, neo4jTraverse, neo4jTraverseSchema, neo4jVectorSearch, neo4jVectorSearchSchema, neo4jVectorSearchWithEmbedding, neo4jVectorSearchWithEmbeddingSchema, notifySlack, objectOmit, objectOmitSchema, objectPick, objectPickSchema, pathBasename, pathBasenameSchema, pathDirname, pathDirnameSchema, pathExtension, pathExtensionSchema, pathJoin, pathJoinSchema, pathNormalize, pathNormalizeSchema, pathParse, pathParseSchema, pathRelative, pathRelativeSchema, pathResolve, pathResolveSchema, pathUtilityTools, phoneValidator, randomNumber, relationalDelete, relationalGetSchema, relationalInsert, relationalQuery, relationalSelect, relationalUpdate, requestWithDestinationPolicy, retryWithBackoff2 as retryWithBackoff, scraperTools, searchConfluence, searchResultSchema, sendSlackMessage, slackTools, statistics, streamSelectChunks, stringCaseConverter, stringJoin, stringLength, stringReplace, stringSplit, stringSubstring, stringTrim, stringUtilityTools, transformerArraySchema, transformerObjectSchema, transformerTools, transformerValueSchema, updateConfluencePage, urlBuilder, urlBuilderSchema, urlQueryParser, urlQueryParserSchema, urlValidator, urlValidatorSchema, urlValidatorSimple, urlValidatorTools, uuidValidator, validateBatch, validateColumnTypes, validateColumnsExist, validateTableExists, validateText, validationTools, webScraper, webScraperSchema, webSearch, webSearchOutputSchema, webSearchSchema, withTransaction, xmlGenerator, xmlGeneratorSchema, xmlParser, xmlParserSchema, xmlToJson, xmlToJsonSchema, xmlTools };
+export { AskHumanInputSchema, CalculatorSchema, ConnectionManager, ConnectionState, CreditCardValidatorSchema, CurrentDateTimeSchema, DEFAULT_BATCH_SIZE, DEFAULT_CHUNK_SIZE, DEFAULT_DESTINATION_POLICY, DEFAULT_FILE_SYSTEM_POLICY, DEFAULT_RETRY_CONFIG2 as DEFAULT_RETRY_CONFIG, DateArithmeticSchema, DateComparisonSchema, DateDifferenceSchema, DateFormatterSchema, DestinationPolicyError, DuckDuckGoProvider, EmailValidatorSchema, EmbeddingManager, FileSystemPolicy, FileSystemPolicyError, HttpMethod, IpValidatorSchema, MAX_BATCH_SIZE, MathFunctionsSchema, MissingPeerDependencyError, OpenAIEmbeddingProvider, PhoneValidatorSchema, RandomNumberSchema, SchemaInspector, SerperProvider, StatisticsSchema, StringCaseConverterSchema, StringJoinSchema, StringLengthSchema, StringReplaceSchema, StringSplitSchema, StringSubstringSchema, StringTrimSchema, UrlValidatorSimpleSchema, UuidValidatorSchema, archiveConfluencePage, arrayFilter, arrayFilterSchema, arrayGroupBy, arrayGroupBySchema, arrayMap, arrayMapSchema, arraySort, arraySortSchema, askHumanTool, assertDestinationAllowed, benchmarkBatchExecution, benchmarkStreamingSelectMemory, buildDeleteQuery, buildInsertQuery, buildSelectQuery, buildUpdateQuery, calculator, checkPeerDependency, confluenceTools, createArrayFilterTool, createArrayGroupByTool, createArrayMapTool, createArraySortTool, createAskHumanTool, createCalculatorTool, createConfluencePage, createConfluenceTools, createCreditCardValidatorTool, createCsvGeneratorTool, createCsvParserTool, createCsvToJsonTool, createCsvTools, createCurrentDateTimeTool, createDateArithmeticTool, createDateComparisonTool, createDateDifferenceTool, createDateFormatterTool, createDateTimeTools, createDirectoryCreateTool, createDirectoryDeleteTool, createDirectoryListTool, createDirectoryOperationTools, createDuckDuckGoProvider, createEmailValidatorTool, createExtractImagesTool, createExtractLinksTool, createFileAppendTool, createFileDeleteTool, createFileExistsTool, createFileOperationTools, createFileReaderTool, createFileSearchTool, createFileSystemPolicy, createFileWriterTool, createHtmlParserTool, createHtmlParserTools, createHttpTools, createIpValidatorTool, createJsonMergeTool, createJsonParserTool, createJsonQueryTool, createJsonStringifyTool, createJsonToCsvTool, createJsonToXmlTool, createJsonTools, createJsonValidatorTool, createMathFunctionsTool, createMathOperationTools, createNeo4jCreateNodeWithEmbeddingTool, createNeo4jFindNodesTool, createNeo4jGetSchemaTool, createNeo4jQueryTool, createNeo4jTools, createNeo4jTraverseTool, createNeo4jVectorSearchTool, createNeo4jVectorSearchWithEmbeddingTool, createObjectOmitTool, createObjectPickTool, createPathBasenameTool, createPathDirnameTool, createPathExtensionTool, createPathJoinTool, createPathNormalizeTool, createPathParseTool, createPathRelativeTool, createPathResolveTool, createPathUtilityTools, createPhoneValidatorTool, createRandomNumberTool, createScraperTools, createSelectReadableStream, createSerperProvider, createSlackTools, createStatisticsTool, createStringCaseConverterTool, createStringJoinTool, createStringLengthTool, createStringReplaceTool, createStringSplitTool, createStringSubstringTool, createStringTrimTool, createStringUtilityTools, createTransformerTools, createUrlBuilderTool, createUrlQueryParserTool, createUrlValidatorSimpleTool, createUrlValidatorTool, createUrlValidatorTools, createUuidValidatorTool, createValidationTools, createWebScraperTool, createXmlGeneratorTool, createXmlParserTool, createXmlToJsonTool, createXmlTools, creditCardValidator, csvGenerator, csvGeneratorSchema, csvParser, csvParserSchema, csvToJson, csvToJsonSchema, csvTools, currentDateTime, dateArithmetic, dateComparison, dateDifference, dateFormatter, dateTimeTools, diffSchemas, directoryCreate, directoryCreateSchema, directoryDelete, directoryDeleteSchema, directoryList, directoryListSchema, directoryOperationTools, emailValidator, embeddingManager, executeBatchedTask, executeQuery2 as executeQuery, executeStreamingSelect, exportSchemaToJson, extractImages, extractImagesSchema, extractLinks, extractLinksSchema, fileAppend, fileAppendSchema, fileDelete, fileDeleteSchema, fileExists, fileExistsSchema, fileOperationTools, fileReader, fileReaderSchema, fileSearch, fileSearchSchema, fileWriter, fileWriterSchema, generateBatchEmbeddings, generateEmbedding, getCohereApiKey, getConfluencePage, getEmbeddingModel, getEmbeddingProvider, getHuggingFaceApiKey, getInstallationInstructions, getOllamaBaseUrl, getOpenAIApiKey, getPeerDependencyName, getSlackChannels, getSlackMessages, getSpacePages, getVendorTypeMap, getVoyageApiKey, htmlParser, htmlParserSchema, htmlParserTools, httpClient, httpGet, httpGetSchema, httpPost, httpPostSchema, httpRequestSchema, httpTools, importSchemaFromJson, initializeEmbeddings, initializeEmbeddingsWithConfig, initializeFromEnv, initializeNeo4jTools, ipValidator, isRetryableError2 as isRetryableError, jsonMerge, jsonMergeSchema, jsonParser, jsonParserSchema, jsonQuery, jsonQuerySchema, jsonStringify, jsonStringifySchema, jsonToCsv, jsonToCsvSchema, jsonToXml, jsonToXmlSchema, jsonTools, jsonValidator, jsonValidatorSchema, listConfluenceSpaces, mapColumnType, mapSchemaTypes, mathFunctions, mathOperationTools, neo4jCoreTools, neo4jCreateNodeWithEmbedding, neo4jCreateNodeWithEmbeddingSchema, neo4jFindNodes, neo4jFindNodesSchema, neo4jGetSchema, neo4jGetSchemaSchema, neo4jPool, neo4jQuery, neo4jQuerySchema, neo4jTools, neo4jTraverse, neo4jTraverseSchema, neo4jVectorSearch, neo4jVectorSearchSchema, neo4jVectorSearchWithEmbedding, neo4jVectorSearchWithEmbeddingSchema, notifySlack, objectOmit, objectOmitSchema, objectPick, objectPickSchema, pathBasename, pathBasenameSchema, pathDirname, pathDirnameSchema, pathExtension, pathExtensionSchema, pathJoin, pathJoinSchema, pathNormalize, pathNormalizeSchema, pathParse, pathParseSchema, pathRelative, pathRelativeSchema, pathResolve, pathResolveSchema, pathUtilityTools, phoneValidator, randomNumber, relationalDelete, relationalGetSchema, relationalInsert, relationalQuery, relationalSelect, relationalUpdate, requestWithDestinationPolicy, resolveFileSystemPolicy, retryWithBackoff2 as retryWithBackoff, scraperTools, searchConfluence, searchResultSchema, sendSlackMessage, slackTools, statistics, streamSelectChunks, stringCaseConverter, stringJoin, stringLength, stringReplace, stringSplit, stringSubstring, stringTrim, stringUtilityTools, transformerArraySchema, transformerObjectSchema, transformerTools, transformerValueSchema, updateConfluencePage, urlBuilder, urlBuilderSchema, urlQueryParser, urlQueryParserSchema, urlValidator, urlValidatorSchema, urlValidatorSimple, urlValidatorTools, uuidValidator, validateBatch, validateColumnTypes, validateColumnsExist, validateTableExists, validateText, validationTools, webScraper, webScraperSchema, webSearch, webSearchOutputSchema, webSearchSchema, withTransaction, xmlGenerator, xmlGeneratorSchema, xmlParser, xmlParserSchema, xmlToJson, xmlToJsonSchema, xmlTools };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map