@agentforge/tools 0.9.0 → 0.10.0

package/dist/index.js

@@ -1032,6 +1032,506 @@ function createSlackTools(config = {}) {
   };
 }
 var slackTools = [sendSlackMessage, notifySlack, getSlackChannels, getSlackMessages];
+
+// src/web/confluence/auth.ts
+function createGetConfiguredAuth(apiKey, email, siteUrl) {
+  return function getConfiguredAuth() {
+    const ATLASSIAN_API_KEY = apiKey || process.env.ATLASSIAN_API_KEY || "";
+    const ATLASSIAN_EMAIL = email || process.env.ATLASSIAN_EMAIL || "";
+    const ATLASSIAN_SITE_URL = (siteUrl || process.env.ATLASSIAN_SITE_URL || "").replace(/\/$/, "");
+    if (!ATLASSIAN_API_KEY || !ATLASSIAN_EMAIL || !ATLASSIAN_SITE_URL) {
+      throw new Error(
+        "Confluence credentials not configured. Set ATLASSIAN_API_KEY, ATLASSIAN_EMAIL, and ATLASSIAN_SITE_URL in config or environment variables."
+      );
+    }
+    return { ATLASSIAN_API_KEY, ATLASSIAN_EMAIL, ATLASSIAN_SITE_URL };
+  };
+}
+function createGetConfiguredAuthHeader(getConfiguredAuth) {
+  return function getConfiguredAuthHeader() {
+    const { ATLASSIAN_API_KEY, ATLASSIAN_EMAIL } = getConfiguredAuth();
+    const auth = Buffer.from(`${ATLASSIAN_EMAIL}:${ATLASSIAN_API_KEY}`).toString("base64");
+    return `Basic ${auth}`;
+  };
+}
+function getConfig() {
+  const ATLASSIAN_API_KEY = process.env.ATLASSIAN_API_KEY || "";
+  const ATLASSIAN_EMAIL = process.env.ATLASSIAN_EMAIL || "";
+  const ATLASSIAN_SITE_URL = (process.env.ATLASSIAN_SITE_URL || "").replace(/\/$/, "");
+  if (!ATLASSIAN_API_KEY || !ATLASSIAN_EMAIL || !ATLASSIAN_SITE_URL) {
+    throw new Error("Confluence credentials not configured. Set ATLASSIAN_API_KEY, ATLASSIAN_EMAIL, and ATLASSIAN_SITE_URL in .env");
+  }
+  return { ATLASSIAN_API_KEY, ATLASSIAN_EMAIL, ATLASSIAN_SITE_URL };
+}
+function getAuthHeader() {
+  const { ATLASSIAN_API_KEY, ATLASSIAN_EMAIL } = getConfig();
+  const auth = Buffer.from(`${ATLASSIAN_EMAIL}:${ATLASSIAN_API_KEY}`).toString("base64");
+  return `Basic ${auth}`;
+}
+function createSearchConfluenceTool(getAuth, getAuthHeader2, logger4) {
+  return toolBuilder().name("search-confluence").description("Search for pages in Confluence using keywords or CQL (Confluence Query Language). Returns matching pages with titles, IDs, and excerpts.").category(ToolCategory.WEB).tag("confluence").tag("search").tag("knowledge-base").usageNotes("Use this to find relevant documentation, policies, or information in Confluence. You can search by keywords or use CQL for advanced queries (e.g., 'space=AI AND type=page'). Use get-confluence-page to retrieve full content of specific pages.").suggests(["get-confluence-page"]).schema(z.object({
+    query: z.string().describe("Search query or CQL expression (e.g., 'payment processing' or 'space=BL3 AND title~payment')"),
+    limit: z.number().optional().describe("Maximum number of results to return (default: 10, max: 25)")
+  })).implement(async ({ query, limit = 10 }) => {
+    logger4.info("search-confluence called", { query, limit });
+    try {
+      const { ATLASSIAN_SITE_URL } = getAuth();
+      const response = await axios.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/content/search`, {
+        headers: {
+          Authorization: getAuthHeader2(),
+          Accept: "application/json"
+        },
+        params: {
+          cql: query,
+          limit: Math.min(limit, 25),
+          expand: "space,version"
+        }
+      });
+      const { ATLASSIAN_SITE_URL: siteUrl } = getAuth();
+      const results = response.data.results.map((page) => ({
+        id: page.id,
+        title: page.title,
+        type: page.type,
+        space: page.space?.name || "Unknown",
+        spaceKey: page.space?.key || "",
+        url: `${siteUrl}/wiki${page._links.webui}`,
+        lastModified: page.version?.when || ""
+      }));
+      if (results.length === 0) {
+        logger4.warn("search-confluence returned NO RESULTS - this is a valid outcome, agent should not retry", {
+          query,
+          limit,
+          totalSize: response.data.totalSize
+        });
+      } else {
+        logger4.info("search-confluence result", {
+          query,
+          resultCount: results.length,
+          totalSize: response.data.totalSize,
+          titles: results.map((r) => r.title).slice(0, 3)
+          // Log first 3 titles
+        });
+      }
+      return JSON.stringify({
+        success: true,
+        count: results.length,
+        total: response.data.totalSize,
+        results
+      });
+    } catch (error) {
+      logger4.error("search-confluence error", {
+        query,
+        error: error.response?.data?.message || error.message,
+        status: error.response?.status
+      });
+      return JSON.stringify({
+        success: false,
+        error: error.response?.data?.message || error.message
+      });
+    }
+  }).build();
+}
+function createGetConfluencePageTool(getAuth, getAuthHeader2, logger4) {
+  return toolBuilder().name("get-confluence-page").description("Get the full content of a specific Confluence page by its ID. Returns the page title, content (in storage format), space, and metadata.").category(ToolCategory.WEB).tag("confluence").tag("page").tag("content").usageNotes("Use this after search-confluence to retrieve the full content of a specific page. The page ID can be found in search results.").requires(["search-confluence"]).schema(z.object({
+    page_id: z.string().describe("The Confluence page ID (from search results)")
+  })).implement(async ({ page_id }) => {
+    logger4.info("get-confluence-page called", { page_id });
+    try {
+      const { ATLASSIAN_SITE_URL } = getAuth();
+      const response = await axios.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`, {
+        headers: {
+          Authorization: getAuthHeader2(),
+          Accept: "application/json"
+        },
+        params: {
+          expand: "body.storage,space,version,history"
+        }
+      });
+      const page = response.data;
+      logger4.info("get-confluence-page result", {
+        page_id,
+        title: page.title,
+        space: page.space?.name,
+        contentLength: page.body?.storage?.value?.length || 0
+      });
+      return JSON.stringify({
+        success: true,
+        page: {
+          id: page.id,
+          title: page.title,
+          type: page.type,
+          space: page.space?.name || "Unknown",
+          spaceKey: page.space?.key || "",
+          content: page.body?.storage?.value || "",
+          url: `${ATLASSIAN_SITE_URL}/wiki${page._links.webui}`,
+          created: page.history?.createdDate || "",
+          lastModified: page.version?.when || "",
+          version: page.version?.number || 1
+        }
+      });
+    } catch (error) {
+      logger4.error("get-confluence-page error", {
+        page_id,
+        error: error.response?.data?.message || error.message,
+        status: error.response?.status
+      });
+      return JSON.stringify({
+        success: false,
+        error: error.response?.data?.message || error.message
+      });
+    }
+  }).build();
+}
+function createListConfluenceSpacesTool(getAuth, getAuthHeader2, logger4) {
+  return toolBuilder().name("list-confluence-spaces").description("List all available Confluence spaces. Returns space names, keys, types, and descriptions to help identify where to search for information.").category(ToolCategory.WEB).tag("confluence").tag("spaces").tag("list").usageNotes("Use this first to discover available spaces before searching. Helps narrow down searches to specific areas (e.g., 'AI', 'BL3', 'Finance').").follows(["search-confluence"]).schema(z.object({
+    limit: z.number().optional().describe("Maximum number of spaces to return (default: 25)")
+  })).implement(async ({ limit = 25 }) => {
+    logger4.info("list-confluence-spaces called", { limit });
+    try {
+      const { ATLASSIAN_SITE_URL } = getAuth();
+      const response = await axios.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/space`, {
+        headers: {
+          Authorization: getAuthHeader2(),
+          Accept: "application/json"
+        },
+        params: {
+          limit
+        }
+      });
+      const spaces = response.data.results.map((space) => ({
+        key: space.key,
+        name: space.name,
+        type: space.type,
+        description: space.description?.plain?.value || "",
+        url: `${ATLASSIAN_SITE_URL}/wiki${space._links.webui}`
+      }));
+      logger4.info("list-confluence-spaces result", {
+        spaceCount: spaces.length,
+        spaceKeys: spaces.map((s) => s.key).slice(0, 5)
+        // Log first 5 space keys
+      });
+      return JSON.stringify({
+        success: true,
+        count: spaces.length,
+        spaces
+      });
+    } catch (error) {
+      logger4.error("list-confluence-spaces error", {
+        error: error.response?.data?.message || error.message,
+        status: error.response?.status
+      });
+      return JSON.stringify({
+        success: false,
+        error: error.response?.data?.message || error.message
+      });
+    }
+  }).build();
+}
+function createGetSpacePagesTool(getAuth, getAuthHeader2, logger4) {
+  return toolBuilder().name("get-space-pages").description("Get all pages from a specific Confluence space by space key. Useful for browsing content in a particular area.").category(ToolCategory.WEB).tag("confluence").tag("space").tag("pages").usageNotes("Use this to explore all pages in a specific space. Get the space key from list-confluence-spaces first.").requires(["list-confluence-spaces"]).schema(z.object({
+    space_key: z.string().describe("The space key (e.g., 'AI', 'BL3', 'FIN')"),
+    limit: z.number().optional().describe("Maximum number of pages to return (default: 25)")
+  })).implement(async ({ space_key, limit = 25 }) => {
+    logger4.info("get-space-pages called", { space_key, limit });
+    try {
+      const { ATLASSIAN_SITE_URL } = getAuth();
+      const response = await axios.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/content`, {
+        headers: {
+          Authorization: getAuthHeader2(),
+          Accept: "application/json"
+        },
+        params: {
+          spaceKey: space_key,
+          type: "page",
+          limit,
+          expand: "version"
+        }
+      });
+      const pages = response.data.results.map((page) => ({
+        id: page.id,
+        title: page.title,
+        url: `${ATLASSIAN_SITE_URL}/wiki${page._links.webui}`,
+        lastModified: page.version?.when || ""
+      }));
+      if (pages.length === 0) {
+        logger4.warn("get-space-pages returned NO PAGES - this is a valid outcome, agent should not retry", {
+          space_key,
+          limit
+        });
+      } else {
+        logger4.info("get-space-pages result", {
+          space_key,
+          pageCount: pages.length,
+          titles: pages.map((p) => p.title).slice(0, 3)
+          // Log first 3 titles
+        });
+      }
+      return JSON.stringify({
+        success: true,
+        space: space_key,
+        count: pages.length,
+        pages
+      });
+    } catch (error) {
+      logger4.error("get-space-pages error", {
+        space_key,
+        error: error.response?.data?.message || error.message,
+        status: error.response?.status
+      });
+      return JSON.stringify({
+        success: false,
+        error: error.response?.data?.message || error.message
+      });
+    }
+  }).build();
+}
+function createCreateConfluencePageTool(getAuth, getAuthHeader2, logger4) {
+  return toolBuilder().name("create-confluence-page").description("Create a new page in a Confluence space. Requires space key, page title, and content (in HTML storage format).").category(ToolCategory.WEB).tag("confluence").tag("create").tag("write").usageNotes("Use this to create new documentation pages. Content should be in Confluence storage format (HTML). Get the space key from list-confluence-spaces first. Be mindful of creating duplicate pages.").requires(["list-confluence-spaces"]).schema(z.object({
+    space_key: z.string().describe("The space key where the page will be created (e.g., 'AI', 'BL3')"),
+    title: z.string().describe("The title of the new page"),
+    content: z.string().describe("The page content in HTML format (Confluence storage format)"),
+    parent_page_id: z.string().optional().describe("Optional parent page ID to create this as a child page")
+  })).implement(async ({ space_key, title, content, parent_page_id }) => {
+    logger4.info("create-confluence-page called", { space_key, title, hasParent: !!parent_page_id });
+    try {
+      const { ATLASSIAN_SITE_URL } = getAuth();
+      const pageData = {
+        type: "page",
+        title,
+        space: { key: space_key },
+        body: {
+          storage: {
+            value: content,
+            representation: "storage"
+          }
+        }
+      };
+      if (parent_page_id) {
+        pageData.ancestors = [{ id: parent_page_id }];
+      }
+      const response = await axios.post(
+        `${ATLASSIAN_SITE_URL}/wiki/rest/api/content`,
+        pageData,
+        {
+          headers: {
+            Authorization: getAuthHeader2(),
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      logger4.info("create-confluence-page result", {
+        page_id: response.data.id,
+        title: response.data.title,
+        space: space_key
+      });
+      return JSON.stringify({
+        success: true,
+        page: {
+          id: response.data.id,
+          title: response.data.title,
+          space: space_key,
+          url: `${ATLASSIAN_SITE_URL}/wiki${response.data._links.webui}`,
+          version: response.data.version?.number || 1
+        }
+      });
+    } catch (error) {
+      logger4.error("create-confluence-page error", {
+        space_key,
+        title,
+        error: error.response?.data?.message || error.message,
+        status: error.response?.status
+      });
+      return JSON.stringify({
+        success: false,
+        error: error.response?.data?.message || error.message
+      });
+    }
+  }).build();
+}
+function createUpdateConfluencePageTool(getAuth, getAuthHeader2, logger4) {
+  return toolBuilder().name("update-confluence-page").description("Update an existing Confluence page's content. Requires page ID, new title, and new content.").category(ToolCategory.WEB).tag("confluence").tag("update").tag("write").usageNotes("Use this to update existing documentation. You must provide the page ID (from search results). The tool will automatically handle version incrementing. Always get the current page content first to avoid overwriting important information.").requires(["get-confluence-page"]).schema(z.object({
+    page_id: z.string().describe("The ID of the page to update"),
+    title: z.string().describe("The new title for the page"),
+    content: z.string().describe("The new content in HTML format (Confluence storage format)")
+  })).implement(async ({ page_id, title, content }) => {
+    logger4.info("update-confluence-page called", { page_id, title });
+    try {
+      const { ATLASSIAN_SITE_URL } = getAuth();
+      const getResponse = await axios.get(
+        `${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`,
+        {
+          headers: {
+            Authorization: getAuthHeader2()
+          },
+          params: { expand: "version" }
+        }
+      );
+      const currentVersion = getResponse.data.version.number;
+      const updateResponse = await axios.put(
+        `${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`,
+        {
+          type: "page",
+          title,
+          version: { number: currentVersion + 1 },
+          body: {
+            storage: {
+              value: content,
+              representation: "storage"
+            }
+          }
+        },
+        {
+          headers: {
+            Authorization: getAuthHeader2(),
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      logger4.info("update-confluence-page result", {
+        page_id,
+        title: updateResponse.data.title,
+        previousVersion: currentVersion,
+        newVersion: updateResponse.data.version.number
+      });
+      return JSON.stringify({
+        success: true,
+        page: {
+          id: updateResponse.data.id,
+          title: updateResponse.data.title,
+          url: `${ATLASSIAN_SITE_URL}/wiki${updateResponse.data._links.webui}`,
+          version: updateResponse.data.version.number,
+          previousVersion: currentVersion
+        }
+      });
+    } catch (error) {
+      logger4.error("update-confluence-page error", {
+        page_id,
+        title,
+        error: error.response?.data?.message || error.message,
+        status: error.response?.status
+      });
+      return JSON.stringify({
+        success: false,
+        error: error.response?.data?.message || error.message
+      });
+    }
+  }).build();
+}
+function createArchiveConfluencePageTool(getAuth, getAuthHeader2, logger4) {
+  return toolBuilder().name("archive-confluence-page").description("Archive a Confluence page by moving it to trash. The page can be restored by space admins. Note: UI may require a note explaining why the page was archived.").category(ToolCategory.WEB).tag("confluence").tag("archive").tag("delete").usageNotes("Use this to archive outdated or obsolete documentation. The page is moved to trash, not permanently deleted. Space admins can restore it if needed. Be very careful - only archive pages that are truly obsolete.").conflicts(["create-confluence-page"]).schema(z.object({
+    page_id: z.string().describe("The ID of the page to archive"),
+    reason: z.string().optional().describe("Optional reason for archiving (for audit trail)")
+  })).implement(async ({ page_id, reason }) => {
+    logger4.info("archive-confluence-page called", { page_id, reason });
+    try {
+      const { ATLASSIAN_SITE_URL } = getAuth();
+      const getResponse = await axios.get(
+        `${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`,
+        {
+          headers: {
+            Authorization: getAuthHeader2()
+          },
+          params: { expand: "version,body.storage,space" }
+        }
+      );
+      const currentVersion = getResponse.data.version.number;
+      const pageData = getResponse.data;
+      await axios.put(
+        `${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`,
+        {
+          version: { number: currentVersion + 1 },
+          title: pageData.title,
+          type: "page",
+          status: "trashed",
+          body: pageData.body,
+          space: { key: pageData.space.key }
+        },
+        {
+          headers: {
+            Authorization: getAuthHeader2(),
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      logger4.info("archive-confluence-page result", {
+        page_id,
+        title: pageData.title,
+        previousVersion: currentVersion,
+        newVersion: currentVersion + 1
+      });
+      return JSON.stringify({
+        success: true,
+        archived: {
+          id: page_id,
+          title: pageData.title,
+          previousVersion: currentVersion,
+          newVersion: currentVersion + 1,
+          reason: reason || "Archived via API",
+          note: "Page moved to trash. Space admins can restore it from the Confluence UI."
+        }
+      });
+    } catch (error) {
+      logger4.error("archive-confluence-page error", {
+        page_id,
+        error: error.response?.data?.message || error.message,
+        status: error.response?.status
+      });
+      return JSON.stringify({
+        success: false,
+        error: error.response?.data?.message || error.message
+      });
+    }
+  }).build();
+}
+
+// src/web/confluence/index.ts
+var logLevel2 = process.env.LOG_LEVEL?.toLowerCase() || LogLevel.INFO;
+var logger2 = createLogger("[tools:confluence]", { level: logLevel2 });
+var searchConfluence = createSearchConfluenceTool(getConfig, getAuthHeader, logger2);
+var getConfluencePage = createGetConfluencePageTool(getConfig, getAuthHeader, logger2);
+var listConfluenceSpaces = createListConfluenceSpacesTool(getConfig, getAuthHeader, logger2);
+var getSpacePages = createGetSpacePagesTool(getConfig, getAuthHeader, logger2);
+var createConfluencePage = createCreateConfluencePageTool(getConfig, getAuthHeader, logger2);
+var updateConfluencePage = createUpdateConfluencePageTool(getConfig, getAuthHeader, logger2);
+var archiveConfluencePage = createArchiveConfluencePageTool(getConfig, getAuthHeader, logger2);
+var confluenceTools = [
+  // Read tools
+  searchConfluence,
+  getConfluencePage,
+  listConfluenceSpaces,
+  getSpacePages,
+  // Write tools
+  createConfluencePage,
+  updateConfluencePage,
+  archiveConfluencePage
+];
+function createConfluenceTools(config = {}) {
+  const {
+    apiKey,
+    email,
+    siteUrl,
+    logLevel: customLogLevel
+  } = config;
+  const getConfiguredAuth = createGetConfiguredAuth(apiKey, email, siteUrl);
+  const getConfiguredAuthHeader = createGetConfiguredAuthHeader(getConfiguredAuth);
+  const toolLogger = customLogLevel ? createLogger("tools:confluence", { level: customLogLevel }) : logger2;
+  const searchConfluence2 = createSearchConfluenceTool(getConfiguredAuth, getConfiguredAuthHeader, toolLogger);
+  const getConfluencePage2 = createGetConfluencePageTool(getConfiguredAuth, getConfiguredAuthHeader, toolLogger);
+  const listConfluenceSpaces2 = createListConfluenceSpacesTool(getConfiguredAuth, getConfiguredAuthHeader, toolLogger);
+  const getSpacePages2 = createGetSpacePagesTool(getConfiguredAuth, getConfiguredAuthHeader, toolLogger);
+  const createConfluencePage2 = createCreateConfluencePageTool(getConfiguredAuth, getConfiguredAuthHeader, toolLogger);
+  const updateConfluencePage2 = createUpdateConfluencePageTool(getConfiguredAuth, getConfiguredAuthHeader, toolLogger);
+  const archiveConfluencePage2 = createArchiveConfluencePageTool(getConfiguredAuth, getConfiguredAuthHeader, toolLogger);
+  return {
+    searchConfluence: searchConfluence2,
+    getConfluencePage: getConfluencePage2,
+    listConfluenceSpaces: listConfluenceSpaces2,
+    getSpacePages: getSpacePages2,
+    createConfluencePage: createConfluencePage2,
+    updateConfluencePage: updateConfluencePage2,
+    archiveConfluencePage: archiveConfluencePage2
+  };
+}
 var jsonParser = toolBuilder().name("json-parser").description("Parse JSON string into an object. Validates JSON syntax and returns parsed data or error details.").category(ToolCategory.UTILITY).tags(["json", "parse", "data"]).schema(z.object({
   json: z.string().describe("JSON string to parse"),
   strict: z.boolean().default(true).describe("Use strict JSON parsing (no trailing commas, etc.)")
@@ -2256,8 +2756,8 @@ var AskHumanInputSchema = z.object({
    */
   suggestions: z.array(z.string()).optional().describe("Suggested responses for the human")
 });
-var logLevel2 = process.env.LOG_LEVEL?.toLowerCase() || LogLevel.INFO;
-var logger2 = createLogger("askHuman", { level: logLevel2 });
+var logLevel3 = process.env.LOG_LEVEL?.toLowerCase() || LogLevel.INFO;
+var logger3 = createLogger("askHuman", { level: logLevel3 });
 function createAskHumanTool() {
   return toolBuilder().name("ask-human").description(
     "Ask a human for input or approval. Use this when you need human guidance, approval for a critical action, or clarification on ambiguous requirements. The agent execution will pause until the human responds."
@@ -2290,13 +2790,13 @@ function createAskHumanTool() {
       suggestions: validatedInput.suggestions,
       status: "pending"
     };
-    logger2.debug("About to call interrupt()", { humanRequest });
+    logger3.debug("About to call interrupt()", { humanRequest });
     let response;
     try {
       response = interrupt(humanRequest);
-      logger2.debug("interrupt() returned successfully", { response, responseType: typeof response });
+      logger3.debug("interrupt() returned successfully", { response, responseType: typeof response });
     } catch (error) {
-      logger2.debug("interrupt() threw error (expected for GraphInterrupt)", {
+      logger3.debug("interrupt() threw error (expected for GraphInterrupt)", {
         errorType: error?.constructor?.name,
         error: error instanceof Error ? error.message : String(error)
       });
@@ -2321,6 +2821,6 @@ function createAskHumanTool() {
 }
 var askHumanTool = createAskHumanTool();
 
-export { AskHumanInputSchema, DuckDuckGoProvider, SerperProvider, arrayFilter, arrayGroupBy, arrayMap, arraySort, askHumanTool, calculator, createAskHumanTool, createDuckDuckGoProvider, createSerperProvider, createSlackTools, creditCardValidator, csvGenerator, csvParser, csvToJson, currentDateTime, dateArithmetic, dateComparison, dateDifference, dateFormatter, directoryCreate, directoryDelete, directoryList, emailValidator, extractImages, extractLinks, fileAppend, fileDelete, fileExists, fileReader, fileSearch, fileWriter, getSlackChannels, getSlackMessages, htmlParser, httpClient, httpGet, httpPost, ipValidator, jsonMerge, jsonParser, jsonQuery, jsonStringify, jsonToCsv, jsonToXml, jsonValidator, mathFunctions, notifySlack, objectOmit, objectPick, pathBasename, pathDirname, pathExtension, pathJoin, pathNormalize, pathParse, pathRelative, pathResolve, phoneValidator, randomNumber, searchResultSchema, sendSlackMessage, slackTools, statistics, stringCaseConverter, stringJoin, stringLength, stringReplace, stringSplit, stringSubstring, stringTrim, urlBuilder, urlQueryParser, urlValidator, urlValidatorSimple, uuidValidator, webScraper, webSearch, webSearchOutputSchema, webSearchSchema, xmlGenerator, xmlParser, xmlToJson };
+export { AskHumanInputSchema, DuckDuckGoProvider, SerperProvider, archiveConfluencePage, arrayFilter, arrayGroupBy, arrayMap, arraySort, askHumanTool, calculator, confluenceTools, createAskHumanTool, createConfluencePage, createConfluenceTools, createDuckDuckGoProvider, createSerperProvider, createSlackTools, creditCardValidator, csvGenerator, csvParser, csvToJson, currentDateTime, dateArithmetic, dateComparison, dateDifference, dateFormatter, directoryCreate, directoryDelete, directoryList, emailValidator, extractImages, extractLinks, fileAppend, fileDelete, fileExists, fileReader, fileSearch, fileWriter, getConfluencePage, getSlackChannels, getSlackMessages, getSpacePages, htmlParser, httpClient, httpGet, httpPost, ipValidator, jsonMerge, jsonParser, jsonQuery, jsonStringify, jsonToCsv, jsonToXml, jsonValidator, listConfluenceSpaces, mathFunctions, notifySlack, objectOmit, objectPick, pathBasename, pathDirname, pathExtension, pathJoin, pathNormalize, pathParse, pathRelative, pathResolve, phoneValidator, randomNumber, searchConfluence, searchResultSchema, sendSlackMessage, slackTools, statistics, stringCaseConverter, stringJoin, stringLength, stringReplace, stringSplit, stringSubstring, stringTrim, updateConfluencePage, urlBuilder, urlQueryParser, urlValidator, urlValidatorSimple, uuidValidator, webScraper, webSearch, webSearchOutputSchema, webSearchSchema, xmlGenerator, xmlParser, xmlToJson };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map