@agentforge/tools 0.17.2 → 0.18.1

package/dist/index.cjs

@@ -14,6 +14,7 @@ var neo4j = require('neo4j-driver');
 var drizzleOrm = require('drizzle-orm');
 var events = require('events');
 var stream = require('stream');
+var async_hooks = require('async_hooks');
 var crypto = require('crypto');
 var fs = require('fs');
 var path = require('path');
@@ -1023,7 +1024,7 @@ function getDefaultSlackClient() {
     }
   };
 }
-function createSendSlackMessageTool(getSlackClient, logger19) {
+function createSendSlackMessageTool(getSlackClient, logger20) {
   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(
@@ -1032,7 +1033,7 @@ function createSendSlackMessageTool(getSlackClient, logger19) {
       message: zod.z.string().describe("Message content to send")
     })
   ).implementSafe(async ({ channel, message }) => {
-    logger19.info("send-slack-message called", { channel, messageLength: message.length });
+    logger20.info("send-slack-message called", { channel, messageLength: message.length });
     try {
       const { client: slack, config } = getSlackClient();
       const result = await slack.chat.postMessage({
@@ -1041,7 +1042,7 @@ function createSendSlackMessageTool(getSlackClient, logger19) {
         username: config.botName,
         icon_emoji: config.botIcon
       });
-      logger19.info("send-slack-message result", {
+      logger20.info("send-slack-message result", {
         ...result.channel ? { channel: result.channel } : {},
         ...result.ts ? { timestamp: result.ts } : {},
         messageLength: message.length,
@@ -1054,7 +1055,7 @@ function createSendSlackMessageTool(getSlackClient, logger19) {
         message_id: result.ts
       };
     } catch (error) {
-      logger19.error("send-slack-message failed", {
+      logger20.error("send-slack-message failed", {
         channel,
         error: error.message,
         data: error.data
@@ -1063,7 +1064,7 @@ function createSendSlackMessageTool(getSlackClient, logger19) {
     }
   }).build();
 }
-function createNotifySlackTool(getSlackClient, logger19) {
+function createNotifySlackTool(getSlackClient, logger20) {
   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(
@@ -1073,7 +1074,7 @@ function createNotifySlackTool(getSlackClient, logger19) {
       mentions: zod.z.array(zod.z.string()).optional().describe("List of usernames to mention (without @)")
     })
   ).implementSafe(async ({ channel, message, mentions = [] }) => {
-    logger19.info("notify-slack called", {
+    logger20.info("notify-slack called", {
       channel,
       messageLength: message.length,
       mentionCount: mentions.length
@@ -1087,7 +1088,7 @@ function createNotifySlackTool(getSlackClient, logger19) {
       username: config.botName,
       icon_emoji: config.botIcon
     });
-    logger19.info("notify-slack result", {
+    logger20.info("notify-slack result", {
       ...result.channel ? { channel: result.channel } : {},
       ...result.ts ? { timestamp: result.ts } : {},
       mentions: mentions.length
@@ -1101,7 +1102,7 @@ function createNotifySlackTool(getSlackClient, logger19) {
     };
   }).build();
 }
-function createGetSlackChannelsTool(getSlackClient, logger19) {
+function createGetSlackChannelsTool(getSlackClient, logger20) {
   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(
@@ -1109,7 +1110,7 @@ function createGetSlackChannelsTool(getSlackClient, logger19) {
       include_private: zod.z.boolean().optional().describe("Include private channels (default: false)")
     })
   ).implementSafe(async ({ include_private = false }) => {
-    logger19.info("get-slack-channels called", { include_private });
+    logger20.info("get-slack-channels called", { include_private });
     const { client: slack } = getSlackClient();
     const publicChannels = await slack.conversations.list({
       types: "public_channel",
@@ -1123,7 +1124,7 @@ function createGetSlackChannelsTool(getSlackClient, logger19) {
       });
       allChannels = [...allChannels, ...privateChannels.channels || []];
     }
-    logger19.info("get-slack-channels result", {
+    logger20.info("get-slack-channels result", {
       channelCount: allChannels.length,
       includePrivate: include_private
     });
@@ -1138,7 +1139,7 @@ function createGetSlackChannelsTool(getSlackClient, logger19) {
     };
   }).build();
 }
-function createGetSlackMessagesTool(getSlackClient, logger19) {
+function createGetSlackMessagesTool(getSlackClient, logger20) {
   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(
@@ -1147,7 +1148,7 @@ function createGetSlackMessagesTool(getSlackClient, logger19) {
       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 }) => {
-    logger19.info("get-slack-messages called", { channel, limit });
+    logger20.info("get-slack-messages called", { channel, limit });
     try {
       const { client: slack } = getSlackClient();
       let channelId = channel;
@@ -1158,7 +1159,7 @@ function createGetSlackMessagesTool(getSlackClient, logger19) {
         });
         const found = channels.channels?.find((c) => c.name === channel);
         if (!found) {
-          logger19.error("get-slack-messages: channel not found", { channel });
+          logger20.error("get-slack-messages: channel not found", { channel });
           throw new Error(
             `Channel '${channel}' not found. Use get-slack-channels to see available channels.`
           );
@@ -1170,7 +1171,7 @@ function createGetSlackMessagesTool(getSlackClient, logger19) {
         limit: Math.min(limit, 100)
         // Cap at 100 for performance
       });
-      logger19.info("get-slack-messages result", {
+      logger20.info("get-slack-messages result", {
         channel: channelId,
         messageCount: result.messages?.length || 0,
         limit
@@ -1188,7 +1189,7 @@ function createGetSlackMessagesTool(getSlackClient, logger19) {
         })) || []
       };
     } catch (error) {
-      logger19.error("get-slack-messages failed", {
+      logger20.error("get-slack-messages failed", {
         channel,
         error: error.message,
         data: error.data
@@ -1269,12 +1270,12 @@ function getAuthHeader() {
   const auth2 = Buffer.from(`${ATLASSIAN_EMAIL}:${ATLASSIAN_API_KEY}`).toString("base64");
   return `Basic ${auth2}`;
 }
-function createSearchConfluenceTool(getAuth, getAuthHeader2, logger19) {
+function createSearchConfluenceTool(getAuth, getAuthHeader2, logger20) {
   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 }) => {
-    logger19.info("search-confluence called", { query, limit });
+    logger20.info("search-confluence called", { query, limit });
     try {
       const { ATLASSIAN_SITE_URL } = getAuth();
       const response = await axios11__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/content/search`, {
@@ -1299,13 +1300,13 @@ function createSearchConfluenceTool(getAuth, getAuthHeader2, logger19) {
         lastModified: page.version?.when || ""
       }));
       if (results.length === 0) {
-        logger19.warn("search-confluence returned NO RESULTS - this is a valid outcome, agent should not retry", {
+        logger20.warn("search-confluence returned NO RESULTS - this is a valid outcome, agent should not retry", {
           query,
           limit,
           totalSize: response.data.totalSize
         });
       } else {
-        logger19.info("search-confluence result", {
+        logger20.info("search-confluence result", {
           query,
           resultCount: results.length,
           totalSize: response.data.totalSize,
@@ -1320,7 +1321,7 @@ function createSearchConfluenceTool(getAuth, getAuthHeader2, logger19) {
         results
       });
     } catch (error) {
-      logger19.error("search-confluence error", {
+      logger20.error("search-confluence error", {
         query,
         error: error.response?.data?.message || error.message,
         status: error.response?.status
@@ -1332,11 +1333,11 @@ function createSearchConfluenceTool(getAuth, getAuthHeader2, logger19) {
     }
   }).build();
 }
-function createGetConfluencePageTool(getAuth, getAuthHeader2, logger19) {
+function createGetConfluencePageTool(getAuth, getAuthHeader2, logger20) {
   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 }) => {
-    logger19.info("get-confluence-page called", { page_id });
+    logger20.info("get-confluence-page called", { page_id });
     try {
       const { ATLASSIAN_SITE_URL } = getAuth();
       const response = await axios11__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/content/${page_id}`, {
@@ -1349,7 +1350,7 @@ function createGetConfluencePageTool(getAuth, getAuthHeader2, logger19) {
         }
       });
       const page = response.data;
-      logger19.info("get-confluence-page result", {
+      logger20.info("get-confluence-page result", {
         page_id,
         title: page.title,
         space: page.space?.name,
@@ -1371,7 +1372,7 @@ function createGetConfluencePageTool(getAuth, getAuthHeader2, logger19) {
         }
       });
     } catch (error) {
-      logger19.error("get-confluence-page error", {
+      logger20.error("get-confluence-page error", {
         page_id,
         error: error.response?.data?.message || error.message,
         status: error.response?.status
@@ -1383,11 +1384,11 @@ function createGetConfluencePageTool(getAuth, getAuthHeader2, logger19) {
     }
   }).build();
 }
-function createListConfluenceSpacesTool(getAuth, getAuthHeader2, logger19) {
+function createListConfluenceSpacesTool(getAuth, getAuthHeader2, logger20) {
   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 }) => {
-    logger19.info("list-confluence-spaces called", { limit });
+    logger20.info("list-confluence-spaces called", { limit });
     try {
       const { ATLASSIAN_SITE_URL } = getAuth();
       const response = await axios11__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/space`, {
@@ -1406,7 +1407,7 @@ function createListConfluenceSpacesTool(getAuth, getAuthHeader2, logger19) {
         description: space.description?.plain?.value || "",
         url: `${ATLASSIAN_SITE_URL}/wiki${space._links.webui}`
       }));
-      logger19.info("list-confluence-spaces result", {
+      logger20.info("list-confluence-spaces result", {
         spaceCount: spaces.length,
         spaceKeys: spaces.map((s) => s.key).slice(0, 5)
         // Log first 5 space keys
@@ -1417,7 +1418,7 @@ function createListConfluenceSpacesTool(getAuth, getAuthHeader2, logger19) {
         spaces
       });
     } catch (error) {
-      logger19.error("list-confluence-spaces error", {
+      logger20.error("list-confluence-spaces error", {
         error: error.response?.data?.message || error.message,
         status: error.response?.status
       });
@@ -1428,12 +1429,12 @@ function createListConfluenceSpacesTool(getAuth, getAuthHeader2, logger19) {
     }
   }).build();
 }
-function createGetSpacePagesTool(getAuth, getAuthHeader2, logger19) {
+function createGetSpacePagesTool(getAuth, getAuthHeader2, logger20) {
   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 }) => {
-    logger19.info("get-space-pages called", { space_key, limit });
+    logger20.info("get-space-pages called", { space_key, limit });
     try {
       const { ATLASSIAN_SITE_URL } = getAuth();
       const response = await axios11__default.default.get(`${ATLASSIAN_SITE_URL}/wiki/rest/api/content`, {
@@ -1455,12 +1456,12 @@ function createGetSpacePagesTool(getAuth, getAuthHeader2, logger19) {
         lastModified: page.version?.when || ""
       }));
       if (pages.length === 0) {
-        logger19.warn("get-space-pages returned NO PAGES - this is a valid outcome, agent should not retry", {
+        logger20.warn("get-space-pages returned NO PAGES - this is a valid outcome, agent should not retry", {
           space_key,
           limit
         });
       } else {
-        logger19.info("get-space-pages result", {
+        logger20.info("get-space-pages result", {
           space_key,
           pageCount: pages.length,
           titles: pages.map((p) => p.title).slice(0, 3)
@@ -1474,7 +1475,7 @@ function createGetSpacePagesTool(getAuth, getAuthHeader2, logger19) {
         pages
       });
     } catch (error) {
-      logger19.error("get-space-pages error", {
+      logger20.error("get-space-pages error", {
         space_key,
         error: error.response?.data?.message || error.message,
         status: error.response?.status
@@ -1486,14 +1487,14 @@ function createGetSpacePagesTool(getAuth, getAuthHeader2, logger19) {
     }
   }).build();
 }
-function createCreateConfluencePageTool(getAuth, getAuthHeader2, logger19) {
+function createCreateConfluencePageTool(getAuth, getAuthHeader2, logger20) {
   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 }) => {
-    logger19.info("create-confluence-page called", { space_key, title, hasParent: !!parent_page_id });
+    logger20.info("create-confluence-page called", { space_key, title, hasParent: !!parent_page_id });
     try {
       const { ATLASSIAN_SITE_URL } = getAuth();
       const pageData = {
@@ -1520,7 +1521,7 @@ function createCreateConfluencePageTool(getAuth, getAuthHeader2, logger19) {
           }
         }
       );
-      logger19.info("create-confluence-page result", {
+      logger20.info("create-confluence-page result", {
         page_id: response.data.id,
         title: response.data.title,
         space: space_key
@@ -1536,7 +1537,7 @@ function createCreateConfluencePageTool(getAuth, getAuthHeader2, logger19) {
         }
       });
     } catch (error) {
-      logger19.error("create-confluence-page error", {
+      logger20.error("create-confluence-page error", {
         space_key,
         title,
         error: error.response?.data?.message || error.message,
@@ -1549,13 +1550,13 @@ function createCreateConfluencePageTool(getAuth, getAuthHeader2, logger19) {
     }
   }).build();
 }
-function createUpdateConfluencePageTool(getAuth, getAuthHeader2, logger19) {
+function createUpdateConfluencePageTool(getAuth, getAuthHeader2, logger20) {
   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 }) => {
-    logger19.info("update-confluence-page called", { page_id, title });
+    logger20.info("update-confluence-page called", { page_id, title });
     try {
       const { ATLASSIAN_SITE_URL } = getAuth();
       const getResponse = await axios11__default.default.get(
@@ -1588,7 +1589,7 @@ function createUpdateConfluencePageTool(getAuth, getAuthHeader2, logger19) {
           }
         }
       );
-      logger19.info("update-confluence-page result", {
+      logger20.info("update-confluence-page result", {
         page_id,
         title: updateResponse.data.title,
         previousVersion: currentVersion,
@@ -1605,7 +1606,7 @@ function createUpdateConfluencePageTool(getAuth, getAuthHeader2, logger19) {
         }
       });
     } catch (error) {
-      logger19.error("update-confluence-page error", {
+      logger20.error("update-confluence-page error", {
         page_id,
         title,
         error: error.response?.data?.message || error.message,
@@ -1618,12 +1619,12 @@ function createUpdateConfluencePageTool(getAuth, getAuthHeader2, logger19) {
     }
   }).build();
 }
-function createArchiveConfluencePageTool(getAuth, getAuthHeader2, logger19) {
+function createArchiveConfluencePageTool(getAuth, getAuthHeader2, logger20) {
   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 }) => {
-    logger19.info("archive-confluence-page called", {
+    logger20.info("archive-confluence-page called", {
       page_id,
       ...reason ? { reason } : {}
     });
@@ -1657,7 +1658,7 @@ function createArchiveConfluencePageTool(getAuth, getAuthHeader2, logger19) {
           }
         }
       );
-      logger19.info("archive-confluence-page result", {
+      logger20.info("archive-confluence-page result", {
         page_id,
         title: pageData.title,
         previousVersion: currentVersion,
@@ -1675,7 +1676,7 @@ function createArchiveConfluencePageTool(getAuth, getAuthHeader2, logger19) {
         }
       });
     } catch (error) {
-      logger19.error("archive-confluence-page error", {
+      logger20.error("archive-confluence-page error", {
         page_id,
         error: error.response?.data?.message || error.message,
         status: error.response?.status
@@ -4185,11 +4186,41 @@ function getInstallationInstructions(vendor) {
 
 // src/data/relational/utils/sql-sanitizer.ts
 var DANGEROUS_SQL_STATEMENT_PATTERN = /^(create|drop|truncate|alter)\b/i;
+var TRANSACTION_CONTROL_STATEMENT_PATTERN = /^(begin|start\s+transaction|commit|end|abort|rollback|prepare\s+transaction|savepoint|release(?:\s+savepoint)?|set\s+(?:(?:local|session|global)\s+)?(?:characteristics\s+as\s+)?transaction)\b/i;
+var AUTOCOMMIT_STATEMENT_PATTERN = /^set\s+(?:(?:session|local|global)\s+|@@(?:(?:session|local|global)\.)?)?autocommit\b/i;
+var MYSQL_IMPLICIT_COMMIT_STATEMENT_PATTERN = /^(?:(?:alter|create|drop)\s+|truncate\s+table\b|rename\s+(?:table|user)\b|(?:lock|unlock)\s+tables\b|(?:grant|revoke)\b|set\s+password\b|(?:analyze|check|optimize|repair)\s+table\b|cache\s+index\b|load\s+(?:data|xml|index\s+into\s+cache)\b|flush\b|reset\b|(?:start|stop)\s+(?:replica|slave)\b|change\s+(?:replication\s+source|master)\s+to\b|(?:install|uninstall)\s+(?:plugin|component)\b)/i;
+var MYSQL_INDIRECT_EXECUTION_STATEMENT_PATTERN = /^(?:call\b|prepare\b|execute(?:\s+immediate)?\b|deallocate\s+prepare\b)/i;
+var MANAGED_TRANSACTION_CONTROL_ERROR_MESSAGE = "Transaction control statements are not allowed in scoped Tools.";
 var NUMBERED_PLACEHOLDER_PATTERN = /\$(\d+)/;
 var QUESTION_PLACEHOLDER_PATTERN = /\?/;
 var NAMED_PLACEHOLDER_PATTERN = /(?<!:):[a-zA-Z_][a-zA-Z0-9_]*/;
 var PARAMETER_REQUIRED_PATTERN = /^(insert|update|delete)\b/i;
 var MUTATION_PATTERN = /\b(insert|update|delete)\b/i;
+function sqlStripOptions(vendor, rejectExecutableComments = false, backslashEscapes = vendor === "mysql") {
+  return {
+    backslashEscapes,
+    hashComments: vendor === "mysql",
+    mysqlDashDashComments: vendor === "mysql",
+    nestedBlockComments: vendor === "postgresql",
+    postgresEscapeStrings: vendor === "postgresql",
+    rejectExecutableComments
+  };
+}
+function isPostgresEscapeStringQuote(sqlString, quoteIndex) {
+  const prefixIndex = quoteIndex - 1;
+  if (prefixIndex < 0 || !/[eE]/.test(sqlString[prefixIndex])) {
+    return false;
+  }
+  const beforePrefix = prefixIndex - 1;
+  return beforePrefix < 0 || !/[A-Za-z0-9_$]/.test(sqlString[beforePrefix]);
+}
+function isWhitespaceOrControlCharacter(value) {
+  if (!value) {
+    return false;
+  }
+  const codePoint = value.charCodeAt(0);
+  return /\s/u.test(value) || codePoint < 32 || codePoint === 127;
+}
 function stripSqlCommentsAndStrings(sqlString, options) {
   const { backslashEscapes } = options;
   let result = "";
@@ -4198,7 +4229,17 @@ function stripSqlCommentsAndStrings(sqlString, options) {
   while (i < len) {
     const ch = sqlString[i];
     const next = i + 1 < len ? sqlString[i + 1] : "";
-    if (ch === "-" && next === "-") {
+    if (options.hashComments && ch === "#") {
+      result += " ";
+      i += 1;
+      while (i < len && sqlString[i] !== "\n") {
+        i += 1;
+      }
+      continue;
+    }
+    const afterDoubleDash = i + 2 < len ? sqlString[i + 2] : "";
+    const doubleDashStartsComment = ch === "-" && next === "-" && (!options.mysqlDashDashComments || isWhitespaceOrControlCharacter(afterDoubleDash));
+    if (doubleDashStartsComment) {
       result += " ";
       i += 2;
       while (i < len && sqlString[i] !== "\n") {
@@ -4207,12 +4248,23 @@ function stripSqlCommentsAndStrings(sqlString, options) {
       continue;
     }
     if (ch === "/" && next === "*") {
+      const executableComment = sqlString[i + 2] === "!" || sqlString[i + 2]?.toLowerCase() === "m" && sqlString[i + 3] === "!";
+      if (options.rejectExecutableComments && executableComment) {
+        throw new Error(MANAGED_TRANSACTION_CONTROL_ERROR_MESSAGE);
+      }
       result += " ";
       i += 2;
-      while (i < len) {
+      let depth = 1;
+      while (i < len && depth > 0) {
+        if (options.nestedBlockComments && sqlString[i] === "/" && i + 1 < len && sqlString[i + 1] === "*") {
+          depth += 1;
+          i += 2;
+          continue;
+        }
         if (sqlString[i] === "*" && i + 1 < len && sqlString[i + 1] === "/") {
+          depth -= 1;
           i += 2;
-          break;
+          continue;
         }
         i += 1;
       }
@@ -4220,9 +4272,10 @@ function stripSqlCommentsAndStrings(sqlString, options) {
     }
     if (ch === "'") {
       result += "''";
+      const singleQuoteBackslashEscapes = backslashEscapes || options.postgresEscapeStrings && isPostgresEscapeStringQuote(sqlString, i);
       i += 1;
       while (i < len) {
-        if (backslashEscapes && sqlString[i] === "\\" && i + 1 < len) {
+        if (singleQuoteBackslashEscapes && sqlString[i] === "\\" && i + 1 < len) {
           i += 2;
           continue;
         }
@@ -4280,6 +4333,20 @@ function stripSqlCommentsAndStrings(sqlString, options) {
   }
   return result;
 }
+function strippedSqlVariants(sqlString, vendor, rejectExecutableComments = false, analyzeMysqlNoBackslashEscapes = false) {
+  const variants = [
+    stripSqlCommentsAndStrings(sqlString, sqlStripOptions(vendor, rejectExecutableComments))
+  ];
+  if (vendor === "mysql" && analyzeMysqlNoBackslashEscapes) {
+    variants.push(
+      stripSqlCommentsAndStrings(
+        sqlString,
+        sqlStripOptions(vendor, rejectExecutableComments, false)
+      )
+    );
+  }
+  return [...new Set(variants)];
+}
 function nextNonWhitespaceChar(sqlString, index) {
   for (let i = index; i < sqlString.length; i += 1) {
     if (!/\s/.test(sqlString[i])) {
@@ -4329,6 +4396,16 @@ function hasParameters(params) {
   }
   return Object.keys(params).length > 0;
 }
+function sqlStatements(sqlString, vendor, rejectExecutableComments = false, analyzeMysqlNoBackslashEscapes = false) {
+  return strippedSqlVariants(
+    sqlString,
+    vendor,
+    rejectExecutableComments,
+    analyzeMysqlNoBackslashEscapes
+  ).flatMap(
+    (normalized) => normalized.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0)
+  );
+}
 function validateSqlString(sqlString, vendor) {
   if (typeof sqlString !== "string" || sqlString.trim().length === 0) {
     throw new Error("SQL query must not be empty");
@@ -4336,18 +4413,20 @@ function validateSqlString(sqlString, vendor) {
   if (sqlString.includes("\0")) {
     throw new Error("SQL query contains null bytes");
   }
-  const normalizedForSafetyCheck = stripSqlCommentsAndStrings(sqlString, {
-    backslashEscapes: vendor === "mysql"
-  });
-  const statements = normalizedForSafetyCheck.split(";").map((statement) => statement.trim()).filter((statement) => statement.length > 0);
+  const statements = sqlStatements(sqlString, vendor);
   if (statements.some((statement) => DANGEROUS_SQL_STATEMENT_PATTERN.test(statement))) {
     throw new Error("Detected dangerous SQL operation. CREATE, DROP, TRUNCATE, and ALTER are not allowed.");
   }
 }
+function validateManagedTransactionSql(sqlString, vendor) {
+  if (sqlStatements(sqlString, vendor, true, true).some(
+    (statement) => TRANSACTION_CONTROL_STATEMENT_PATTERN.test(statement) || AUTOCOMMIT_STATEMENT_PATTERN.test(statement) || vendor === "mysql" && (MYSQL_IMPLICIT_COMMIT_STATEMENT_PATTERN.test(statement) || MYSQL_INDIRECT_EXECUTION_STATEMENT_PATTERN.test(statement))
+  )) {
+    throw new Error(MANAGED_TRANSACTION_CONTROL_ERROR_MESSAGE);
+  }
+}
 function enforceParameterizedQueryUsage(sqlString, params, vendor) {
-  const normalizedForAnalysis = stripSqlCommentsAndStrings(sqlString, {
-    backslashEscapes: vendor === "mysql"
-  });
+  const normalizedForAnalysis = stripSqlCommentsAndStrings(sqlString, sqlStripOptions(vendor));
   const normalized = normalizedForAnalysis.trim().toLowerCase();
   const hasPlaceholders = hasSqlPlaceholders(normalizedForAnalysis, vendor);
   const hasParams = hasParameters(params);
@@ -4406,19 +4485,19 @@ var ConnectionState = /* @__PURE__ */ ((ConnectionState2) => {
   ConnectionState2["ERROR"] = "error";
   return ConnectionState2;
 })(ConnectionState || {});
-function cancelPendingReconnection(timer, logger19, vendor, message) {
+function cancelPendingReconnection(timer, logger20, vendor, message) {
   if (!timer) {
     return null;
   }
-  logger19.debug(message, { vendor });
+  logger20.debug(message, { vendor });
   clearTimeout(timer);
   return null;
 }
-async function waitForInFlightConnection(promise, logger19, vendor, phase) {
+async function waitForInFlightConnection(promise, logger20, vendor, phase) {
   if (!promise) {
     return null;
   }
-  logger19.debug(`Waiting for in-flight connection attempt to complete before ${phase}`, {
+  logger20.debug(`Waiting for in-flight connection attempt to complete before ${phase}`, {
     vendor
   });
   try {
@@ -4435,9 +4514,9 @@ function shutdownClient(vendor, client) {
     client.close();
   }
 }
-function scheduleReconnection(context, logger19) {
+function scheduleReconnection(context, logger20) {
   if (context.reconnectionConfig.maxAttempts > 0 && context.reconnectionAttempts >= context.reconnectionConfig.maxAttempts) {
-    logger19.error("Max reconnection attempts reached", {
+    logger20.error("Max reconnection attempts reached", {
       vendor: context.vendor,
       attempts: context.reconnectionAttempts,
       maxAttempts: context.reconnectionConfig.maxAttempts
@@ -4451,7 +4530,7 @@ function scheduleReconnection(context, logger19) {
   const nextAttempt = context.reconnectionAttempts + 1;
   context.setReconnectionAttempts(nextAttempt);
   context.setState("reconnecting" /* RECONNECTING */);
-  logger19.info("Scheduling reconnection attempt", {
+  logger20.info("Scheduling reconnection attempt", {
     vendor: context.vendor,
     attempt: nextAttempt,
     maxAttempts: context.reconnectionConfig.maxAttempts,
@@ -4465,7 +4544,7 @@ function scheduleReconnection(context, logger19) {
   const timer = setTimeout(async () => {
     context.setReconnectionTimer(null);
     try {
-      logger19.info("Attempting reconnection", {
+      logger20.info("Attempting reconnection", {
         vendor: context.vendor,
         attempt: nextAttempt
       });
@@ -4475,7 +4554,7 @@ function scheduleReconnection(context, logger19) {
       context.setConnectPromise(promise);
       await promise;
     } catch (error) {
-      logger19.error("Reconnection attempt failed", {
+      logger20.error("Reconnection attempt failed", {
         vendor: context.vendor,
         attempt: nextAttempt,
         error: error instanceof Error ? error.message : String(error)
@@ -4486,17 +4565,17 @@ function scheduleReconnection(context, logger19) {
 }
 
 // src/data/relational/connection/connection-cleanup.ts
-async function cleanupConnectionResources(vendor, client, clearConnection, logger19) {
+async function cleanupConnectionResources(vendor, client, clearConnection, logger20) {
   if (!client) {
     return;
   }
-  logger19.debug("Cleaning up cancelled connection", {
+  logger20.debug("Cleaning up cancelled connection", {
     vendor
   });
   try {
     await shutdownClient(vendor, client);
   } catch (error) {
-    logger19.debug("Error during cancelled connection cleanup", {
+    logger20.debug("Error during cancelled connection cleanup", {
       vendor,
       error: error instanceof Error ? error.message : String(error)
     });
@@ -4504,10 +4583,10 @@ async function cleanupConnectionResources(vendor, client, clearConnection, logge
     clearConnection();
   }
 }
-async function closeManagedConnection(runtime, logger19) {
+async function closeManagedConnection(runtime, logger20) {
   const client = runtime.getClient();
   if (client) {
-    logger19.info("Closing database connection", {
+    logger20.info("Closing database connection", {
       vendor: runtime.vendor,
       state: runtime.getState()
     });
@@ -4515,12 +4594,12 @@ async function closeManagedConnection(runtime, logger19) {
       await shutdownClient(runtime.vendor, client);
       runtime.setState("disconnected" /* DISCONNECTED */);
       runtime.emitDisconnected();
-      logger19.debug("Database connection closed successfully", {
+      logger20.debug("Database connection closed successfully", {
         vendor: runtime.vendor,
         state: runtime.getState()
       });
     } catch (error) {
-      logger19.error("Error closing database connection", {
+      logger20.error("Error closing database connection", {
         vendor: runtime.vendor,
         error: error instanceof Error ? error.message : String(error),
         state: runtime.getState()
@@ -4693,11 +4772,11 @@ async function initializeSQLiteConnection(connection) {
 }
 
 // src/data/relational/connection/connection-initialization.ts
-async function initializeManagedConnection(runtime, logger19) {
+async function initializeManagedConnection(runtime, logger20) {
   const startTime = Date.now();
   const currentGeneration = runtime.getConnectionGeneration();
   if (runtime.getState() === "connected" /* CONNECTED */ && runtime.getClient()) {
-    logger19.warn("Re-initializing an already connected manager; emitting disconnected before cleanup", {
+    logger20.warn("Re-initializing an already connected manager; emitting disconnected before cleanup", {
       vendor: runtime.vendor
     });
     runtime.setState("disconnected" /* DISCONNECTED */);
@@ -4709,11 +4788,11 @@ async function initializeManagedConnection(runtime, logger19) {
         runtime.setClient(null);
         runtime.setDb(null);
       },
-      logger19
+      logger20
     );
   }
   runtime.setState("connecting" /* CONNECTING */);
-  logger19.info("Initializing database connection", {
+  logger20.info("Initializing database connection", {
     vendor: runtime.vendor,
     connectionType: typeof runtime.config.connection,
     state: runtime.getState()
@@ -4723,7 +4802,7 @@ async function initializeManagedConnection(runtime, logger19) {
     runtime.setClient(initialized.client);
     runtime.setDb(initialized.db);
     if (currentGeneration !== runtime.getConnectionGeneration()) {
-      logger19.debug("Connection cancelled during initialization", {
+      logger20.debug("Connection cancelled during initialization", {
         vendor: runtime.vendor,
         currentGeneration,
         newGeneration: runtime.getConnectionGeneration()
@@ -4735,18 +4814,18 @@ async function initializeManagedConnection(runtime, logger19) {
           runtime.setClient(null);
           runtime.setDb(null);
         },
-        logger19
+        logger20
       );
       runtime.setState("disconnected" /* DISCONNECTED */);
       throw new Error("Connection cancelled during initialization");
     }
-    logger19.debug("Validating connection health", { vendor: runtime.vendor });
+    logger20.debug("Validating connection health", { vendor: runtime.vendor });
     const healthy = await runtime.isHealthy();
     if (!healthy) {
       throw new Error(`Failed to establish healthy connection to ${runtime.vendor} database`);
     }
     if (currentGeneration !== runtime.getConnectionGeneration()) {
-      logger19.debug("Connection cancelled during health check", {
+      logger20.debug("Connection cancelled during health check", {
         vendor: runtime.vendor,
         currentGeneration,
         newGeneration: runtime.getConnectionGeneration()
@@ -4758,7 +4837,7 @@ async function initializeManagedConnection(runtime, logger19) {
           runtime.setClient(null);
           runtime.setDb(null);
         },
-        logger19
+        logger20
       );
       runtime.setState("disconnected" /* DISCONNECTED */);
       throw new Error("Connection cancelled during health check");
@@ -4766,7 +4845,7 @@ async function initializeManagedConnection(runtime, logger19) {
     runtime.setState("connected" /* CONNECTED */);
     runtime.emitConnected();
     runtime.resetReconnectionAttempts();
-    logger19.info("Database connection initialized successfully", {
+    logger20.info("Database connection initialized successfully", {
       vendor: runtime.vendor,
       duration: Date.now() - startTime,
       state: runtime.getState()
@@ -4787,7 +4866,7 @@ async function initializeManagedConnection(runtime, logger19) {
       if (runtime.errorListenerCount() > 0) {
         runtime.emitError(normalizedError);
       }
-      logger19.error(errorMessage, {
+      logger20.error(errorMessage, {
         vendor: runtime.vendor,
         error: normalizedError.message,
         duration: Date.now() - startTime,
@@ -4800,13 +4879,13 @@ async function initializeManagedConnection(runtime, logger19) {
           runtime.setClient(null);
           runtime.setDb(null);
         },
-        logger19
+        logger20
       );
       if (runtime.getReconnectionConfig().enabled && currentGeneration === runtime.getConnectionGeneration()) {
         runtime.scheduleReconnection();
       }
     } else {
-      logger19.debug("Connection initialization cancelled", {
+      logger20.debug("Connection initialization cancelled", {
         vendor: runtime.vendor,
         duration: Date.now() - startTime,
         state: runtime.getState()
@@ -4824,17 +4903,17 @@ function isSqliteNonQueryError(error) {
   const hasNonQueryMessage = error.message.includes("does not return data");
   return isSqliteOrTypeError && hasNonQueryMessage;
 }
-async function checkConnectionHealth(args, logger19) {
+async function checkConnectionHealth(args, logger20) {
   if (!args.db || !args.client) {
-    logger19.debug("Health check failed: connection not initialized", { vendor: args.vendor });
+    logger20.debug("Health check failed: connection not initialized", { vendor: args.vendor });
     return false;
   }
   try {
     await args.execute(drizzleOrm.sql`SELECT 1`);
-    logger19.debug("Health check passed", { vendor: args.vendor });
+    logger20.debug("Health check passed", { vendor: args.vendor });
     return true;
   } catch (error) {
-    logger19.debug("Health check failed", {
+    logger20.debug("Health check failed", {
       vendor: args.vendor,
       error: error instanceof Error ? error.message : String(error)
     });
@@ -4877,8 +4956,8 @@ function getConnectionPoolMetrics(vendor, client) {
 }
 
 // src/data/relational/connection/query-execution.ts
-async function executeQuery(context, query, logger19) {
-  logger19.debug("Executing SQL query", {
+async function executeQuery(context, query, logger20) {
+  logger20.debug("Executing SQL query", {
     vendor: context.vendor
   });
   if (context.vendor === "sqlite") {
@@ -4929,7 +5008,7 @@ async function executeInDedicatedConnection(context, callback) {
     try {
       const { drizzle } = await import('drizzle-orm/node-postgres');
       const sessionDb = drizzle({ client: poolClient });
-      return await callback((query) => sessionDb.execute(query));
+      return await callback(async (query) => sessionDb.execute(query));
     } finally {
       poolClient.release();
     }
@@ -5254,7 +5333,7 @@ function buildParameterizedQuery(sqlString, params) {
     return sqlChunks.length > 0 ? drizzleOrm.sql.join(sqlChunks, drizzleOrm.sql.raw("")) : drizzleOrm.sql.raw(sqlString);
   }
 }
-async function executeQuery2(manager, input, context) {
+async function executeQuery2(executor, input, context) {
   const startTime = Date.now();
   logger8.debug("Executing query", {
     vendor: input.vendor,
@@ -5263,10 +5342,13 @@ async function executeQuery2(manager, input, context) {
   });
   try {
     validateSqlString(input.sql, input.vendor);
+    if (context?.transaction) {
+      validateManagedTransactionSql(input.sql, input.vendor);
+    }
     enforceParameterizedQueryUsage(input.sql, input.params, input.vendor);
     const parameterizedQuery = buildParameterizedQuery(input.sql, input.params);
-    const executor = context?.transaction ?? manager;
-    const result = await executor.execute(parameterizedQuery);
+    const session = context?.transaction ?? executor;
+    const result = await session.execute(parameterizedQuery);
     const executionTime = Date.now() - startTime;
     const rows = Array.isArray(result) ? result : result.rows || [];
     const rowCount = result.rowCount || result.affectedRows || rows.length;
@@ -5289,7 +5371,7 @@ async function executeQuery2(manager, input, context) {
     });
     if (error instanceof Error) {
       const message = error.message;
-      if (message.includes("Missing parameter") || message.includes("Missing parameters") || message.includes("Parameters provided but no placeholders") || message.includes("Mixed parameter styles") || message.includes("SQL query must not be empty") || message.includes("SQL query contains null bytes") || message.includes("Detected dangerous SQL operation") || message.includes("Parameters are required for INSERT/UPDATE/DELETE queries")) {
+      if (message.includes("Missing parameter") || message.includes("Missing parameters") || message.includes("Parameters provided but no placeholders") || message.includes("Mixed parameter styles") || message.includes("SQL query must not be empty") || message.includes("SQL query contains null bytes") || message.includes("Detected dangerous SQL operation") || message === MANAGED_TRANSACTION_CONTROL_ERROR_MESSAGE || message.includes("Parameters are required for INSERT/UPDATE/DELETE queries")) {
         throw error;
       }
     }
@@ -6146,6 +6228,8 @@ var ManagedTransaction = class {
   executeQuery;
   completed = false;
   cancelledReason = null;
+  inFlight = /* @__PURE__ */ new Set();
+  inFlightFailure = null;
   savepointCounter = 0;
   sqliteReadUncommittedOriginal = null;
   shouldRestoreSqliteReadUncommitted = false;
@@ -6158,14 +6242,36 @@ var ManagedTransaction = class {
   isActive() {
     return !this.completed;
   }
-  async execute(query) {
+  execute(query) {
+    try {
+      return this.executeScopedQuery(query);
+    } catch (error) {
+      return Promise.reject(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  async settle() {
+    while (this.inFlight.size > 0) {
+      await Promise.allSettled([...this.inFlight]);
+    }
+    return this.inFlightFailure;
+  }
+  executeScopedQuery(query) {
     if (this.cancelledReason) {
       throw new Error(this.cancelledReason);
     }
     if (!this.isActive()) {
       throw new Error("Transaction is no longer active");
     }
-    return this.executeQuery(query);
+    const execution = this.executeQuery(query);
+    this.inFlight.add(execution);
+    void execution.then(
+      () => this.inFlight.delete(execution),
+      (reason) => {
+        this.inFlightFailure ??= { reason };
+        this.inFlight.delete(execution);
+      }
+    );
+    return execution;
   }
   async begin() {
     if (this.vendor === "mysql") {
@@ -6202,7 +6308,7 @@ var ManagedTransaction = class {
       throw new Error("Transaction is no longer active");
     }
     const savepointName = this.normalizeSavepointName(name ?? `sp_${++this.savepointCounter}`);
-    await this.executeQuery(drizzleOrm.sql.raw(`SAVEPOINT ${savepointName}`));
+    await this.executeScopedQuery(drizzleOrm.sql.raw(`SAVEPOINT ${savepointName}`));
     return savepointName;
   }
   async rollbackToSavepoint(name) {
@@ -6210,14 +6316,14 @@ var ManagedTransaction = class {
       throw new Error("Transaction is no longer active");
     }
     const savepointName = this.normalizeSavepointName(name);
-    await this.executeQuery(drizzleOrm.sql.raw(`ROLLBACK TO SAVEPOINT ${savepointName}`));
+    await this.executeScopedQuery(drizzleOrm.sql.raw(`ROLLBACK TO SAVEPOINT ${savepointName}`));
   }
   async releaseSavepoint(name) {
     if (!this.isActive()) {
       throw new Error("Transaction is no longer active");
     }
     const savepointName = this.normalizeSavepointName(name);
-    await this.executeQuery(drizzleOrm.sql.raw(`RELEASE SAVEPOINT ${savepointName}`));
+    await this.executeScopedQuery(drizzleOrm.sql.raw(`RELEASE SAVEPOINT ${savepointName}`));
   }
   async withSavepoint(operation, name) {
     const savepointName = await this.createSavepoint(name);
@@ -6316,17 +6422,24 @@ async function withTransaction(manager, operation, options) {
       executeQuery: executeQuery3,
       options: resolvedOptions
     });
-    await transaction.begin();
+    let timedOut = false;
     try {
+      await transaction.begin();
       const result = await withTransactionTimeout(
         operation(transaction),
         resolvedOptions.timeoutMs,
         () => {
           if (resolvedOptions.timeoutMs) {
+            timedOut = true;
             transaction.cancel(`Transaction timed out after ${resolvedOptions.timeoutMs}ms`);
           }
         }
       );
+      transaction.cancel("Transaction is no longer active");
+      const inFlightFailure = await transaction.settle();
+      if (inFlightFailure) {
+        throw inFlightFailure.reason;
+      }
       if (transaction.isActive()) {
         await transaction.commit();
       }
@@ -6337,6 +6450,10 @@ async function withTransaction(manager, operation, options) {
       });
       return result;
     } catch (error) {
+      if (!timedOut) {
+        transaction.cancel(error instanceof Error ? error.message : "Transaction failed");
+      }
+      await transaction.settle();
       if (transaction.isActive()) {
         try {
           await transaction.rollback();
@@ -6841,16 +6958,33 @@ async function inspectSQLite(runQueryRows) {
 // src/data/relational/schema/schema-inspector.ts
 var logger11 = core.createLogger("agentforge:tools:data:relational:schema-inspector");
 var DEFAULT_CACHE_TTL_MS = 6e4;
-var schemaCache = /* @__PURE__ */ new Map();
-var SchemaInspector = class _SchemaInspector {
-  constructor(manager, vendor, config) {
-    this.manager = manager;
+var SchemaCache = class {
+  entries = /* @__PURE__ */ new Map();
+  get(cacheKey) {
+    return this.entries.get(cacheKey);
+  }
+  set(cacheKey, entry) {
+    this.entries.set(cacheKey, entry);
+  }
+  delete(cacheKey) {
+    this.entries.delete(cacheKey);
+  }
+  clear() {
+    this.entries.clear();
+  }
+};
+var schemaCache = new SchemaCache();
+var SchemaInspector = class {
+  constructor(executor, vendor, config) {
+    this.executor = executor;
     this.vendor = vendor;
     this.cacheTtlMs = config?.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS;
     this.cacheKey = config?.cacheKey;
+    this.cache = config?.cache ?? schemaCache;
   }
   cacheTtlMs;
   cacheKey;
+  cache;
   static clearCache(cacheKey) {
     if (cacheKey) {
       schemaCache.delete(cacheKey);
@@ -6859,21 +6993,25 @@ var SchemaInspector = class _SchemaInspector {
     schemaCache.clear();
   }
   invalidateCache() {
-    _SchemaInspector.clearCache(this.cacheKey);
+    if (this.cacheKey) {
+      this.cache.delete(this.cacheKey);
+      return;
+    }
+    this.cache.clear();
   }
   async inspect(options) {
     const tableFilters = validateTableFilters(options?.tables);
     const bypassCache = options?.bypassCache ?? false;
-    if (!bypassCache && this.cacheKey) {
-      const cached = schemaCache.get(this.cacheKey);
+    if (!bypassCache && this.cacheKey && this.cacheTtlMs > 0) {
+      const cached = this.cache.get(this.cacheKey);
       if (cached && cached.expiresAt > Date.now()) {
         logger11.debug("Schema cache hit", { vendor: this.vendor });
         return filterSchemaTables(cloneSchema(cached.schema), tableFilters);
       }
     }
     const schema = await this.inspectFromDatabase();
-    if (this.cacheKey && this.cacheTtlMs > 0) {
-      schemaCache.set(this.cacheKey, {
+    if (!bypassCache && this.cacheKey && this.cacheTtlMs > 0) {
+      this.cache.set(this.cacheKey, {
         schema: cloneSchema(schema),
         expiresAt: Date.now() + this.cacheTtlMs
       });
@@ -6905,7 +7043,7 @@ var SchemaInspector = class _SchemaInspector {
     }
   }
   async runQueryRows(query) {
-    const result = await executeQuery2(this.manager, {
+    const result = await executeQuery2(this.executor, {
       sql: query,
       vendor: this.vendor
     });
@@ -7364,95 +7502,29 @@ function sortedReplacer(_key, value) {
   }
   return value;
 }
-var relationalQuerySchema = zod.z.object({
-  sql: zod.z.string().describe("SQL query string to execute"),
-  params: zod.z.union([
-    zod.z.array(zod.z.unknown()).describe("Positional parameters (e.g., [value1, value2])"),
-    zod.z.record(zod.z.string(), zod.z.unknown()).describe('Named parameters (e.g., { name: "John", age: 30 })')
-  ]).optional().describe("Query parameters for parameter binding (prevents SQL injection)"),
-  vendor: zod.z.enum(["postgresql", "mysql", "sqlite"]).describe("Database vendor"),
-  connectionString: zod.z.string().min(1, "Database connection string is required").describe("Database connection string used to create a new connection")
-});
-var relationalQuery = core.toolBuilder().name("relational-query").displayName("Relational Query").description("Execute raw SQL queries against relational databases (PostgreSQL, MySQL, SQLite) with parameter binding to prevent SQL injection").category(core.ToolCategory.DATABASE).tags(["database", "sql", "query", "postgresql", "mysql", "sqlite"]).schema(relationalQuerySchema).example({
-  description: "SELECT query with positional parameters",
-  input: {
-    sql: "SELECT * FROM users WHERE id = $1",
-    params: [42],
-    vendor: "postgresql",
-    connectionString: "postgresql://user:pass@localhost:5432/mydb"
-  }
-}).example({
-  description: "INSERT query with named parameters",
-  input: {
-    sql: "INSERT INTO users (name, email) VALUES (:name, :email)",
-    params: { name: "John Doe", email: "john@example.com" },
-    vendor: "postgresql",
-    connectionString: "postgresql://user:pass@localhost:5432/mydb"
-  }
-}).example({
-  description: "UPDATE query with positional parameters",
-  input: {
-    sql: "UPDATE users SET status = ? WHERE id = ?",
-    params: ["active", 42],
-    vendor: "mysql",
-    connectionString: "mysql://user:pass@localhost:3306/mydb"
-  }
-}).usageNotes("Always use parameter binding (params) instead of string concatenation to prevent SQL injection. Supports positional ($1, ?) and named (:name) parameters.").limitation("Requires database-specific driver as peer dependency (pg, mysql2, or better-sqlite3)").limitation("Connection string must be valid for the specified vendor").limitation("Large result sets may impact performance").limitation("Placeholder characters ($n, ?, :name) inside SQL string literals are not supported. Use parameter binding for all dynamic values instead of embedding them in string literals").implement(async (input) => {
-  const manager = new ConnectionManager({
-    vendor: input.vendor,
-    connection: input.connectionString || ""
-  });
-  try {
-    await manager.initialize();
-    const result = await executeQuery2(manager, {
-      sql: input.sql,
-      params: input.params,
-      vendor: input.vendor
-    });
-    return {
-      success: true,
-      rows: result.rows,
-      rowCount: result.rowCount,
-      executionTime: result.executionTime
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Unknown error occurred",
-      rows: [],
-      rowCount: 0
-    };
-  } finally {
-    await manager.close();
-  }
-}).build();
-var whereOperatorSchema = zod.z.enum([
+
+// src/data/relational/connection-failure-messages.ts
+var QUERY_CONNECTION_FAILURE = "Failed to connect to the configured database.";
+var SELECT_CONNECTION_FAILURE = "Failed to execute SELECT query. Please verify the configured database connection.";
+var INSERT_CONNECTION_FAILURE = "Failed to execute INSERT query. Please verify the configured database connection.";
+var UPDATE_CONNECTION_FAILURE = "Failed to execute UPDATE query. Please verify the configured database connection.";
+var DELETE_CONNECTION_FAILURE = "Failed to execute DELETE query. Please verify the configured database connection.";
+var deleteWhereOperatorSchema = zod.z.enum([
   "eq",
-  // equals
   "ne",
-  // not equals
   "gt",
-  // greater than
   "lt",
-  // less than
   "gte",
-  // greater than or equal
   "lte",
-  // less than or equal
   "like",
-  // LIKE pattern matching
   "in",
-  // IN array
   "notIn",
-  // NOT IN array
   "isNull",
-  // IS NULL
   "isNotNull"
-  // IS NOT NULL
 ]);
-var whereConditionSchema = zod.z.object({
+var deleteWhereConditionSchema = zod.z.object({
   column: zod.z.string().min(1, "Column name must not be empty").describe("Column name to filter on"),
-  operator: whereOperatorSchema.describe("Comparison operator"),
+  operator: deleteWhereOperatorSchema.describe("Comparison operator"),
   value: zod.z.union([
     zod.z.string(),
     zod.z.number(),
@@ -7460,10 +7532,10 @@ var whereConditionSchema = zod.z.object({
     zod.z.array(zod.z.union([zod.z.string(), zod.z.number()])),
     zod.z.null()
   ]).optional().describe("Value to compare against (not required for isNull/isNotNull)")
-}).superRefine((val, ctx) => {
-  const op = val.operator;
+}).superRefine((value, ctx) => {
+  const op = value.operator;
   if (op === "isNull" || op === "isNotNull") {
-    if (val.value !== void 0) {
+    if (value.value !== void 0) {
       ctx.addIssue({
         code: zod.z.ZodIssueCode.custom,
         path: ["value"],
@@ -7472,7 +7544,7 @@ var whereConditionSchema = zod.z.object({
     }
     return;
   }
-  if (val.value === void 0) {
+  if (value.value === void 0) {
     ctx.addIssue({
       code: zod.z.ZodIssueCode.custom,
       path: ["value"],
@@ -7481,13 +7553,13 @@ var whereConditionSchema = zod.z.object({
     return;
   }
   if (op === "in" || op === "notIn") {
-    if (!Array.isArray(val.value)) {
+    if (!Array.isArray(value.value)) {
       ctx.addIssue({
         code: zod.z.ZodIssueCode.custom,
         path: ["value"],
         message: `${op === "in" ? "IN" : "NOT IN"} operator requires an array value`
       });
-    } else if (val.value.length === 0) {
+    } else if (value.value.length === 0) {
       ctx.addIssue({
         code: zod.z.ZodIssueCode.custom,
         path: ["value"],
@@ -7496,7 +7568,7 @@ var whereConditionSchema = zod.z.object({
     }
     return;
   }
-  if (val.value === null) {
+  if (value.value === null) {
     ctx.addIssue({
       code: zod.z.ZodIssueCode.custom,
       path: ["value"],
@@ -7504,7 +7576,7 @@ var whereConditionSchema = zod.z.object({
     });
     return;
   }
-  if (op === "like" && typeof val.value !== "string") {
+  if (op === "like" && typeof value.value !== "string") {
     ctx.addIssue({
       code: zod.z.ZodIssueCode.custom,
       path: ["value"],
@@ -7512,326 +7584,124 @@ var whereConditionSchema = zod.z.object({
     });
     return;
   }
-  if ((op === "gt" || op === "lt" || op === "gte" || op === "lte") && typeof val.value !== "string" && typeof val.value !== "number") {
+  if ((op === "gt" || op === "lt" || op === "gte" || op === "lte") && typeof value.value !== "string" && typeof value.value !== "number") {
     ctx.addIssue({
       code: zod.z.ZodIssueCode.custom,
       path: ["value"],
       message: `${op.toUpperCase()} operator requires a string or number value`
     });
-    return;
   }
-  if ((op === "eq" || op === "ne") && Array.isArray(val.value)) {
+});
+var deleteSoftDeleteSchema = zod.z.object({
+  column: zod.z.string().min(1, "Soft delete column must not be empty").default("deleted_at").describe("Column to write deletion timestamp/value into"),
+  value: zod.z.union([zod.z.string(), zod.z.number()]).optional().describe("Optional explicit value for the soft-delete column (defaults to ISO timestamp)")
+}).describe("Enable soft delete by updating a column instead of physically deleting rows");
+var deleteBatchOperationSchema = zod.z.object({
+  where: zod.z.array(deleteWhereConditionSchema).optional().describe("WHERE conditions (combined with AND)"),
+  allowFullTableDelete: zod.z.boolean().default(false).describe("Explicitly allow DELETE without WHERE conditions for this operation"),
+  cascade: zod.z.boolean().default(false).describe("Enable cascade-aware error messaging for this operation"),
+  softDelete: deleteSoftDeleteSchema.optional().describe("Use soft-delete semantics instead of hard DELETE for this operation")
+}).superRefine((value, ctx) => {
+  const hasWhere = (value.where?.length ?? 0) > 0;
+  if (!value.allowFullTableDelete && !hasWhere) {
     ctx.addIssue({
       code: zod.z.ZodIssueCode.custom,
-      path: ["value"],
-      message: `${op.toUpperCase()} operator requires a scalar value`
+      path: ["where"],
+      message: "WHERE conditions are required unless allowFullTableDelete is true"
     });
   }
 });
-var orderDirectionSchema = zod.z.enum(["asc", "desc"]);
-var orderBySchema = zod.z.object({
-  column: zod.z.string().min(1, "Column name must not be empty").describe("Column name to order by"),
-  direction: orderDirectionSchema.describe("Sort direction (ascending or descending)")
-});
-var streamingOptionsSchema = zod.z.object({
-  enabled: zod.z.boolean().default(true).describe("Enable chunked streaming mode for large result sets"),
-  chunkSize: zod.z.number().int().min(1).max(5e3).optional().describe("Rows fetched per chunk (default: 100)"),
-  maxRows: zod.z.number().int().positive().optional().describe("Optional cap on streamed rows"),
-  sampleSize: zod.z.number().int().min(0).max(5e3).optional().describe("Number of rows to include in the response payload"),
-  benchmark: zod.z.boolean().optional().default(false).describe("Run memory benchmark comparing regular vs streaming execution (adds two extra query executions; use side-effect-free SELECT statements)")
+var deleteBatchOptionsSchema = zod.z.object({
+  enabled: zod.z.boolean().optional().default(true).describe("Enable batched processing for operations[] payloads"),
+  batchSize: zod.z.number().int().positive().max(5e3).optional().default(100).describe("Operations per batch chunk"),
+  continueOnError: zod.z.boolean().optional().default(true).describe("Continue processing remaining chunks when one chunk fails"),
+  maxRetries: zod.z.number().int().min(0).max(5).optional().default(0).describe("Retry attempts per failed chunk"),
+  retryDelayMs: zod.z.number().int().min(0).max(6e4).optional().default(0).describe("Delay between retry attempts in milliseconds"),
+  benchmark: zod.z.boolean().optional().default(false).describe("Run synthetic benchmark metadata comparing individual vs batched execution callbacks")
 });
-var relationalSelectSchema = zod.z.object({
+var relationalDeleteSchema = zod.z.object({
   table: zod.z.string().min(1, "Table name is required").regex(
     VALID_QUALIFIED_IDENTIFIER_PATTERN,
     "Table name contains invalid characters. Only alphanumeric characters, underscores, and dots (for schema qualification) are allowed."
-  ).describe("Table name to select from (schema-qualified names supported, e.g. public.users)"),
-  columns: zod.z.array(zod.z.string().min(1, "Column name must not be empty")).min(1, "Columns array must not be empty").optional().describe("Columns to select (omit for SELECT *)"),
-  where: zod.z.array(whereConditionSchema).optional().describe("WHERE conditions (combined with AND)"),
-  orderBy: zod.z.array(orderBySchema).optional().describe("ORDER BY clauses"),
-  limit: zod.z.number().int().positive().optional().describe("Maximum number of rows to return"),
-  offset: zod.z.number().int().nonnegative().optional().describe("Number of rows to skip"),
-  streaming: streamingOptionsSchema.optional().describe("Optional streaming mode configuration"),
+  ).describe("Table name to delete from (schema-qualified names supported, e.g. public.users)"),
+  where: zod.z.array(deleteWhereConditionSchema).optional().describe("WHERE conditions (combined with AND)"),
+  allowFullTableDelete: zod.z.boolean().default(false).describe("Explicitly allow DELETE without WHERE conditions"),
+  cascade: zod.z.boolean().default(false).describe("Enable cascade-aware error messaging for foreign key constraints"),
+  softDelete: deleteSoftDeleteSchema.optional().describe("Use soft-delete semantics instead of hard DELETE"),
+  operations: zod.z.array(deleteBatchOperationSchema).min(1, "operations must contain at least one batch item").optional().describe("Batch delete operation list"),
+  batch: deleteBatchOptionsSchema.optional().describe("Optional batch execution controls for operations payloads"),
   vendor: zod.z.enum(["postgresql", "mysql", "sqlite"]).describe("Database vendor"),
   connectionString: zod.z.string().min(1, "Database connection string is required").describe("Database connection string")
+}).superRefine((value, ctx) => {
+  const hasOperations = (value.operations?.length ?? 0) > 0;
+  if (hasOperations && (value.where?.length ?? 0) > 0) {
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      path: ["where"],
+      message: "where cannot be provided when operations[] is used"
+    });
+  }
+  if (hasOperations && value.allowFullTableDelete) {
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      path: ["allowFullTableDelete"],
+      message: "allowFullTableDelete cannot be provided when operations[] is used"
+    });
+  }
+  if (hasOperations && value.cascade) {
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      path: ["cascade"],
+      message: "cascade cannot be provided when operations[] is used"
+    });
+  }
+  if (hasOperations && value.softDelete) {
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      path: ["softDelete"],
+      message: "softDelete cannot be provided when operations[] is used"
+    });
+  }
+  if (hasOperations) {
+    return;
+  }
+  const hasWhere = (value.where?.length ?? 0) > 0;
+  if (!value.allowFullTableDelete && !hasWhere) {
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      path: ["where"],
+      message: "WHERE conditions are required unless allowFullTableDelete is true"
+    });
+  }
 });
 
-// src/data/relational/tools/relational-select/query-builder.ts
-function buildSelectQuery2(input) {
-  const queryInput = {
-    table: input.table,
-    columns: input.columns,
-    where: input.where,
-    orderBy: input.orderBy,
-    limit: input.limit,
-    offset: input.offset,
-    vendor: input.vendor
-  };
-  return buildSelectQuery(queryInput);
-}
-
-// src/data/relational/tools/relational-select/error-utils.ts
-var SAFE_VALIDATION_ERROR_PATTERNS = [
+// src/data/relational/tools/relational-delete/error-utils.ts
+var SAFE_DELETE_VALIDATION_PATTERNS = [
   "must not be empty",
   "contains invalid characters",
-  "requires an array value",
-  "requires a non-empty array value",
-  "must be an integer between",
-  "must be a positive integer",
+  "WHERE conditions are required for DELETE queries",
+  "WHERE conditions are required unless allowFullTableDelete is true",
+  "value is required for this operator",
   "null is only allowed with isNull/isNotNull operators",
-  "LIKE operator requires a string value",
+  "operator requires a value",
   "operator requires a string or number value",
-  "operator requires a scalar value",
-  "Stream cancelled by caller"
-];
-function isSafeValidationError(error) {
-  if (!(error instanceof Error)) {
-    return false;
-  }
-  return SAFE_VALIDATION_ERROR_PATTERNS.some(
-    (pattern) => error.message.includes(pattern)
-  );
-}
-
-// src/data/relational/tools/relational-select/executor.ts
-var logger16 = core.createLogger("agentforge:tools:data:relational:select");
-function toSelectQueryInput(input) {
-  return {
-    table: input.table,
-    columns: input.columns,
-    where: input.where,
-    orderBy: input.orderBy,
-    limit: input.limit,
-    offset: input.offset,
-    vendor: input.vendor
-  };
-}
-async function executeSelect(manager, input, context) {
-  const startTime = Date.now();
-  logger16.debug("Building SELECT query", {
-    vendor: input.vendor,
-    table: input.table,
-    hasWhere: !!input.where,
-    hasOrderBy: !!input.orderBy,
-    hasLimit: !!input.limit,
-    streamingEnabled: !!input.streaming?.enabled
-  });
-  try {
-    const executor = context?.transaction ?? manager;
-    if (input.streaming?.enabled) {
-      const streamOptions = {
-        chunkSize: input.streaming.chunkSize,
-        maxRows: input.streaming.maxRows,
-        sampleSize: input.streaming.sampleSize
-      };
-      const streamInput = toSelectQueryInput(input);
-      if (input.streaming.benchmark) {
-        logger16.warn("Streaming benchmark enabled; SELECT will execute up to three times (result + benchmark regular + benchmark streaming).", {
-          vendor: input.vendor,
-          table: input.table,
-          chunkSize: streamOptions.chunkSize ?? DEFAULT_CHUNK_SIZE,
-          ...streamOptions.maxRows !== void 0 ? { maxRows: streamOptions.maxRows } : {},
-          ...streamOptions.sampleSize !== void 0 ? { sampleSize: streamOptions.sampleSize } : {}
-        });
-      }
-      const streamResult = await executeStreamingSelect(executor, streamInput, streamOptions);
-      const benchmark = input.streaming.benchmark ? await benchmarkStreamingSelectMemory(executor, streamInput, streamOptions) : void 0;
-      const executionTime2 = Date.now() - startTime;
-      logger16.debug("Streaming SELECT query executed successfully", {
-        vendor: input.vendor,
-        table: input.table,
-        rowCount: streamResult.rowCount,
-        chunkCount: streamResult.chunkCount,
-        executionTime: executionTime2,
-        cancelled: streamResult.cancelled
-      });
-      return {
-        rows: streamResult.rows,
-        rowCount: streamResult.rowCount,
-        executionTime: executionTime2,
-        streaming: {
-          enabled: true,
-          chunkSize: input.streaming.chunkSize ?? DEFAULT_CHUNK_SIZE,
-          chunkCount: streamResult.chunkCount,
-          sampledRowCount: streamResult.rows.length,
-          streamedRowCount: streamResult.rowCount,
-          cancelled: streamResult.cancelled,
-          memoryUsage: streamResult.memoryUsage,
-          benchmark
-        }
-      };
-    }
-    const query = buildSelectQuery2(input);
-    const result = await executor.execute(query);
-    const executionTime = Date.now() - startTime;
-    const rows = Array.isArray(result) ? result : result.rows || [];
-    const rowCount = rows.length;
-    logger16.debug("SELECT query executed successfully", {
-      vendor: input.vendor,
-      table: input.table,
-      rowCount,
-      executionTime
-    });
-    return {
-      rows,
-      rowCount,
-      executionTime
-    };
-  } catch (error) {
-    const executionTime = Date.now() - startTime;
-    logger16.error("SELECT query execution failed", {
-      vendor: input.vendor,
-      table: input.table,
-      error: error instanceof Error ? error.message : String(error),
-      executionTime
-    });
-    if (isSafeValidationError(error)) {
-      throw error;
-    }
-    throw new Error("SELECT query failed. See logs for details.", { cause: error });
-  }
-}
-
-// src/data/relational/tools/relational-select/index.ts
-var relationalSelect = core.toolBuilder().name("relational-select").displayName("Relational SELECT").description("Execute type-safe SELECT queries with WHERE conditions, ORDER BY, LIMIT, and OFFSET using Drizzle ORM query builder").category(core.ToolCategory.DATABASE).tags(["database", "sql", "select", "query", "postgresql", "mysql", "sqlite"]).schema(relationalSelectSchema).example({
-  description: "SELECT with WHERE condition",
-  input: {
-    table: "users",
-    columns: ["id", "name", "email"],
-    where: [{ column: "status", operator: "eq", value: "active" }],
-    vendor: "postgresql",
-    connectionString: "postgresql://localhost/mydb"
-  }
-}).example({
-  description: "SELECT with pagination",
-  input: {
-    table: "products",
-    orderBy: [{ column: "created_at", direction: "desc" }],
-    limit: 20,
-    offset: 0,
-    vendor: "mysql",
-    connectionString: "mysql://localhost/shop"
-  }
-}).example({
-  description: "SELECT with streaming mode",
-  input: {
-    table: "events",
-    orderBy: [{ column: "id", direction: "asc" }],
-    streaming: {
-      enabled: true,
-      chunkSize: 250,
-      sampleSize: 25
-    },
-    vendor: "postgresql",
-    connectionString: "postgresql://localhost/analytics"
-  }
-}).implement(async (input) => {
-  const manager = new ConnectionManager({
-    vendor: input.vendor,
-    connection: input.connectionString
-  });
-  try {
-    await manager.connect();
-    const result = await executeSelect(manager, input);
-    return {
-      success: true,
-      rows: result.rows,
-      rowCount: result.rowCount,
-      executionTime: result.executionTime,
-      streaming: result.streaming
-    };
-  } catch (error) {
-    let errorMessage = "Failed to execute SELECT query. Please verify your input and database connection.";
-    if (isSafeValidationError(error)) {
-      errorMessage = error.message;
-    }
-    return {
-      success: false,
-      error: errorMessage,
-      rows: [],
-      rowCount: 0
-    };
-  } finally {
-    await manager.disconnect();
-  }
-}).build();
-var insertValueSchema = zod.z.union([
-  zod.z.string().describe("String value"),
-  zod.z.number().describe("Numeric value"),
-  zod.z.boolean().describe("Boolean value"),
-  zod.z.null().describe("Null value")
-]).describe("Scalar value for an INSERT column");
-var insertRowSchema = zod.z.record(
-  zod.z.string().min(1, "Column name must not be empty").describe("Column name"),
-  insertValueSchema
-).describe("One row object where keys are column names and values are scalar values");
-var insertReturningModeSchema = zod.z.enum(["none", "id", "row"]);
-var insertReturningSchema = zod.z.object({
-  mode: insertReturningModeSchema.default("none").describe("Returning mode: none, id, or full row"),
-  idColumn: zod.z.string().min(1, "idColumn must not be empty").optional().describe('Primary key column to return when mode is "id"')
-}).superRefine((value, ctx) => {
-  if (value.idColumn && value.mode !== "id") {
-    ctx.addIssue({
-      code: zod.z.ZodIssueCode.custom,
-      path: ["idColumn"],
-      message: 'idColumn can only be provided when returning.mode is "id"'
-    });
-  }
-});
-var insertBatchOptionsSchema = zod.z.object({
-  enabled: zod.z.boolean().optional().default(true).describe("Enable chunked batch execution for array insert payloads"),
-  batchSize: zod.z.number().int().positive().max(5e3).optional().default(100).describe("Rows per batch chunk"),
-  continueOnError: zod.z.boolean().optional().default(true).describe("Continue processing remaining chunks when one chunk fails"),
-  maxRetries: zod.z.number().int().min(0).max(5).optional().default(0).describe("Retry attempts per failed chunk"),
-  retryDelayMs: zod.z.number().int().min(0).max(6e4).optional().default(0).describe("Delay between retry attempts in milliseconds"),
-  benchmark: zod.z.boolean().optional().default(false).describe("Run synthetic benchmark metadata comparing individual vs batched execution callbacks")
-});
-var relationalInsertSchema = zod.z.object({
-  table: zod.z.string().min(1, "Table name is required").regex(
-    VALID_QUALIFIED_IDENTIFIER_PATTERN,
-    "Table name contains invalid characters. Only alphanumeric characters, underscores, and dots (for schema qualification) are allowed."
-  ).describe("Table name to insert into (schema-qualified names supported, e.g. public.users)"),
-  data: zod.z.union([
-    insertRowSchema,
-    zod.z.array(insertRowSchema).min(1, "Insert data array must not be empty")
-  ]).describe("Single row object or array of row objects to insert"),
-  batch: insertBatchOptionsSchema.optional().describe("Optional batch execution controls for array insert payloads"),
-  returning: insertReturningSchema.optional().describe("Optional RETURNING behavior"),
-  vendor: zod.z.enum(["postgresql", "mysql", "sqlite"]).describe("Database vendor"),
-  connectionString: zod.z.string().min(1, "Database connection string is required").describe("Database connection string")
-});
-
-// src/data/relational/tools/relational-insert/error-utils.ts
-var SAFE_INSERT_VALIDATION_PATTERNS = [
-  "must not be empty",
-  "contains invalid characters",
-  "must be an object",
-  "must not be an empty array",
-  "must not be undefined",
-  "idColumn can only be provided",
-  "Returning full rows is not supported for mysql",
-  "Batch INSERT with only DEFAULT VALUES is not supported"
+  "operator requires a string value",
+  "operator requires a non-empty array value",
+  "must not include value"
 ];
 var CONSTRAINT_VIOLATION_PATTERNS = [
   {
-    pattern: /(unique constraint|duplicate key|duplicate entry)/i,
-    message: "Insert failed: unique constraint violation."
-  },
-  {
-    pattern: /(foreign key constraint|violates foreign key constraint)/i,
-    message: "Insert failed: foreign key constraint violation."
-  },
-  {
-    pattern: /(not null constraint|cannot be null)/i,
-    message: "Insert failed: NOT NULL constraint violation."
+    pattern: /(foreign key constraint|violates foreign key constraint|foreign key mismatch|a foreign key constraint fails)/i,
+    message: "Delete failed: foreign key constraint violation."
   }
 ];
-function isSafeInsertValidationError(error) {
+function isSafeDeleteValidationError(error) {
   if (!(error instanceof Error)) {
     return false;
   }
-  return SAFE_INSERT_VALIDATION_PATTERNS.some((pattern) => error.message.includes(pattern));
+  return SAFE_DELETE_VALIDATION_PATTERNS.some((pattern) => error.message.includes(pattern));
 }
-function getConstraintViolationMessage(error) {
+function getDeleteConstraintViolationMessage(error, cascade) {
   if (!(error instanceof Error)) {
     return null;
   }
@@ -7841,79 +7711,43 @@ function getConstraintViolationMessage(error) {
   }
   for (const entry of CONSTRAINT_VIOLATION_PATTERNS) {
     if (messages.some((msg) => entry.pattern.test(msg))) {
+      if (cascade) {
+        return `${entry.message} Verify database-level ON DELETE CASCADE is configured for related foreign keys.`;
+      }
       return entry.message;
     }
   }
   return null;
 }
-function isSafeInsertError(error) {
+function isSafeDeleteError(error) {
   if (!(error instanceof Error)) {
     return false;
   }
-  return isSafeInsertValidationError(error) || getConstraintViolationMessage(error) !== null;
+  return SAFE_DELETE_VALIDATION_PATTERNS.some((pattern) => error.message.includes(pattern)) || error.message.startsWith("Delete failed:");
 }
-var insertExecutorLogger = core.createLogger("agentforge:tools:data:relational:insert");
+var deleteExecutorLogger = core.createLogger("agentforge:tools:data:relational:delete");
 function toNumber(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function isPlainObject(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function normalizeExecutionResult(result) {
+function normalizeAffectedRows(result) {
   if (Array.isArray(result)) {
-    if (result.length > 0 && isPlainObject(result[0])) {
+    if (result.length > 0 && result[0] && typeof result[0] === "object") {
       const first = result[0];
       const affectedRows = toNumber(first.affectedRows) ?? toNumber(first.rowCount) ?? toNumber(first.changes);
-      const insertId = toNumber(first.insertId);
-      const lastInsertRowid = toNumber(first.lastInsertRowid);
-      if (affectedRows !== void 0 || insertId !== void 0 || lastInsertRowid !== void 0) {
-        return {
-          rows: [],
-          rowCount: affectedRows ?? 0,
-          insertId,
-          lastInsertRowid
-        };
+      if (affectedRows !== void 0) {
+        return affectedRows;
       }
     }
-    return {
-      rows: result,
-      rowCount: result.length
-    };
+    return result.length;
   }
-  if (isPlainObject(result)) {
-    const rows = Array.isArray(result.rows) ? result.rows : [];
-    const rowCount = toNumber(result.rowCount) ?? toNumber(result.affectedRows) ?? toNumber(result.changes) ?? rows.length;
-    return {
-      rows,
-      rowCount,
-      insertId: toNumber(result.insertId),
-      lastInsertRowid: toNumber(result.lastInsertRowid)
-    };
+  if (result && typeof result === "object") {
+    const resultRecord = result;
+    return toNumber(resultRecord.rowCount) ?? toNumber(resultRecord.affectedRows) ?? toNumber(resultRecord.changes) ?? (Array.isArray(resultRecord.rows) ? resultRecord.rows.length : 0);
   }
-  return {
-    rows: [],
-    rowCount: 0
-  };
+  return 0;
 }
-function deriveInsertedIds(options) {
-  const { idColumn, inputRows, returnedRows, rowCount, insertId, lastInsertRowid } = options;
-  if (returnedRows.length > 0) {
-    const idsFromReturn = returnedRows.map((row) => isPlainObject(row) ? row[idColumn] : void 0).filter((id) => typeof id === "number" || typeof id === "string");
-    if (idsFromReturn.length > 0) {
-      return idsFromReturn;
-    }
-  }
-  if (inputRows.every((row) => typeof row[idColumn] === "number" || typeof row[idColumn] === "string")) {
-    return inputRows.map((row) => row[idColumn]);
-  }
-  if (insertId !== void 0 && rowCount > 0) {
-    return Array.from({ length: rowCount }, (_, index) => insertId + index);
-  }
-  if (lastInsertRowid !== void 0 && rowCount > 0) {
-    const startId = lastInsertRowid - rowCount + 1;
-    return Array.from({ length: rowCount }, (_, index) => startId + index);
-  }
-  return [];
+function toErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
 }
 function resolveBatchOptions(batch) {
   if (!batch || batch.enabled === false) {
@@ -7928,79 +7762,87 @@ function resolveBatchOptions(batch) {
     benchmark: batch.benchmark ?? false
   };
 }
-function toSingleInsertRows(row) {
-  return [row];
+function toSingleDeleteOperation(input) {
+  return {
+    where: input.where,
+    allowFullTableDelete: input.allowFullTableDelete,
+    cascade: input.cascade,
+    softDelete: input.softDelete
+  };
 }
 
-// src/data/relational/tools/relational-insert/executor-single.ts
-async function executeInsertOnce(manager, input, context) {
-  const built = buildInsertQuery({
+// src/data/relational/tools/relational-delete/executor-single.ts
+async function executeSingleDelete(executor, input, operation, context) {
+  const built = buildDeleteQuery({
     table: input.table,
-    data: input.data,
-    returning: input.returning,
+    where: operation.where,
+    allowFullTableDelete: operation.allowFullTableDelete,
+    softDelete: operation.softDelete,
     vendor: input.vendor
   });
-  const executor = manager;
-  if (Array.isArray(built.query)) {
-    let totalRowCount = 0;
-    const allRows = [];
-    const allIds = [];
-    for (const singleQuery of built.query) {
-      const rawResult2 = await executor.execute(singleQuery);
-      const normalized2 = normalizeExecutionResult(rawResult2);
-      totalRowCount += normalized2.rowCount > 0 ? normalized2.rowCount : 1;
-      if (built.returningMode === "row") {
-        allRows.push(...normalized2.rows);
-      }
-      if (built.returningMode === "id") {
-        const ids = deriveInsertedIds({
-          idColumn: built.idColumn,
-          inputRows: toSingleInsertRows(built.rows[allIds.length]),
-          returnedRows: normalized2.rows,
-          rowCount: 1,
-          insertId: normalized2.insertId,
-          lastInsertRowid: normalized2.lastInsertRowid
-        });
-        allIds.push(...ids);
-      }
-    }
-    return {
-      rowCount: totalRowCount,
-      rows: allRows,
-      insertedIds: allIds,
-      executionTime: 0
-    };
-  }
-  const rawResult = await executor.execute(built.query);
-  const normalized = normalizeExecutionResult(rawResult);
-  const rowCount = normalized.rowCount > 0 ? normalized.rowCount : built.rows.length;
-  const rows = built.returningMode === "row" ? normalized.rows : [];
-  const insertedIds = built.returningMode === "id" ? deriveInsertedIds({
-    idColumn: built.idColumn,
-    inputRows: built.rows,
-    returnedRows: normalized.rows,
-    rowCount,
-    insertId: normalized.insertId,
-    lastInsertRowid: normalized.lastInsertRowid
-  }) : [];
+  const session = context?.transaction ?? executor;
+  const rawResult = await session.execute(built.query);
+  const rowCount = normalizeAffectedRows(rawResult);
   return {
     rowCount,
-    rows,
-    insertedIds,
-    executionTime: 0
+    executionTime: 0,
+    softDeleted: built.usesSoftDelete
   };
 }
 
-// src/data/relational/tools/relational-insert/executor-batch.ts
-async function executeInsertInBatchMode(manager, input, context, options) {
+// src/data/relational/tools/relational-delete/executor-batch.ts
+async function executeDeleteInBatchMode(executor, input, context, options) {
   const batchResult = await executeBatchedTask(
     {
-      operation: "insert",
-      items: input.data,
-      executeBatch: async (rows2) => executeInsertOnce(manager, {
-        ...input,
-        data: rows2}),
-      getBatchSuccessCount: (result, rows2) => Math.min(result.rowCount, rows2.length)
+      operation: "delete",
+      items: input.operations,
+      executeBatch: async (operations, batchIndex) => {
+        let rowCount2 = 0;
+        let successfulItems = 0;
+        let failedItems = 0;
+        let softDeletedCount = 0;
+        const failures = [];
+        for (const operation of operations) {
+          try {
+            const result = await executeSingleDelete(
+              executor,
+              input,
+              {
+                where: operation.where,
+                allowFullTableDelete: operation.allowFullTableDelete,
+                cascade: operation.cascade,
+                softDelete: operation.softDelete
+              },
+              context
+            );
+            rowCount2 += result.rowCount;
+            successfulItems += 1;
+            if (result.softDeleted) {
+              softDeletedCount += 1;
+            }
+          } catch (error) {
+            if (!options.continueOnError) {
+              throw error;
+            }
+            failedItems += 1;
+            failures.push({
+              operation: "delete",
+              batchIndex,
+              batchSize: operations.length,
+              attempts: 1,
+              error: toErrorMessage(error)
+            });
+          }
+        }
+        return {
+          rowCount: rowCount2,
+          successfulItems,
+          failedItems,
+          softDeletedCount,
+          failures
+        };
+      },
+      getBatchSuccessCount: (result) => result.successfulItems
     },
     {
       batchSize: options.batchSize,
@@ -8008,7 +7850,7 @@ async function executeInsertInBatchMode(manager, input, context, options) {
       maxRetries: options.maxRetries,
       retryDelayMs: options.retryDelayMs,
       onProgress: (progress) => {
-        insertExecutorLogger.debug("INSERT batch progress", {
+        deleteExecutorLogger.debug("DELETE batch progress", {
           vendor: input.vendor,
           table: input.table,
           ...progress
@@ -8017,18 +7859,21 @@ async function executeInsertInBatchMode(manager, input, context, options) {
     }
   );
   const rowCount = batchResult.results.reduce((total, result) => total + result.rowCount, 0);
-  const rows = batchResult.results.flatMap((result) => result.rows);
-  const insertedIds = batchResult.results.flatMap((result) => result.insertedIds);
+  const softDeleted = batchResult.results.some((result) => result.softDeletedCount > 0);
+  const operationFailures = batchResult.results.flatMap((result) => result.failures);
   let benchmark;
   if (options.benchmark) {
-    insertExecutorLogger.warn("INSERT batch benchmark enabled. Synthetic benchmark callbacks are side-effect free and do not execute SQL.", {
-      vendor: input.vendor,
-      table: input.table,
-      totalRows: input.data.length,
-      batchSize: options.batchSize
-    });
+    deleteExecutorLogger.warn(
+      "DELETE batch benchmark enabled. Synthetic benchmark callbacks are side-effect free and do not execute SQL.",
+      {
+        vendor: input.vendor,
+        table: input.table,
+        operationCount: input.operations.length,
+        batchSize: options.batchSize
+      }
+    );
     benchmark = await benchmarkBatchExecution({
-      items: input.data,
+      items: input.operations,
       batchSize: options.batchSize,
       runIndividual: async () => {
       },
@@ -8038,9 +7883,8 @@ async function executeInsertInBatchMode(manager, input, context, options) {
   }
   return {
     rowCount,
-    rows,
-    insertedIds,
     executionTime: batchResult.executionTime,
+    softDeleted,
     batch: {
       enabled: true,
       batchSize: options.batchSize,
@@ -8051,38 +7895,41 @@ async function executeInsertInBatchMode(manager, input, context, options) {
       totalBatches: batchResult.totalBatches,
       retries: batchResult.retries,
       partialSuccess: batchResult.partialSuccess,
-      failures: batchResult.failures,
+      failures: [...batchResult.failures, ...operationFailures],
       benchmark
     }
   };
 }
 
-// src/data/relational/tools/relational-insert/executor.ts
-async function executeInsert(manager, input, context) {
+// src/data/relational/tools/relational-delete/executor.ts
+async function executeDelete(executor, input, context) {
   const startTime = Date.now();
-  insertExecutorLogger.debug("Building INSERT query", {
+  deleteExecutorLogger.debug("Building DELETE query", {
     vendor: input.vendor,
     table: input.table,
-    isBatch: Array.isArray(input.data),
-    batchModeEnabled: !!input.batch?.enabled,
-    returningMode: input.returning?.mode ?? "none"
+    hasWhere: !!input.where?.length,
+    ...input.allowFullTableDelete !== void 0 ? { allowFullTableDelete: input.allowFullTableDelete } : {},
+    ...input.cascade !== void 0 ? { cascade: input.cascade } : {},
+    softDelete: !!input.softDelete,
+    operationCount: input.operations?.length ?? 0,
+    batchModeEnabled: !!input.batch?.enabled
   });
   try {
     const batchOptions = resolveBatchOptions(input.batch);
-    const result = Array.isArray(input.data) && batchOptions ? await executeInsertInBatchMode(
-      manager,
+    const result = input.operations && batchOptions ? await executeDeleteInBatchMode(
+      executor,
       input,
       context,
       batchOptions
-    ) : await executeInsertOnce(manager, input, context);
+    ) : await executeSingleDelete(executor, input, toSingleDeleteOperation(input), context);
     const executionTime = Date.now() - startTime;
-    insertExecutorLogger.debug("INSERT query executed successfully", {
+    deleteExecutorLogger.debug("DELETE query executed successfully", {
       vendor: input.vendor,
       table: input.table,
       rowCount: result.rowCount,
-      returnedRows: result.rows.length,
-      returnedIds: result.insertedIds.length,
       executionTime,
+      softDelete: result.softDeleted,
+      ...input.cascade !== void 0 ? { cascade: input.cascade } : {},
       batchMode: !!result.batch,
       partialSuccess: result.batch?.partialSuccess ?? false
     });
@@ -8092,314 +7939,332 @@ async function executeInsert(manager, input, context) {
     };
   } catch (error) {
     const executionTime = Date.now() - startTime;
-    insertExecutorLogger.error("INSERT query execution failed", {
+    deleteExecutorLogger.error("DELETE query execution failed", {
       vendor: input.vendor,
       table: input.table,
       error: error instanceof Error ? error.message : String(error),
-      executionTime
+      executionTime,
+      ...input.cascade !== void 0 ? { cascade: input.cascade } : {},
+      softDelete: !!input.softDelete
     });
-    const constraintMessage = getConstraintViolationMessage(error);
+    const constraintMessage = getDeleteConstraintViolationMessage(error, input.cascade ?? false);
     if (constraintMessage) {
       throw new Error(constraintMessage, { cause: error });
     }
-    if (isSafeInsertValidationError(error)) {
+    if (isSafeDeleteValidationError(error)) {
       throw error;
     }
-    throw new Error("INSERT query failed. See logs for details.", { cause: error });
+    throw new Error("DELETE query failed. See logs for details.", { cause: error });
   }
 }
 
-// src/data/relational/tools/relational-insert/index.ts
-var relationalInsert = core.toolBuilder().name("relational-insert").displayName("Relational INSERT").description("Execute type-safe INSERT queries with single-row and batch insert support").category(core.ToolCategory.DATABASE).tags(["database", "sql", "insert", "postgresql", "mysql", "sqlite"]).schema(relationalInsertSchema).example({
-  description: "Insert a single row and return generated ID",
-  input: {
-    table: "users",
-    data: { name: "Alice", email: "alice@example.com" },
-    returning: { mode: "id", idColumn: "id" },
-    vendor: "postgresql",
-    connectionString: "postgresql://localhost/mydb"
-  }
-}).example({
-  description: "Batch insert rows",
-  input: {
-    table: "users",
-    data: [
-      { name: "Bob", email: "bob@example.com" },
-      { name: "Carol", email: "carol@example.com" }
-    ],
-    batch: {
-      batchSize: 250,
-      continueOnError: true,
-      maxRetries: 1
-    },
-    vendor: "sqlite",
-    connectionString: "data.db"
+// src/data/relational/tools/legacy-mutation-adapter.ts
+function replaceMutationConnectionFailure(result, configuredMessage, legacyMessage) {
+  if (!result.success && result.error === configuredMessage) {
+    return { ...result, error: legacyMessage };
   }
-}).implement(async (input) => {
-  const manager = new ConnectionManager({
-    vendor: input.vendor,
-    connection: input.connectionString
+  return result;
+}
+async function withEphemeralRelationalMutationToolSet(database, invoke, toErrorResponse) {
+  const toolSet = createLegacyRelationalMutationToolSet({
+    vendor: database.vendor,
+    connection: database.connectionString
   });
   try {
-    await manager.connect();
-    const result = await executeInsert(manager, input);
+    try {
+      return await invoke(toolSet);
+    } catch (error) {
+      if (error instanceof MissingPeerDependencyError) {
+        throw error;
+      }
+      return toErrorResponse(error);
+    }
+  } finally {
+    await toolSet.dispose();
+  }
+}
+
+// src/data/relational/tools/relational-delete/index.ts
+function toDeleteErrorResponse(error) {
+  const errorMessage = isSafeDeleteError(error) ? error.message : "Failed to execute DELETE query. Please verify your input and database connection.";
+  return {
+    success: false,
+    error: errorMessage,
+    rowCount: 0,
+    softDeleted: false
+  };
+}
+async function invokeRelationalDelete(execution, input) {
+  try {
+    const result = await executeDelete(
+      execution.executor,
+      { ...input, vendor: execution.vendor },
+      execution.transaction ? { transaction: execution.transaction } : void 0
+    );
     return {
       success: true,
       rowCount: result.rowCount,
-      insertedIds: result.insertedIds,
-      rows: result.rows,
       executionTime: result.executionTime,
+      softDeleted: result.softDeleted,
       batch: result.batch
     };
   } catch (error) {
-    let errorMessage = "Failed to execute INSERT query. Please verify your input and database connection.";
-    if (isSafeInsertError(error)) {
-      errorMessage = error.message;
-    }
-    return {
-      success: false,
-      error: errorMessage,
-      rowCount: 0,
-      insertedIds: [],
-      rows: []
-    };
-  } finally {
-    await manager.disconnect();
+    return toDeleteErrorResponse(error);
+  }
+}
+var relationalDelete = core.toolBuilder().name("relational-delete").displayName("Relational DELETE").description("Execute type-safe DELETE queries with single and batched operation support").category(core.ToolCategory.DATABASE).tags(["database", "sql", "delete", "postgresql", "mysql", "sqlite"]).schema(relationalDeleteSchema).example({
+  description: "Delete one row by condition",
+  input: {
+    table: "users",
+    where: [{ column: "id", operator: "eq", value: 123 }],
+    vendor: "postgresql",
+    connectionString: "postgresql://localhost/mydb"
+  }
+}).example({
+  description: "Soft delete rows",
+  input: {
+    table: "users",
+    where: [{ column: "status", operator: "eq", value: "inactive" }],
+    softDelete: { column: "deleted_at" },
+    vendor: "sqlite",
+    connectionString: "data.db"
+  }
+}).example({
+  description: "Batch delete operations",
+  input: {
+    table: "users",
+    operations: [
+      {
+        where: [{ column: "status", operator: "eq", value: "inactive" }],
+        softDelete: { column: "deleted_at" }
+      },
+      {
+        where: [{ column: "status", operator: "eq", value: "pending_delete" }],
+        softDelete: { column: "deleted_at" }
+      }
+    ],
+    batch: {
+      batchSize: 100,
+      continueOnError: true
+    },
+    vendor: "postgresql",
+    connectionString: "postgresql://localhost/mydb"
   }
+}).implement(async (input) => {
+  const { connectionString, vendor, ...operation } = input;
+  return withEphemeralRelationalMutationToolSet(
+    { vendor, connectionString },
+    async (toolSet) => replaceMutationConnectionFailure(
+      await toolSet.delete.invoke(operation),
+      DELETE_CONNECTION_FAILURE,
+      "Failed to execute DELETE query. Please verify your input and database connection."
+    ),
+    toDeleteErrorResponse
+  );
 }).build();
-var updateValueSchema = zod.z.union([
-  zod.z.string().describe("String value"),
-  zod.z.number().describe("Numeric value"),
-  zod.z.boolean().describe("Boolean value"),
-  zod.z.null().describe("Null value")
-]).describe("Scalar value for an UPDATE column");
-var updateDataSchema = zod.z.record(
-  zod.z.string().min(1, "Column name must not be empty").describe("Column name"),
-  updateValueSchema
-).superRefine((value, ctx) => {
-  if (Object.keys(value).length === 0) {
-    ctx.addIssue({
-      code: zod.z.ZodIssueCode.custom,
-      message: "Update data must not be empty"
-    });
+
+// src/data/relational/tools/relational-get-schema-error-utils.ts
+var SAFE_VALIDATION_ERROR_PATTERNS = [
+  "must not be empty",
+  "contains invalid characters",
+  "Invalid table filter"
+];
+function isSafeGetSchemaValidationError(error) {
+  if (!(error instanceof Error)) {
+    return false;
   }
-}).describe("Object containing column-value pairs to update");
-var updateWhereOperatorSchema = zod.z.enum([
-  "eq",
-  "ne",
-  "gt",
-  "lt",
-  "gte",
-  "lte",
-  "like",
-  "in",
-  "notIn",
-  "isNull",
-  "isNotNull"
-]);
-var updateWhereConditionSchema = zod.z.object({
-  column: zod.z.string().min(1, "Column name must not be empty").describe("Column name to filter on"),
-  operator: updateWhereOperatorSchema.describe("Comparison operator"),
-  value: zod.z.union([
-    zod.z.string(),
-    zod.z.number(),
-    zod.z.boolean(),
-    zod.z.array(zod.z.union([zod.z.string(), zod.z.number()])),
-    zod.z.null()
-  ]).optional().describe("Value to compare against (not required for isNull/isNotNull)")
-}).superRefine((value, ctx) => {
-  const op = value.operator;
-  if (op === "isNull" || op === "isNotNull") {
-    if (value.value !== void 0) {
-      ctx.addIssue({
-        code: zod.z.ZodIssueCode.custom,
-        path: ["value"],
-        message: "value must not be provided when using isNull or isNotNull operator"
-      });
-    }
-    return;
+  return SAFE_VALIDATION_ERROR_PATTERNS.some(
+    (pattern) => error.message.includes(pattern)
+  );
+}
+
+// src/data/relational/tools/legacy-read-adapter.ts
+function replaceConnectionFailureMessage(result, configuredMessage, legacyMessage) {
+  if (!result.success && result.error === configuredMessage) {
+    return { ...result, error: legacyMessage };
   }
-  if (value.value === void 0) {
-    ctx.addIssue({
-      code: zod.z.ZodIssueCode.custom,
-      path: ["value"],
-      message: "value is required for this operator"
-    });
-    return;
+  return result;
+}
+async function withEphemeralRelationalToolSet(database, invoke, options = {}, sharedSchemaCacheKey) {
+  const config = { vendor: database.vendor, connection: database.connectionString };
+  const toolSet = createLegacyRelationalReadToolSet(config, options, sharedSchemaCacheKey);
+  try {
+    return await invoke(toolSet);
+  } finally {
+    await toolSet.dispose();
   }
-  if (op === "in" || op === "notIn") {
-    if (!Array.isArray(value.value)) {
-      ctx.addIssue({
-        code: zod.z.ZodIssueCode.custom,
-        path: ["value"],
-        message: `${op === "in" ? "IN" : "NOT IN"} operator requires an array value`
-      });
-    } else if (value.value.length === 0) {
-      ctx.addIssue({
-        code: zod.z.ZodIssueCode.custom,
-        path: ["value"],
-        message: `${op === "in" ? "IN" : "NOT IN"} operator requires a non-empty array value`
-      });
+}
+
+// src/data/relational/tools/relational-get-schema.ts
+var logger16 = core.createLogger("agentforge:tools:data:relational:get-schema");
+function buildSchemaCacheKey(vendor, connectionString, database) {
+  const databaseScope = database ?? "default";
+  const connectionHash = crypto.createHash("sha256").update(connectionString).digest("hex");
+  return `${vendor}:${databaseScope}:${connectionHash}`;
+}
+var relationalGetSchemaInputSchema = zod.z.object({
+  vendor: zod.z.enum(["postgresql", "mysql", "sqlite"]).describe("Database vendor"),
+  connectionString: zod.z.string().min(1, "Database connection string is required").describe("Database connection string used to create a new connection"),
+  database: zod.z.string().min(1).optional().describe("Optional logical database name used for cache scoping"),
+  tables: zod.z.array(
+    zod.z.string().regex(
+      VALID_TABLE_FILTER_PATTERN,
+      "Table filter contains invalid characters. Use alphanumeric, underscore, and optional schema qualification."
+    )
+  ).optional().describe("Optional table filter list. When omitted, all tables are returned."),
+  cacheTtlMs: zod.z.number().int().min(0).optional().describe("Schema cache TTL in milliseconds (0 disables caching)"),
+  refreshCache: zod.z.boolean().optional().describe("Force cache invalidation before introspecting schema")
+});
+function toGetSchemaErrorResponse(execution, input, error) {
+  logger16.error("Schema introspection failed", {
+    vendor: execution.vendor,
+    hasTablesFilter: Array.isArray(input.tables),
+    tablesFilterCount: input.tables?.length ?? 0,
+    refreshCache: input.refreshCache ?? false,
+    error: error instanceof Error ? error.message : String(error)
+  });
+  const errorMessage = isSafeGetSchemaValidationError(error) ? error.message : "Failed to inspect schema. See logs for details.";
+  return {
+    success: false,
+    error: errorMessage,
+    schema: null
+  };
+}
+async function invokeRelationalGetSchema(execution, input) {
+  const cacheKey = execution.schemaCacheKey ?? (execution.schemaCache ? input.database ?? "default" : void 0);
+  const inspector = new SchemaInspector(
+    execution.transaction ?? execution.executor,
+    execution.vendor,
+    {
+      cacheTtlMs: input.cacheTtlMs,
+      cacheKey,
+      cache: execution.schemaCache
     }
-    return;
+  );
+  try {
+    if (input.refreshCache && cacheKey) {
+      inspector.invalidateCache();
+    }
+    const schema = await inspector.inspect(
+      execution.transaction ? { tables: input.tables, bypassCache: true } : { tables: input.tables }
+    );
+    const summary = schema.tables.reduce(
+      (accumulator, table) => {
+        accumulator.tableCount += 1;
+        accumulator.columnCount += table.columns.length;
+        accumulator.foreignKeyCount += table.foreignKeys.length;
+        accumulator.indexCount += table.indexes.length;
+        return accumulator;
+      },
+      { tableCount: 0, columnCount: 0, foreignKeyCount: 0, indexCount: 0 }
+    );
+    return { success: true, schema, summary };
+  } catch (error) {
+    return toGetSchemaErrorResponse(execution, input, error);
   }
-  if (value.value === null) {
-    ctx.addIssue({
-      code: zod.z.ZodIssueCode.custom,
-      path: ["value"],
-      message: "null is only allowed with isNull/isNotNull operators"
-    });
-    return;
+}
+var relationalGetSchema = core.toolBuilder().name("relational-get-schema").displayName("Relational Get Schema").description("Inspect relational database schema (tables, columns, primary keys, foreign keys, indexes) across PostgreSQL, MySQL, and SQLite").category(core.ToolCategory.DATABASE).tags(["database", "schema", "introspection", "postgresql", "mysql", "sqlite"]).schema(relationalGetSchemaInputSchema).example({
+  description: "Inspect all SQLite tables",
+  input: {
+    vendor: "sqlite",
+    connectionString: ":memory:"
   }
-  if (op === "like" && typeof value.value !== "string") {
-    ctx.addIssue({
-      code: zod.z.ZodIssueCode.custom,
-      path: ["value"],
-      message: "LIKE operator requires a string value"
-    });
-    return;
+}).example({
+  description: "Inspect selected PostgreSQL tables with cache control",
+  input: {
+    vendor: "postgresql",
+    connectionString: "postgresql://localhost/app",
+    tables: ["public.users", "public.orders"],
+    cacheTtlMs: 3e4,
+    refreshCache: true
   }
-  if ((op === "gt" || op === "lt" || op === "gte" || op === "lte") && typeof value.value !== "string" && typeof value.value !== "number") {
+}).implement(async (input) => {
+  const { connectionString, vendor, database, cacheTtlMs, tables, refreshCache } = input;
+  return withEphemeralRelationalToolSet(
+    { vendor, connectionString },
+    (toolSet) => toolSet.getSchema.invoke({ tables, refreshCache }),
+    { schemaCacheTtlMs: cacheTtlMs },
+    buildSchemaCacheKey(vendor, connectionString, database)
+  );
+}).build();
+var insertValueSchema = zod.z.union([
+  zod.z.string().describe("String value"),
+  zod.z.number().describe("Numeric value"),
+  zod.z.boolean().describe("Boolean value"),
+  zod.z.null().describe("Null value")
+]).describe("Scalar value for an INSERT column");
+var insertRowSchema = zod.z.record(
+  zod.z.string().min(1, "Column name must not be empty").describe("Column name"),
+  insertValueSchema
+).describe("One row object where keys are column names and values are scalar values");
+var insertReturningModeSchema = zod.z.enum(["none", "id", "row"]);
+var insertReturningSchema = zod.z.object({
+  mode: insertReturningModeSchema.default("none").describe("Returning mode: none, id, or full row"),
+  idColumn: zod.z.string().min(1, "idColumn must not be empty").optional().describe('Primary key column to return when mode is "id"')
+}).superRefine((value, ctx) => {
+  if (value.idColumn && value.mode !== "id") {
     ctx.addIssue({
       code: zod.z.ZodIssueCode.custom,
-      path: ["value"],
-      message: `${op.toUpperCase()} operator requires a string or number value`
+      path: ["idColumn"],
+      message: 'idColumn can only be provided when returning.mode is "id"'
     });
   }
 });
-var updateOptimisticLockSchema = zod.z.object({
-  column: zod.z.string().min(1, "Optimistic lock column must not be empty").describe("Version or lock column name"),
-  expectedValue: zod.z.union([
-    zod.z.string().describe("Expected string version value"),
-    zod.z.number().describe("Expected numeric version value")
-  ]).describe("Expected current value for the lock column")
-}).describe("Optional optimistic lock condition");
-var updateBatchOperationSchema = zod.z.object({
-  data: updateDataSchema.describe("Columns and values to update"),
-  where: zod.z.array(updateWhereConditionSchema).optional().describe("WHERE conditions (combined with AND)"),
-  allowFullTableUpdate: zod.z.boolean().default(false).describe("Explicitly allow UPDATE without WHERE conditions for this operation"),
-  optimisticLock: updateOptimisticLockSchema.optional().describe("Optional optimistic locking condition for this operation")
-}).superRefine((value, ctx) => {
-  const hasWhere = (value.where?.length ?? 0) > 0;
-  const hasOptimisticLock = !!value.optimisticLock;
-  if (!value.allowFullTableUpdate && !hasWhere && !hasOptimisticLock) {
-    ctx.addIssue({
-      code: zod.z.ZodIssueCode.custom,
-      path: ["where"],
-      message: "WHERE conditions are required unless allowFullTableUpdate is true"
-    });
-  }
-});
-var updateBatchOptionsSchema = zod.z.object({
-  enabled: zod.z.boolean().optional().default(true).describe("Enable batched processing for operations[] payloads"),
-  batchSize: zod.z.number().int().positive().max(5e3).optional().default(100).describe("Operations per batch chunk"),
+var insertBatchOptionsSchema = zod.z.object({
+  enabled: zod.z.boolean().optional().default(true).describe("Enable chunked batch execution for array insert payloads"),
+  batchSize: zod.z.number().int().positive().max(5e3).optional().default(100).describe("Rows per batch chunk"),
   continueOnError: zod.z.boolean().optional().default(true).describe("Continue processing remaining chunks when one chunk fails"),
   maxRetries: zod.z.number().int().min(0).max(5).optional().default(0).describe("Retry attempts per failed chunk"),
   retryDelayMs: zod.z.number().int().min(0).max(6e4).optional().default(0).describe("Delay between retry attempts in milliseconds"),
   benchmark: zod.z.boolean().optional().default(false).describe("Run synthetic benchmark metadata comparing individual vs batched execution callbacks")
 });
-var relationalUpdateSchema = zod.z.object({
+var relationalInsertSchema = zod.z.object({
   table: zod.z.string().min(1, "Table name is required").regex(
     VALID_QUALIFIED_IDENTIFIER_PATTERN,
     "Table name contains invalid characters. Only alphanumeric characters, underscores, and dots (for schema qualification) are allowed."
-  ).describe("Table name to update (schema-qualified names supported, e.g. public.users)"),
-  data: updateDataSchema.optional().describe("Columns and values to update"),
-  where: zod.z.array(updateWhereConditionSchema).optional().describe("WHERE conditions (combined with AND)"),
-  allowFullTableUpdate: zod.z.boolean().default(false).describe("Explicitly allow UPDATE without WHERE conditions"),
-  optimisticLock: updateOptimisticLockSchema.optional().describe("Optional optimistic locking condition"),
-  operations: zod.z.array(updateBatchOperationSchema).min(1, "operations must contain at least one batch item").optional().describe("Batch update operation list"),
-  batch: updateBatchOptionsSchema.optional().describe("Optional batch execution controls for operations payloads"),
+  ).describe("Table name to insert into (schema-qualified names supported, e.g. public.users)"),
+  data: zod.z.union([
+    insertRowSchema,
+    zod.z.array(insertRowSchema).min(1, "Insert data array must not be empty")
+  ]).describe("Single row object or array of row objects to insert"),
+  batch: insertBatchOptionsSchema.optional().describe("Optional batch execution controls for array insert payloads"),
+  returning: insertReturningSchema.optional().describe("Optional RETURNING behavior"),
   vendor: zod.z.enum(["postgresql", "mysql", "sqlite"]).describe("Database vendor"),
   connectionString: zod.z.string().min(1, "Database connection string is required").describe("Database connection string")
-}).superRefine((value, ctx) => {
-  const hasOperations = (value.operations?.length ?? 0) > 0;
-  if (hasOperations && value.data) {
-    ctx.addIssue({
-      code: zod.z.ZodIssueCode.custom,
-      path: ["data"],
-      message: "data cannot be provided when operations[] is used"
-    });
-  }
-  if (!hasOperations && !value.data) {
-    ctx.addIssue({
-      code: zod.z.ZodIssueCode.custom,
-      path: ["data"],
-      message: "data is required when operations[] is not provided"
-    });
-  }
-  if (hasOperations && (value.where?.length ?? 0) > 0) {
-    ctx.addIssue({
-      code: zod.z.ZodIssueCode.custom,
-      path: ["where"],
-      message: "where cannot be provided when operations[] is used"
-    });
-  }
-  if (hasOperations && value.optimisticLock) {
-    ctx.addIssue({
-      code: zod.z.ZodIssueCode.custom,
-      path: ["optimisticLock"],
-      message: "optimisticLock cannot be provided when operations[] is used"
-    });
-  }
-  if (hasOperations && value.allowFullTableUpdate) {
-    ctx.addIssue({
-      code: zod.z.ZodIssueCode.custom,
-      path: ["allowFullTableUpdate"],
-      message: "allowFullTableUpdate cannot be provided when operations[] is used"
-    });
-  }
-  if (hasOperations) {
-    return;
-  }
-  const hasWhere = (value.where?.length ?? 0) > 0;
-  const hasOptimisticLock = !!value.optimisticLock;
-  if (!value.allowFullTableUpdate && !hasWhere && !hasOptimisticLock) {
-    ctx.addIssue({
-      code: zod.z.ZodIssueCode.custom,
-      path: ["where"],
-      message: "WHERE conditions are required unless allowFullTableUpdate is true"
-    });
-  }
 });
 
-// src/data/relational/tools/relational-update/error-utils.ts
-var SAFE_UPDATE_VALIDATION_PATTERNS = [
+// src/data/relational/tools/relational-insert/error-utils.ts
+var SAFE_INSERT_VALIDATION_PATTERNS = [
   "must not be empty",
   "contains invalid characters",
-  "Update data must be an object",
-  "Update data must not be empty",
+  "must be an object",
+  "must not be an empty array",
   "must not be undefined",
-  "WHERE conditions are required for UPDATE queries",
-  "null is only allowed with isNull/isNotNull operators",
-  "operator requires a string or number value",
-  "operator requires a non-empty array value",
-  "operator requires a string value",
-  "must not include value",
-  "Optimistic lock expectedValue must not be empty",
-  "optimistic lock check failed",
-  "WHERE conditions are required unless allowFullTableUpdate is true"
+  "idColumn can only be provided",
+  "Returning full rows is not supported for mysql",
+  "Batch INSERT with only DEFAULT VALUES is not supported"
 ];
 var CONSTRAINT_VIOLATION_PATTERNS2 = [
   {
     pattern: /(unique constraint|duplicate key|duplicate entry)/i,
-    message: "Update failed: unique constraint violation."
+    message: "Insert failed: unique constraint violation."
   },
   {
     pattern: /(foreign key constraint|violates foreign key constraint)/i,
-    message: "Update failed: foreign key constraint violation."
+    message: "Insert failed: foreign key constraint violation."
   },
   {
     pattern: /(not null constraint|cannot be null)/i,
-    message: "Update failed: NOT NULL constraint violation."
+    message: "Insert failed: NOT NULL constraint violation."
   }
 ];
-function isSafeUpdateValidationError(error) {
+function isSafeInsertValidationError(error) {
   if (!(error instanceof Error)) {
     return false;
   }
-  return SAFE_UPDATE_VALIDATION_PATTERNS.some((pattern) => error.message.includes(pattern));
+  return SAFE_INSERT_VALIDATION_PATTERNS.some((pattern) => error.message.includes(pattern));
 }
-function getUpdateConstraintViolationMessage(error) {
+function getConstraintViolationMessage(error) {
   if (!(error instanceof Error)) {
     return null;
   }
@@ -8414,35 +8279,74 @@ function getUpdateConstraintViolationMessage(error) {
   }
   return null;
 }
-function isSafeUpdateError(error) {
+function isSafeInsertError(error) {
   if (!(error instanceof Error)) {
     return false;
   }
-  return isSafeUpdateValidationError(error) || getUpdateConstraintViolationMessage(error) !== null;
+  return isSafeInsertValidationError(error) || getConstraintViolationMessage(error) !== null;
 }
-var updateExecutorLogger = core.createLogger("agentforge:tools:data:relational:update");
+var insertExecutorLogger = core.createLogger("agentforge:tools:data:relational:insert");
 function toNumber2(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
-function normalizeAffectedRows(result) {
+function isPlainObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeExecutionResult(result) {
   if (Array.isArray(result)) {
-    if (result.length > 0 && result[0] && typeof result[0] === "object") {
+    if (result.length > 0 && isPlainObject(result[0])) {
       const first = result[0];
       const affectedRows = toNumber2(first.affectedRows) ?? toNumber2(first.rowCount) ?? toNumber2(first.changes);
-      if (affectedRows !== void 0) {
-        return affectedRows;
+      const insertId = toNumber2(first.insertId);
+      const lastInsertRowid = toNumber2(first.lastInsertRowid);
+      if (affectedRows !== void 0 || insertId !== void 0 || lastInsertRowid !== void 0) {
+        return {
+          rows: [],
+          rowCount: affectedRows ?? 0,
+          insertId,
+          lastInsertRowid
+        };
       }
     }
-    return result.length;
+    return {
+      rows: result,
+      rowCount: result.length
+    };
   }
-  if (result && typeof result === "object") {
-    const resultRecord = result;
-    return toNumber2(resultRecord.rowCount) ?? toNumber2(resultRecord.affectedRows) ?? toNumber2(resultRecord.changes) ?? (Array.isArray(resultRecord.rows) ? resultRecord.rows.length : 0);
+  if (isPlainObject(result)) {
+    const rows = Array.isArray(result.rows) ? result.rows : [];
+    const rowCount = toNumber2(result.rowCount) ?? toNumber2(result.affectedRows) ?? toNumber2(result.changes) ?? rows.length;
+    return {
+      rows,
+      rowCount,
+      insertId: toNumber2(result.insertId),
+      lastInsertRowid: toNumber2(result.lastInsertRowid)
+    };
   }
-  return 0;
+  return {
+    rows: [],
+    rowCount: 0
+  };
 }
-function toErrorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
+function deriveInsertedIds(options) {
+  const { idColumn, inputRows, returnedRows, rowCount, insertId, lastInsertRowid } = options;
+  if (returnedRows.length > 0) {
+    const idsFromReturn = returnedRows.map((row) => isPlainObject(row) ? row[idColumn] : void 0).filter((id) => typeof id === "number" || typeof id === "string");
+    if (idsFromReturn.length > 0) {
+      return idsFromReturn;
+    }
+  }
+  if (inputRows.every((row) => typeof row[idColumn] === "number" || typeof row[idColumn] === "string")) {
+    return inputRows.map((row) => row[idColumn]);
+  }
+  if (insertId !== void 0 && rowCount > 0) {
+    return Array.from({ length: rowCount }, (_, index) => insertId + index);
+  }
+  if (lastInsertRowid !== void 0 && rowCount > 0) {
+    const startId = lastInsertRowid - rowCount + 1;
+    return Array.from({ length: rowCount }, (_, index) => startId + index);
+  }
+  return [];
 }
 function resolveBatchOptions2(batch) {
   if (!batch || batch.enabled === false) {
@@ -8457,88 +8361,79 @@ function resolveBatchOptions2(batch) {
     benchmark: batch.benchmark ?? false
   };
 }
-function toSingleUpdateOperation(input) {
-  if (!input.data) {
-    throw new Error("UPDATE data is required when operations[] is not provided.");
-  }
-  return {
-    data: input.data,
-    where: input.where,
-    allowFullTableUpdate: input.allowFullTableUpdate,
-    optimisticLock: input.optimisticLock
-  };
+function toSingleInsertRows(row) {
+  return [row];
 }
 
-// src/data/relational/tools/relational-update/executor-single.ts
-async function executeSingleUpdate(manager, input, operation, context) {
-  const built = buildUpdateQuery({
+// src/data/relational/tools/relational-insert/executor-single.ts
+async function executeInsertOnce(executor, input, context) {
+  const built = buildInsertQuery({
     table: input.table,
-    data: operation.data,
-    where: operation.where,
-    allowFullTableUpdate: operation.allowFullTableUpdate,
-    optimisticLock: operation.optimisticLock,
+    data: input.data,
+    returning: input.returning,
     vendor: input.vendor
   });
-  const executor = manager;
-  const rawResult = await executor.execute(built.query);
-  const rowCount = normalizeAffectedRows(rawResult);
-  if (built.usesOptimisticLock && rowCount === 0) {
-    throw new Error("Update failed: optimistic lock check failed.");
+  const session = context?.transaction ?? executor;
+  if (Array.isArray(built.query)) {
+    let totalRowCount = 0;
+    const allRows = [];
+    const allIds = [];
+    for (const singleQuery of built.query) {
+      const rawResult2 = await session.execute(singleQuery);
+      const normalized2 = normalizeExecutionResult(rawResult2);
+      totalRowCount += normalized2.rowCount > 0 ? normalized2.rowCount : 1;
+      if (built.returningMode === "row") {
+        allRows.push(...normalized2.rows);
+      }
+      if (built.returningMode === "id") {
+        const ids = deriveInsertedIds({
+          idColumn: built.idColumn,
+          inputRows: toSingleInsertRows(built.rows[allIds.length]),
+          returnedRows: normalized2.rows,
+          rowCount: 1,
+          insertId: normalized2.insertId,
+          lastInsertRowid: normalized2.lastInsertRowid
+        });
+        allIds.push(...ids);
+      }
+    }
+    return {
+      rowCount: totalRowCount,
+      rows: allRows,
+      insertedIds: allIds,
+      executionTime: 0
+    };
   }
+  const rawResult = await session.execute(built.query);
+  const normalized = normalizeExecutionResult(rawResult);
+  const rowCount = normalized.rowCount > 0 ? normalized.rowCount : built.rows.length;
+  const rows = built.returningMode === "row" ? normalized.rows : [];
+  const insertedIds = built.returningMode === "id" ? deriveInsertedIds({
+    idColumn: built.idColumn,
+    inputRows: built.rows,
+    returnedRows: normalized.rows,
+    rowCount,
+    insertId: normalized.insertId,
+    lastInsertRowid: normalized.lastInsertRowid
+  }) : [];
   return {
     rowCount,
+    rows,
+    insertedIds,
     executionTime: 0
   };
 }
 
-// src/data/relational/tools/relational-update/executor-batch.ts
-async function executeUpdateInBatchMode(manager, input, context, options) {
+// src/data/relational/tools/relational-insert/executor-batch.ts
+async function executeInsertInBatchMode(executor, input, context, options) {
   const batchResult = await executeBatchedTask(
     {
-      operation: "update",
-      items: input.operations,
-      executeBatch: async (operations, batchIndex) => {
-        let rowCount2 = 0;
-        let successfulItems = 0;
-        let failedItems = 0;
-        const failures = [];
-        for (const operation of operations) {
-          try {
-            const result = await executeSingleUpdate(
-              manager,
-              input,
-              {
-                data: operation.data,
-                where: operation.where,
-                allowFullTableUpdate: operation.allowFullTableUpdate,
-                optimisticLock: operation.optimisticLock
-              },
-              context
-            );
-            rowCount2 += result.rowCount;
-            successfulItems += 1;
-          } catch (error) {
-            if (!options.continueOnError) {
-              throw error;
-            }
-            failedItems += 1;
-            failures.push({
-              operation: "update",
-              batchIndex,
-              batchSize: operations.length,
-              attempts: 1,
-              error: toErrorMessage(error)
-            });
-          }
-        }
-        return {
-          rowCount: rowCount2,
-          successfulItems,
-          failedItems,
-          failures
-        };
-      },
-      getBatchSuccessCount: (result) => result.successfulItems
+      operation: "insert",
+      items: input.data,
+      executeBatch: async (rows2) => executeInsertOnce(executor, {
+        ...input,
+        data: rows2}, context),
+      getBatchSuccessCount: (result, rows2) => Math.min(result.rowCount, rows2.length)
     },
     {
       batchSize: options.batchSize,
@@ -8546,7 +8441,7 @@ async function executeUpdateInBatchMode(manager, input, context, options) {
       maxRetries: options.maxRetries,
       retryDelayMs: options.retryDelayMs,
       onProgress: (progress) => {
-        updateExecutorLogger.debug("UPDATE batch progress", {
+        insertExecutorLogger.debug("INSERT batch progress", {
           vendor: input.vendor,
           table: input.table,
           ...progress
@@ -8555,165 +8450,601 @@ async function executeUpdateInBatchMode(manager, input, context, options) {
     }
   );
   const rowCount = batchResult.results.reduce((total, result) => total + result.rowCount, 0);
-  const operationFailures = batchResult.results.flatMap((result) => result.failures);
+  const rows = batchResult.results.flatMap((result) => result.rows);
+  const insertedIds = batchResult.results.flatMap((result) => result.insertedIds);
   let benchmark;
   if (options.benchmark) {
-    updateExecutorLogger.warn("UPDATE batch benchmark enabled. Synthetic benchmark callbacks are side-effect free and do not execute SQL.", {
+    insertExecutorLogger.warn("INSERT batch benchmark enabled. Synthetic benchmark callbacks are side-effect free and do not execute SQL.", {
       vendor: input.vendor,
       table: input.table,
-      operationCount: input.operations.length,
+      totalRows: input.data.length,
       batchSize: options.batchSize
     });
-    benchmark = await benchmarkBatchExecution({
-      items: input.operations,
-      batchSize: options.batchSize,
-      runIndividual: async () => {
-      },
-      runBatch: async () => {
-      }
+    benchmark = await benchmarkBatchExecution({
+      items: input.data,
+      batchSize: options.batchSize,
+      runIndividual: async () => {
+      },
+      runBatch: async () => {
+      }
+    });
+  }
+  return {
+    rowCount,
+    rows,
+    insertedIds,
+    executionTime: batchResult.executionTime,
+    batch: {
+      enabled: true,
+      batchSize: options.batchSize,
+      totalItems: batchResult.totalItems,
+      processedItems: batchResult.processedItems,
+      successfulItems: batchResult.successfulItems,
+      failedItems: batchResult.failedItems,
+      totalBatches: batchResult.totalBatches,
+      retries: batchResult.retries,
+      partialSuccess: batchResult.partialSuccess,
+      failures: batchResult.failures,
+      benchmark
+    }
+  };
+}
+
+// src/data/relational/tools/relational-insert/executor.ts
+function getCauseMetadata(error) {
+  if (!(error instanceof Error) || !error.cause || typeof error.cause !== "object") {
+    return {};
+  }
+  const cause = error.cause;
+  return {
+    causeType: error.cause instanceof Error ? error.cause.name : "object",
+    ...typeof cause.code === "string" ? { causeCode: cause.code } : {},
+    ...typeof cause.constraint === "string" ? { causeConstraint: cause.constraint } : {}
+  };
+}
+async function executeInsert(executor, input, context) {
+  const startTime = Date.now();
+  insertExecutorLogger.debug("Building INSERT query", {
+    vendor: input.vendor,
+    table: input.table,
+    isBatch: Array.isArray(input.data),
+    batchModeEnabled: !!input.batch?.enabled,
+    returningMode: input.returning?.mode ?? "none"
+  });
+  try {
+    const batchOptions = resolveBatchOptions2(input.batch);
+    const result = Array.isArray(input.data) && batchOptions ? await executeInsertInBatchMode(
+      executor,
+      input,
+      context,
+      batchOptions
+    ) : await executeInsertOnce(executor, input, context);
+    const executionTime = Date.now() - startTime;
+    insertExecutorLogger.debug("INSERT query executed successfully", {
+      vendor: input.vendor,
+      table: input.table,
+      rowCount: result.rowCount,
+      returnedRows: result.rows.length,
+      returnedIds: result.insertedIds.length,
+      executionTime,
+      batchMode: !!result.batch,
+      partialSuccess: result.batch?.partialSuccess ?? false
+    });
+    return {
+      ...result,
+      executionTime
+    };
+  } catch (error) {
+    const executionTime = Date.now() - startTime;
+    insertExecutorLogger.error("INSERT query execution failed", {
+      vendor: input.vendor,
+      table: input.table,
+      error: error instanceof Error ? error.message : String(error),
+      ...getCauseMetadata(error),
+      executionTime
+    });
+    const constraintMessage = getConstraintViolationMessage(error);
+    if (constraintMessage) {
+      throw new Error(constraintMessage, { cause: error });
+    }
+    if (isSafeInsertValidationError(error)) {
+      throw error;
+    }
+    throw new Error("INSERT query failed. See logs for details.", { cause: error });
+  }
+}
+
+// src/data/relational/tools/relational-insert/index.ts
+function toInsertErrorResponse(error) {
+  const errorMessage = isSafeInsertError(error) ? error.message : "Failed to execute INSERT query. Please verify your input and database connection.";
+  return {
+    success: false,
+    error: errorMessage,
+    rowCount: 0,
+    insertedIds: [],
+    rows: []
+  };
+}
+async function invokeRelationalInsert(execution, input) {
+  try {
+    const result = await executeInsert(
+      execution.executor,
+      { ...input, vendor: execution.vendor },
+      execution.transaction ? { transaction: execution.transaction } : void 0
+    );
+    return {
+      success: true,
+      rowCount: result.rowCount,
+      insertedIds: result.insertedIds,
+      rows: result.rows,
+      executionTime: result.executionTime,
+      batch: result.batch
+    };
+  } catch (error) {
+    return toInsertErrorResponse(error);
+  }
+}
+var relationalInsert = core.toolBuilder().name("relational-insert").displayName("Relational INSERT").description("Execute type-safe INSERT queries with single-row and batch insert support").category(core.ToolCategory.DATABASE).tags(["database", "sql", "insert", "postgresql", "mysql", "sqlite"]).schema(relationalInsertSchema).example({
+  description: "Insert a single row and return generated ID",
+  input: {
+    table: "users",
+    data: { name: "Alice", email: "alice@example.com" },
+    returning: { mode: "id", idColumn: "id" },
+    vendor: "postgresql",
+    connectionString: "postgresql://localhost/mydb"
+  }
+}).example({
+  description: "Batch insert rows",
+  input: {
+    table: "users",
+    data: [
+      { name: "Bob", email: "bob@example.com" },
+      { name: "Carol", email: "carol@example.com" }
+    ],
+    batch: {
+      batchSize: 250,
+      continueOnError: true,
+      maxRetries: 1
+    },
+    vendor: "sqlite",
+    connectionString: "data.db"
+  }
+}).implement(async (input) => {
+  const { connectionString, vendor, ...operation } = input;
+  return withEphemeralRelationalMutationToolSet(
+    { vendor, connectionString },
+    async (toolSet) => replaceMutationConnectionFailure(
+      await toolSet.insert.invoke(operation),
+      INSERT_CONNECTION_FAILURE,
+      "Failed to execute INSERT query. Please verify your input and database connection."
+    ),
+    toInsertErrorResponse
+  );
+}).build();
+var relationalQuerySchema = zod.z.object({
+  sql: zod.z.string().describe("SQL query string to execute"),
+  params: zod.z.union([
+    zod.z.array(zod.z.unknown()).describe("Positional parameters (e.g., [value1, value2])"),
+    zod.z.record(zod.z.string(), zod.z.unknown()).describe('Named parameters (e.g., { name: "John", age: 30 })')
+  ]).optional().describe("Query parameters for parameter binding (prevents SQL injection)"),
+  vendor: zod.z.enum(["postgresql", "mysql", "sqlite"]).describe("Database vendor"),
+  connectionString: zod.z.string().min(1, "Database connection string is required").describe("Database connection string used to create a new connection")
+});
+function toQueryErrorResponse(error) {
+  return {
+    success: false,
+    error: error instanceof Error ? error.message : "Unknown error occurred",
+    rows: [],
+    rowCount: 0
+  };
+}
+async function invokeRelationalQuery(execution, input) {
+  try {
+    const queryInput = {
+      sql: input.sql,
+      params: input.params,
+      vendor: execution.vendor
+    };
+    const result = execution.transaction ? await executeQuery2(execution.executor, queryInput, { transaction: execution.transaction }) : await executeQuery2(execution.executor, queryInput);
+    return {
+      success: true,
+      rows: result.rows,
+      rowCount: result.rowCount,
+      executionTime: result.executionTime
+    };
+  } catch (error) {
+    return toQueryErrorResponse(error);
+  }
+}
+var relationalQuery = core.toolBuilder().name("relational-query").displayName("Relational Query").description("Execute raw SQL queries against relational databases (PostgreSQL, MySQL, SQLite) with parameter binding to prevent SQL injection").category(core.ToolCategory.DATABASE).tags(["database", "sql", "query", "postgresql", "mysql", "sqlite"]).schema(relationalQuerySchema).example({
+  description: "SELECT query with positional parameters",
+  input: {
+    sql: "SELECT * FROM users WHERE id = $1",
+    params: [42],
+    vendor: "postgresql",
+    connectionString: "postgresql://user:pass@localhost:5432/mydb"
+  }
+}).example({
+  description: "INSERT query with named parameters",
+  input: {
+    sql: "INSERT INTO users (name, email) VALUES (:name, :email)",
+    params: { name: "John Doe", email: "john@example.com" },
+    vendor: "postgresql",
+    connectionString: "postgresql://user:pass@localhost:5432/mydb"
+  }
+}).example({
+  description: "UPDATE query with positional parameters",
+  input: {
+    sql: "UPDATE users SET status = ? WHERE id = ?",
+    params: ["active", 42],
+    vendor: "mysql",
+    connectionString: "mysql://user:pass@localhost:3306/mydb"
+  }
+}).usageNotes("Always use parameter binding (params) instead of string concatenation to prevent SQL injection. Supports positional ($1, ?) and named (:name) parameters.").limitation("Requires database-specific driver as peer dependency (pg, mysql2, or better-sqlite3)").limitation("Connection string must be valid for the specified vendor").limitation("Large result sets may impact performance").limitation("Placeholder characters ($n, ?, :name) inside SQL string literals are not supported. Use parameter binding for all dynamic values instead of embedding them in string literals").implement(async (input) => {
+  const { connectionString, vendor, ...operation } = input;
+  return withEphemeralRelationalToolSet(
+    { vendor, connectionString },
+    async (toolSet) => replaceConnectionFailureMessage(
+      await toolSet.query.invoke(operation),
+      QUERY_CONNECTION_FAILURE,
+      `Failed to initialize ${vendor} connection`
+    )
+  );
+}).build();
+var whereOperatorSchema = zod.z.enum([
+  "eq",
+  // equals
+  "ne",
+  // not equals
+  "gt",
+  // greater than
+  "lt",
+  // less than
+  "gte",
+  // greater than or equal
+  "lte",
+  // less than or equal
+  "like",
+  // LIKE pattern matching
+  "in",
+  // IN array
+  "notIn",
+  // NOT IN array
+  "isNull",
+  // IS NULL
+  "isNotNull"
+  // IS NOT NULL
+]);
+var whereConditionSchema = zod.z.object({
+  column: zod.z.string().min(1, "Column name must not be empty").describe("Column name to filter on"),
+  operator: whereOperatorSchema.describe("Comparison operator"),
+  value: zod.z.union([
+    zod.z.string(),
+    zod.z.number(),
+    zod.z.boolean(),
+    zod.z.array(zod.z.union([zod.z.string(), zod.z.number()])),
+    zod.z.null()
+  ]).optional().describe("Value to compare against (not required for isNull/isNotNull)")
+}).superRefine((val, ctx) => {
+  const op = val.operator;
+  if (op === "isNull" || op === "isNotNull") {
+    if (val.value !== void 0) {
+      ctx.addIssue({
+        code: zod.z.ZodIssueCode.custom,
+        path: ["value"],
+        message: "value must not be provided when using isNull or isNotNull operator"
+      });
+    }
+    return;
+  }
+  if (val.value === void 0) {
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      path: ["value"],
+      message: "value is required for this operator"
+    });
+    return;
+  }
+  if (op === "in" || op === "notIn") {
+    if (!Array.isArray(val.value)) {
+      ctx.addIssue({
+        code: zod.z.ZodIssueCode.custom,
+        path: ["value"],
+        message: `${op === "in" ? "IN" : "NOT IN"} operator requires an array value`
+      });
+    } else if (val.value.length === 0) {
+      ctx.addIssue({
+        code: zod.z.ZodIssueCode.custom,
+        path: ["value"],
+        message: `${op === "in" ? "IN" : "NOT IN"} operator requires a non-empty array value`
+      });
+    }
+    return;
+  }
+  if (val.value === null) {
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      path: ["value"],
+      message: "null is only allowed with isNull/isNotNull operators"
+    });
+    return;
+  }
+  if (op === "like" && typeof val.value !== "string") {
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      path: ["value"],
+      message: "LIKE operator requires a string value"
+    });
+    return;
+  }
+  if ((op === "gt" || op === "lt" || op === "gte" || op === "lte") && typeof val.value !== "string" && typeof val.value !== "number") {
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      path: ["value"],
+      message: `${op.toUpperCase()} operator requires a string or number value`
     });
+    return;
   }
-  return {
-    rowCount,
-    executionTime: batchResult.executionTime,
-    batch: {
-      enabled: true,
-      batchSize: options.batchSize,
-      totalItems: batchResult.totalItems,
-      processedItems: batchResult.processedItems,
-      successfulItems: batchResult.successfulItems,
-      failedItems: batchResult.failedItems,
-      totalBatches: batchResult.totalBatches,
-      retries: batchResult.retries,
-      partialSuccess: batchResult.partialSuccess,
-      failures: [...batchResult.failures, ...operationFailures],
-      benchmark
-    }
+  if ((op === "eq" || op === "ne") && Array.isArray(val.value)) {
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      path: ["value"],
+      message: `${op.toUpperCase()} operator requires a scalar value`
+    });
+  }
+});
+var orderDirectionSchema = zod.z.enum(["asc", "desc"]);
+var orderBySchema = zod.z.object({
+  column: zod.z.string().min(1, "Column name must not be empty").describe("Column name to order by"),
+  direction: orderDirectionSchema.describe("Sort direction (ascending or descending)")
+});
+var streamingOptionsSchema = zod.z.object({
+  enabled: zod.z.boolean().default(true).describe("Enable chunked streaming mode for large result sets"),
+  chunkSize: zod.z.number().int().min(1).max(5e3).optional().describe("Rows fetched per chunk (default: 100)"),
+  maxRows: zod.z.number().int().positive().optional().describe("Optional cap on streamed rows"),
+  sampleSize: zod.z.number().int().min(0).max(5e3).optional().describe("Number of rows to include in the response payload"),
+  benchmark: zod.z.boolean().optional().default(false).describe("Run memory benchmark comparing regular vs streaming execution (adds two extra query executions; use side-effect-free SELECT statements)")
+});
+var relationalSelectSchema = zod.z.object({
+  table: zod.z.string().min(1, "Table name is required").regex(
+    VALID_QUALIFIED_IDENTIFIER_PATTERN,
+    "Table name contains invalid characters. Only alphanumeric characters, underscores, and dots (for schema qualification) are allowed."
+  ).describe("Table name to select from (schema-qualified names supported, e.g. public.users)"),
+  columns: zod.z.array(zod.z.string().min(1, "Column name must not be empty")).min(1, "Columns array must not be empty").optional().describe("Columns to select (omit for SELECT *)"),
+  where: zod.z.array(whereConditionSchema).optional().describe("WHERE conditions (combined with AND)"),
+  orderBy: zod.z.array(orderBySchema).optional().describe("ORDER BY clauses"),
+  limit: zod.z.number().int().positive().optional().describe("Maximum number of rows to return"),
+  offset: zod.z.number().int().nonnegative().optional().describe("Number of rows to skip"),
+  streaming: streamingOptionsSchema.optional().describe("Optional streaming mode configuration"),
+  vendor: zod.z.enum(["postgresql", "mysql", "sqlite"]).describe("Database vendor"),
+  connectionString: zod.z.string().min(1, "Database connection string is required").describe("Database connection string")
+});
+
+// src/data/relational/tools/relational-select/query-builder.ts
+function buildSelectQuery2(input) {
+  const queryInput = {
+    table: input.table,
+    columns: input.columns,
+    where: input.where,
+    orderBy: input.orderBy,
+    limit: input.limit,
+    offset: input.offset,
+    vendor: input.vendor
   };
+  return buildSelectQuery(queryInput);
 }
 
-// src/data/relational/tools/relational-update/executor.ts
-async function executeUpdate(manager, input, context) {
+// src/data/relational/tools/relational-select/error-utils.ts
+var SAFE_VALIDATION_ERROR_PATTERNS2 = [
+  "must not be empty",
+  "contains invalid characters",
+  "requires an array value",
+  "requires a non-empty array value",
+  "must be an integer between",
+  "must be a positive integer",
+  "null is only allowed with isNull/isNotNull operators",
+  "LIKE operator requires a string value",
+  "operator requires a string or number value",
+  "operator requires a scalar value",
+  "Stream cancelled by caller"
+];
+function isSafeValidationError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  return SAFE_VALIDATION_ERROR_PATTERNS2.some(
+    (pattern) => error.message.includes(pattern)
+  );
+}
+
+// src/data/relational/tools/relational-select/executor.ts
+var logger17 = core.createLogger("agentforge:tools:data:relational:select");
+function toSelectQueryInput(input) {
+  return {
+    table: input.table,
+    columns: input.columns,
+    where: input.where,
+    orderBy: input.orderBy,
+    limit: input.limit,
+    offset: input.offset,
+    vendor: input.vendor
+  };
+}
+async function executeSelect(executor, input, context) {
   const startTime = Date.now();
-  updateExecutorLogger.debug("Building UPDATE query", {
+  logger17.debug("Building SELECT query", {
     vendor: input.vendor,
     table: input.table,
-    hasWhere: !!input.where?.length,
-    ...input.allowFullTableUpdate !== void 0 ? { allowFullTableUpdate: input.allowFullTableUpdate } : {},
-    hasOptimisticLock: !!input.optimisticLock,
-    operationCount: input.operations?.length ?? 0,
-    batchModeEnabled: !!input.batch?.enabled
+    hasWhere: !!input.where,
+    hasOrderBy: !!input.orderBy,
+    hasLimit: !!input.limit,
+    streamingEnabled: !!input.streaming?.enabled
   });
   try {
-    const batchOptions = resolveBatchOptions2(input.batch);
-    const result = input.operations && batchOptions ? await executeUpdateInBatchMode(
-      manager,
-      input,
-      context,
-      batchOptions
-    ) : await executeSingleUpdate(manager, input, toSingleUpdateOperation(input), context);
+    const session = context?.transaction ?? executor;
+    if (input.streaming?.enabled) {
+      const streamOptions = {
+        chunkSize: input.streaming.chunkSize,
+        maxRows: input.streaming.maxRows,
+        sampleSize: input.streaming.sampleSize
+      };
+      const streamInput = toSelectQueryInput(input);
+      if (input.streaming.benchmark) {
+        logger17.warn("Streaming benchmark enabled; SELECT will execute up to three times (result + benchmark regular + benchmark streaming).", {
+          vendor: input.vendor,
+          table: input.table,
+          chunkSize: streamOptions.chunkSize ?? DEFAULT_CHUNK_SIZE,
+          ...streamOptions.maxRows !== void 0 ? { maxRows: streamOptions.maxRows } : {},
+          ...streamOptions.sampleSize !== void 0 ? { sampleSize: streamOptions.sampleSize } : {}
+        });
+      }
+      const streamResult = await executeStreamingSelect(session, streamInput, streamOptions);
+      const benchmark = input.streaming.benchmark ? await benchmarkStreamingSelectMemory(session, streamInput, streamOptions) : void 0;
+      const executionTime2 = Date.now() - startTime;
+      logger17.debug("Streaming SELECT query executed successfully", {
+        vendor: input.vendor,
+        table: input.table,
+        rowCount: streamResult.rowCount,
+        chunkCount: streamResult.chunkCount,
+        executionTime: executionTime2,
+        cancelled: streamResult.cancelled
+      });
+      return {
+        rows: streamResult.rows,
+        rowCount: streamResult.rowCount,
+        executionTime: executionTime2,
+        streaming: {
+          enabled: true,
+          chunkSize: input.streaming.chunkSize ?? DEFAULT_CHUNK_SIZE,
+          chunkCount: streamResult.chunkCount,
+          sampledRowCount: streamResult.rows.length,
+          streamedRowCount: streamResult.rowCount,
+          cancelled: streamResult.cancelled,
+          memoryUsage: streamResult.memoryUsage,
+          benchmark
+        }
+      };
+    }
+    const query = buildSelectQuery2(input);
+    const result = await session.execute(query);
     const executionTime = Date.now() - startTime;
-    updateExecutorLogger.debug("UPDATE query executed successfully", {
+    const rows = Array.isArray(result) ? result : result.rows || [];
+    const rowCount = rows.length;
+    logger17.debug("SELECT query executed successfully", {
       vendor: input.vendor,
       table: input.table,
-      rowCount: result.rowCount,
-      executionTime,
-      batchMode: !!result.batch,
-      partialSuccess: result.batch?.partialSuccess ?? false
+      rowCount,
+      executionTime
     });
     return {
-      ...result,
+      rows,
+      rowCount,
       executionTime
     };
   } catch (error) {
     const executionTime = Date.now() - startTime;
-    updateExecutorLogger.error("UPDATE query execution failed", {
+    logger17.error("SELECT query execution failed", {
       vendor: input.vendor,
       table: input.table,
       error: error instanceof Error ? error.message : String(error),
       executionTime
     });
-    const constraintMessage = getUpdateConstraintViolationMessage(error);
-    if (constraintMessage) {
-      throw new Error(constraintMessage, { cause: error });
-    }
-    if (isSafeUpdateValidationError(error)) {
+    if (isSafeValidationError(error)) {
       throw error;
     }
-    throw new Error("UPDATE query failed. See logs for details.", { cause: error });
+    throw new Error("SELECT query failed. See logs for details.", { cause: error });
   }
 }
 
-// src/data/relational/tools/relational-update/index.ts
-var relationalUpdate = core.toolBuilder().name("relational-update").displayName("Relational UPDATE").description("Execute type-safe UPDATE queries with single and batched operation support").category(core.ToolCategory.DATABASE).tags(["database", "sql", "update", "postgresql", "mysql", "sqlite"]).schema(relationalUpdateSchema).example({
-  description: "Update one row by condition",
+// src/data/relational/tools/relational-select/index.ts
+function toSelectErrorResponse(error) {
+  const errorMessage = isSafeValidationError(error) ? error.message : "Failed to execute SELECT query. Please verify your input and database connection.";
+  return {
+    success: false,
+    error: errorMessage,
+    rows: [],
+    rowCount: 0
+  };
+}
+async function invokeRelationalSelect(execution, input) {
+  try {
+    const result = await executeSelect(
+      execution.executor,
+      { ...input, vendor: execution.vendor },
+      execution.transaction ? { transaction: execution.transaction } : void 0
+    );
+    return {
+      success: true,
+      rows: result.rows,
+      rowCount: result.rowCount,
+      executionTime: result.executionTime,
+      streaming: result.streaming
+    };
+  } catch (error) {
+    return toSelectErrorResponse(error);
+  }
+}
+var relationalSelect = core.toolBuilder().name("relational-select").displayName("Relational SELECT").description("Execute type-safe SELECT queries with WHERE conditions, ORDER BY, LIMIT, and OFFSET using Drizzle ORM query builder").category(core.ToolCategory.DATABASE).tags(["database", "sql", "select", "query", "postgresql", "mysql", "sqlite"]).schema(relationalSelectSchema).example({
+  description: "SELECT with WHERE condition",
   input: {
     table: "users",
-    data: { status: "inactive" },
-    where: [{ column: "id", operator: "eq", value: 123 }],
+    columns: ["id", "name", "email"],
+    where: [{ column: "status", operator: "eq", value: "active" }],
     vendor: "postgresql",
     connectionString: "postgresql://localhost/mydb"
   }
 }).example({
-  description: "Optimistic lock update",
+  description: "SELECT with pagination",
   input: {
-    table: "users",
-    data: { status: "active" },
-    where: [{ column: "id", operator: "eq", value: 123 }],
-    optimisticLock: { column: "version", expectedValue: 5 },
-    vendor: "sqlite",
-    connectionString: "data.db"
+    table: "products",
+    orderBy: [{ column: "created_at", direction: "desc" }],
+    limit: 20,
+    offset: 0,
+    vendor: "mysql",
+    connectionString: "mysql://localhost/shop"
   }
 }).example({
-  description: "Batch update operations",
+  description: "SELECT with streaming mode",
   input: {
-    table: "users",
-    operations: [
-      {
-        data: { status: "inactive" },
-        where: [{ column: "id", operator: "eq", value: 1 }]
-      },
-      {
-        data: { status: "inactive" },
-        where: [{ column: "id", operator: "eq", value: 2 }]
-      }
-    ],
-    batch: {
-      batchSize: 100,
-      continueOnError: true
+    table: "events",
+    orderBy: [{ column: "id", direction: "asc" }],
+    streaming: {
+      enabled: true,
+      chunkSize: 250,
+      sampleSize: 25
     },
     vendor: "postgresql",
-    connectionString: "postgresql://localhost/mydb"
+    connectionString: "postgresql://localhost/analytics"
   }
 }).implement(async (input) => {
-  const manager = new ConnectionManager({
-    vendor: input.vendor,
-    connection: input.connectionString
-  });
-  try {
-    await manager.connect();
-    const result = await executeUpdate(manager, input);
-    return {
-      success: true,
-      rowCount: result.rowCount,
-      executionTime: result.executionTime,
-      batch: result.batch
-    };
-  } catch (error) {
-    let errorMessage = "Failed to execute UPDATE query. Please verify your input and database connection.";
-    if (isSafeUpdateError(error)) {
-      errorMessage = error.message;
-    }
-    return {
-      success: false,
-      error: errorMessage,
-      rowCount: 0
-    };
-  } finally {
-    await manager.disconnect();
-  }
+  const { connectionString, vendor, ...operation } = input;
+  return withEphemeralRelationalToolSet(
+    { vendor, connectionString },
+    async (toolSet) => replaceConnectionFailureMessage(
+      await toolSet.select.invoke(operation),
+      SELECT_CONNECTION_FAILURE,
+      "Failed to execute SELECT query. Please verify your input and database connection."
+    )
+  );
 }).build();
-var deleteWhereOperatorSchema = zod.z.enum([
+var updateValueSchema = zod.z.union([
+  zod.z.string().describe("String value"),
+  zod.z.number().describe("Numeric value"),
+  zod.z.boolean().describe("Boolean value"),
+  zod.z.null().describe("Null value")
+]).describe("Scalar value for an UPDATE column");
+var updateDataSchema = zod.z.record(
+  zod.z.string().min(1, "Column name must not be empty").describe("Column name"),
+  updateValueSchema
+).superRefine((value, ctx) => {
+  if (Object.keys(value).length === 0) {
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      message: "Update data must not be empty"
+    });
+  }
+}).describe("Object containing column-value pairs to update");
+var updateWhereOperatorSchema = zod.z.enum([
   "eq",
   "ne",
   "gt",
@@ -8726,9 +9057,9 @@ var deleteWhereOperatorSchema = zod.z.enum([
   "isNull",
   "isNotNull"
 ]);
-var deleteWhereConditionSchema = zod.z.object({
+var updateWhereConditionSchema = zod.z.object({
   column: zod.z.string().min(1, "Column name must not be empty").describe("Column name to filter on"),
-  operator: deleteWhereOperatorSchema.describe("Comparison operator"),
+  operator: updateWhereOperatorSchema.describe("Comparison operator"),
   value: zod.z.union([
     zod.z.string(),
     zod.z.number(),
@@ -8796,26 +9127,30 @@ var deleteWhereConditionSchema = zod.z.object({
     });
   }
 });
-var deleteSoftDeleteSchema = zod.z.object({
-  column: zod.z.string().min(1, "Soft delete column must not be empty").default("deleted_at").describe("Column to write deletion timestamp/value into"),
-  value: zod.z.union([zod.z.string(), zod.z.number()]).optional().describe("Optional explicit value for the soft-delete column (defaults to ISO timestamp)")
-}).describe("Enable soft delete by updating a column instead of physically deleting rows");
-var deleteBatchOperationSchema = zod.z.object({
-  where: zod.z.array(deleteWhereConditionSchema).optional().describe("WHERE conditions (combined with AND)"),
-  allowFullTableDelete: zod.z.boolean().default(false).describe("Explicitly allow DELETE without WHERE conditions for this operation"),
-  cascade: zod.z.boolean().default(false).describe("Enable cascade-aware error messaging for this operation"),
-  softDelete: deleteSoftDeleteSchema.optional().describe("Use soft-delete semantics instead of hard DELETE for this operation")
+var updateOptimisticLockSchema = zod.z.object({
+  column: zod.z.string().min(1, "Optimistic lock column must not be empty").describe("Version or lock column name"),
+  expectedValue: zod.z.union([
+    zod.z.string().describe("Expected string version value"),
+    zod.z.number().describe("Expected numeric version value")
+  ]).describe("Expected current value for the lock column")
+}).describe("Optional optimistic lock condition");
+var updateBatchOperationSchema = zod.z.object({
+  data: updateDataSchema.describe("Columns and values to update"),
+  where: zod.z.array(updateWhereConditionSchema).optional().describe("WHERE conditions (combined with AND)"),
+  allowFullTableUpdate: zod.z.boolean().default(false).describe("Explicitly allow UPDATE without WHERE conditions for this operation"),
+  optimisticLock: updateOptimisticLockSchema.optional().describe("Optional optimistic locking condition for this operation")
 }).superRefine((value, ctx) => {
   const hasWhere = (value.where?.length ?? 0) > 0;
-  if (!value.allowFullTableDelete && !hasWhere) {
+  const hasOptimisticLock = !!value.optimisticLock;
+  if (!value.allowFullTableUpdate && !hasWhere && !hasOptimisticLock) {
     ctx.addIssue({
       code: zod.z.ZodIssueCode.custom,
       path: ["where"],
-      message: "WHERE conditions are required unless allowFullTableDelete is true"
+      message: "WHERE conditions are required unless allowFullTableUpdate is true"
     });
   }
 });
-var deleteBatchOptionsSchema = zod.z.object({
+var updateBatchOptionsSchema = zod.z.object({
   enabled: zod.z.boolean().optional().default(true).describe("Enable batched processing for operations[] payloads"),
   batchSize: zod.z.number().int().positive().max(5e3).optional().default(100).describe("Operations per batch chunk"),
   continueOnError: zod.z.boolean().optional().default(true).describe("Continue processing remaining chunks when one chunk fails"),
@@ -8823,89 +9158,108 @@ var deleteBatchOptionsSchema = zod.z.object({
   retryDelayMs: zod.z.number().int().min(0).max(6e4).optional().default(0).describe("Delay between retry attempts in milliseconds"),
   benchmark: zod.z.boolean().optional().default(false).describe("Run synthetic benchmark metadata comparing individual vs batched execution callbacks")
 });
-var relationalDeleteSchema = zod.z.object({
+var relationalUpdateSchema = zod.z.object({
   table: zod.z.string().min(1, "Table name is required").regex(
     VALID_QUALIFIED_IDENTIFIER_PATTERN,
     "Table name contains invalid characters. Only alphanumeric characters, underscores, and dots (for schema qualification) are allowed."
-  ).describe("Table name to delete from (schema-qualified names supported, e.g. public.users)"),
-  where: zod.z.array(deleteWhereConditionSchema).optional().describe("WHERE conditions (combined with AND)"),
-  allowFullTableDelete: zod.z.boolean().default(false).describe("Explicitly allow DELETE without WHERE conditions"),
-  cascade: zod.z.boolean().default(false).describe("Enable cascade-aware error messaging for foreign key constraints"),
-  softDelete: deleteSoftDeleteSchema.optional().describe("Use soft-delete semantics instead of hard DELETE"),
-  operations: zod.z.array(deleteBatchOperationSchema).min(1, "operations must contain at least one batch item").optional().describe("Batch delete operation list"),
-  batch: deleteBatchOptionsSchema.optional().describe("Optional batch execution controls for operations payloads"),
+  ).describe("Table name to update (schema-qualified names supported, e.g. public.users)"),
+  data: updateDataSchema.optional().describe("Columns and values to update"),
+  where: zod.z.array(updateWhereConditionSchema).optional().describe("WHERE conditions (combined with AND)"),
+  allowFullTableUpdate: zod.z.boolean().default(false).describe("Explicitly allow UPDATE without WHERE conditions"),
+  optimisticLock: updateOptimisticLockSchema.optional().describe("Optional optimistic locking condition"),
+  operations: zod.z.array(updateBatchOperationSchema).min(1, "operations must contain at least one batch item").optional().describe("Batch update operation list"),
+  batch: updateBatchOptionsSchema.optional().describe("Optional batch execution controls for operations payloads"),
   vendor: zod.z.enum(["postgresql", "mysql", "sqlite"]).describe("Database vendor"),
   connectionString: zod.z.string().min(1, "Database connection string is required").describe("Database connection string")
 }).superRefine((value, ctx) => {
   const hasOperations = (value.operations?.length ?? 0) > 0;
-  if (hasOperations && (value.where?.length ?? 0) > 0) {
+  if (hasOperations && value.data) {
     ctx.addIssue({
       code: zod.z.ZodIssueCode.custom,
-      path: ["where"],
-      message: "where cannot be provided when operations[] is used"
+      path: ["data"],
+      message: "data cannot be provided when operations[] is used"
     });
   }
-  if (hasOperations && value.allowFullTableDelete) {
+  if (!hasOperations && !value.data) {
     ctx.addIssue({
       code: zod.z.ZodIssueCode.custom,
-      path: ["allowFullTableDelete"],
-      message: "allowFullTableDelete cannot be provided when operations[] is used"
+      path: ["data"],
+      message: "data is required when operations[] is not provided"
     });
   }
-  if (hasOperations && value.cascade) {
+  if (hasOperations && (value.where?.length ?? 0) > 0) {
     ctx.addIssue({
       code: zod.z.ZodIssueCode.custom,
-      path: ["cascade"],
-      message: "cascade cannot be provided when operations[] is used"
+      path: ["where"],
+      message: "where cannot be provided when operations[] is used"
     });
   }
-  if (hasOperations && value.softDelete) {
+  if (hasOperations && value.optimisticLock) {
     ctx.addIssue({
       code: zod.z.ZodIssueCode.custom,
-      path: ["softDelete"],
-      message: "softDelete cannot be provided when operations[] is used"
+      path: ["optimisticLock"],
+      message: "optimisticLock cannot be provided when operations[] is used"
+    });
+  }
+  if (hasOperations && value.allowFullTableUpdate) {
+    ctx.addIssue({
+      code: zod.z.ZodIssueCode.custom,
+      path: ["allowFullTableUpdate"],
+      message: "allowFullTableUpdate cannot be provided when operations[] is used"
     });
   }
   if (hasOperations) {
     return;
   }
   const hasWhere = (value.where?.length ?? 0) > 0;
-  if (!value.allowFullTableDelete && !hasWhere) {
+  const hasOptimisticLock = !!value.optimisticLock;
+  if (!value.allowFullTableUpdate && !hasWhere && !hasOptimisticLock) {
     ctx.addIssue({
       code: zod.z.ZodIssueCode.custom,
       path: ["where"],
-      message: "WHERE conditions are required unless allowFullTableDelete is true"
+      message: "WHERE conditions are required unless allowFullTableUpdate is true"
     });
   }
 });
 
-// src/data/relational/tools/relational-delete/error-utils.ts
-var SAFE_DELETE_VALIDATION_PATTERNS = [
+// src/data/relational/tools/relational-update/error-utils.ts
+var SAFE_UPDATE_VALIDATION_PATTERNS = [
   "must not be empty",
   "contains invalid characters",
-  "WHERE conditions are required for DELETE queries",
-  "WHERE conditions are required unless allowFullTableDelete is true",
-  "value is required for this operator",
+  "Update data must be an object",
+  "Update data must not be empty",
+  "must not be undefined",
+  "WHERE conditions are required for UPDATE queries",
   "null is only allowed with isNull/isNotNull operators",
-  "operator requires a value",
   "operator requires a string or number value",
-  "operator requires a string value",
   "operator requires a non-empty array value",
-  "must not include value"
+  "operator requires a string value",
+  "must not include value",
+  "Optimistic lock expectedValue must not be empty",
+  "optimistic lock check failed",
+  "WHERE conditions are required unless allowFullTableUpdate is true"
 ];
 var CONSTRAINT_VIOLATION_PATTERNS3 = [
   {
-    pattern: /(foreign key constraint|violates foreign key constraint|foreign key mismatch|a foreign key constraint fails)/i,
-    message: "Delete failed: foreign key constraint violation."
+    pattern: /(unique constraint|duplicate key|duplicate entry)/i,
+    message: "Update failed: unique constraint violation."
+  },
+  {
+    pattern: /(foreign key constraint|violates foreign key constraint)/i,
+    message: "Update failed: foreign key constraint violation."
+  },
+  {
+    pattern: /(not null constraint|cannot be null)/i,
+    message: "Update failed: NOT NULL constraint violation."
   }
 ];
-function isSafeDeleteValidationError(error) {
+function isSafeUpdateValidationError(error) {
   if (!(error instanceof Error)) {
     return false;
   }
-  return SAFE_DELETE_VALIDATION_PATTERNS.some((pattern) => error.message.includes(pattern));
+  return SAFE_UPDATE_VALIDATION_PATTERNS.some((pattern) => error.message.includes(pattern));
 }
-function getDeleteConstraintViolationMessage(error, cascade) {
+function getUpdateConstraintViolationMessage(error) {
   if (!(error instanceof Error)) {
     return null;
   }
@@ -8915,21 +9269,18 @@ function getDeleteConstraintViolationMessage(error, cascade) {
   }
   for (const entry of CONSTRAINT_VIOLATION_PATTERNS3) {
     if (messages.some((msg) => entry.pattern.test(msg))) {
-      if (cascade) {
-        return `${entry.message} Verify database-level ON DELETE CASCADE is configured for related foreign keys.`;
-      }
       return entry.message;
     }
   }
   return null;
 }
-function isSafeDeleteError(error) {
+function isSafeUpdateError(error) {
   if (!(error instanceof Error)) {
     return false;
   }
-  return SAFE_DELETE_VALIDATION_PATTERNS.some((pattern) => error.message.includes(pattern)) || error.message.startsWith("Delete failed:");
+  return isSafeUpdateValidationError(error) || getUpdateConstraintViolationMessage(error) !== null;
 }
-var deleteExecutorLogger = core.createLogger("agentforge:tools:data:relational:delete");
+var updateExecutorLogger = core.createLogger("agentforge:tools:data:relational:update");
 function toNumber3(value) {
   return typeof value === "number" && Number.isFinite(value) ? value : void 0;
 }
@@ -8966,71 +9317,73 @@ function resolveBatchOptions3(batch) {
     benchmark: batch.benchmark ?? false
   };
 }
-function toSingleDeleteOperation(input) {
+function toSingleUpdateOperation(input) {
+  if (!input.data) {
+    throw new Error("UPDATE data is required when operations[] is not provided.");
+  }
   return {
+    data: input.data,
     where: input.where,
-    allowFullTableDelete: input.allowFullTableDelete,
-    cascade: input.cascade,
-    softDelete: input.softDelete
+    allowFullTableUpdate: input.allowFullTableUpdate,
+    optimisticLock: input.optimisticLock
   };
 }
 
-// src/data/relational/tools/relational-delete/executor-single.ts
-async function executeSingleDelete(manager, input, operation, context) {
-  const built = buildDeleteQuery({
+// src/data/relational/tools/relational-update/executor-single.ts
+async function executeSingleUpdate(executor, input, operation, context) {
+  const built = buildUpdateQuery({
     table: input.table,
+    data: operation.data,
     where: operation.where,
-    allowFullTableDelete: operation.allowFullTableDelete,
-    softDelete: operation.softDelete,
+    allowFullTableUpdate: operation.allowFullTableUpdate,
+    optimisticLock: operation.optimisticLock,
     vendor: input.vendor
   });
-  const executor = manager;
-  const rawResult = await executor.execute(built.query);
+  const session = context?.transaction ?? executor;
+  const rawResult = await session.execute(built.query);
   const rowCount = normalizeAffectedRows2(rawResult);
+  if (built.usesOptimisticLock && rowCount === 0) {
+    throw new Error("Update failed: optimistic lock check failed.");
+  }
   return {
     rowCount,
-    executionTime: 0,
-    softDeleted: built.usesSoftDelete
+    executionTime: 0
   };
 }
 
-// src/data/relational/tools/relational-delete/executor-batch.ts
-async function executeDeleteInBatchMode(manager, input, context, options) {
+// src/data/relational/tools/relational-update/executor-batch.ts
+async function executeUpdateInBatchMode(executor, input, context, options) {
   const batchResult = await executeBatchedTask(
     {
-      operation: "delete",
+      operation: "update",
       items: input.operations,
       executeBatch: async (operations, batchIndex) => {
         let rowCount2 = 0;
         let successfulItems = 0;
         let failedItems = 0;
-        let softDeletedCount = 0;
         const failures = [];
         for (const operation of operations) {
           try {
-            const result = await executeSingleDelete(
-              manager,
+            const result = await executeSingleUpdate(
+              executor,
               input,
               {
+                data: operation.data,
                 where: operation.where,
-                allowFullTableDelete: operation.allowFullTableDelete,
-                cascade: operation.cascade,
-                softDelete: operation.softDelete
+                allowFullTableUpdate: operation.allowFullTableUpdate,
+                optimisticLock: operation.optimisticLock
               },
               context
             );
             rowCount2 += result.rowCount;
             successfulItems += 1;
-            if (result.softDeleted) {
-              softDeletedCount += 1;
-            }
           } catch (error) {
             if (!options.continueOnError) {
               throw error;
             }
             failedItems += 1;
             failures.push({
-              operation: "delete",
+              operation: "update",
               batchIndex,
               batchSize: operations.length,
               attempts: 1,
@@ -9042,7 +9395,6 @@ async function executeDeleteInBatchMode(manager, input, context, options) {
           rowCount: rowCount2,
           successfulItems,
           failedItems,
-          softDeletedCount,
           failures
         };
       },
@@ -9054,7 +9406,7 @@ async function executeDeleteInBatchMode(manager, input, context, options) {
       maxRetries: options.maxRetries,
       retryDelayMs: options.retryDelayMs,
       onProgress: (progress) => {
-        deleteExecutorLogger.debug("DELETE batch progress", {
+        updateExecutorLogger.debug("UPDATE batch progress", {
           vendor: input.vendor,
           table: input.table,
           ...progress
@@ -9063,19 +9415,15 @@ async function executeDeleteInBatchMode(manager, input, context, options) {
     }
   );
   const rowCount = batchResult.results.reduce((total, result) => total + result.rowCount, 0);
-  const softDeleted = batchResult.results.some((result) => result.softDeletedCount > 0);
   const operationFailures = batchResult.results.flatMap((result) => result.failures);
   let benchmark;
   if (options.benchmark) {
-    deleteExecutorLogger.warn(
-      "DELETE batch benchmark enabled. Synthetic benchmark callbacks are side-effect free and do not execute SQL.",
-      {
-        vendor: input.vendor,
-        table: input.table,
-        operationCount: input.operations.length,
-        batchSize: options.batchSize
-      }
-    );
+    updateExecutorLogger.warn("UPDATE batch benchmark enabled. Synthetic benchmark callbacks are side-effect free and do not execute SQL.", {
+      vendor: input.vendor,
+      table: input.table,
+      operationCount: input.operations.length,
+      batchSize: options.batchSize
+    });
     benchmark = await benchmarkBatchExecution({
       items: input.operations,
       batchSize: options.batchSize,
@@ -9088,7 +9436,6 @@ async function executeDeleteInBatchMode(manager, input, context, options) {
   return {
     rowCount,
     executionTime: batchResult.executionTime,
-    softDeleted,
     batch: {
       enabled: true,
       batchSize: options.batchSize,
@@ -9105,35 +9452,32 @@ async function executeDeleteInBatchMode(manager, input, context, options) {
   };
 }
 
-// src/data/relational/tools/relational-delete/executor.ts
-async function executeDelete(manager, input, context) {
+// src/data/relational/tools/relational-update/executor.ts
+async function executeUpdate(executor, input, context) {
   const startTime = Date.now();
-  deleteExecutorLogger.debug("Building DELETE query", {
+  updateExecutorLogger.debug("Building UPDATE query", {
     vendor: input.vendor,
     table: input.table,
     hasWhere: !!input.where?.length,
-    ...input.allowFullTableDelete !== void 0 ? { allowFullTableDelete: input.allowFullTableDelete } : {},
-    ...input.cascade !== void 0 ? { cascade: input.cascade } : {},
-    softDelete: !!input.softDelete,
+    ...input.allowFullTableUpdate !== void 0 ? { allowFullTableUpdate: input.allowFullTableUpdate } : {},
+    hasOptimisticLock: !!input.optimisticLock,
     operationCount: input.operations?.length ?? 0,
     batchModeEnabled: !!input.batch?.enabled
   });
   try {
     const batchOptions = resolveBatchOptions3(input.batch);
-    const result = input.operations && batchOptions ? await executeDeleteInBatchMode(
-      manager,
+    const result = input.operations && batchOptions ? await executeUpdateInBatchMode(
+      executor,
       input,
       context,
       batchOptions
-    ) : await executeSingleDelete(manager, input, toSingleDeleteOperation(input), context);
+    ) : await executeSingleUpdate(executor, input, toSingleUpdateOperation(input), context);
     const executionTime = Date.now() - startTime;
-    deleteExecutorLogger.debug("DELETE query executed successfully", {
+    updateExecutorLogger.debug("UPDATE query executed successfully", {
       vendor: input.vendor,
       table: input.table,
       rowCount: result.rowCount,
       executionTime,
-      softDelete: result.softDeleted,
-      ...input.cascade !== void 0 ? { cascade: input.cascade } : {},
       batchMode: !!result.batch,
       partialSuccess: result.batch?.partialSuccess ?? false
     });
@@ -9143,55 +9487,80 @@ async function executeDelete(manager, input, context) {
     };
   } catch (error) {
     const executionTime = Date.now() - startTime;
-    deleteExecutorLogger.error("DELETE query execution failed", {
+    updateExecutorLogger.error("UPDATE query execution failed", {
       vendor: input.vendor,
       table: input.table,
       error: error instanceof Error ? error.message : String(error),
-      executionTime,
-      ...input.cascade !== void 0 ? { cascade: input.cascade } : {},
-      softDelete: !!input.softDelete
+      executionTime
     });
-    const constraintMessage = getDeleteConstraintViolationMessage(error, input.cascade ?? false);
+    const constraintMessage = getUpdateConstraintViolationMessage(error);
     if (constraintMessage) {
       throw new Error(constraintMessage, { cause: error });
     }
-    if (isSafeDeleteValidationError(error)) {
+    if (isSafeUpdateValidationError(error)) {
       throw error;
     }
-    throw new Error("DELETE query failed. See logs for details.", { cause: error });
+    throw new Error("UPDATE query failed. See logs for details.", { cause: error });
   }
 }
 
-// src/data/relational/tools/relational-delete/index.ts
-var relationalDelete = core.toolBuilder().name("relational-delete").displayName("Relational DELETE").description("Execute type-safe DELETE queries with single and batched operation support").category(core.ToolCategory.DATABASE).tags(["database", "sql", "delete", "postgresql", "mysql", "sqlite"]).schema(relationalDeleteSchema).example({
-  description: "Delete one row by condition",
+// src/data/relational/tools/relational-update/index.ts
+function toUpdateErrorResponse(error) {
+  const errorMessage = isSafeUpdateError(error) ? error.message : "Failed to execute UPDATE query. Please verify your input and database connection.";
+  return {
+    success: false,
+    error: errorMessage,
+    rowCount: 0
+  };
+}
+async function invokeRelationalUpdate(execution, input) {
+  try {
+    const result = await executeUpdate(
+      execution.executor,
+      { ...input, vendor: execution.vendor },
+      execution.transaction ? { transaction: execution.transaction } : void 0
+    );
+    return {
+      success: true,
+      rowCount: result.rowCount,
+      executionTime: result.executionTime,
+      batch: result.batch
+    };
+  } catch (error) {
+    return toUpdateErrorResponse(error);
+  }
+}
+var relationalUpdate = core.toolBuilder().name("relational-update").displayName("Relational UPDATE").description("Execute type-safe UPDATE queries with single and batched operation support").category(core.ToolCategory.DATABASE).tags(["database", "sql", "update", "postgresql", "mysql", "sqlite"]).schema(relationalUpdateSchema).example({
+  description: "Update one row by condition",
   input: {
     table: "users",
+    data: { status: "inactive" },
     where: [{ column: "id", operator: "eq", value: 123 }],
     vendor: "postgresql",
     connectionString: "postgresql://localhost/mydb"
   }
 }).example({
-  description: "Soft delete rows",
+  description: "Optimistic lock update",
   input: {
     table: "users",
-    where: [{ column: "status", operator: "eq", value: "inactive" }],
-    softDelete: { column: "deleted_at" },
+    data: { status: "active" },
+    where: [{ column: "id", operator: "eq", value: 123 }],
+    optimisticLock: { column: "version", expectedValue: 5 },
     vendor: "sqlite",
     connectionString: "data.db"
   }
 }).example({
-  description: "Batch delete operations",
+  description: "Batch update operations",
   input: {
     table: "users",
     operations: [
       {
-        where: [{ column: "status", operator: "eq", value: "inactive" }],
-        softDelete: { column: "deleted_at" }
+        data: { status: "inactive" },
+        where: [{ column: "id", operator: "eq", value: 1 }]
       },
       {
-        where: [{ column: "status", operator: "eq", value: "pending_delete" }],
-        softDelete: { column: "deleted_at" }
+        data: { status: "inactive" },
+        where: [{ column: "id", operator: "eq", value: 2 }]
       }
     ],
     batch: {
@@ -9202,141 +9571,503 @@ var relationalDelete = core.toolBuilder().name("relational-delete").displayName(
     connectionString: "postgresql://localhost/mydb"
   }
 }).implement(async (input) => {
-  const manager = new ConnectionManager({
-    vendor: input.vendor,
-    connection: input.connectionString
-  });
-  try {
-    await manager.connect();
-    const result = await executeDelete(manager, input);
-    return {
-      success: true,
-      rowCount: result.rowCount,
-      executionTime: result.executionTime,
-      softDeleted: result.softDeleted,
-      batch: result.batch
-    };
-  } catch (error) {
-    let errorMessage = "Failed to execute DELETE query. Please verify your input and database connection.";
-    if (isSafeDeleteError(error)) {
-      errorMessage = error.message;
-    }
-    return {
-      success: false,
-      error: errorMessage,
-      rowCount: 0,
-      softDeleted: false
-    };
-  } finally {
-    await manager.disconnect();
-  }
+  const { connectionString, vendor, ...operation } = input;
+  return withEphemeralRelationalMutationToolSet(
+    { vendor, connectionString },
+    async (toolSet) => replaceMutationConnectionFailure(
+      await toolSet.update.invoke(operation),
+      UPDATE_CONNECTION_FAILURE,
+      "Failed to execute UPDATE query. Please verify your input and database connection."
+    ),
+    toUpdateErrorResponse
+  );
 }).build();
 
-// src/data/relational/tools/relational-get-schema-error-utils.ts
-var SAFE_VALIDATION_ERROR_PATTERNS2 = [
-  "must not be empty",
-  "contains invalid characters",
-  "Invalid table filter"
-];
-function isSafeGetSchemaValidationError(error) {
-  if (!(error instanceof Error)) {
+// src/data/relational/tool-set.ts
+var DEFAULT_SCHEMA_CACHE_TTL_MS = 6e4;
+var TOOL_SET_SCHEMA_CACHE_KEY = "relational-tool-set";
+var PREFIX_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
+var ROLLBACK_ONLY_MESSAGE = "Transaction is rollback-only; no database work was executed.";
+var logger18 = core.createLogger("agentforge:tools:data:relational:tool-set");
+var RelationalToolSetConfigurationError = class extends Error {
+  name = "RelationalToolSetConfigurationError";
+};
+var RelationalToolSetDisposedError = class extends Error {
+  name = "RelationalToolSetDisposedError";
+  constructor() {
+    super("The Relational Tool Set is disposing or has been disposed.");
+  }
+};
+var RelationalTransactionError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+  }
+  name = "RelationalTransactionError";
+};
+function isFailedOrPartialResult(result) {
+  if (!result || typeof result !== "object") {
     return false;
   }
-  return SAFE_VALIDATION_ERROR_PATTERNS2.some(
-    (pattern) => error.message.includes(pattern)
+  const response = result;
+  return response.success === false || response.batch?.partialSuccess === true || (response.batch?.failedItems ?? 0) > 0;
+}
+var TransactionToolScope = class {
+  constructor(execution) {
+    this.execution = execution;
+  }
+  active = true;
+  rollbackOnly = false;
+  tail = Promise.resolve();
+  run(operation, failure) {
+    if (!this.active) {
+      return Promise.reject(
+        new RelationalTransactionError(
+          "Transaction-scoped Tools can no longer be used because their callback has settled.",
+          "SCOPE_EXPIRED"
+        )
+      );
+    }
+    const invocation = this.tail.then(async () => {
+      if (this.rollbackOnly) {
+        return failure(ROLLBACK_ONLY_MESSAGE);
+      }
+      const result = await operation(this.execution);
+      if (isFailedOrPartialResult(result)) {
+        this.rollbackOnly = true;
+      }
+      return result;
+    });
+    this.tail = invocation.then(
+      () => void 0,
+      () => void 0
+    );
+    return invocation;
+  }
+  async settle() {
+    this.active = false;
+    await this.tail;
+  }
+  isRollbackOnly() {
+    return this.rollbackOnly;
+  }
+};
+function createConfiguredTools(options, execution) {
+  const query = core.createTool(
+    configuredMetadata(relationalQuery, options.prefix),
+    relationalQuerySchema.omit({ vendor: true, connectionString: true }),
+    (input) => execution(
+      (context) => invokeRelationalQuery(context, input),
+      (error) => ({ success: false, error, rows: [], rowCount: 0 }),
+      QUERY_CONNECTION_FAILURE
+    )
+  );
+  const select = core.createTool(
+    configuredMetadata(relationalSelect, options.prefix),
+    relationalSelectSchema.omit({ vendor: true, connectionString: true }),
+    (input) => execution(
+      (context) => invokeRelationalSelect(context, input),
+      (error) => ({ success: false, error, rows: [], rowCount: 0 }),
+      SELECT_CONNECTION_FAILURE
+    )
+  );
+  const insert = core.createTool(
+    configuredMetadata(relationalInsert, options.prefix),
+    relationalInsertSchema.omit({ vendor: true, connectionString: true }),
+    (input) => execution(
+      (context) => invokeRelationalInsert(context, input),
+      (error) => ({
+        success: false,
+        error,
+        rowCount: 0,
+        insertedIds: [],
+        rows: []
+      }),
+      INSERT_CONNECTION_FAILURE
+    )
+  );
+  const update = core.createTool(
+    configuredMetadata(relationalUpdate, options.prefix),
+    relationalUpdateOperationSchema,
+    (input) => execution(
+      (context) => invokeRelationalUpdate(context, input),
+      (error) => ({ success: false, error, rowCount: 0 }),
+      UPDATE_CONNECTION_FAILURE
+    )
+  );
+  const deleteTool = core.createTool(
+    configuredMetadata(relationalDelete, options.prefix),
+    relationalDeleteOperationSchema,
+    (input) => execution(
+      (context) => invokeRelationalDelete(context, input),
+      (error) => ({ success: false, error, rowCount: 0, softDeleted: false }),
+      DELETE_CONNECTION_FAILURE
+    )
+  );
+  const getSchema = core.createTool(
+    configuredMetadata(relationalGetSchema, options.prefix),
+    relationalGetSchemaInputSchema.omit({
+      vendor: true,
+      connectionString: true,
+      database: true,
+      cacheTtlMs: true
+    }),
+    (input) => execution(
+      (context) => invokeRelationalGetSchema(context, {
+        ...input,
+        cacheTtlMs: options.schemaCacheTtlMs ?? DEFAULT_SCHEMA_CACHE_TTL_MS
+      }),
+      (error) => ({ success: false, error, schema: null }),
+      "Failed to inspect schema. See logs for details."
+    )
   );
+  const tools = [query, select, insert, update, deleteTool, getSchema];
+  return Object.freeze({
+    query,
+    select,
+    insert,
+    update,
+    delete: deleteTool,
+    getSchema,
+    [Symbol.iterator]: () => tools[Symbol.iterator]()
+  });
 }
-
-// src/data/relational/tools/relational-get-schema.ts
-var logger17 = core.createLogger("agentforge:tools:data:relational:get-schema");
-function buildSchemaCacheKey(vendor, connectionString, database) {
-  const databaseScope = database ?? "default";
-  const connectionHash = crypto.createHash("sha256").update(connectionString).digest("hex");
-  return `${vendor}:${databaseScope}:${connectionHash}`;
+function validateConfiguration(config, options) {
+  if (!config || !["postgresql", "mysql", "sqlite"].includes(config.vendor)) {
+    throw new RelationalToolSetConfigurationError(
+      "Database vendor must be postgresql, mysql, or sqlite."
+    );
+  }
+  if (typeof config.connection === "string" && config.connection.trim().length === 0 || typeof config.connection !== "string" && (!config.connection || Array.isArray(config.connection))) {
+    throw new RelationalToolSetConfigurationError(
+      "Database connection must be a non-empty string or configuration object."
+    );
+  }
+  if (config.vendor === "sqlite" && typeof config.connection !== "string" && (typeof config.connection.url !== "string" || config.connection.url.trim().length === 0)) {
+    throw new RelationalToolSetConfigurationError(
+      "SQLite object configuration requires a non-empty url."
+    );
+  }
+  if (options.prefix !== void 0 && !PREFIX_PATTERN.test(options.prefix)) {
+    throw new RelationalToolSetConfigurationError(
+      "Tool name prefix must be non-empty kebab-case starting with a letter."
+    );
+  }
+  if (options.schemaCacheTtlMs !== void 0 && (!Number.isInteger(options.schemaCacheTtlMs) || options.schemaCacheTtlMs < 0)) {
+    throw new RelationalToolSetConfigurationError(
+      "Schema cache TTL must be a non-negative integer."
+    );
+  }
+  const longestName = configuredName("relational-get-schema", options.prefix);
+  if (longestName.length > 50) {
+    throw new RelationalToolSetConfigurationError(
+      "Tool name prefix is too long; configured Tool names must not exceed 50 characters."
+    );
+  }
 }
-var relationalGetSchemaInputSchema = zod.z.object({
-  vendor: zod.z.enum(["postgresql", "mysql", "sqlite"]).describe("Database vendor"),
-  connectionString: zod.z.string().min(1, "Database connection string is required").describe("Database connection string used to create a new connection"),
-  database: zod.z.string().min(1).optional().describe("Optional logical database name used for cache scoping"),
-  tables: zod.z.array(
-    zod.z.string().regex(
-      VALID_TABLE_FILTER_PATTERN,
-      "Table filter contains invalid characters. Use alphanumeric, underscore, and optional schema qualification."
-    )
-  ).optional().describe("Optional table filter list. When omitted, all tables are returned."),
-  cacheTtlMs: zod.z.number().int().min(0).optional().describe("Schema cache TTL in milliseconds (0 disables caching)"),
-  refreshCache: zod.z.boolean().optional().describe("Force cache invalidation before introspecting schema")
-});
-var relationalGetSchema = core.toolBuilder().name("relational-get-schema").displayName("Relational Get Schema").description("Inspect relational database schema (tables, columns, primary keys, foreign keys, indexes) across PostgreSQL, MySQL, and SQLite").category(core.ToolCategory.DATABASE).tags(["database", "schema", "introspection", "postgresql", "mysql", "sqlite"]).schema(relationalGetSchemaInputSchema).example({
-  description: "Inspect all SQLite tables",
-  input: {
-    vendor: "sqlite",
-    connectionString: ":memory:"
+function cloneImmutableValue(value) {
+  if (Array.isArray(value)) {
+    return Object.freeze(value.map(cloneImmutableValue));
   }
-}).example({
-  description: "Inspect selected PostgreSQL tables with cache control",
-  input: {
-    vendor: "postgresql",
-    connectionString: "postgresql://localhost/app",
-    tables: ["public.users", "public.orders"],
-    cacheTtlMs: 3e4,
-    refreshCache: true
+  if (value instanceof Date) {
+    return new Date(value.getTime());
   }
-}).implement(async (input) => {
-  const manager = new ConnectionManager({
-    vendor: input.vendor,
-    connection: input.connectionString
-  });
-  const cacheKey = buildSchemaCacheKey(
-    input.vendor,
-    input.connectionString,
-    input.database
-  );
-  const inspector = new SchemaInspector(manager, input.vendor, {
-    cacheTtlMs: input.cacheTtlMs,
-    cacheKey
+  if (value instanceof ArrayBuffer) {
+    return value.slice(0);
+  }
+  if (Buffer.isBuffer(value)) {
+    return Buffer.from(value);
+  }
+  if (ArrayBuffer.isView(value)) {
+    return structuredClone(value);
+  }
+  if (value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+    return Object.freeze(
+      Object.fromEntries(
+        Object.entries(value).map(([key, nestedValue]) => [key, cloneImmutableValue(nestedValue)])
+      )
+    );
+  }
+  if (value && typeof value === "object") {
+    throw new RelationalToolSetConfigurationError(
+      "Database configuration contains an unsupported mutable object."
+    );
+  }
+  return value;
+}
+function snapshotConfiguration(config) {
+  const connection = cloneImmutableValue(config.connection);
+  return Object.freeze({ vendor: config.vendor, connection });
+}
+function configuredName(name, prefix) {
+  return prefix ? `${prefix}-${name}` : name;
+}
+function configuredMetadata(tool, prefix) {
+  return {
+    ...tool.metadata,
+    name: configuredName(tool.metadata.name, prefix),
+    examples: void 0
+  };
+}
+function preserveOperationValidation(legacySchema, input, context) {
+  const result = legacySchema.safeParse({
+    ...input,
+    vendor: "sqlite",
+    connectionString: "configured"
   });
-  try {
-    await manager.connect();
-    if (input.refreshCache) {
-      inspector.invalidateCache();
+  if (!result.success) {
+    for (const issue of result.error.issues) {
+      context.addIssue(issue);
+    }
+  }
+}
+var relationalUpdateOperationSchema = relationalUpdateSchema.innerType().omit({ vendor: true, connectionString: true }).superRefine((input, context) => {
+  preserveOperationValidation(relationalUpdateSchema, input, context);
+});
+var relationalDeleteOperationSchema = relationalDeleteSchema.innerType().omit({ vendor: true, connectionString: true }).superRefine((input, context) => {
+  preserveOperationValidation(relationalDeleteSchema, input, context);
+});
+var RelationalToolSetImplementation = class {
+  constructor(config, options, sharedSchemaCacheKey) {
+    this.config = config;
+    this.sharedSchemaCacheKey = sharedSchemaCacheKey;
+    this.prefix = options.prefix;
+    const configuredTools = createConfiguredTools(
+      options,
+      (operation, failure, failureMessage) => this.run(operation, () => failure(failureMessage))
+    );
+    this.query = configuredTools.query;
+    this.select = configuredTools.select;
+    this.insert = configuredTools.insert;
+    this.update = configuredTools.update;
+    this.delete = configuredTools.delete;
+    this.getSchema = configuredTools.getSchema;
+    this.tools = Object.freeze([
+      this.query,
+      this.select,
+      this.insert,
+      this.update,
+      this.delete,
+      this.getSchema
+    ]);
+  }
+  query;
+  select;
+  insert;
+  update;
+  delete;
+  getSchema;
+  tools;
+  schemaCache = new SchemaCache();
+  prefix;
+  transactionContext = new async_hooks.AsyncLocalStorage();
+  sqliteWorkTail = Promise.resolve();
+  manager;
+  initialization;
+  activeWork = 0;
+  state = "open";
+  drain;
+  resolveDrain;
+  disposal;
+  [Symbol.iterator]() {
+    return this.tools[Symbol.iterator]();
+  }
+  async transaction(operation, options) {
+    if (this.transactionContext.getStore()?.active) {
+      throw new RelationalTransactionError(
+        "Nested Relational Tool Set transactions are not supported.",
+        "NESTED_TRANSACTION"
+      );
     }
-    const schema = await inspector.inspect({
-      tables: input.tables
+    return this.runTransaction((manager) => {
+      const transactionState = { active: true };
+      return this.transactionContext.run(
+        transactionState,
+        () => withTransaction(
+          manager,
+          async (transaction) => {
+            const scope = new TransactionToolScope(this.transactionExecutionFor(transaction));
+            const scopedTools = createConfiguredTools(
+              { prefix: this.prefix },
+              (scopedOperation, failure) => scope.run(scopedOperation, failure)
+            );
+            let result;
+            try {
+              result = await operation(scopedTools);
+            } finally {
+              try {
+                await scope.settle();
+              } finally {
+                transactionState.active = false;
+              }
+            }
+            if (scope.isRollbackOnly()) {
+              throw new RelationalTransactionError(
+                "The transaction was rolled back because a scoped Tool failed.",
+                "ROLLBACK_ONLY"
+              );
+            }
+            return result;
+          },
+          options
+        )
+      );
     });
-    const summary = schema.tables.reduce(
-      (accumulator, table) => {
-        accumulator.tableCount += 1;
-        accumulator.columnCount += table.columns.length;
-        accumulator.foreignKeyCount += table.foreignKeys.length;
-        accumulator.indexCount += table.indexes.length;
-        return accumulator;
-      },
-      { tableCount: 0, columnCount: 0, foreignKeyCount: 0, indexCount: 0 }
+  }
+  refreshSchema() {
+    if (this.state !== "open") {
+      throw new RelationalToolSetDisposedError();
+    }
+    if (this.sharedSchemaCacheKey) {
+      SchemaInspector.clearCache(this.sharedSchemaCacheKey);
+    } else {
+      this.schemaCache.delete(TOOL_SET_SCHEMA_CACHE_KEY);
+    }
+  }
+  dispose() {
+    if (!this.disposal) {
+      this.state = "closing";
+      this.disposal = this.finishDisposal();
+    }
+    return this.disposal;
+  }
+  async run(operation, connectionFailure) {
+    if (this.transactionContext.getStore()?.active) {
+      throw new RelationalTransactionError(
+        "Use the scoped Tools supplied to the transaction callback.",
+        "UNSCOPED_TOOL_IN_TRANSACTION"
+      );
+    }
+    if (this.state !== "open") {
+      throw new RelationalToolSetDisposedError();
+    }
+    this.activeWork += 1;
+    try {
+      let manager;
+      try {
+        manager = await this.ensureConnection();
+      } catch (error) {
+        if (error instanceof MissingPeerDependencyError) {
+          throw error;
+        }
+        return connectionFailure();
+      }
+      const execute = () => operation(this.schemaExecutionFor(manager));
+      return this.config.vendor === "sqlite" ? await this.serializeSqliteWork(execute) : await execute();
+    } finally {
+      this.activeWork -= 1;
+      if (this.activeWork === 0) {
+        this.resolveDrain?.();
+      }
+    }
+  }
+  async runTransaction(operation) {
+    if (this.state !== "open") {
+      throw new RelationalToolSetDisposedError();
+    }
+    this.activeWork += 1;
+    try {
+      let manager;
+      try {
+        manager = await this.ensureConnection();
+      } catch (error) {
+        if (error instanceof MissingPeerDependencyError) {
+          throw error;
+        }
+        throw new RelationalTransactionError(
+          "Failed to start the managed database transaction.",
+          "START_FAILED"
+        );
+      }
+      if (this.config.vendor !== "sqlite") {
+        return await operation(manager);
+      }
+      return await this.serializeSqliteWork(() => operation(manager));
+    } finally {
+      this.activeWork -= 1;
+      if (this.activeWork === 0) {
+        this.resolveDrain?.();
+      }
+    }
+  }
+  async serializeSqliteWork(operation) {
+    const work = this.sqliteWorkTail.then(operation);
+    this.sqliteWorkTail = work.then(
+      () => void 0,
+      () => void 0
     );
-    return {
-      success: true,
-      schema,
-      summary
+    return work;
+  }
+  ensureConnection() {
+    if (this.manager?.isConnected()) {
+      return Promise.resolve(this.manager);
+    }
+    if (!this.initialization) {
+      const manager = new ConnectionManager(this.config);
+      this.manager = manager;
+      this.initialization = manager.connect().then(() => manager).catch(async (error) => {
+        this.manager = void 0;
+        this.initialization = void 0;
+        if (!(error instanceof MissingPeerDependencyError)) {
+          logger18.error("Relational Tool Set connection initialization failed", {
+            vendor: this.config.vendor,
+            errorType: error instanceof Error ? error.name : typeof error
+          });
+        }
+        try {
+          await manager.dispose();
+        } catch {
+        }
+        throw error;
+      });
+    }
+    return this.initialization;
+  }
+  schemaExecutionFor(manager) {
+    const execution = { executor: manager, vendor: this.config.vendor };
+    return this.sharedSchemaCacheKey ? { ...execution, schemaCacheKey: this.sharedSchemaCacheKey } : {
+      ...execution,
+      schemaCache: this.schemaCache,
+      schemaCacheKey: TOOL_SET_SCHEMA_CACHE_KEY
     };
-  } catch (error) {
-    logger17.error("Schema introspection failed", {
-      vendor: input.vendor,
-      hasTablesFilter: Array.isArray(input.tables),
-      tablesFilterCount: input.tables?.length ?? 0,
-      refreshCache: input.refreshCache ?? false,
-      error: error instanceof Error ? error.message : String(error)
-    });
-    const errorMessage = isSafeGetSchemaValidationError(error) ? error.message : "Failed to inspect schema. See logs for details.";
+  }
+  transactionExecutionFor(transaction) {
     return {
-      success: false,
-      error: errorMessage,
-      schema: null
+      executor: transaction,
+      transaction,
+      vendor: this.config.vendor
     };
-  } finally {
-    await manager.disconnect();
   }
-}).build();
+  async finishDisposal() {
+    if (this.activeWork > 0) {
+      this.drain = new Promise((resolve3) => {
+        this.resolveDrain = resolve3;
+      });
+      await this.drain;
+    }
+    this.schemaCache.clear();
+    try {
+      await this.manager?.dispose();
+    } finally {
+      this.state = "closed";
+      this.resolveDrain = void 0;
+    }
+  }
+};
+function createRelationalToolSet(config, options = {}) {
+  validateConfiguration(config, options);
+  return new RelationalToolSetImplementation(snapshotConfiguration(config), { ...options });
+}
+function createLegacyRelationalReadToolSet(config, options = {}, schemaCacheKey) {
+  return new RelationalToolSetImplementation(
+    snapshotConfiguration(config),
+    { ...options },
+    schemaCacheKey
+  );
+}
+function createLegacyRelationalMutationToolSet(config) {
+  return new RelationalToolSetImplementation(snapshotConfiguration(config), {});
+}
 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")
@@ -10668,7 +11399,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 logger18 = core.createLogger("agentforge:tools:agent:ask-human", { level: logLevel3 });
+var logger19 = core.createLogger("agentforge:tools:agent:ask-human", { level: logLevel3 });
 function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
@@ -10733,7 +11464,7 @@ function createAskHumanTool() {
       suggestions: validatedInput.suggestions,
       status: "pending"
     };
-    logger18.debug("About to call interrupt()", {
+    logger19.debug("About to call interrupt()", {
       humanRequest: {
         id: humanRequest.id,
         question: humanRequest.question,
@@ -10749,13 +11480,13 @@ function createAskHumanTool() {
     let response;
     try {
       response = interrupt(humanRequest);
-      logger18.debug("interrupt() returned successfully", {
+      logger19.debug("interrupt() returned successfully", {
         responseType: typeof response,
         hasResponse: response != null,
         ...typeof response === "string" ? { responseLength: response.length } : {}
       });
     } catch (error) {
-      logger18.debug("interrupt() threw error (expected for GraphInterrupt)", {
+      logger19.debug("interrupt() threw error (expected for GraphInterrupt)", {
         ...error && typeof error === "object" && "constructor" in error ? { errorType: error.constructor?.name } : {},
         error: error instanceof Error ? error.message : String(error)
       });
@@ -10809,6 +11540,10 @@ exports.MissingPeerDependencyError = MissingPeerDependencyError;
 exports.OpenAIEmbeddingProvider = OpenAIEmbeddingProvider;
 exports.PhoneValidatorSchema = PhoneValidatorSchema;
 exports.RandomNumberSchema = RandomNumberSchema;
+exports.RelationalToolSetConfigurationError = RelationalToolSetConfigurationError;
+exports.RelationalToolSetDisposedError = RelationalToolSetDisposedError;
+exports.RelationalTransactionError = RelationalTransactionError;
+exports.SchemaCache = SchemaCache;
 exports.SchemaInspector = SchemaInspector;
 exports.SerperProvider = SerperProvider;
 exports.StatisticsSchema = StatisticsSchema;
@@ -10912,6 +11647,7 @@ exports.createPathResolveTool = createPathResolveTool;
 exports.createPathUtilityTools = createPathUtilityTools;
 exports.createPhoneValidatorTool = createPhoneValidatorTool;
 exports.createRandomNumberTool = createRandomNumberTool;
+exports.createRelationalToolSet = createRelationalToolSet;
 exports.createScraperTools = createScraperTools;
 exports.createSelectReadableStream = createSelectReadableStream;
 exports.createSerperProvider = createSerperProvider;