@agentforge/tools 0.12.5 → 0.12.6

package/dist/index.cjs

@@ -1,13 +1,14 @@
 'use strict';
 
 var core = require('@agentforge/core');
-var axios12 = require('axios');
+var axios16 = require('axios');
 var zod = require('zod');
 var cheerio = require('cheerio');
 var webApi = require('@slack/web-api');
 var sync = require('csv-parse/sync');
 var sync$1 = require('csv-stringify/sync');
 var fastXmlParser = require('fast-xml-parser');
+var neo4j = require('neo4j-driver');
 var fs = require('fs');
 var path7 = require('path');
 var dateFns = require('date-fns');
@@ -33,8 +34,9 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var axios12__default = /*#__PURE__*/_interopDefault(axios12);
+var axios16__default = /*#__PURE__*/_interopDefault(axios16);
 var cheerio__namespace = /*#__PURE__*/_interopNamespace(cheerio);
+var neo4j__default = /*#__PURE__*/_interopDefault(neo4j);
 var path7__namespace = /*#__PURE__*/_interopNamespace(path7);
 
 // src/web/http/tools/http-client.ts
@@ -71,7 +73,7 @@ function createHttpClientTool(defaultTimeout = 3e4, defaultHeaders = {}) {
       validateStatus: () => true
       // Don't throw on any status code
     };
-    const response = await axios12__default.default(config);
+    const response = await axios16__default.default(config);
     return {
       status: response.status,
       statusText: response.statusText,
@@ -84,7 +86,7 @@ function createHttpClientTool(defaultTimeout = 3e4, defaultHeaders = {}) {
 }
 function createHttpGetTool(defaultTimeout = 3e4, defaultHeaders = {}) {
   return core.toolBuilder().name("http-get").description("Make a simple HTTP GET request to a URL and return the response data.").category(core.ToolCategory.WEB).tags(["http", "get", "fetch", "web"]).schema(httpGetSchema).implement(async (input) => {
-    const response = await axios12__default.default.get(input.url, {
+    const response = await axios16__default.default.get(input.url, {
       headers: { ...defaultHeaders, ...input.headers },
       params: input.params,
       timeout: defaultTimeout
@@ -94,7 +96,7 @@ function createHttpGetTool(defaultTimeout = 3e4, defaultHeaders = {}) {
 }
 function createHttpPostTool(defaultTimeout = 3e4, defaultHeaders = {}) {
   return core.toolBuilder().name("http-post").description("Make a simple HTTP POST request with JSON body and return the response data.").category(core.ToolCategory.WEB).tags(["http", "post", "api", "web"]).schema(httpPostSchema).implement(async (input) => {
-    const response = await axios12__default.default.post(input.url, input.body, {
+    const response = await axios16__default.default.post(input.url, input.body, {
       headers: {
         "Content-Type": "application/json",
         ...defaultHeaders,
@@ -131,7 +133,7 @@ var webScraperSchema = zod.z.object({
 });
 function createWebScraperTool(defaultTimeout = 3e4, userAgent = "Mozilla/5.0 (compatible; AgentForge/1.0; +https://agentforge.dev)") {
   return core.toolBuilder().name("web-scraper").description("Scrape and extract data from web pages. Can extract text, HTML, links, images, and use CSS selectors to target specific elements.").category(core.ToolCategory.WEB).tags(["scraper", "web", "html", "extract", "parse"]).schema(webScraperSchema).implement(async (input) => {
-    const response = await axios12__default.default.get(input.url, {
+    const response = await axios16__default.default.get(input.url, {
       timeout: input.timeout || defaultTimeout,
       headers: {
         "User-Agent": userAgent
@@ -521,7 +523,7 @@ var DuckDuckGoProvider = class {
   async search(query, maxResults, timeout = DEFAULT_TIMEOUT) {
     return retryWithBackoff(async () => {
       try {
-        const response = await axios12__default.default.get(
+        const response = await axios16__default.default.get(
           "https://api.duckduckgo.com/",
           {
             params: {
@@ -625,7 +627,7 @@ var SerperProvider = class {
     }
     return retryWithBackoff(async () => {
       try {
-        const response = await axios12__default.default.post(
+        const response = await axios16__default.default.post(
           "https://google.serper.dev/search",
           {
             q: query,
@@ -805,7 +807,7 @@ function getDefaultSlackClient() {
     }
   };
 }
-function createSendSlackMessageTool(getSlackClient, logger4) {
+function createSendSlackMessageTool(getSlackClient, logger8) {
   return core.toolBuilder().name("send-slack-message").description("Send a message to a Slack channel for team communication and notifications").category(core.ToolCategory.WEB).tags(["slack", "messaging", "communication"]).usageNotes(
     "Use this for general team communication. For notifications with @mentions, consider using notify-slack instead. Use get-slack-channels first if you need to find the right channel."
   ).suggests(["get-slack-channels"]).schema(
@@ -814,7 +816,7 @@ function createSendSlackMessageTool(getSlackClient, logger4) {
       message: zod.z.string().describe("Message content to send")
     })
   ).implementSafe(async ({ channel, message }) => {
-    logger4.info("send-slack-message called", { channel, messageLength: message.length });
+    logger8.info("send-slack-message called", { channel, messageLength: message.length });
     try {
       const { client: slack, config } = getSlackClient();
       const result = await slack.chat.postMessage({
@@ -823,7 +825,7 @@ function createSendSlackMessageTool(getSlackClient, logger4) {
         username: config.botName,
         icon_emoji: config.botIcon
       });
-      logger4.info("send-slack-message result", {
+      logger8.info("send-slack-message result", {
         channel: result.channel,
         timestamp: result.ts,
         messageLength: message.length,
@@ -836,7 +838,7 @@ function createSendSlackMessageTool(getSlackClient, logger4) {
         message_id: result.ts
       };
     } catch (error) {
-      logger4.error("send-slack-message failed", {
+      logger8.error("send-slack-message failed", {
         channel,
         error: error.message,
         data: error.data
@@ -845,7 +847,7 @@ function createSendSlackMessageTool(getSlackClient, logger4) {
     }
   }).build();
 }
-function createNotifySlackTool(getSlackClient, logger4) {
+function createNotifySlackTool(getSlackClient, logger8) {
   return core.toolBuilder().name("notify-slack").description("Send a notification to a Slack channel with optional @mentions for urgent alerts").category(core.ToolCategory.WEB).tags(["slack", "notification", "alert"]).usageNotes(
     "Use this for urgent notifications that require @mentions. For general messages without mentions, use send-slack-message instead."
   ).suggests(["get-slack-channels"]).schema(
@@ -855,7 +857,7 @@ function createNotifySlackTool(getSlackClient, logger4) {
       mentions: zod.z.array(zod.z.string()).optional().describe("List of usernames to mention (without @)")
     })
   ).implementSafe(async ({ channel, message, mentions = [] }) => {
-    logger4.info("notify-slack called", {
+    logger8.info("notify-slack called", {
       channel,
       messageLength: message.length,
       mentionCount: mentions.length
@@ -869,7 +871,7 @@ function createNotifySlackTool(getSlackClient, logger4) {
       username: config.botName,
       icon_emoji: config.botIcon
     });
-    logger4.info("notify-slack result", {
+    logger8.info("notify-slack result", {
       channel: result.channel,
       timestamp: result.ts,
       mentions: mentions.length
@@ -883,7 +885,7 @@ function createNotifySlackTool(getSlackClient, logger4) {
     };
   }).build();
 }
-function createGetSlackChannelsTool(getSlackClient, logger4) {
+function createGetSlackChannelsTool(getSlackClient, logger8) {
   return core.toolBuilder().name("get-slack-channels").description("Get a list of available Slack channels to find the right channel for messaging").category(core.ToolCategory.WEB).tags(["slack", "channels", "list"]).usageNotes(
     "Use this first to discover available channels before sending messages. Helps ensure you are sending to the correct channel."
   ).follows(["send-slack-message", "notify-slack"]).schema(
@@ -891,7 +893,7 @@ function createGetSlackChannelsTool(getSlackClient, logger4) {
       include_private: zod.z.boolean().optional().describe("Include private channels (default: false)")
     })
   ).implementSafe(async ({ include_private = false }) => {
-    logger4.info("get-slack-channels called", { include_private });
+    logger8.info("get-slack-channels called", { include_private });
     const { client: slack } = getSlackClient();
     const publicChannels = await slack.conversations.list({
       types: "public_channel",
@@ -905,7 +907,7 @@ function createGetSlackChannelsTool(getSlackClient, logger4) {
       });
       allChannels = [...allChannels, ...privateChannels.channels || []];
     }
-    logger4.info("get-slack-channels result", {
+    logger8.info("get-slack-channels result", {
       channelCount: allChannels.length,
       includePrivate: include_private
     });
@@ -920,7 +922,7 @@ function createGetSlackChannelsTool(getSlackClient, logger4) {
     };
   }).build();
 }
-function createGetSlackMessagesTool(getSlackClient, logger4) {
+function createGetSlackMessagesTool(getSlackClient, logger8) {
   return core.toolBuilder().name("get-slack-messages").description("Retrieve message history from a Slack channel to read recent conversations").category(core.ToolCategory.WEB).tags(["slack", "messages", "history", "read"]).usageNotes(
     "Use this to read recent messages from a channel. Use get-slack-channels first if you need to find the channel ID. Returns messages in reverse chronological order (newest first)."
   ).suggests(["get-slack-channels"]).schema(
@@ -929,7 +931,7 @@ function createGetSlackMessagesTool(getSlackClient, logger4) {
       limit: zod.z.number().int().min(1).max(100).optional().describe("Number of messages to retrieve (default: 20, max: 100)")
     })
   ).implementSafe(async ({ channel, limit = 20 }) => {
-    logger4.info("get-slack-messages called", { channel, limit });
+    logger8.info("get-slack-messages called", { channel, limit });
     try {
       const { client: slack } = getSlackClient();
       let channelId = channel;
@@ -940,7 +942,7 @@ function createGetSlackMessagesTool(getSlackClient, logger4) {
         });
         const found = channels.channels?.find((c) => c.name === channel);
         if (!found) {
-          logger4.error("get-slack-messages: channel not found", { channel });
+          logger8.error("get-slack-messages: channel not found", { channel });
           throw new Error(
             `Channel '${channel}' not found. Use get-slack-channels to see available channels.`
           );
@@ -952,7 +954,7 @@ function createGetSlackMessagesTool(getSlackClient, logger4) {
         limit: Math.min(limit, 100)
         // Cap at 100 for performance
       });
-      logger4.info("get-slack-messages result", {
+      logger8.info("get-slack-messages result", {
         channel: channelId,
         messageCount: result.messages?.length || 0,
         limit
@@ -970,7 +972,7 @@ function createGetSlackMessagesTool(getSlackClient, logger4) {
         })) || []
       };
     } catch (error) {
-      logger4.error("get-slack-messages failed", {
+      logger8.error("get-slack-messages failed", {
         channel,
         error: error.message,
         data: error.data
@@ -1033,8 +1035,8 @@ function createGetConfiguredAuth(apiKey, email, siteUrl) {
 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}`;
+    const auth2 = Buffer.from(`${ATLASSIAN_EMAIL}:${ATLASSIAN_API_KEY}`).toString("base64");
+    return `Basic ${auth2}`;
   };
 }
 function getConfig() {
@@ -1048,18 +1050,18 @@ function getConfig() {
 }
 function getAuthHeader() {
   const { ATLASSIAN_API_KEY, ATLASSIAN_EMAIL } = getConfig();
-  const auth = Buffer.from(`${ATLASSIAN_EMAIL}:${ATLASSIAN_API_KEY}`).toString("base64");
-  return `Basic ${auth}`;
+  const auth2 = Buffer.from(`${ATLASSIAN_EMAIL}:${ATLASSIAN_API_KEY}`).toString("base64");
+  return `Basic ${auth2}`;
 }
-function createSearchConfluenceTool(getAuth, getAuthHeader2, logger4) {
+function createSearchConfluenceTool(getAuth, getAuthHeader2, logger8) {
   return core.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(core.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(zod.z.object({
     query: zod.z.string().describe("Search query or CQL expression (e.g., 'payment processing' or 'space=BL3 AND title~payment')"),
     limit: zod.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 });
+    logger8.info("search-confluence called", { query, limit });
     try {
       const { ATLASSIAN_SITE_URL } = getAuth();
-      const response = await axios12__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/content/search`, {
+      const response = await axios16__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/content/search`, {
         headers: {
           Authorization: getAuthHeader2(),
           Accept: "application/json"
@@ -1081,13 +1083,13 @@ function createSearchConfluenceTool(getAuth, getAuthHeader2, logger4) {
         lastModified: page.version?.when || ""
       }));
       if (results.length === 0) {
-        logger4.warn("search-confluence returned NO RESULTS - this is a valid outcome, agent should not retry", {
+        logger8.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", {
+        logger8.info("search-confluence result", {
           query,
           resultCount: results.length,
           totalSize: response.data.totalSize,
@@ -1102,7 +1104,7 @@ function createSearchConfluenceTool(getAuth, getAuthHeader2, logger4) {
         results
       });
     } catch (error) {
-      logger4.error("search-confluence error", {
+      logger8.error("search-confluence error", {
         query,
         error: error.response?.data?.message || error.message,
         status: error.response?.status
@@ -1114,14 +1116,14 @@ function createSearchConfluenceTool(getAuth, getAuthHeader2, logger4) {
     }
   }).build();
 }
-function createGetConfluencePageTool(getAuth, getAuthHeader2, logger4) {
+function createGetConfluencePageTool(getAuth, getAuthHeader2, logger8) {
   return core.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(core.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(zod.z.object({
     page_id: zod.z.string().describe("The Confluence page ID (from search results)")
   })).implement(async ({ page_id }) => {
-    logger4.info("get-confluence-page called", { page_id });
+    logger8.info("get-confluence-page called", { page_id });
     try {
       const { ATLASSIAN_SITE_URL } = getAuth();
-      const response = await axios12__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`, {
+      const response = await axios16__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`, {
         headers: {
           Authorization: getAuthHeader2(),
           Accept: "application/json"
@@ -1131,7 +1133,7 @@ function createGetConfluencePageTool(getAuth, getAuthHeader2, logger4) {
         }
       });
       const page = response.data;
-      logger4.info("get-confluence-page result", {
+      logger8.info("get-confluence-page result", {
         page_id,
         title: page.title,
         space: page.space?.name,
@@ -1153,7 +1155,7 @@ function createGetConfluencePageTool(getAuth, getAuthHeader2, logger4) {
         }
       });
     } catch (error) {
-      logger4.error("get-confluence-page error", {
+      logger8.error("get-confluence-page error", {
         page_id,
         error: error.response?.data?.message || error.message,
         status: error.response?.status
@@ -1165,14 +1167,14 @@ function createGetConfluencePageTool(getAuth, getAuthHeader2, logger4) {
     }
   }).build();
 }
-function createListConfluenceSpacesTool(getAuth, getAuthHeader2, logger4) {
+function createListConfluenceSpacesTool(getAuth, getAuthHeader2, logger8) {
   return core.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(core.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(zod.z.object({
     limit: zod.z.number().optional().describe("Maximum number of spaces to return (default: 25)")
   })).implement(async ({ limit = 25 }) => {
-    logger4.info("list-confluence-spaces called", { limit });
+    logger8.info("list-confluence-spaces called", { limit });
     try {
       const { ATLASSIAN_SITE_URL } = getAuth();
-      const response = await axios12__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/space`, {
+      const response = await axios16__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/space`, {
         headers: {
           Authorization: getAuthHeader2(),
           Accept: "application/json"
@@ -1188,7 +1190,7 @@ function createListConfluenceSpacesTool(getAuth, getAuthHeader2, logger4) {
         description: space.description?.plain?.value || "",
         url: `${ATLASSIAN_SITE_URL}/wiki${space._links.webui}`
       }));
-      logger4.info("list-confluence-spaces result", {
+      logger8.info("list-confluence-spaces result", {
         spaceCount: spaces.length,
         spaceKeys: spaces.map((s) => s.key).slice(0, 5)
         // Log first 5 space keys
@@ -1199,7 +1201,7 @@ function createListConfluenceSpacesTool(getAuth, getAuthHeader2, logger4) {
         spaces
       });
     } catch (error) {
-      logger4.error("list-confluence-spaces error", {
+      logger8.error("list-confluence-spaces error", {
         error: error.response?.data?.message || error.message,
         status: error.response?.status
       });
@@ -1210,15 +1212,15 @@ function createListConfluenceSpacesTool(getAuth, getAuthHeader2, logger4) {
     }
   }).build();
 }
-function createGetSpacePagesTool(getAuth, getAuthHeader2, logger4) {
+function createGetSpacePagesTool(getAuth, getAuthHeader2, logger8) {
   return core.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(core.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(zod.z.object({
     space_key: zod.z.string().describe("The space key (e.g., 'AI', 'BL3', 'FIN')"),
     limit: zod.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 });
+    logger8.info("get-space-pages called", { space_key, limit });
     try {
       const { ATLASSIAN_SITE_URL } = getAuth();
-      const response = await axios12__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/content`, {
+      const response = await axios16__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/content`, {
         headers: {
           Authorization: getAuthHeader2(),
           Accept: "application/json"
@@ -1237,12 +1239,12 @@ function createGetSpacePagesTool(getAuth, getAuthHeader2, logger4) {
         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", {
+        logger8.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", {
+        logger8.info("get-space-pages result", {
           space_key,
           pageCount: pages.length,
           titles: pages.map((p) => p.title).slice(0, 3)
@@ -1256,7 +1258,7 @@ function createGetSpacePagesTool(getAuth, getAuthHeader2, logger4) {
         pages
       });
     } catch (error) {
-      logger4.error("get-space-pages error", {
+      logger8.error("get-space-pages error", {
         space_key,
         error: error.response?.data?.message || error.message,
         status: error.response?.status
@@ -1268,14 +1270,14 @@ function createGetSpacePagesTool(getAuth, getAuthHeader2, logger4) {
     }
   }).build();
 }
-function createCreateConfluencePageTool(getAuth, getAuthHeader2, logger4) {
+function createCreateConfluencePageTool(getAuth, getAuthHeader2, logger8) {
   return core.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(core.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(zod.z.object({
     space_key: zod.z.string().describe("The space key where the page will be created (e.g., 'AI', 'BL3')"),
     title: zod.z.string().describe("The title of the new page"),
     content: zod.z.string().describe("The page content in HTML format (Confluence storage format)"),
     parent_page_id: zod.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 });
+    logger8.info("create-confluence-page called", { space_key, title, hasParent: !!parent_page_id });
     try {
       const { ATLASSIAN_SITE_URL } = getAuth();
       const pageData = {
@@ -1292,7 +1294,7 @@ function createCreateConfluencePageTool(getAuth, getAuthHeader2, logger4) {
       if (parent_page_id) {
         pageData.ancestors = [{ id: parent_page_id }];
       }
-      const response = await axios12__default.default.post(
+      const response = await axios16__default.default.post(
         `${ATLASSIAN_SITE_URL}/wiki/rest/api/content`,
         pageData,
         {
@@ -1302,7 +1304,7 @@ function createCreateConfluencePageTool(getAuth, getAuthHeader2, logger4) {
           }
         }
       );
-      logger4.info("create-confluence-page result", {
+      logger8.info("create-confluence-page result", {
         page_id: response.data.id,
         title: response.data.title,
         space: space_key
@@ -1318,7 +1320,7 @@ function createCreateConfluencePageTool(getAuth, getAuthHeader2, logger4) {
         }
       });
     } catch (error) {
-      logger4.error("create-confluence-page error", {
+      logger8.error("create-confluence-page error", {
         space_key,
         title,
         error: error.response?.data?.message || error.message,
@@ -1331,16 +1333,16 @@ function createCreateConfluencePageTool(getAuth, getAuthHeader2, logger4) {
     }
   }).build();
 }
-function createUpdateConfluencePageTool(getAuth, getAuthHeader2, logger4) {
+function createUpdateConfluencePageTool(getAuth, getAuthHeader2, logger8) {
   return core.toolBuilder().name("update-confluence-page").description("Update an existing Confluence page's content. Requires page ID, new title, and new content.").category(core.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(zod.z.object({
     page_id: zod.z.string().describe("The ID of the page to update"),
     title: zod.z.string().describe("The new title for the page"),
     content: zod.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 });
+    logger8.info("update-confluence-page called", { page_id, title });
     try {
       const { ATLASSIAN_SITE_URL } = getAuth();
-      const getResponse = await axios12__default.default.get(
+      const getResponse = await axios16__default.default.get(
         `${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`,
         {
           headers: {
@@ -1350,7 +1352,7 @@ function createUpdateConfluencePageTool(getAuth, getAuthHeader2, logger4) {
         }
       );
       const currentVersion = getResponse.data.version.number;
-      const updateResponse = await axios12__default.default.put(
+      const updateResponse = await axios16__default.default.put(
         `${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`,
         {
           type: "page",
@@ -1370,7 +1372,7 @@ function createUpdateConfluencePageTool(getAuth, getAuthHeader2, logger4) {
           }
         }
       );
-      logger4.info("update-confluence-page result", {
+      logger8.info("update-confluence-page result", {
         page_id,
         title: updateResponse.data.title,
         previousVersion: currentVersion,
@@ -1387,7 +1389,7 @@ function createUpdateConfluencePageTool(getAuth, getAuthHeader2, logger4) {
         }
       });
     } catch (error) {
-      logger4.error("update-confluence-page error", {
+      logger8.error("update-confluence-page error", {
         page_id,
         title,
         error: error.response?.data?.message || error.message,
@@ -1400,15 +1402,15 @@ function createUpdateConfluencePageTool(getAuth, getAuthHeader2, logger4) {
     }
   }).build();
 }
-function createArchiveConfluencePageTool(getAuth, getAuthHeader2, logger4) {
+function createArchiveConfluencePageTool(getAuth, getAuthHeader2, logger8) {
   return core.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(core.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(zod.z.object({
     page_id: zod.z.string().describe("The ID of the page to archive"),
     reason: zod.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 });
+    logger8.info("archive-confluence-page called", { page_id, reason });
     try {
       const { ATLASSIAN_SITE_URL } = getAuth();
-      const getResponse = await axios12__default.default.get(
+      const getResponse = await axios16__default.default.get(
         `${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`,
         {
           headers: {
@@ -1419,7 +1421,7 @@ function createArchiveConfluencePageTool(getAuth, getAuthHeader2, logger4) {
       );
       const currentVersion = getResponse.data.version.number;
       const pageData = getResponse.data;
-      await axios12__default.default.put(
+      await axios16__default.default.put(
         `${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`,
         {
           version: { number: currentVersion + 1 },
@@ -1436,7 +1438,7 @@ function createArchiveConfluencePageTool(getAuth, getAuthHeader2, logger4) {
           }
         }
       );
-      logger4.info("archive-confluence-page result", {
+      logger8.info("archive-confluence-page result", {
         page_id,
         title: pageData.title,
         previousVersion: currentVersion,
@@ -1454,7 +1456,7 @@ function createArchiveConfluencePageTool(getAuth, getAuthHeader2, logger4) {
         }
       });
     } catch (error) {
-      logger4.error("archive-confluence-page error", {
+      logger8.error("archive-confluence-page error", {
         page_id,
         error: error.response?.data?.message || error.message,
         status: error.response?.status
@@ -2051,6 +2053,1706 @@ function createTransformerTools(config = {}) {
     createObjectOmitTool()
   ];
 }
+var neo4jQuerySchema = zod.z.object({
+  cypher: zod.z.string().describe("Cypher query to execute"),
+  parameters: zod.z.record(zod.z.any()).optional().describe("Query parameters for parameterized queries"),
+  database: zod.z.string().optional().describe("Database name (defaults to configured database)")
+});
+var neo4jGetSchemaSchema = zod.z.object({
+  database: zod.z.string().optional().describe("Database name (defaults to configured database)")
+});
+var neo4jFindNodesSchema = zod.z.object({
+  label: zod.z.string().describe("Node label to search for"),
+  properties: zod.z.record(zod.z.any()).optional().describe("Properties to match (key-value pairs)"),
+  limit: zod.z.number().default(100).describe("Maximum number of nodes to return"),
+  database: zod.z.string().optional().describe("Database name (defaults to configured database)")
+});
+var neo4jTraverseSchema = zod.z.object({
+  startNodeId: zod.z.union([
+    zod.z.string().describe("Node ID as string"),
+    zod.z.number().describe("Node ID as number")
+  ]).describe("ID of the starting node"),
+  relationshipType: zod.z.string().optional().describe("Type of relationship to follow (optional, follows all if not specified)"),
+  direction: zod.z.enum(["outgoing", "incoming", "both"]).default("outgoing").describe("Direction to traverse"),
+  maxDepth: zod.z.number().default(1).describe("Maximum depth to traverse"),
+  limit: zod.z.number().default(100).describe("Maximum number of nodes to return"),
+  database: zod.z.string().optional().describe("Database name (defaults to configured database)")
+});
+var neo4jVectorSearchSchema = zod.z.object({
+  indexName: zod.z.string().describe("Name of the vector index to search"),
+  queryVector: zod.z.array(zod.z.number().describe("Vector dimension value")).describe("Query vector for similarity search"),
+  limit: zod.z.number().default(10).describe("Maximum number of results to return"),
+  database: zod.z.string().optional().describe("Database name (defaults to configured database)")
+});
+var neo4jVectorSearchWithEmbeddingSchema = zod.z.object({
+  indexName: zod.z.string().describe("Name of the vector index to search"),
+  queryText: zod.z.string().describe("Text to generate embedding from for similarity search"),
+  limit: zod.z.number().default(10).describe("Maximum number of results to return"),
+  model: zod.z.string().optional().describe("Embedding model to use (defaults to configured model)"),
+  database: zod.z.string().optional().describe("Database name (defaults to configured database)")
+});
+var neo4jCreateNodeWithEmbeddingSchema = zod.z.object({
+  label: zod.z.string().describe("Node label"),
+  properties: zod.z.record(zod.z.string(), zod.z.any().describe("Property value")).describe("Node properties (key-value pairs)"),
+  textProperty: zod.z.string().describe("Name of the property containing text to embed"),
+  embeddingProperty: zod.z.string().default("embedding").describe("Name of the property to store the embedding vector"),
+  model: zod.z.string().optional().describe("Embedding model to use (defaults to configured model)"),
+  database: zod.z.string().optional().describe("Database name (defaults to configured database)")
+});
+var logger3 = core.createLogger("agentforge:tools:neo4j:pool");
+var Neo4jConnectionPool = class {
+  driver = null;
+  config = null;
+  /**
+   * Initialize the connection pool
+   */
+  async initialize(config) {
+    const startTime = Date.now();
+    logger3.debug("Initializing Neo4j connection pool", {
+      uri: config.uri,
+      username: config.username,
+      database: config.database || "neo4j",
+      maxConnectionPoolSize: config.maxConnectionPoolSize || 50,
+      connectionTimeout: config.connectionTimeout || 3e4
+    });
+    if (this.driver) {
+      logger3.debug("Closing existing connection before reinitializing");
+      await this.close();
+    }
+    this.config = config;
+    this.driver = neo4j__default.default.driver(
+      config.uri,
+      neo4j.auth.basic(config.username, config.password),
+      {
+        maxConnectionPoolSize: config.maxConnectionPoolSize || 50,
+        connectionTimeout: config.connectionTimeout || 3e4
+      }
+    );
+    await this.verifyConnectivity();
+    logger3.info("Neo4j connection pool initialized", {
+      uri: config.uri,
+      database: config.database || "neo4j",
+      duration: Date.now() - startTime
+    });
+  }
+  /**
+   * Verify connectivity to Neo4j
+   */
+  async verifyConnectivity() {
+    if (!this.driver) {
+      const error = "Neo4j driver not initialized";
+      logger3.error(error);
+      throw new Error(error);
+    }
+    logger3.debug("Verifying Neo4j connectivity");
+    try {
+      await this.driver.verifyConnectivity();
+      logger3.debug("Neo4j connectivity verified");
+    } catch (error) {
+      const errorMessage = `Failed to connect to Neo4j: ${error instanceof Error ? error.message : "Unknown error"}`;
+      logger3.error("Neo4j connectivity verification failed", {
+        error: error instanceof Error ? error.message : "Unknown error",
+        uri: this.config?.uri
+      });
+      throw new Error(errorMessage);
+    }
+  }
+  /**
+   * Get a session for executing queries
+   */
+  getSession(database) {
+    if (!this.driver) {
+      throw new Error("Neo4j driver not initialized. Call initialize() first.");
+    }
+    return this.driver.session({
+      database: database || this.config?.database || "neo4j"
+    });
+  }
+  /**
+   * Execute a query with automatic session management
+   */
+  async executeQuery(cypher, parameters, database) {
+    const session = this.getSession(database);
+    try {
+      const result = await session.run(cypher, parameters);
+      return result.records.map((record) => record.toObject());
+    } finally {
+      await session.close();
+    }
+  }
+  /**
+   * Execute a read query
+   */
+  async executeReadQuery(cypher, parameters, database) {
+    const session = this.getSession(database);
+    try {
+      const result = await session.executeRead((tx) => tx.run(cypher, parameters));
+      return result.records.map((record) => record.toObject());
+    } finally {
+      await session.close();
+    }
+  }
+  /**
+   * Execute a write query
+   */
+  async executeWriteQuery(cypher, parameters, database) {
+    const session = this.getSession(database);
+    try {
+      const result = await session.executeWrite((tx) => tx.run(cypher, parameters));
+      return result.records.map((record) => record.toObject());
+    } finally {
+      await session.close();
+    }
+  }
+  /**
+   * Check if driver is initialized
+   */
+  isInitialized() {
+    return this.driver !== null;
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Close the connection pool
+   */
+  async close() {
+    if (this.driver) {
+      logger3.debug("Closing Neo4j connection pool");
+      await this.driver.close();
+      this.driver = null;
+      this.config = null;
+      logger3.info("Neo4j connection pool closed");
+    }
+  }
+};
+var neo4jPool = new Neo4jConnectionPool();
+async function initializeFromEnv() {
+  if (!process.env.NEO4J_URI) {
+    logger3.warn("NEO4J_URI environment variable not set, using default", {
+      default: "bolt://localhost:7687"
+    });
+  }
+  if (!process.env.NEO4J_USER) {
+    logger3.warn("NEO4J_USER environment variable not set, using default", {
+      default: "neo4j"
+    });
+  }
+  if (!process.env.NEO4J_PASSWORD) {
+    logger3.warn("NEO4J_PASSWORD environment variable not set, using default", {
+      default: "password"
+    });
+  }
+  if (!process.env.NEO4J_DATABASE) {
+    logger3.debug("NEO4J_DATABASE environment variable not set, using default", {
+      default: "neo4j"
+    });
+  }
+  const config = {
+    uri: process.env.NEO4J_URI || "bolt://localhost:7687",
+    username: process.env.NEO4J_USER || "neo4j",
+    password: process.env.NEO4J_PASSWORD || "password",
+    database: process.env.NEO4J_DATABASE
+  };
+  await neo4jPool.initialize(config);
+}
+
+// src/data/neo4j/embeddings/utils.ts
+var DEFAULT_RETRY_CONFIG2 = {
+  maxRetries: 3,
+  initialDelay: 1e3,
+  // 1 second
+  maxDelay: 1e4,
+  // 10 seconds
+  backoffMultiplier: 2
+};
+function isRetryableError2(error) {
+  if (error.code === "ECONNRESET" || error.code === "ETIMEDOUT" || error.code === "ENOTFOUND") {
+    return true;
+  }
+  if (error.code === "ECONNABORTED" || error.message?.includes("timeout")) {
+    return true;
+  }
+  if (error.response?.status >= 500 && error.response?.status < 600) {
+    return true;
+  }
+  if (error.response?.status === 429) {
+    return true;
+  }
+  return false;
+}
+function sleep2(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function retryWithBackoff2(fn, config = DEFAULT_RETRY_CONFIG2) {
+  let lastError;
+  let delay = config.initialDelay;
+  for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (!isRetryableError2(error)) {
+        throw error;
+      }
+      if (attempt === config.maxRetries) {
+        break;
+      }
+      await sleep2(delay);
+      delay = Math.min(delay * config.backoffMultiplier, config.maxDelay);
+    }
+  }
+  throw lastError;
+}
+function getOpenAIApiKey() {
+  return process.env.OPENAI_API_KEY;
+}
+function getCohereApiKey() {
+  return process.env.COHERE_API_KEY;
+}
+function getHuggingFaceApiKey() {
+  return process.env.HUGGINGFACE_API_KEY;
+}
+function getVoyageApiKey() {
+  return process.env.VOYAGE_API_KEY;
+}
+function getOllamaBaseUrl() {
+  return process.env.OLLAMA_BASE_URL || "http://localhost:11434";
+}
+function getEmbeddingProvider() {
+  return process.env.EMBEDDING_PROVIDER || "openai";
+}
+function getEmbeddingModel() {
+  return process.env.EMBEDDING_MODEL;
+}
+function validateText(text) {
+  if (!text || text.trim().length === 0) {
+    throw new Error("Text cannot be empty");
+  }
+  if (text.length > 5e4) {
+    throw new Error("Text is too long for embedding generation (max ~50,000 characters)");
+  }
+}
+function validateBatch(texts) {
+  if (!texts || texts.length === 0) {
+    throw new Error("Batch cannot be empty");
+  }
+  if (texts.length > 2048) {
+    throw new Error("Batch size too large (max 2048 texts)");
+  }
+  texts.forEach((text, index) => {
+    try {
+      validateText(text);
+    } catch (error) {
+      throw new Error(`Invalid text at index ${index}: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  });
+}
+var OpenAIEmbeddingProvider = class {
+  name = "openai";
+  defaultModel = "text-embedding-3-small";
+  apiKey;
+  baseURL = "https://api.openai.com/v1";
+  constructor(apiKey) {
+    this.apiKey = apiKey || getOpenAIApiKey();
+  }
+  /**
+   * Check if OpenAI is available (API key is set)
+   */
+  isAvailable() {
+    return !!this.apiKey;
+  }
+  /**
+   * Generate embedding for a single text
+   */
+  async generateEmbedding(text, model) {
+    if (!this.apiKey) {
+      throw new Error(
+        "OpenAI API key not found. Set OPENAI_API_KEY environment variable. Get your key at https://platform.openai.com/api-keys"
+      );
+    }
+    validateText(text);
+    const modelToUse = model || this.defaultModel;
+    return retryWithBackoff2(async () => {
+      try {
+        const response = await axios16__default.default.post(
+          `${this.baseURL}/embeddings`,
+          {
+            input: text,
+            model: modelToUse
+          },
+          {
+            headers: {
+              "Authorization": `Bearer ${this.apiKey}`,
+              "Content-Type": "application/json"
+            },
+            timeout: 3e4
+            // 30 seconds
+          }
+        );
+        const data = response.data;
+        if (!data.data || data.data.length === 0) {
+          throw new Error("No embedding returned from OpenAI");
+        }
+        return {
+          embedding: data.data[0].embedding,
+          model: data.model,
+          dimensions: data.data[0].embedding.length,
+          usage: {
+            promptTokens: data.usage.prompt_tokens,
+            totalTokens: data.usage.total_tokens
+          }
+        };
+      } catch (error) {
+        let wrappedError;
+        if (error.response?.status === 401) {
+          wrappedError = new Error(
+            "Invalid OpenAI API key. Get your key at https://platform.openai.com/api-keys"
+          );
+        } else if (error.response?.status === 429) {
+          wrappedError = new Error(
+            "OpenAI API rate limit exceeded. Please try again later or upgrade your plan."
+          );
+        } else if (error.response?.status === 400) {
+          wrappedError = new Error(
+            `OpenAI API error: ${error.response.data?.error?.message || "Bad request"}`
+          );
+        } else {
+          wrappedError = new Error(`OpenAI embedding generation failed: ${error.message}`);
+        }
+        if (error.code) wrappedError.code = error.code;
+        if (error.response) wrappedError.response = error.response;
+        throw wrappedError;
+      }
+    });
+  }
+  /**
+   * Generate embeddings for multiple texts (batch)
+   */
+  async generateBatchEmbeddings(texts, model) {
+    if (!this.apiKey) {
+      throw new Error(
+        "OpenAI API key not found. Set OPENAI_API_KEY environment variable. Get your key at https://platform.openai.com/api-keys"
+      );
+    }
+    validateBatch(texts);
+    const modelToUse = model || this.defaultModel;
+    return retryWithBackoff2(async () => {
+      try {
+        const response = await axios16__default.default.post(
+          `${this.baseURL}/embeddings`,
+          {
+            input: texts,
+            model: modelToUse
+          },
+          {
+            headers: {
+              "Authorization": `Bearer ${this.apiKey}`,
+              "Content-Type": "application/json"
+            },
+            timeout: 6e4
+            // 60 seconds for batch
+          }
+        );
+        const data = response.data;
+        if (!data.data || data.data.length === 0) {
+          throw new Error("No embeddings returned from OpenAI");
+        }
+        const sortedData = data.data.sort((a, b) => a.index - b.index);
+        return {
+          embeddings: sortedData.map((item) => item.embedding),
+          model: data.model,
+          dimensions: sortedData[0].embedding.length,
+          usage: {
+            promptTokens: data.usage.prompt_tokens,
+            totalTokens: data.usage.total_tokens
+          }
+        };
+      } catch (error) {
+        let wrappedError;
+        if (error.response?.status === 401) {
+          wrappedError = new Error(
+            "Invalid OpenAI API key. Get your key at https://platform.openai.com/api-keys"
+          );
+        } else if (error.response?.status === 429) {
+          wrappedError = new Error(
+            "OpenAI API rate limit exceeded. Please try again later or upgrade your plan."
+          );
+        } else if (error.response?.status === 400) {
+          wrappedError = new Error(
+            `OpenAI API error: ${error.response.data?.error?.message || "Bad request"}`
+          );
+        } else {
+          wrappedError = new Error(`OpenAI batch embedding generation failed: ${error.message}`);
+        }
+        if (error.code) wrappedError.code = error.code;
+        if (error.response) wrappedError.response = error.response;
+        throw wrappedError;
+      }
+    });
+  }
+};
+var CohereEmbeddingProvider = class {
+  name = "cohere";
+  defaultModel = "embed-english-v3.0";
+  apiKey;
+  baseUrl = "https://api.cohere.ai/v1";
+  constructor(apiKey, model) {
+    this.apiKey = apiKey;
+  }
+  /**
+   * Check if Cohere is available (API key is set)
+   */
+  isAvailable() {
+    return !!this.apiKey;
+  }
+  async generateEmbedding(text, model) {
+    const result = await this.generateBatchEmbeddings([text], model);
+    return {
+      embedding: result.embeddings[0],
+      model: result.model,
+      dimensions: result.dimensions,
+      usage: result.usage
+    };
+  }
+  async generateBatchEmbeddings(texts, model) {
+    const modelToUse = model || this.defaultModel;
+    return retryWithBackoff2(async () => {
+      try {
+        const response = await axios16__default.default.post(
+          `${this.baseUrl}/embed`,
+          {
+            texts,
+            model: modelToUse,
+            input_type: "search_document",
+            // For storing in vector DB
+            embedding_types: ["float"]
+          },
+          {
+            headers: {
+              "Authorization": `Bearer ${this.apiKey}`,
+              "Content-Type": "application/json"
+            }
+          }
+        );
+        const embeddings = response.data.embeddings.float;
+        const dimensions = embeddings[0]?.length || 0;
+        return {
+          embeddings,
+          model: modelToUse,
+          dimensions,
+          usage: response.data.meta?.billed_units ? {
+            promptTokens: response.data.meta.billed_units.input_tokens || 0,
+            totalTokens: response.data.meta.billed_units.input_tokens || 0
+          } : void 0
+        };
+      } catch (error) {
+        if (axios16__default.default.isAxiosError(error)) {
+          const status = error.response?.status;
+          const message = error.response?.data?.message || error.message;
+          let wrappedError;
+          if (status === 401) {
+            wrappedError = new Error(`Cohere API authentication failed. Please check your COHERE_API_KEY. ${message}`);
+          } else if (status === 429) {
+            wrappedError = new Error(`Cohere API rate limit exceeded. ${message}`);
+          } else if (status === 400) {
+            wrappedError = new Error(`Cohere API request invalid: ${message}`);
+          } else {
+            wrappedError = new Error(`Cohere API error (${status}): ${message}`);
+          }
+          if (error.code) wrappedError.code = error.code;
+          if (error.response) wrappedError.response = error.response;
+          throw wrappedError;
+        }
+        throw error;
+      }
+    });
+  }
+};
+var HuggingFaceEmbeddingProvider = class {
+  name = "huggingface";
+  defaultModel = "sentence-transformers/all-MiniLM-L6-v2";
+  apiKey;
+  baseUrl = "https://api-inference.huggingface.co/pipeline/feature-extraction";
+  constructor(apiKey, model) {
+    this.apiKey = apiKey;
+  }
+  /**
+   * Check if HuggingFace is available (API key is set)
+   */
+  isAvailable() {
+    return !!this.apiKey;
+  }
+  async generateEmbedding(text, model) {
+    const modelToUse = model || this.defaultModel;
+    return retryWithBackoff2(async () => {
+      try {
+        const response = await axios16__default.default.post(
+          `${this.baseUrl}/${modelToUse}`,
+          {
+            inputs: text,
+            options: {
+              wait_for_model: true
+            }
+          },
+          {
+            headers: {
+              "Authorization": `Bearer ${this.apiKey}`,
+              "Content-Type": "application/json"
+            }
+          }
+        );
+        const embedding = Array.isArray(response.data) ? response.data : response.data[0];
+        return {
+          embedding,
+          model: modelToUse,
+          dimensions: embedding.length
+        };
+      } catch (error) {
+        if (axios16__default.default.isAxiosError(error)) {
+          const status = error.response?.status;
+          const message = error.response?.data?.error || error.message;
+          let wrappedError;
+          if (status === 401) {
+            wrappedError = new Error(`HuggingFace API authentication failed. Please check your HUGGINGFACE_API_KEY. ${message}`);
+          } else if (status === 429) {
+            wrappedError = new Error(`HuggingFace API rate limit exceeded. ${message}`);
+          } else if (status === 400) {
+            wrappedError = new Error(`HuggingFace API request invalid: ${message}`);
+          } else if (status === 503) {
+            wrappedError = new Error(`HuggingFace model is loading. Please retry in a moment. ${message}`);
+          } else {
+            wrappedError = new Error(`HuggingFace API error (${status}): ${message}`);
+          }
+          if (error.code) wrappedError.code = error.code;
+          if (error.response) wrappedError.response = error.response;
+          throw wrappedError;
+        }
+        throw error;
+      }
+    });
+  }
+  async generateBatchEmbeddings(texts, model) {
+    const modelToUse = model || this.defaultModel;
+    return retryWithBackoff2(async () => {
+      try {
+        const response = await axios16__default.default.post(
+          `${this.baseUrl}/${modelToUse}`,
+          {
+            inputs: texts,
+            options: {
+              wait_for_model: true
+            }
+          },
+          {
+            headers: {
+              "Authorization": `Bearer ${this.apiKey}`,
+              "Content-Type": "application/json"
+            }
+          }
+        );
+        const embeddings = response.data;
+        const dimensions = embeddings[0]?.length || 0;
+        return {
+          embeddings,
+          model: modelToUse,
+          dimensions
+        };
+      } catch (error) {
+        if (axios16__default.default.isAxiosError(error)) {
+          const status = error.response?.status;
+          const message = error.response?.data?.error || error.message;
+          let wrappedError;
+          if (status === 401) {
+            wrappedError = new Error(`HuggingFace API authentication failed. Please check your HUGGINGFACE_API_KEY. ${message}`);
+          } else if (status === 429) {
+            wrappedError = new Error(`HuggingFace API rate limit exceeded. ${message}`);
+          } else if (status === 400) {
+            wrappedError = new Error(`HuggingFace API request invalid: ${message}`);
+          } else if (status === 503) {
+            wrappedError = new Error(`HuggingFace model is loading. Please retry in a moment. ${message}`);
+          } else {
+            wrappedError = new Error(`HuggingFace API error (${status}): ${message}`);
+          }
+          if (error.code) wrappedError.code = error.code;
+          if (error.response) wrappedError.response = error.response;
+          throw wrappedError;
+        }
+        throw error;
+      }
+    });
+  }
+};
+var VoyageEmbeddingProvider = class {
+  name = "voyage";
+  defaultModel = "voyage-2";
+  apiKey;
+  baseUrl = "https://api.voyageai.com/v1";
+  constructor(apiKey, model) {
+    this.apiKey = apiKey;
+  }
+  /**
+   * Check if Voyage AI is available (API key is set)
+   */
+  isAvailable() {
+    return !!this.apiKey;
+  }
+  async generateEmbedding(text, model) {
+    const result = await this.generateBatchEmbeddings([text], model);
+    return {
+      embedding: result.embeddings[0],
+      model: result.model,
+      dimensions: result.dimensions,
+      usage: result.usage
+    };
+  }
+  async generateBatchEmbeddings(texts, model) {
+    const modelToUse = model || this.defaultModel;
+    return retryWithBackoff2(async () => {
+      try {
+        const response = await axios16__default.default.post(
+          `${this.baseUrl}/embeddings`,
+          {
+            input: texts,
+            model: modelToUse,
+            input_type: "document"
+            // For storing in vector DB
+          },
+          {
+            headers: {
+              "Authorization": `Bearer ${this.apiKey}`,
+              "Content-Type": "application/json"
+            }
+          }
+        );
+        const embeddings = response.data.data.map((item) => item.embedding);
+        const dimensions = embeddings[0]?.length || 0;
+        return {
+          embeddings,
+          model: modelToUse,
+          dimensions,
+          usage: response.data.usage ? {
+            promptTokens: response.data.usage.total_tokens || 0,
+            totalTokens: response.data.usage.total_tokens || 0
+          } : void 0
+        };
+      } catch (error) {
+        if (axios16__default.default.isAxiosError(error)) {
+          const status = error.response?.status;
+          const message = error.response?.data?.message || error.message;
+          let wrappedError;
+          if (status === 401) {
+            wrappedError = new Error(`Voyage AI API authentication failed. Please check your VOYAGE_API_KEY. ${message}`);
+          } else if (status === 429) {
+            wrappedError = new Error(`Voyage AI API rate limit exceeded. ${message}`);
+          } else if (status === 400) {
+            wrappedError = new Error(`Voyage AI API request invalid: ${message}`);
+          } else {
+            wrappedError = new Error(`Voyage AI API error (${status}): ${message}`);
+          }
+          if (error.code) wrappedError.code = error.code;
+          if (error.response) wrappedError.response = error.response;
+          throw wrappedError;
+        }
+        throw error;
+      }
+    });
+  }
+};
+var OllamaEmbeddingProvider = class {
+  name = "ollama";
+  defaultModel = "nomic-embed-text";
+  baseUrl;
+  constructor(model, baseUrl = "http://localhost:11434") {
+    this.baseUrl = baseUrl;
+  }
+  /**
+   * Check if Ollama is available (always true for local service)
+   */
+  isAvailable() {
+    return true;
+  }
+  async generateEmbedding(text, model) {
+    const modelToUse = model || this.defaultModel;
+    return retryWithBackoff2(async () => {
+      try {
+        const response = await axios16__default.default.post(
+          `${this.baseUrl}/api/embeddings`,
+          {
+            model: modelToUse,
+            prompt: text
+          },
+          {
+            headers: {
+              "Content-Type": "application/json"
+            }
+          }
+        );
+        const embedding = response.data.embedding;
+        return {
+          embedding,
+          model: modelToUse,
+          dimensions: embedding.length
+        };
+      } catch (error) {
+        if (axios16__default.default.isAxiosError(error)) {
+          const status = error.response?.status;
+          const message = error.response?.data?.error || error.message;
+          let wrappedError;
+          if (error.code === "ECONNREFUSED") {
+            wrappedError = new Error(`Cannot connect to Ollama at ${this.baseUrl}. Make sure Ollama is running locally.`);
+          } else if (status === 404) {
+            wrappedError = new Error(`Ollama model not found. Pull it with: ollama pull <model-name>`);
+          } else if (status === 400) {
+            wrappedError = new Error(`Ollama API request invalid: ${message}`);
+          } else {
+            wrappedError = new Error(`Ollama API error (${status}): ${message}`);
+          }
+          if (error.code) wrappedError.code = error.code;
+          if (error.response) wrappedError.response = error.response;
+          throw wrappedError;
+        }
+        throw error;
+      }
+    });
+  }
+  async generateBatchEmbeddings(texts, model) {
+    const modelToUse = model || this.defaultModel;
+    const embeddings = [];
+    for (const text of texts) {
+      const result = await this.generateEmbedding(text, modelToUse);
+      embeddings.push(result.embedding);
+    }
+    const dimensions = embeddings[0]?.length || 0;
+    return {
+      embeddings,
+      model: modelToUse,
+      dimensions
+    };
+  }
+};
+
+// src/data/neo4j/embeddings/embedding-manager.ts
+var logger4 = core.createLogger("agentforge:tools:neo4j:embeddings");
+var EmbeddingManager = class {
+  provider = null;
+  config = null;
+  /**
+   * Initialize with configuration
+   */
+  initialize(config) {
+    logger4.debug("Initializing embedding manager", {
+      provider: config.provider,
+      model: config.model
+    });
+    this.config = config;
+    this.provider = this.createProvider(config.provider, config.apiKey);
+    logger4.info("Embedding manager initialized", {
+      provider: config.provider,
+      model: config.model || this.getDefaultModel(config.provider)
+    });
+  }
+  /**
+   * Initialize from environment variables
+   */
+  initializeFromEnv() {
+    const providerName = getEmbeddingProvider();
+    const model = getEmbeddingModel();
+    logger4.debug("Initializing embedding manager from environment", {
+      provider: providerName,
+      model: model || this.getDefaultModel(providerName)
+    });
+    let apiKey = "";
+    let baseUrl = "";
+    switch (providerName) {
+      case "openai": {
+        const key = getOpenAIApiKey();
+        if (!key) {
+          logger4.error("OPENAI_API_KEY environment variable not set", {
+            provider: "openai",
+            required: true
+          });
+          throw new Error("OPENAI_API_KEY environment variable is required for OpenAI embeddings");
+        }
+        apiKey = key;
+        logger4.debug("OpenAI API key found");
+        break;
+      }
+      case "cohere": {
+        const key = getCohereApiKey();
+        if (!key) {
+          logger4.error("COHERE_API_KEY environment variable not set", {
+            provider: "cohere",
+            required: true
+          });
+          throw new Error("COHERE_API_KEY environment variable is required for Cohere embeddings");
+        }
+        apiKey = key;
+        logger4.debug("Cohere API key found");
+        break;
+      }
+      case "huggingface": {
+        const key = getHuggingFaceApiKey();
+        if (!key) {
+          logger4.error("HUGGINGFACE_API_KEY environment variable not set", {
+            provider: "huggingface",
+            required: true
+          });
+          throw new Error("HUGGINGFACE_API_KEY environment variable is required for HuggingFace embeddings");
+        }
+        apiKey = key;
+        logger4.debug("HuggingFace API key found");
+        break;
+      }
+      case "voyage": {
+        const key = getVoyageApiKey();
+        if (!key) {
+          logger4.error("VOYAGE_API_KEY environment variable not set", {
+            provider: "voyage",
+            required: true
+          });
+          throw new Error("VOYAGE_API_KEY environment variable is required for Voyage AI embeddings");
+        }
+        apiKey = key;
+        logger4.debug("Voyage API key found");
+        break;
+      }
+      case "ollama":
+        baseUrl = getOllamaBaseUrl();
+        logger4.debug("Using Ollama (local, no API key required)", {
+          baseUrl: baseUrl || "http://localhost:11434"
+        });
+        break;
+      default:
+        logger4.error("Unknown embedding provider", {
+          provider: providerName
+        });
+        throw new Error(`Unknown embedding provider: ${providerName}`);
+    }
+    this.provider = this.createProvider(providerName, apiKey, model, baseUrl);
+    this.config = {
+      provider: providerName,
+      model: model || this.getDefaultModel(providerName),
+      apiKey: ""
+      // Not stored when using env
+    };
+    logger4.info("Embedding manager initialized from environment", {
+      provider: providerName,
+      model: this.config.model
+    });
+  }
+  /**
+   * Check if manager is initialized
+   */
+  isInitialized() {
+    return this.provider !== null && this.config !== null;
+  }
+  /**
+   * Get current provider
+   */
+  getProvider() {
+    if (!this.provider) {
+      throw new Error("Embedding manager not initialized. Call initialize() or initializeFromEnv() first.");
+    }
+    return this.provider;
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    if (!this.config) {
+      throw new Error("Embedding manager not initialized. Call initialize() or initializeFromEnv() first.");
+    }
+    return this.config;
+  }
+  /**
+   * Generate embedding for a single text
+   */
+  async generateEmbedding(text, model) {
+    const startTime = Date.now();
+    const provider = this.getProvider();
+    const config = this.getConfig();
+    const modelToUse = model || config.model;
+    logger4.debug("Generating embedding", {
+      provider: provider.name,
+      model: modelToUse,
+      textLength: text.length
+    });
+    const result = await provider.generateEmbedding(text, modelToUse);
+    logger4.info("Embedding generated", {
+      provider: provider.name,
+      model: result.model,
+      dimensions: result.dimensions,
+      duration: Date.now() - startTime
+    });
+    return result;
+  }
+  /**
+   * Generate embeddings for multiple texts (batch)
+   */
+  async generateBatchEmbeddings(texts, model) {
+    const startTime = Date.now();
+    const provider = this.getProvider();
+    const config = this.getConfig();
+    const modelToUse = model || config.model;
+    logger4.debug("Generating batch embeddings", {
+      provider: provider.name,
+      model: modelToUse,
+      count: texts.length
+    });
+    const result = await provider.generateBatchEmbeddings(texts, modelToUse);
+    logger4.info("Batch embeddings generated", {
+      provider: provider.name,
+      model: result.model,
+      dimensions: result.dimensions,
+      count: texts.length,
+      duration: Date.now() - startTime
+    });
+    return result;
+  }
+  /**
+   * Get default model for a provider
+   */
+  getDefaultModel(provider) {
+    switch (provider) {
+      case "openai":
+        return "text-embedding-3-small";
+      case "cohere":
+        return "embed-english-v3.0";
+      case "huggingface":
+        return "sentence-transformers/all-MiniLM-L6-v2";
+      case "voyage":
+        return "voyage-2";
+      case "ollama":
+        return "nomic-embed-text";
+      default:
+        return "text-embedding-3-small";
+    }
+  }
+  /**
+   * Create a provider instance
+   */
+  createProvider(providerName, apiKey, model, baseUrl) {
+    switch (providerName) {
+      case "openai":
+        return new OpenAIEmbeddingProvider(apiKey);
+      case "cohere":
+        return new CohereEmbeddingProvider(apiKey);
+      case "huggingface":
+        return new HuggingFaceEmbeddingProvider(apiKey);
+      case "voyage":
+        return new VoyageEmbeddingProvider(apiKey);
+      case "ollama":
+        return new OllamaEmbeddingProvider(model, baseUrl || "http://localhost:11434");
+      default:
+        throw new Error(`Unknown embedding provider: ${providerName}`);
+    }
+  }
+  /**
+   * Reset the manager (for testing)
+   */
+  reset() {
+    this.provider = null;
+    this.config = null;
+  }
+};
+var embeddingManager = new EmbeddingManager();
+function initializeEmbeddings() {
+  embeddingManager.initializeFromEnv();
+}
+function initializeEmbeddingsWithConfig(config) {
+  embeddingManager.initialize(config);
+}
+async function generateEmbedding(text, model) {
+  return embeddingManager.generateEmbedding(text, model);
+}
+async function generateBatchEmbeddings(texts, model) {
+  return embeddingManager.generateBatchEmbeddings(texts, model);
+}
+function formatInteger(value) {
+  if (value.inSafeRange()) {
+    return value.toNumber();
+  }
+  return value.toString();
+}
+function formatValue(value) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (value instanceof neo4j.Integer) {
+    return formatInteger(value);
+  }
+  if (value instanceof neo4j.Node) {
+    return formatNode(value);
+  }
+  if (value instanceof neo4j.Relationship) {
+    return formatRelationship(value);
+  }
+  if (value instanceof neo4j.Path) {
+    return formatPath(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map(formatValue);
+  }
+  if (typeof value === "object") {
+    const formatted = {};
+    for (const [key, val] of Object.entries(value)) {
+      formatted[key] = formatValue(val);
+    }
+    return formatted;
+  }
+  return value;
+}
+function formatNode(node) {
+  return {
+    identity: formatInteger(node.identity),
+    labels: node.labels,
+    properties: formatValue(node.properties)
+  };
+}
+function formatRelationship(rel) {
+  return {
+    identity: formatInteger(rel.identity),
+    type: rel.type,
+    start: formatInteger(rel.start),
+    end: formatInteger(rel.end),
+    properties: formatValue(rel.properties)
+  };
+}
+function formatPath(path12) {
+  return {
+    start: formatNode(path12.start),
+    end: formatNode(path12.end),
+    segments: path12.segments.map((segment) => ({
+      start: formatNode(segment.start),
+      relationship: formatRelationship(segment.relationship),
+      end: formatNode(segment.end)
+    })),
+    length: path12.length
+  };
+}
+function formatResults(records) {
+  return records.map((record) => {
+    const formatted = {};
+    for (const key of record.keys) {
+      formatted[key] = formatValue(record.get(key));
+    }
+    return formatted;
+  });
+}
+
+// src/data/neo4j/tools/neo4j-query.ts
+var logger5 = core.createLogger("agentforge:tools:neo4j:query");
+function createNeo4jQueryTool() {
+  return core.toolBuilder().name("neo4j-query").description(
+    "Execute a Cypher query against the Neo4j graph database. Supports parameterized queries for safety. Use this for complex queries, graph traversals, and custom operations."
+  ).category(core.ToolCategory.DATABASE).tags(["neo4j", "graph", "database", "cypher", "query"]).schema(neo4jQuerySchema).implement(async (input) => {
+    if (!neo4jPool.isInitialized()) {
+      logger5.warn("Neo4j query attempted but connection not initialized");
+      return {
+        success: false,
+        error: "Neo4j connection not initialized. Please configure Neo4j connection first."
+      };
+    }
+    const startTime = Date.now();
+    logger5.debug("Executing Neo4j query", {
+      cypherPreview: input.cypher.substring(0, 100),
+      parameterCount: Object.keys(input.parameters || {}).length,
+      database: input.database
+    });
+    try {
+      const session = neo4jPool.getSession(input.database);
+      try {
+        const result = await session.run(input.cypher, input.parameters || {});
+        const formattedResults = formatResults(result.records);
+        const duration = Date.now() - startTime;
+        logger5.info("Neo4j query executed successfully", {
+          recordCount: result.records.length,
+          nodesCreated: result.summary.counters.updates().nodesCreated,
+          nodesDeleted: result.summary.counters.updates().nodesDeleted,
+          relationshipsCreated: result.summary.counters.updates().relationshipsCreated,
+          relationshipsDeleted: result.summary.counters.updates().relationshipsDeleted,
+          propertiesSet: result.summary.counters.updates().propertiesSet,
+          duration
+        });
+        return {
+          success: true,
+          data: formattedResults,
+          recordCount: result.records.length,
+          summary: {
+            query: input.cypher,
+            parameters: input.parameters,
+            counters: {
+              nodesCreated: result.summary.counters.updates().nodesCreated,
+              nodesDeleted: result.summary.counters.updates().nodesDeleted,
+              relationshipsCreated: result.summary.counters.updates().relationshipsCreated,
+              relationshipsDeleted: result.summary.counters.updates().relationshipsDeleted,
+              propertiesSet: result.summary.counters.updates().propertiesSet
+            }
+          }
+        };
+      } finally {
+        await session.close();
+      }
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : "Failed to execute query";
+      logger5.error("Neo4j query execution failed", {
+        error: errorMessage,
+        cypherPreview: input.cypher.substring(0, 100),
+        duration
+      });
+      return {
+        success: false,
+        error: errorMessage,
+        query: input.cypher
+      };
+    }
+  }).build();
+}
+function createNeo4jGetSchemaTool() {
+  return core.toolBuilder().name("neo4j-get-schema").description(
+    "Get the schema of the Neo4j graph database including node labels, relationship types, property keys, constraints, and indexes. This helps understand the structure of the graph before querying."
+  ).category(core.ToolCategory.DATABASE).tags(["neo4j", "graph", "database", "schema", "introspection"]).schema(neo4jGetSchemaSchema).implement(async (input) => {
+    if (!neo4jPool.isInitialized()) {
+      return {
+        success: false,
+        error: "Neo4j connection not initialized. Please configure Neo4j connection first."
+      };
+    }
+    try {
+      const session = neo4jPool.getSession(input.database);
+      try {
+        const labelsResult = await session.run("CALL db.labels()");
+        const nodeLabels = labelsResult.records.map((r) => r.get("label"));
+        const relTypesResult = await session.run("CALL db.relationshipTypes()");
+        const relationshipTypes = relTypesResult.records.map((r) => r.get("relationshipType"));
+        const propsResult = await session.run("CALL db.propertyKeys()");
+        const propertyKeys = propsResult.records.map((r) => r.get("propertyKey"));
+        const constraintsResult = await session.run("SHOW CONSTRAINTS");
+        const constraints = constraintsResult.records.map((r) => ({
+          name: r.get("name"),
+          type: r.get("type"),
+          entityType: r.get("entityType"),
+          labelsOrTypes: r.get("labelsOrTypes"),
+          properties: r.get("properties")
+        }));
+        const indexesResult = await session.run("SHOW INDEXES");
+        const indexes = indexesResult.records.map((r) => ({
+          name: r.get("name"),
+          type: r.get("type"),
+          entityType: r.get("entityType"),
+          labelsOrTypes: r.get("labelsOrTypes"),
+          properties: r.get("properties")
+        }));
+        return {
+          success: true,
+          schema: {
+            nodeLabels,
+            relationshipTypes,
+            propertyKeys,
+            constraints,
+            indexes
+          },
+          summary: {
+            totalLabels: nodeLabels.length,
+            totalRelationshipTypes: relationshipTypes.length,
+            totalPropertyKeys: propertyKeys.length,
+            totalConstraints: constraints.length,
+            totalIndexes: indexes.length
+          }
+        };
+      } finally {
+        await session.close();
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to get schema"
+      };
+    }
+  }).build();
+}
+
+// src/data/neo4j/utils/cypher-sanitizer.ts
+function escapeCypherIdentifier(identifier, type = "identifier") {
+  if (!identifier || typeof identifier !== "string") {
+    throw new Error(`Invalid ${type}: must be a non-empty string`);
+  }
+  const trimmed = identifier.trim();
+  if (trimmed.length === 0) {
+    throw new Error(`Invalid ${type}: cannot be empty or whitespace`);
+  }
+  if (trimmed.includes("\0")) {
+    throw new Error(`Invalid ${type}: cannot contain null bytes`);
+  }
+  const simplePattern = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+  if (simplePattern.test(trimmed)) {
+    return trimmed;
+  }
+  const escaped = trimmed.replace(/`/g, "``");
+  return `\`${escaped}\``;
+}
+function validateLabel(label) {
+  return escapeCypherIdentifier(label, "label");
+}
+function validatePropertyKey(key) {
+  return escapeCypherIdentifier(key, "property key");
+}
+function validateRelationshipType(type) {
+  return escapeCypherIdentifier(type, "relationship type");
+}
+function validateDirection(direction) {
+  const normalized = direction.toUpperCase();
+  if (normalized !== "OUTGOING" && normalized !== "INCOMING" && normalized !== "BOTH") {
+    throw new Error(`Invalid direction: must be 'OUTGOING', 'INCOMING', or 'BOTH'`);
+  }
+  return normalized;
+}
+function buildPropertyFilter(properties, nodeVar = "n") {
+  const keys = Object.keys(properties);
+  if (keys.length === 0) {
+    return { whereClause: "", parameters: {} };
+  }
+  const safeNodeVar = escapeCypherIdentifier(nodeVar, "node variable");
+  const conditions = keys.map((key, index) => {
+    const safeKey = validatePropertyKey(key);
+    const paramName = `prop_${index}`;
+    return `${safeNodeVar}.${safeKey} = $${paramName}`;
+  });
+  const parameters = {};
+  keys.forEach((key, index) => {
+    parameters[`prop_${index}`] = properties[key];
+  });
+  return {
+    whereClause: `WHERE ${conditions.join(" AND ")}`,
+    parameters
+  };
+}
+
+// src/data/neo4j/tools/neo4j-find-nodes.ts
+function createNeo4jFindNodesTool() {
+  return core.toolBuilder().name("neo4j-find-nodes").description(
+    "Find nodes in the Neo4j graph by label and optional property filters. This is a simplified interface for common node lookup operations. Returns nodes matching the specified criteria."
+  ).category(core.ToolCategory.DATABASE).tags(["neo4j", "graph", "database", "nodes", "search"]).schema(neo4jFindNodesSchema).implement(async (input) => {
+    if (!neo4jPool.isInitialized()) {
+      return {
+        success: false,
+        error: "Neo4j connection not initialized. Please configure Neo4j connection first."
+      };
+    }
+    try {
+      const safeLabel = validateLabel(input.label);
+      const session = neo4jPool.getSession(input.database);
+      try {
+        let cypher = `MATCH (n:${safeLabel})`;
+        let parameters = {};
+        if (input.properties && Object.keys(input.properties).length > 0) {
+          const { whereClause, parameters: filterParams } = buildPropertyFilter(input.properties, "n");
+          cypher += ` ${whereClause}`;
+          parameters = { ...parameters, ...filterParams };
+        }
+        cypher += ` RETURN n LIMIT $limit`;
+        parameters.limit = input.limit;
+        const result = await session.run(cypher, parameters);
+        const formattedResults = formatResults(result.records);
+        return {
+          success: true,
+          nodes: formattedResults.map((r) => r.n),
+          count: result.records.length,
+          query: {
+            label: input.label,
+            properties: input.properties,
+            limit: input.limit
+          }
+        };
+      } finally {
+        await session.close();
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to find nodes",
+        query: {
+          label: input.label,
+          properties: input.properties
+        }
+      };
+    }
+  }).build();
+}
+function createNeo4jTraverseTool() {
+  return core.toolBuilder().name("neo4j-traverse").description(
+    "Traverse the Neo4j graph from a starting node by following relationships. Supports filtering by relationship type, direction, and maximum depth. Returns connected nodes and their relationships."
+  ).category(core.ToolCategory.DATABASE).tags(["neo4j", "graph", "database", "traverse", "relationships"]).schema(neo4jTraverseSchema).implement(async (input) => {
+    if (!neo4jPool.isInitialized()) {
+      return {
+        success: false,
+        error: "Neo4j connection not initialized. Please configure Neo4j connection first."
+      };
+    }
+    try {
+      const safeDirection = validateDirection(input.direction || "outgoing");
+      const safeRelType = input.relationshipType ? validateRelationshipType(input.relationshipType) : null;
+      const session = neo4jPool.getSession(input.database);
+      try {
+        let relPattern = "";
+        if (safeDirection === "OUTGOING") {
+          relPattern = safeRelType ? `-[r:${safeRelType}*1..${input.maxDepth}]->` : `-[r*1..${input.maxDepth}]->`;
+        } else if (safeDirection === "INCOMING") {
+          relPattern = safeRelType ? `<-[r:${safeRelType}*1..${input.maxDepth}]-` : `<-[r*1..${input.maxDepth}]-`;
+        } else {
+          relPattern = safeRelType ? `-[r:${safeRelType}*1..${input.maxDepth}]-` : `-[r*1..${input.maxDepth}]-`;
+        }
+        const cypher = `
+            MATCH path = (start)${relPattern}(end)
+            WHERE id(start) = $startNodeId
+            RETURN start, end, relationships(path) as rels, length(path) as depth
+            LIMIT $limit
+          `;
+        const parameters = {
+          startNodeId: typeof input.startNodeId === "string" ? parseInt(input.startNodeId, 10) : input.startNodeId,
+          limit: input.limit
+        };
+        const result = await session.run(cypher, parameters);
+        const formattedResults = formatResults(result.records);
+        return {
+          success: true,
+          paths: formattedResults.map((r) => ({
+            start: r.start,
+            end: r.end,
+            relationships: r.rels,
+            depth: r.depth
+          })),
+          count: result.records.length,
+          query: {
+            startNodeId: input.startNodeId,
+            relationshipType: input.relationshipType,
+            direction: input.direction,
+            maxDepth: input.maxDepth
+          }
+        };
+      } finally {
+        await session.close();
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to traverse graph",
+        query: {
+          startNodeId: input.startNodeId,
+          relationshipType: input.relationshipType,
+          direction: input.direction
+        }
+      };
+    }
+  }).build();
+}
+function createNeo4jVectorSearchTool() {
+  return core.toolBuilder().name("neo4j-vector-search").description(
+    "Perform semantic similarity search using vector indexes in Neo4j. Essential for GraphRAG applications - finds nodes with similar embeddings. Requires a vector index to be created in advance."
+  ).category(core.ToolCategory.DATABASE).tags(["neo4j", "graph", "database", "vector", "search", "semantic", "graphrag"]).schema(neo4jVectorSearchSchema).implement(async (input) => {
+    if (!neo4jPool.isInitialized()) {
+      return {
+        success: false,
+        error: "Neo4j connection not initialized. Please configure Neo4j connection first."
+      };
+    }
+    try {
+      const session = neo4jPool.getSession(input.database);
+      try {
+        const cypher = `
+            CALL db.index.vector.queryNodes($indexName, $limit, $queryVector)
+            YIELD node, score
+            RETURN node, score
+            ORDER BY score DESC
+          `;
+        const parameters = {
+          indexName: input.indexName,
+          limit: input.limit,
+          queryVector: input.queryVector
+        };
+        const result = await session.run(cypher, parameters);
+        const formattedResults = formatResults(result.records);
+        return {
+          success: true,
+          results: formattedResults.map((r) => ({
+            node: r.node,
+            score: r.score
+          })),
+          count: result.records.length,
+          query: {
+            indexName: input.indexName,
+            vectorDimension: input.queryVector.length,
+            limit: input.limit
+          }
+        };
+      } finally {
+        await session.close();
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Failed to perform vector search";
+      let helpText = "";
+      if (errorMessage.includes("index") || errorMessage.includes("not found")) {
+        helpText = " Make sure the vector index exists. Create one with: CREATE VECTOR INDEX <name> FOR (n:Label) ON (n.embedding)";
+      }
+      return {
+        success: false,
+        error: errorMessage + helpText,
+        query: {
+          indexName: input.indexName,
+          vectorDimension: input.queryVector.length
+        }
+      };
+    }
+  }).build();
+}
+var logger6 = core.createLogger("agentforge:tools:neo4j:vector-search");
+function createNeo4jVectorSearchWithEmbeddingTool() {
+  return core.toolBuilder().name("neo4j-vector-search-with-embedding").description(
+    "Perform semantic similarity search in Neo4j by automatically generating embeddings from text. This tool takes text input, generates an embedding vector, and searches for similar nodes. Essential for GraphRAG applications - no need to manually generate embeddings. Requires a vector index and embedding provider (OpenAI) to be configured."
+  ).category(core.ToolCategory.DATABASE).tags(["neo4j", "graph", "database", "vector", "search", "semantic", "graphrag", "embedding", "ai"]).schema(neo4jVectorSearchWithEmbeddingSchema).implement(async (input) => {
+    if (!neo4jPool.isInitialized()) {
+      logger6.warn("Vector search attempted but Neo4j connection not initialized");
+      return {
+        success: false,
+        error: "Neo4j connection not initialized. Please configure Neo4j connection first."
+      };
+    }
+    if (!embeddingManager.isInitialized()) {
+      logger6.warn("Vector search attempted but embedding manager not initialized");
+      return {
+        success: false,
+        error: "Embedding manager not initialized. Please configure embedding provider (set OPENAI_API_KEY and optionally EMBEDDING_MODEL)."
+      };
+    }
+    const startTime = Date.now();
+    logger6.debug("Performing vector search with embedding", {
+      queryTextLength: input.queryText.length,
+      indexName: input.indexName,
+      limit: input.limit,
+      model: input.model
+    });
+    try {
+      const embeddingResult = await embeddingManager.generateEmbedding(input.queryText, input.model);
+      const session = neo4jPool.getSession(input.database);
+      try {
+        const cypher = `
+            CALL db.index.vector.queryNodes($indexName, $limit, $queryVector)
+            YIELD node, score
+            RETURN node, score
+            ORDER BY score DESC
+          `;
+        const parameters = {
+          indexName: input.indexName,
+          limit: input.limit,
+          queryVector: embeddingResult.embedding
+        };
+        const result = await session.run(cypher, parameters);
+        const formattedResults = formatResults(result.records);
+        const duration = Date.now() - startTime;
+        logger6.info("Vector search completed successfully", {
+          resultCount: result.records.length,
+          indexName: input.indexName,
+          embeddingModel: embeddingResult.model,
+          embeddingDimensions: embeddingResult.dimensions,
+          duration
+        });
+        return {
+          success: true,
+          results: formattedResults.map((r) => ({
+            node: r.node,
+            score: r.score
+          })),
+          count: result.records.length,
+          query: {
+            text: input.queryText,
+            indexName: input.indexName,
+            embeddingModel: embeddingResult.model,
+            vectorDimension: embeddingResult.dimensions,
+            limit: input.limit
+          },
+          embedding: {
+            model: embeddingResult.model,
+            dimensions: embeddingResult.dimensions,
+            usage: embeddingResult.usage
+          }
+        };
+      } finally {
+        await session.close();
+      }
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      const errorMessage = error instanceof Error ? error.message : "Failed to perform vector search with embedding";
+      let helpText = "";
+      if (errorMessage.includes("index") || errorMessage.includes("not found")) {
+        helpText = " Make sure the vector index exists. Create one with: CREATE VECTOR INDEX <name> FOR (n:Label) ON (n.embedding)";
+      } else if (errorMessage.includes("API key") || errorMessage.includes("not initialized")) {
+        helpText = " Make sure OPENAI_API_KEY is set in your environment variables.";
+      } else if (errorMessage.includes("dimension")) {
+        helpText = " Make sure the vector index dimensions match your embedding model dimensions.";
+      }
+      logger6.error("Vector search failed", {
+        error: errorMessage,
+        indexName: input.indexName,
+        queryTextLength: input.queryText.length,
+        duration
+      });
+      return {
+        success: false,
+        error: errorMessage + helpText,
+        query: {
+          text: input.queryText,
+          indexName: input.indexName
+        }
+      };
+    }
+  }).build();
+}
+function createNeo4jCreateNodeWithEmbeddingTool() {
+  return core.toolBuilder().name("neo4j-create-node-with-embedding").description(
+    "Create a Neo4j node with automatic embedding generation from text content. This tool extracts text from a specified property, generates an embedding vector, and stores both the original properties and the embedding in the node. Perfect for building GraphRAG knowledge bases. Requires embedding provider (OpenAI) to be configured."
+  ).category(core.ToolCategory.DATABASE).tags(["neo4j", "graph", "database", "create", "node", "embedding", "graphrag", "ai"]).schema(neo4jCreateNodeWithEmbeddingSchema).implement(async (input) => {
+    if (!neo4jPool.isInitialized()) {
+      return {
+        success: false,
+        error: "Neo4j connection not initialized. Please configure Neo4j connection first."
+      };
+    }
+    if (!embeddingManager.isInitialized()) {
+      return {
+        success: false,
+        error: "Embedding manager not initialized. Please configure embedding provider (set OPENAI_API_KEY and optionally EMBEDDING_MODEL)."
+      };
+    }
+    try {
+      const textToEmbed = input.properties[input.textProperty];
+      if (!textToEmbed || typeof textToEmbed !== "string") {
+        return {
+          success: false,
+          error: `Property '${input.textProperty}' not found or is not a string in the provided properties.`
+        };
+      }
+      const embeddingResult = await embeddingManager.generateEmbedding(textToEmbed, input.model);
+      const safeLabel = validateLabel(input.label);
+      const safeEmbeddingProp = validatePropertyKey(input.embeddingProperty || "embedding");
+      const session = neo4jPool.getSession(input.database);
+      try {
+        const allProperties = {
+          ...input.properties
+        };
+        allProperties[input.embeddingProperty || "embedding"] = embeddingResult.embedding;
+        const cypher = `
+            CREATE (n:${safeLabel})
+            SET n = $properties
+            RETURN n, id(n) as nodeId
+          `;
+        const parameters = {
+          properties: allProperties
+        };
+        const result = await session.run(cypher, parameters);
+        const formattedResults = formatResults(result.records);
+        if (formattedResults.length === 0) {
+          return {
+            success: false,
+            error: "Failed to create node"
+          };
+        }
+        const createdNode = formattedResults[0];
+        return {
+          success: true,
+          node: createdNode.n,
+          nodeId: createdNode.nodeId,
+          embedding: {
+            model: embeddingResult.model,
+            dimensions: embeddingResult.dimensions,
+            property: safeEmbeddingProp,
+            usage: embeddingResult.usage
+          },
+          message: `Created node with label '${input.label}' and ${embeddingResult.dimensions}-dimensional embedding`
+        };
+      } finally {
+        await session.close();
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Failed to create node with embedding";
+      let helpText = "";
+      if (errorMessage.includes("API key") || errorMessage.includes("not initialized")) {
+        helpText = " Make sure OPENAI_API_KEY is set in your environment variables.";
+      } else if (errorMessage.includes("Syntax error") || errorMessage.includes("Invalid")) {
+        helpText = " Check that the label and property names are valid.";
+      }
+      return {
+        success: false,
+        error: errorMessage + helpText
+      };
+    }
+  }).build();
+}
+
+// src/data/neo4j/index.ts
+var neo4jQuery = createNeo4jQueryTool();
+var neo4jGetSchema = createNeo4jGetSchemaTool();
+var neo4jFindNodes = createNeo4jFindNodesTool();
+var neo4jTraverse = createNeo4jTraverseTool();
+var neo4jVectorSearch = createNeo4jVectorSearchTool();
+var neo4jVectorSearchWithEmbedding = createNeo4jVectorSearchWithEmbeddingTool();
+var neo4jCreateNodeWithEmbedding = createNeo4jCreateNodeWithEmbeddingTool();
+var neo4jTools = [
+  neo4jQuery,
+  neo4jGetSchema,
+  neo4jFindNodes,
+  neo4jTraverse,
+  neo4jVectorSearch,
+  neo4jVectorSearchWithEmbedding,
+  neo4jCreateNodeWithEmbedding
+];
+var neo4jCoreTools = [
+  neo4jQuery,
+  neo4jGetSchema,
+  neo4jFindNodes,
+  neo4jTraverse,
+  neo4jVectorSearch
+];
+function createNeo4jTools(config = {}, includeEmbeddingTools = true) {
+  if (config.uri && config.username && config.password) {
+    neo4jPool.initialize({
+      uri: config.uri,
+      username: config.username,
+      password: config.password,
+      database: config.database,
+      maxConnectionPoolSize: config.maxConnectionPoolSize,
+      connectionTimeout: config.connectionTimeout
+    }).catch((error) => {
+      console.error("Failed to initialize Neo4j connection:", error);
+    });
+  }
+  const coreTools = [
+    createNeo4jQueryTool(),
+    createNeo4jGetSchemaTool(),
+    createNeo4jFindNodesTool(),
+    createNeo4jTraverseTool(),
+    createNeo4jVectorSearchTool()
+  ];
+  if (includeEmbeddingTools) {
+    return [
+      ...coreTools,
+      createNeo4jVectorSearchWithEmbeddingTool(),
+      createNeo4jCreateNodeWithEmbeddingTool()
+    ];
+  }
+  return coreTools;
+}
+async function initializeNeo4jTools() {
+  await initializeFromEnv();
+  try {
+    embeddingManager.initializeFromEnv();
+  } catch (error) {
+  }
+}
 var fileReaderSchema = zod.z.object({
   path: zod.z.string().describe("Path to the file to read"),
   encoding: zod.z.enum(["utf8", "utf-8", "ascii", "base64", "hex", "binary"]).default("utf8").describe("File encoding")
@@ -3200,7 +4902,7 @@ var AskHumanInputSchema = zod.z.object({
   suggestions: zod.z.array(zod.z.string()).optional().describe("Suggested responses for the human")
 });
 var logLevel3 = process.env.LOG_LEVEL?.toLowerCase() || core.LogLevel.INFO;
-var logger3 = core.createLogger("askHuman", { level: logLevel3 });
+var logger7 = core.createLogger("askHuman", { level: logLevel3 });
 function createAskHumanTool() {
   return core.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."
@@ -3233,13 +4935,13 @@ function createAskHumanTool() {
       suggestions: validatedInput.suggestions,
       status: "pending"
     };
-    logger3.debug("About to call interrupt()", { humanRequest });
+    logger7.debug("About to call interrupt()", { humanRequest });
     let response;
     try {
       response = interrupt(humanRequest);
-      logger3.debug("interrupt() returned successfully", { response, responseType: typeof response });
+      logger7.debug("interrupt() returned successfully", { response, responseType: typeof response });
     } catch (error) {
-      logger3.debug("interrupt() threw error (expected for GraphInterrupt)", {
+      logger7.debug("interrupt() threw error (expected for GraphInterrupt)", {
         errorType: error?.constructor?.name,
         error: error instanceof Error ? error.message : String(error)
       });
@@ -3268,15 +4970,18 @@ exports.AskHumanInputSchema = AskHumanInputSchema;
 exports.CalculatorSchema = CalculatorSchema;
 exports.CreditCardValidatorSchema = CreditCardValidatorSchema;
 exports.CurrentDateTimeSchema = CurrentDateTimeSchema;
+exports.DEFAULT_RETRY_CONFIG = DEFAULT_RETRY_CONFIG2;
 exports.DateArithmeticSchema = DateArithmeticSchema;
 exports.DateComparisonSchema = DateComparisonSchema;
 exports.DateDifferenceSchema = DateDifferenceSchema;
 exports.DateFormatterSchema = DateFormatterSchema;
 exports.DuckDuckGoProvider = DuckDuckGoProvider;
 exports.EmailValidatorSchema = EmailValidatorSchema;
+exports.EmbeddingManager = EmbeddingManager;
 exports.HttpMethod = HttpMethod;
 exports.IpValidatorSchema = IpValidatorSchema;
 exports.MathFunctionsSchema = MathFunctionsSchema;
+exports.OpenAIEmbeddingProvider = OpenAIEmbeddingProvider;
 exports.PhoneValidatorSchema = PhoneValidatorSchema;
 exports.RandomNumberSchema = RandomNumberSchema;
 exports.SerperProvider = SerperProvider;
@@ -3350,6 +5055,14 @@ exports.createJsonTools = createJsonTools;
 exports.createJsonValidatorTool = createJsonValidatorTool;
 exports.createMathFunctionsTool = createMathFunctionsTool;
 exports.createMathOperationTools = createMathOperationTools;
+exports.createNeo4jCreateNodeWithEmbeddingTool = createNeo4jCreateNodeWithEmbeddingTool;
+exports.createNeo4jFindNodesTool = createNeo4jFindNodesTool;
+exports.createNeo4jGetSchemaTool = createNeo4jGetSchemaTool;
+exports.createNeo4jQueryTool = createNeo4jQueryTool;
+exports.createNeo4jTools = createNeo4jTools;
+exports.createNeo4jTraverseTool = createNeo4jTraverseTool;
+exports.createNeo4jVectorSearchTool = createNeo4jVectorSearchTool;
+exports.createNeo4jVectorSearchWithEmbeddingTool = createNeo4jVectorSearchWithEmbeddingTool;
 exports.createObjectOmitTool = createObjectOmitTool;
 exports.createObjectPickTool = createObjectPickTool;
 exports.createPathBasenameTool = createPathBasenameTool;
@@ -3410,6 +5123,7 @@ exports.directoryList = directoryList;
 exports.directoryListSchema = directoryListSchema;
 exports.directoryOperationTools = directoryOperationTools;
 exports.emailValidator = emailValidator;
+exports.embeddingManager = embeddingManager;
 exports.extractImages = extractImages;
 exports.extractImagesSchema = extractImagesSchema;
 exports.extractLinks = extractLinks;
@@ -3427,10 +5141,19 @@ exports.fileSearch = fileSearch;
 exports.fileSearchSchema = fileSearchSchema;
 exports.fileWriter = fileWriter;
 exports.fileWriterSchema = fileWriterSchema;
+exports.generateBatchEmbeddings = generateBatchEmbeddings;
+exports.generateEmbedding = generateEmbedding;
+exports.getCohereApiKey = getCohereApiKey;
 exports.getConfluencePage = getConfluencePage;
+exports.getEmbeddingModel = getEmbeddingModel;
+exports.getEmbeddingProvider = getEmbeddingProvider;
+exports.getHuggingFaceApiKey = getHuggingFaceApiKey;
+exports.getOllamaBaseUrl = getOllamaBaseUrl;
+exports.getOpenAIApiKey = getOpenAIApiKey;
 exports.getSlackChannels = getSlackChannels;
 exports.getSlackMessages = getSlackMessages;
 exports.getSpacePages = getSpacePages;
+exports.getVoyageApiKey = getVoyageApiKey;
 exports.htmlParser = htmlParser;
 exports.htmlParserSchema = htmlParserSchema;
 exports.htmlParserTools = htmlParserTools;
@@ -3441,7 +5164,12 @@ exports.httpPost = httpPost;
 exports.httpPostSchema = httpPostSchema;
 exports.httpRequestSchema = httpRequestSchema;
 exports.httpTools = httpTools;
+exports.initializeEmbeddings = initializeEmbeddings;
+exports.initializeEmbeddingsWithConfig = initializeEmbeddingsWithConfig;
+exports.initializeFromEnv = initializeFromEnv;
+exports.initializeNeo4jTools = initializeNeo4jTools;
 exports.ipValidator = ipValidator;
+exports.isRetryableError = isRetryableError2;
 exports.jsonMerge = jsonMerge;
 exports.jsonMergeSchema = jsonMergeSchema;
 exports.jsonParser = jsonParser;
@@ -3460,6 +5188,23 @@ exports.jsonValidatorSchema = jsonValidatorSchema;
 exports.listConfluenceSpaces = listConfluenceSpaces;
 exports.mathFunctions = mathFunctions;
 exports.mathOperationTools = mathOperationTools;
+exports.neo4jCoreTools = neo4jCoreTools;
+exports.neo4jCreateNodeWithEmbedding = neo4jCreateNodeWithEmbedding;
+exports.neo4jCreateNodeWithEmbeddingSchema = neo4jCreateNodeWithEmbeddingSchema;
+exports.neo4jFindNodes = neo4jFindNodes;
+exports.neo4jFindNodesSchema = neo4jFindNodesSchema;
+exports.neo4jGetSchema = neo4jGetSchema;
+exports.neo4jGetSchemaSchema = neo4jGetSchemaSchema;
+exports.neo4jPool = neo4jPool;
+exports.neo4jQuery = neo4jQuery;
+exports.neo4jQuerySchema = neo4jQuerySchema;
+exports.neo4jTools = neo4jTools;
+exports.neo4jTraverse = neo4jTraverse;
+exports.neo4jTraverseSchema = neo4jTraverseSchema;
+exports.neo4jVectorSearch = neo4jVectorSearch;
+exports.neo4jVectorSearchSchema = neo4jVectorSearchSchema;
+exports.neo4jVectorSearchWithEmbedding = neo4jVectorSearchWithEmbedding;
+exports.neo4jVectorSearchWithEmbeddingSchema = neo4jVectorSearchWithEmbeddingSchema;
 exports.notifySlack = notifySlack;
 exports.objectOmit = objectOmit;
 exports.objectOmitSchema = objectOmitSchema;
@@ -3484,6 +5229,7 @@ exports.pathResolveSchema = pathResolveSchema;
 exports.pathUtilityTools = pathUtilityTools;
 exports.phoneValidator = phoneValidator;
 exports.randomNumber = randomNumber;
+exports.retryWithBackoff = retryWithBackoff2;
 exports.scraperTools = scraperTools;
 exports.searchConfluence = searchConfluence;
 exports.searchResultSchema = searchResultSchema;
@@ -3509,6 +5255,8 @@ exports.urlValidatorSchema = urlValidatorSchema;
 exports.urlValidatorSimple = urlValidatorSimple;
 exports.urlValidatorTools = urlValidatorTools;
 exports.uuidValidator = uuidValidator;
+exports.validateBatch = validateBatch;
+exports.validateText = validateText;
 exports.validationTools = validationTools;
 exports.webScraper = webScraper;
 exports.webScraperSchema = webScraperSchema;