@agentforge/tools 0.12.6 → 0.13.0

package/dist/index.d.cts

@@ -1,6 +1,9 @@
 import * as _agentforge_core from '@agentforge/core';
 import { LogLevel, HumanRequestPriority } from '@agentforge/core';
 import { z } from 'zod';
+import { SQL } from 'drizzle-orm';
+import { EventEmitter } from 'events';
+import { Readable } from 'node:stream';
 import { Session } from 'neo4j-driver';
 
 /**
@@ -294,8 +297,7 @@ declare function createScraperTools(config?: ScraperToolsConfig): _agentforge_co
 /**
  * HTML parser tools configuration
  */
-interface HtmlParserToolsConfig {
-}
+type HtmlParserToolsConfig = Record<string, never>;
 /**
  * HTML parser input schema
  */
@@ -571,8 +573,7 @@ interface UrlValidationResult {
 /**
  * URL validator tools configuration
  */
-interface UrlValidatorToolsConfig {
-}
+type UrlValidatorToolsConfig = Record<string, never>;
 /**
  * URL validator input schema
  */
@@ -2631,8 +2632,7 @@ declare const objectOmitSchema: z.ZodObject<{
 /**
  * Transformer tools configuration
  */
-interface TransformerToolsConfig {
-}
+type TransformerToolsConfig = Record<string, never>;
 
 /**
  * Array Filter Tool
@@ -4675,266 +4675,1917 @@ declare function createNeo4jTools(config?: Neo4jToolsConfig, includeEmbeddingToo
 declare function initializeNeo4jTools(): Promise<void>;
 
 /**
- * File Operations Types
- *
- * Type definitions and schemas for file operation tools.
+ * Shared types for relational database operations
+ * @module types
  */
 
 /**
- * File reader schema
+ * Supported database vendors
  */
-declare const fileReaderSchema: z.ZodObject<{
-    path: z.ZodString;
-    encoding: z.ZodDefault<z.ZodEnum<["utf8", "utf-8", "ascii", "base64", "hex", "binary"]>>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    encoding: "ascii" | "binary" | "base64" | "hex" | "utf-8" | "utf8";
-}, {
-    path: string;
-    encoding?: "ascii" | "binary" | "base64" | "hex" | "utf-8" | "utf8" | undefined;
-}>;
+type DatabaseVendor = 'postgresql' | 'mysql' | 'sqlite';
 /**
- * File writer schema
+ * Database connection configuration
  */
-declare const fileWriterSchema: z.ZodObject<{
-    path: z.ZodString;
-    content: z.ZodString;
-    encoding: z.ZodDefault<z.ZodEnum<["utf8", "utf-8", "ascii", "base64", "hex"]>>;
-    createDirs: z.ZodDefault<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    content: string;
-    encoding: "ascii" | "base64" | "hex" | "utf-8" | "utf8";
-    createDirs: boolean;
-}, {
-    path: string;
-    content: string;
-    encoding?: "ascii" | "base64" | "hex" | "utf-8" | "utf8" | undefined;
-    createDirs?: boolean | undefined;
-}>;
+interface DatabaseConfig {
+    /** Database vendor type */
+    vendor: DatabaseVendor;
+    /** Connection string or configuration object */
+    connection: string | Record<string, unknown>;
+    /** Optional connection pool configuration */
+    pool?: {
+        min?: number;
+        max?: number;
+        idleTimeoutMillis?: number;
+    };
+}
 /**
- * File append schema
+ * Database connection interface
+ *
+ * NOTE: The execute() signature was changed from execute(sql: string, params?: unknown)
+ * to execute(query: SQL) in ST-02001 to align with Drizzle's type-safe SQL template design.
+ * This is a breaking change but provides better type safety and prevents SQL injection.
+ * Parameter binding is now handled by buildParameterizedQuery() before calling execute().
+ */
+interface DatabaseConnection {
+    /** Execute a Drizzle SQL query */
+    execute(query: SQL): Promise<unknown>;
+    /** Close the connection */
+    close(): Promise<void>;
+    /** Check if connection is healthy */
+    isHealthy(): Promise<boolean>;
+}
+/**
+ * Query result metadata
  */
-declare const fileAppendSchema: z.ZodObject<{
-    path: z.ZodString;
-    content: z.ZodString;
-    encoding: z.ZodDefault<z.ZodEnum<["utf8", "utf-8", "ascii"]>>;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-    content: string;
-    encoding: "ascii" | "utf-8" | "utf8";
-}, {
-    path: string;
-    content: string;
-    encoding?: "ascii" | "utf-8" | "utf8" | undefined;
-}>;
+interface QueryMetadata {
+    /** Number of rows affected */
+    rowCount?: number;
+    /** Execution time in milliseconds */
+    executionTime?: number;
+    /** Additional vendor-specific metadata */
+    [key: string]: unknown;
+}
 /**
- * File delete schema
+ * Query result with data and metadata
  */
-declare const fileDeleteSchema: z.ZodObject<{
-    path: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-}, {
-    path: string;
-}>;
+interface QueryResult<T = unknown> {
+    /** Query result data */
+    data: T[];
+    /** Query metadata */
+    metadata: QueryMetadata;
+}
+
 /**
- * File exists schema
+ * Runtime peer dependency checker for database drivers
+ * @module utils/peer-dependency-checker
  */
-declare const fileExistsSchema: z.ZodObject<{
-    path: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    path: string;
-}, {
-    path: string;
-}>;
+
 /**
- * File operations configuration
+ * Error thrown when a required peer dependency is missing
  */
-interface FileOperationsConfig {
-    defaultEncoding?: 'utf8' | 'utf-8' | 'ascii' | 'base64' | 'hex';
-    createDirsDefault?: boolean;
+declare class MissingPeerDependencyError extends Error {
+    readonly vendor: DatabaseVendor;
+    readonly packageName: string;
+    constructor(vendor: DatabaseVendor, packageName: string);
 }
-
 /**
- * File Reader Tool
+ * Check if the required peer dependency for a database vendor is installed
+ * @param vendor - Database vendor to check
+ * @throws {MissingPeerDependencyError} If the required peer dependency is not installed
  */
+declare function checkPeerDependency(vendor: DatabaseVendor): void;
 /**
- * Create file reader tool
+ * Get the required peer dependency package name for a database vendor
+ * @param vendor - Database vendor
+ * @returns Package name of the required peer dependency
  */
-declare function createFileReaderTool(defaultEncoding?: string): _agentforge_core.Tool<{
-    path: string;
-    encoding?: "ascii" | "binary" | "base64" | "hex" | "utf-8" | "utf8" | undefined;
-}, {
-    success: boolean;
-    data?: {
-        content: string;
-        size: number;
-        path: string;
-        encoding: string;
-    } | undefined;
-    error?: string;
-}>;
-
+declare function getPeerDependencyName(vendor: DatabaseVendor): string;
 /**
- * File Writer Tool
+ * Get installation instructions for a database vendor
+ * @param vendor - Database vendor
+ * @returns Installation command for the required peer dependency
  */
+declare function getInstallationInstructions(vendor: DatabaseVendor): string;
+
 /**
- * Create file writer tool
+ * Query execution types for relational databases
+ * @module query/types
  */
-declare function createFileWriterTool(defaultEncoding?: string, createDirsDefault?: boolean): _agentforge_core.Tool<{
-    path: string;
-    content: string;
-    encoding?: "ascii" | "base64" | "hex" | "utf-8" | "utf8" | undefined;
-    createDirs?: boolean | undefined;
-}, {
-    success: boolean;
-    data?: {
-        path: string;
-        size: number;
-        encoding: string;
-    } | undefined;
-    error?: string;
-}>;
 
 /**
- * File Append Tool
+ * Query parameters for parameterized SQL execution
+ *
+ * Parameters can be provided as:
+ * - An array for positional parameters (e.g., [value1, value2])
+ * - An object for named parameters (e.g., { name: 'John', age: 30 })
  */
+type QueryParams = unknown[] | Record<string, unknown>;
 /**
- * Create file append tool
+ * Query execution input
  */
-declare function createFileAppendTool(defaultEncoding?: string): _agentforge_core.Tool<{
-    path: string;
-    content: string;
-    encoding?: "ascii" | "utf-8" | "utf8" | undefined;
-}, {
-    success: boolean;
-    data?: {
-        path: string;
-        size: number;
-    } | undefined;
-    error?: string;
-}>;
-
+interface QueryInput {
+    /** SQL query string */
+    sql: string;
+    /** Query parameters for parameter binding */
+    params?: QueryParams;
+    /** Database vendor */
+    vendor: DatabaseVendor;
+}
 /**
- * File Delete Tool
+ * Query execution result
  */
+interface QueryExecutionResult {
+    /** Query result rows */
+    rows: unknown[];
+    /** Number of rows affected (for INSERT/UPDATE/DELETE) */
+    rowCount: number;
+    /** Execution time in milliseconds */
+    executionTime: number;
+}
 /**
- * Create file delete tool
+ * Minimal SQL executor abstraction.
+ * Used by ConnectionManager and transaction contexts.
  */
-declare function createFileDeleteTool(): _agentforge_core.Tool<{
-    path: string;
-}, {
-    success: boolean;
-    data?: {
-        path: string;
-        message: string;
-    } | undefined;
-    error?: string;
-}>;
+interface SqlExecutor {
+    execute(query: SQL): Promise<unknown>;
+}
 
 /**
- * File Exists Tool
+ * Connection configuration types for relational databases
+ * @module connection/types
  */
+
 /**
- * Create file exists tool
+ * Connection pool configuration options
+ *
+ * These options control how the connection pool manages database connections.
+ * Different vendors may support different subsets of these options.
+ *
+ * Note: Some options are vendor-specific and may be ignored by certain drivers.
+ * See vendor-specific documentation for supported options.
+ */
+interface PoolConfig {
+    /** Maximum number of connections in the pool (default: vendor-specific) */
+    max?: number;
+    /** Maximum time (ms) to wait for a connection from the pool before timing out */
+    acquireTimeoutMillis?: number;
+    /** Time (ms) a connection can remain idle before being closed (default: vendor-specific) */
+    idleTimeoutMillis?: number;
+}
+/**
+ * PostgreSQL-specific connection configuration
  */
-declare function createFileExistsTool(): _agentforge_core.Tool<{
-    path: string;
-}, {
-    exists: boolean;
-    path: string;
-    isFile: boolean;
-    isDirectory: boolean;
-    size: number;
-    modified: string;
-} | {
-    exists: boolean;
-    path: string;
-    isFile?: undefined;
-    isDirectory?: undefined;
-    size?: undefined;
-    modified?: undefined;
-}>;
-
+interface PostgreSQLConnectionConfig {
+    /** Connection string (e.g., postgresql://user:password@host:port/database) */
+    connectionString?: string;
+    /** Host address */
+    host?: string;
+    /** Port number (default: 5432) */
+    port?: number;
+    /** Database name */
+    database?: string;
+    /** Username */
+    user?: string;
+    /** Password */
+    password?: string;
+    /** Enable SSL */
+    ssl?: boolean | Record<string, unknown>;
+    /** Connection timeout in milliseconds */
+    connectionTimeoutMillis?: number;
+    /** Connection pool configuration */
+    pool?: PoolConfig;
+    /** Additional pg-specific options */
+    [key: string]: unknown;
+}
 /**
- * Default file operation tool instances
+ * MySQL-specific connection configuration
+ *
+ * Note: mysql2.createPool accepts connection strings directly as a parameter,
+ * not as a property of the config object. Use the ConnectionConfig discriminated
+ * union type which allows either a config object OR a string.
+ */
+interface MySQLConnectionConfig {
+    /** Host address */
+    host?: string;
+    /** Port number (default: 3306) */
+    port?: number;
+    /** Database name */
+    database?: string;
+    /** Username */
+    user?: string;
+    /** Password */
+    password?: string;
+    /** Enable SSL */
+    ssl?: boolean | Record<string, unknown>;
+    /** Connection timeout in milliseconds */
+    connectTimeout?: number;
+    /** Connection pool configuration */
+    pool?: PoolConfig;
+    /** Additional mysql2-specific options */
+    [key: string]: unknown;
+}
+/**
+ * SQLite-specific connection configuration
+ *
+ * Note: SQLite typically uses a single connection with serialized access rather than a
+ * traditional multi-connection pool. The `pool` configuration is accepted for API
+ * consistency and future extensions, but it may not affect runtime behavior for SQLite.
  */
-declare const fileReader: _agentforge_core.Tool<{
-    path: string;
-    encoding?: "ascii" | "binary" | "base64" | "hex" | "utf-8" | "utf8" | undefined;
-}, {
-    success: boolean;
-    data?: {
-        content: string;
-        size: number;
-        path: string;
-        encoding: string;
-    } | undefined;
-    error?: string;
-}>;
-declare const fileWriter: _agentforge_core.Tool<{
-    path: string;
-    content: string;
-    encoding?: "ascii" | "base64" | "hex" | "utf-8" | "utf8" | undefined;
-    createDirs?: boolean | undefined;
-}, {
-    success: boolean;
-    data?: {
-        path: string;
-        size: number;
-        encoding: string;
-    } | undefined;
-    error?: string;
-}>;
-declare const fileAppend: _agentforge_core.Tool<{
-    path: string;
-    content: string;
-    encoding?: "ascii" | "utf-8" | "utf8" | undefined;
-}, {
-    success: boolean;
-    data?: {
-        path: string;
-        size: number;
-    } | undefined;
-    error?: string;
-}>;
-declare const fileDelete: _agentforge_core.Tool<{
-    path: string;
-}, {
-    success: boolean;
-    data?: {
-        path: string;
-        message: string;
-    } | undefined;
-    error?: string;
-}>;
-declare const fileExists: _agentforge_core.Tool<{
-    path: string;
-}, {
-    exists: boolean;
-    path: string;
-    isFile: boolean;
-    isDirectory: boolean;
-    size: number;
-    modified: string;
-} | {
-    exists: boolean;
-    path: string;
-    isFile?: undefined;
-    isDirectory?: undefined;
-    size?: undefined;
-    modified?: undefined;
-}>;
+interface SQLiteConnectionConfig {
+    /** Database file path or ':memory:' for in-memory database */
+    url: string;
+    /**
+     * Connection pool configuration.
+     *
+     * For SQLite this is primarily for API compatibility with other vendors and may be
+     * ignored by the underlying driver.
+     */
+    pool?: PoolConfig;
+    /** Additional better-sqlite3-specific options */
+    [key: string]: unknown;
+}
 /**
- * Array of all file operation tools
+ * Union type for vendor-specific connection configurations
  */
-declare const fileOperationTools: (_agentforge_core.Tool<{
-    path: string;
-    encoding?: "ascii" | "binary" | "base64" | "hex" | "utf-8" | "utf8" | undefined;
-}, {
-    success: boolean;
-    data?: {
+type VendorConnectionConfig = PostgreSQLConnectionConfig | MySQLConnectionConfig | SQLiteConnectionConfig;
+/**
+ * Connection configuration for ConnectionManager
+ *
+ * Uses a discriminated union to ensure that the connection string format
+ * matches the selected database vendor at compile time.
+ */
+type ConnectionConfig = {
+    /** PostgreSQL database vendor */
+    vendor: Extract<DatabaseVendor, 'postgresql'>;
+    /**
+     * PostgreSQL-specific connection configuration or connection string.
+     * When using a string, it should be a PostgreSQL URL
+     * (e.g., "postgresql://user:password@host:port/database").
+     */
+    connection: PostgreSQLConnectionConfig | string;
+} | {
+    /** MySQL database vendor */
+    vendor: Extract<DatabaseVendor, 'mysql'>;
+    /**
+     * MySQL-specific connection configuration or connection string.
+     * When using a string, it should be a MySQL URL
+     * (e.g., "mysql://user:password@host:port/database").
+     */
+    connection: MySQLConnectionConfig | string;
+} | {
+    /** SQLite database vendor */
+    vendor: Extract<DatabaseVendor, 'sqlite'>;
+    /**
+     * SQLite-specific connection configuration or location.
+     * Can be a file path, ':memory:' for in-memory database, or a config object.
+     */
+    connection: SQLiteConnectionConfig | string;
+};
+
+/**
+ * Connection manager for relational databases using Drizzle ORM
+ * @module connection/connection-manager
+ */
+
+/**
+ * Connection state enum
+ */
+declare enum ConnectionState {
+    DISCONNECTED = "disconnected",
+    CONNECTING = "connecting",
+    CONNECTED = "connected",
+    RECONNECTING = "reconnecting",
+    ERROR = "error"
+}
+/**
+ * Connection lifecycle events
+ */
+type ConnectionEvent = 'connected' | 'disconnected' | 'error' | 'reconnecting';
+/**
+ * Reconnection configuration
+ */
+interface ReconnectionConfig {
+    /** Enable automatic reconnection on connection loss */
+    enabled: boolean;
+    /** Maximum number of reconnection attempts (0 = infinite) */
+    maxAttempts: number;
+    /** Base delay in milliseconds for exponential backoff */
+    baseDelayMs: number;
+    /** Maximum delay in milliseconds between reconnection attempts */
+    maxDelayMs: number;
+}
+/**
+ * Connection manager that handles database connections for PostgreSQL, MySQL, and SQLite
+ * using Drizzle ORM with lifecycle management and automatic reconnection
+ */
+declare class ConnectionManager extends EventEmitter implements DatabaseConnection {
+    private vendor;
+    private db;
+    private client;
+    private config;
+    private state;
+    private reconnectionConfig;
+    private reconnectionAttempts;
+    private reconnectionTimer;
+    private connectPromise;
+    private connectionGeneration;
+    /**
+     * Create a new ConnectionManager instance
+     * @param config - Connection configuration
+     * @param reconnectionConfig - Optional reconnection configuration
+     */
+    constructor(config: ConnectionConfig, reconnectionConfig?: Partial<ReconnectionConfig>);
+    /**
+     * Connect to the database
+     * Initializes the connection and sets up automatic reconnection if configured
+     * @throws {Error} If connection fails or configuration is invalid
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the database
+     * Closes the connection and cancels any pending reconnection attempts
+     *
+     * Note: Event listeners are NOT removed by this method. If you need to dispose
+     * of the ConnectionManager instance entirely, call dispose() instead.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Dispose of the ConnectionManager instance
+     * Disconnects and removes all event listeners
+     * Call this when you're done with the ConnectionManager and won't reuse it
+     */
+    dispose(): Promise<void>;
+    /**
+     * Check if the connection is currently connected
+     * @returns true if connected, false otherwise
+     */
+    isConnected(): boolean;
+    /**
+     * Get the current connection state
+     * @returns Current connection state
+     */
+    getState(): ConnectionState;
+    /**
+     * Get the configured database vendor.
+     */
+    getVendor(): DatabaseVendor;
+    /**
+     * Initialize the database connection
+     *
+     * This method is public to maintain compatibility with the DatabaseConnection interface
+     * and existing code (e.g., relational-query.ts). For new code, prefer using connect()
+     * which provides lifecycle management and automatic reconnection.
+     *
+     * @throws {Error} If connection fails or configuration is invalid
+     */
+    initialize(): Promise<void>;
+    /**
+     * Set the connection state and log the change
+     * @param newState - New connection state
+     * @private
+     */
+    private setState;
+    /**
+     * Schedule a reconnection attempt with exponential backoff
+     * @private
+     */
+    private scheduleReconnection;
+    /**
+     * Initialize PostgreSQL connection using Drizzle ORM with node-postgres
+     *
+     * Applies pool configuration options to pg.Pool for connection management.
+     */
+    private initializePostgreSQL;
+    /**
+     * Initialize MySQL connection using Drizzle ORM with mysql2
+     *
+     * Applies pool configuration options to mysql2.createPool for connection management.
+     */
+    private initializeMySQL;
+    /**
+     * Initialize SQLite connection using Drizzle ORM with better-sqlite3
+     *
+     * Note: SQLite uses a single connection. Pool configuration is logged but not applied
+     * as SQLite handles concurrent access through its internal locking mechanism.
+     */
+    private initializeSQLite;
+    /**
+     * Determine whether an error thrown by drizzle-orm's better-sqlite3 adapter
+     * `.all()` indicates the statement does not return data (i.e. it is DML/DDL,
+     * not a SELECT).
+     *
+     * The adapter may surface this as either a native `SqliteError` or a
+     * `TypeError` depending on the drizzle-orm / better-sqlite3 version, so we
+     * accept both types while still requiring the distinctive message substring
+     * to avoid false positives from unrelated errors.
+     */
+    private isSqliteNonQueryError;
+    /**
+     * Execute a SQL query
+     *
+     * Executes a parameterized SQL query using Drizzle's SQL template objects.
+     * This method provides safe parameter binding to prevent SQL injection.
+     *
+     * @param query - Drizzle SQL template object with parameter binding
+     * @returns Query result
+     *
+     * @example
+     * ```typescript
+     * import { sql } from 'drizzle-orm';
+     *
+     * const result = await manager.execute(
+     *   sql`SELECT * FROM users WHERE id = ${userId}`
+     * );
+     * ```
+     */
+    execute(query: SQL): Promise<unknown>;
+    /**
+     * Execute a callback with a single dedicated database connection/session.
+     *
+     * This is required for multi-statement transactions so all statements run on
+     * the same underlying connection.
+     */
+    executeInConnection<T>(callback: (execute: (query: SQL) => Promise<unknown>) => Promise<T>): Promise<T>;
+    /**
+     * Get connection pool metrics
+     *
+     * Returns information about the current state of the connection pool.
+     * For SQLite, returns basic connection status since it uses a single connection.
+     *
+     * @returns Pool metrics including total, active, idle, and waiting connections
+     */
+    getPoolMetrics(): {
+        totalCount: number;
+        activeCount: number;
+        idleCount: number;
+        waitingCount: number;
+    };
+    /**
+     * Close the database connection
+     *
+     * This method is public to maintain compatibility with the DatabaseConnection interface
+     * and existing code (e.g., relational-query.ts). For new code, prefer using disconnect()
+     * for connection lifecycle management. Note that disconnect() does NOT clean up event
+     * listeners; call dispose() if you need full cleanup including listener removal.
+     *
+     * Note: This method coordinates with in-flight connect()/initialize() operations
+     * and cancels pending reconnection timers to prevent unexpected reconnections.
+     */
+    close(): Promise<void>;
+    /**
+     * Clean up resources when a connection is cancelled during initialization
+     * This prevents connection leaks when disconnect() is called while initialize() is in-flight
+     */
+    private cleanupCancelledConnection;
+    /**
+     * Check if the connection is healthy
+     * @returns true if connection is healthy, false otherwise
+     */
+    isHealthy(): Promise<boolean>;
+}
+
+/**
+ * Transaction helpers for relational databases.
+ * @module query/transaction
+ */
+
+/**
+ * SQL transaction isolation level.
+ *
+ * Determines the visibility of changes made by concurrent transactions.
+ * Supported by PostgreSQL and MySQL. SQLite supports `'read uncommitted'`
+ * via `PRAGMA read_uncommitted = 1`; other levels are silently ignored
+ * (SQLite uses serializable semantics by default).
+ */
+type TransactionIsolationLevel = 'read uncommitted' | 'read committed' | 'repeatable read' | 'serializable';
+/**
+ * Options for configuring a database transaction.
+ *
+ * @property isolationLevel - SQL isolation level for the transaction
+ * @property timeoutMs - Maximum duration in milliseconds before the transaction is rolled back
+ */
+interface TransactionOptions {
+    isolationLevel?: TransactionIsolationLevel;
+    timeoutMs?: number;
+}
+/**
+ * Active transaction handle with savepoint support.
+ *
+ * Extends {@link SqlExecutor} so queries can be executed within the transaction.
+ * The transaction is automatically rolled back if an error occurs and is not
+ * explicitly committed.
+ *
+ * @property id - Unique identifier for this transaction
+ * @property vendor - Database vendor this transaction belongs to
+ */
+interface TransactionContext extends SqlExecutor {
+    id: string;
+    vendor: DatabaseVendor;
+    /** Whether the transaction is still active (not committed or rolled back). */
+    isActive(): boolean;
+    /** Commit all changes made within this transaction. */
+    commit(): Promise<void>;
+    /** Roll back all changes made within this transaction. */
+    rollback(): Promise<void>;
+    /** Create a savepoint within this transaction. Returns the savepoint name. */
+    createSavepoint(name?: string): Promise<string>;
+    /** Roll back to a previously created savepoint. */
+    rollbackToSavepoint(name: string): Promise<void>;
+    /** Release a savepoint, making its changes permanent within the transaction. */
+    releaseSavepoint(name: string): Promise<void>;
+    /** Execute an operation within a nested savepoint, with automatic rollback on failure. */
+    withSavepoint<T>(operation: (transaction: TransactionContext) => Promise<T>, name?: string): Promise<T>;
+}
+/**
+ * Execute a callback inside a database transaction.
+ *
+ * Automatically commits on success and rolls back on failure.
+ */
+declare function withTransaction<T>(manager: ConnectionManager, operation: (transaction: TransactionContext) => Promise<T>, options?: TransactionOptions): Promise<T>;
+
+/**
+ * Query executor for relational databases using Drizzle ORM
+ * @module query/query-executor
+ */
+
+/**
+ * Execution context for raw SQL queries.
+ *
+ * @property transaction - Optional active transaction to execute within
+ */
+interface QueryExecutionContext {
+    transaction?: TransactionContext;
+}
+/**
+ * Execute a parameterized SQL query
+ *
+ * This function executes a SQL query with proper parameter binding to prevent
+ * SQL injection. It supports SELECT, INSERT, UPDATE, DELETE, and other SQL statements.
+ *
+ * @param manager - ConnectionManager instance with initialized database connection
+ * @param input - Query input with SQL string, parameters, and options
+ * @returns Query execution result with rows, row count, and execution time
+ * @throws {Error} If database is not initialized or query execution fails
+ */
+declare function executeQuery(manager: ConnectionManager, input: QueryInput, context?: QueryExecutionContext): Promise<QueryExecutionResult>;
+
+/**
+ * Query builder helpers for relational CRUD operations.
+ * @module query/query-builder
+ */
+
+/**
+ * Supported scalar values for INSERT payloads.
+ */
+type InsertValue = string | number | boolean | null;
+/**
+ * One INSERT row payload.
+ */
+type InsertRow = Record<string, InsertValue>;
+/**
+ * INSERT payload input shape.
+ */
+type InsertData = InsertRow | InsertRow[];
+/**
+ * INSERT RETURNING behavior.
+ */
+type InsertReturningMode = 'none' | 'id' | 'row';
+/**
+ * INSERT RETURNING configuration.
+ */
+interface InsertReturningOptions {
+    mode?: InsertReturningMode;
+    idColumn?: string;
+}
+/**
+ * Builder input for INSERT queries.
+ */
+interface InsertQueryInput {
+    table: string;
+    data: InsertData;
+    returning?: InsertReturningOptions;
+    vendor: DatabaseVendor;
+}
+/**
+ * Built INSERT query with normalized metadata used by execution layer.
+ */
+interface BuiltInsertQuery {
+    query: SQL | SQL[];
+    rows: InsertRow[];
+    returningMode: InsertReturningMode;
+    idColumn: string;
+    supportsReturning: boolean;
+}
+/**
+ * Build a safe parameterized INSERT query from structured input.
+ */
+declare function buildInsertQuery(input: InsertQueryInput): BuiltInsertQuery;
+/**
+ * Supported scalar values for UPDATE payloads.
+ */
+type UpdateValue = InsertValue;
+/**
+ * UPDATE payload shape.
+ */
+type UpdateData = Record<string, UpdateValue>;
+/**
+ * WHERE operator types for UPDATE conditions.
+ */
+type UpdateWhereOperator = 'eq' | 'ne' | 'gt' | 'lt' | 'gte' | 'lte' | 'like' | 'in' | 'notIn' | 'isNull' | 'isNotNull';
+/**
+ * WHERE condition for UPDATE queries.
+ */
+interface UpdateWhereCondition {
+    column: string;
+    operator: UpdateWhereOperator;
+    value?: string | number | boolean | null | Array<string | number>;
+}
+/**
+ * Optional optimistic lock condition appended to WHERE.
+ */
+interface UpdateOptimisticLock {
+    column: string;
+    expectedValue: string | number;
+}
+/**
+ * Builder input for UPDATE queries.
+ */
+interface UpdateQueryInput {
+    table: string;
+    data: UpdateData;
+    where?: UpdateWhereCondition[];
+    allowFullTableUpdate?: boolean;
+    optimisticLock?: UpdateOptimisticLock;
+    vendor: DatabaseVendor;
+}
+/**
+ * Built UPDATE query with normalized metadata used by execution layer.
+ */
+interface BuiltUpdateQuery {
+    query: SQL;
+    whereApplied: boolean;
+    usesOptimisticLock: boolean;
+}
+/**
+ * WHERE condition for DELETE queries.
+ */
+interface DeleteWhereCondition {
+    column: string;
+    operator: UpdateWhereOperator;
+    value?: string | number | boolean | null | Array<string | number>;
+}
+/**
+ * Soft-delete configuration.
+ */
+interface DeleteSoftDeleteOptions {
+    column?: string;
+    value?: string | number;
+}
+/**
+ * Builder input for DELETE queries.
+ */
+interface DeleteQueryInput {
+    table: string;
+    where?: DeleteWhereCondition[];
+    allowFullTableDelete?: boolean;
+    softDelete?: DeleteSoftDeleteOptions;
+    vendor: DatabaseVendor;
+}
+/**
+ * Built DELETE query with normalized metadata used by execution layer.
+ */
+interface BuiltDeleteQuery {
+    query: SQL;
+    whereApplied: boolean;
+    usesSoftDelete: boolean;
+    softDeleteColumn?: string;
+}
+/**
+ * Build a safe parameterized UPDATE query from structured input.
+ */
+declare function buildUpdateQuery(input: UpdateQueryInput): BuiltUpdateQuery;
+/**
+ * Build a safe parameterized DELETE query from structured input.
+ */
+declare function buildDeleteQuery(input: DeleteQueryInput): BuiltDeleteQuery;
+/**
+ * ORDER BY direction for SELECT queries.
+ */
+type SelectOrderDirection = 'asc' | 'desc';
+/**
+ * ORDER BY clause for SELECT queries.
+ */
+interface SelectOrderBy {
+    column: string;
+    direction: SelectOrderDirection;
+}
+/**
+ * WHERE condition for SELECT queries.
+ */
+interface SelectWhereCondition {
+    column: string;
+    operator: UpdateWhereOperator;
+    value?: string | number | boolean | null | Array<string | number>;
+}
+/**
+ * Builder input for SELECT queries.
+ */
+interface SelectQueryInput {
+    table: string;
+    columns?: string[];
+    where?: SelectWhereCondition[];
+    orderBy?: SelectOrderBy[];
+    limit?: number;
+    offset?: number;
+    vendor: DatabaseVendor;
+}
+/**
+ * Build a safe parameterized SELECT query from structured input.
+ */
+declare function buildSelectQuery(input: SelectQueryInput): SQL;
+
+/**
+ * Generic batch execution helpers for relational operations.
+ * @module query/batch-executor
+ */
+/** Default number of items processed per batch chunk. */
+declare const DEFAULT_BATCH_SIZE = 100;
+/** Maximum allowed batch size to prevent memory exhaustion. */
+declare const MAX_BATCH_SIZE = 5000;
+/**
+ * Progress payload emitted after each processed batch.
+ */
+interface BatchProgressUpdate {
+    operation: string;
+    batchIndex: number;
+    totalBatches: number;
+    batchSize: number;
+    processedItems: number;
+    totalItems: number;
+    successfulItems: number;
+    failedItems: number;
+    lastBatchSucceeded: boolean;
+}
+/**
+ * Recorded batch failure metadata.
+ */
+interface BatchFailureDetail {
+    operation: string;
+    batchIndex: number;
+    batchSize: number;
+    attempts: number;
+    error: string;
+}
+/**
+ * Runtime options for batched execution.
+ */
+interface BatchExecutionOptions {
+    batchSize?: number;
+    continueOnError?: boolean;
+    maxRetries?: number;
+    retryDelayMs?: number;
+    onProgress?: (progress: BatchProgressUpdate) => Promise<void> | void;
+}
+/**
+ * Task descriptor for generic batched execution.
+ */
+interface BatchExecutionTask<TItem, TResult> {
+    operation: string;
+    items: TItem[];
+    executeBatch: (batchItems: TItem[], batchIndex: number) => Promise<TResult>;
+    getBatchSuccessCount?: (result: TResult, batchItems: TItem[]) => number;
+}
+/**
+ * Batched execution summary.
+ */
+interface BatchExecutionResult<TResult> {
+    results: TResult[];
+    totalItems: number;
+    processedItems: number;
+    successfulItems: number;
+    failedItems: number;
+    totalBatches: number;
+    retries: number;
+    partialSuccess: boolean;
+    executionTime: number;
+    failures: BatchFailureDetail[];
+}
+/**
+ * Synthetic benchmark output comparing individual and batched processing.
+ */
+interface BatchBenchmarkResult {
+    itemCount: number;
+    batchSize: number;
+    batchCount: number;
+    individualExecutionTime: number;
+    batchedExecutionTime: number;
+    timeSavedMs: number;
+    speedupRatio: number;
+    speedupPercent: number;
+}
+/**
+ * Execute operation items in batches with retry and progress callbacks.
+ */
+declare function executeBatchedTask<TItem, TResult>(task: BatchExecutionTask<TItem, TResult>, options?: BatchExecutionOptions): Promise<BatchExecutionResult<TResult>>;
+/**
+ * Benchmark individual vs batched execution.
+ *
+ * Note: callers should run this only for idempotent or isolated workloads.
+ */
+declare function benchmarkBatchExecution<TItem, TIndividualResult, TBatchResult>(params: {
+    items: TItem[];
+    batchSize?: number;
+    runIndividual: (item: TItem, index: number) => Promise<TIndividualResult>;
+    runBatch: (batchItems: TItem[], batchIndex: number) => Promise<TBatchResult>;
+}): Promise<BatchBenchmarkResult>;
+
+/**
+ * Streaming SELECT executor for large result sets.
+ * @module query/stream-executor
+ */
+
+/** Default number of rows fetched per streaming chunk. */
+declare const DEFAULT_CHUNK_SIZE = 100;
+/**
+ * Memory usage information captured during streaming execution.
+ */
+interface StreamingMemoryUsage$1 {
+    startHeapUsed: number;
+    peakHeapUsed: number;
+    endHeapUsed: number;
+    deltaHeapUsed: number;
+}
+/**
+ * One streamed chunk payload.
+ */
+interface StreamingSelectChunk {
+    chunkIndex: number;
+    offset: number;
+    rows: unknown[];
+}
+/**
+ * Streaming execution options.
+ */
+interface StreamingSelectOptions {
+    chunkSize?: number;
+    maxRows?: number;
+    sampleSize?: number;
+    collectAllRows?: boolean;
+    signal?: AbortSignal;
+    onChunk?: (chunk: StreamingSelectChunk) => Promise<void> | void;
+}
+/**
+ * Streaming execution result.
+ */
+interface StreamingSelectResult {
+    rows: unknown[];
+    rowCount: number;
+    chunkCount: number;
+    executionTime: number;
+    cancelled: boolean;
+    memoryUsage: StreamingMemoryUsage$1;
+}
+/**
+ * Optional benchmark result comparing regular vs streaming SELECT execution.
+ */
+interface StreamingBenchmarkResult {
+    nonStreamingExecutionTime: number;
+    nonStreamingPeakHeapUsed: number;
+    streamingExecutionTime: number;
+    streamingPeakHeapUsed: number;
+    memorySavedBytes: number;
+    memorySavedPercent: number;
+}
+/**
+ * Yield SELECT rows chunk-by-chunk using LIMIT/OFFSET pagination.
+ *
+ * NOTE:
+ * OFFSET-based pagination can degrade on very large offsets because many SQL
+ * engines must scan/skip intermediate rows. For very large datasets, prefer
+ * keyset/cursor pagination when available.
+ */
+declare function streamSelectChunks(executor: SqlExecutor, input: SelectQueryInput, options?: StreamingSelectOptions): AsyncGenerator<StreamingSelectChunk>;
+/**
+ * Create a Node.js Readable stream that emits SELECT chunks in object mode.
+ */
+declare function createSelectReadableStream(executor: SqlExecutor, input: SelectQueryInput, options?: StreamingSelectOptions): Readable;
+/**
+ * Execute a SELECT query in streaming mode while tracking memory usage.
+ */
+declare function executeStreamingSelect(executor: SqlExecutor, input: SelectQueryInput, options?: StreamingSelectOptions): Promise<StreamingSelectResult>;
+/**
+ * Benchmark memory usage of regular SELECT execution vs streaming execution.
+ *
+ * NOTE:
+ * This benchmark intentionally executes the SELECT query twice (one regular,
+ * one streaming). Use only with side-effect-free queries.
+ */
+declare function benchmarkStreamingSelectMemory(executor: SqlExecutor, input: SelectQueryInput, options?: StreamingSelectOptions): Promise<StreamingBenchmarkResult>;
+
+/**
+ * Type definitions for relational schema introspection.
+ * @module schema/types
+ */
+
+/**
+ * Foreign key definition for a table column.
+ */
+interface ForeignKeySchema {
+    name?: string;
+    column: string;
+    referencedTable: string;
+    referencedColumn: string;
+    referencedSchema?: string;
+}
+/**
+ * Index definition for a table.
+ */
+interface IndexSchema {
+    name: string;
+    columns: string[];
+    isUnique: boolean;
+}
+/**
+ * Column definition for a table.
+ */
+interface ColumnSchema {
+    name: string;
+    type: string;
+    isNullable: boolean;
+    defaultValue: unknown;
+    isPrimaryKey: boolean;
+}
+/**
+ * Table schema definition.
+ */
+interface TableSchema {
+    name: string;
+    schema?: string;
+    columns: ColumnSchema[];
+    primaryKey: string[];
+    foreignKeys: ForeignKeySchema[];
+    indexes: IndexSchema[];
+}
+/**
+ * Introspected database schema.
+ */
+interface DatabaseSchema {
+    vendor: DatabaseVendor;
+    tables: TableSchema[];
+    generatedAt: string;
+}
+/**
+ * Runtime options for schema introspection.
+ */
+interface SchemaInspectOptions {
+    tables?: string[];
+    bypassCache?: boolean;
+}
+/**
+ * Schema inspector configuration.
+ */
+interface SchemaInspectorConfig {
+    cacheTtlMs?: number;
+    cacheKey?: string;
+}
+
+/**
+ * Schema inspector for relational databases.
+ * @module schema/schema-inspector
+ */
+
+/**
+ * Inspects database schemas across PostgreSQL, MySQL, and SQLite.
+ *
+ * Retrieves table, column, index, and foreign key metadata with built-in
+ * caching support. Use {@link SchemaInspector.clearCache} to invalidate
+ * cached schemas.
+ */
+declare class SchemaInspector {
+    private readonly manager;
+    private readonly vendor;
+    private readonly cacheTtlMs;
+    private readonly cacheKey?;
+    /**
+     * Create a new SchemaInspector.
+     *
+     * @param manager - ConnectionManager instance for database access
+     * @param vendor - Database vendor ('postgresql' | 'mysql' | 'sqlite')
+     * @param config - Optional configuration for cache TTL and cache key
+     */
+    constructor(manager: ConnectionManager, vendor: DatabaseVendor, config?: SchemaInspectorConfig);
+    /**
+     * Clear cached schema data.
+     *
+     * @param cacheKey - Specific cache key to clear. If omitted, clears all cached schemas.
+     */
+    static clearCache(cacheKey?: string): void;
+    /** Invalidate this inspector's cached schema, if any. */
+    invalidateCache(): void;
+    /**
+     * Inspect the database schema and return structured metadata.
+     *
+     * Results are cached when a `cacheKey` was provided at construction time.
+     *
+     * @param options - Optional table filters and cache bypass flag
+     * @returns Structured schema with tables, columns, indexes, and foreign keys
+     */
+    inspect(options?: SchemaInspectOptions): Promise<DatabaseSchema>;
+    private inspectFromDatabase;
+    private runQueryRows;
+    private createTableMap;
+    private getTableFromRow;
+    private inspectPostgreSQL;
+    private inspectMySQL;
+    private inspectSQLite;
+    private applyIndexRows;
+}
+
+/**
+ * Schema metadata validation utilities.
+ *
+ * Validates table existence, column existence, and column types
+ * against an introspected {@link DatabaseSchema}.
+ *
+ * @module schema/schema-validator
+ */
+
+/**
+ * Result of a schema validation check.
+ */
+interface ValidationResult {
+    /** Whether the validation passed */
+    valid: boolean;
+    /** Error messages (empty when valid) */
+    errors: string[];
+}
+/**
+ * Validate that a table exists in the database schema.
+ *
+ * Supports both plain table names (`users`) and schema-qualified names (`public.users`).
+ *
+ * @param schema - The introspected database schema
+ * @param tableName - Table name to check (plain or schema-qualified)
+ * @returns Validation result
+ */
+declare function validateTableExists(schema: DatabaseSchema, tableName: string): ValidationResult;
+/**
+ * Validate that one or more columns exist in a table.
+ *
+ * @param schema - The introspected database schema
+ * @param tableName - Table that should contain the columns
+ * @param columnNames - Column names to verify
+ * @returns Validation result
+ */
+declare function validateColumnsExist(schema: DatabaseSchema, tableName: string, columnNames: string[]): ValidationResult;
+/**
+ * Validate that columns in a table match expected types.
+ *
+ * Type matching is case-insensitive and uses substring containment:
+ * a match succeeds when either string contains the other.  For example
+ * `varchar` matches `varchar(255)` (the actual type contains the expected
+ * string), but `varchar` does **not** match `character varying` because
+ * neither is a substring of the other.
+ *
+ * @param schema - The introspected database schema
+ * @param tableName - Table to validate against
+ * @param expectedTypes - Map of column name → expected type substring
+ * @returns Validation result
+ */
+declare function validateColumnTypes(schema: DatabaseSchema, tableName: string, expectedTypes: Record<string, string>): ValidationResult;
+
+/**
+ * Database type → TypeScript type mapper.
+ *
+ * Maps vendor-specific SQL column types to their closest TypeScript
+ * equivalents.  Used for code generation hints, documentation, and
+ * schema-aware validation utilities.
+ *
+ * @module schema/type-mapper
+ */
+
+/**
+ * TypeScript type representation for a mapped database column.
+ */
+interface MappedType {
+    /** The TypeScript type string (e.g. `string`, `number`, `boolean`) */
+    tsType: string;
+    /** Whether the column is nullable (adds `| null`) */
+    nullable: boolean;
+    /** The original database type string */
+    dbType: string;
+    /** Optional notes about precision loss, range, etc. */
+    notes?: string;
+}
+/**
+ * Map a single database column type to its TypeScript equivalent.
+ *
+ * Normalises the input type to lower-case and strips size suffixes
+ * (e.g. `varchar(255)` → `varchar`) before looking up the mapping.
+ *
+ * @param vendor - Database vendor
+ * @param dbType - The raw column type string from the database
+ * @param nullable - Whether the column is nullable
+ * @returns The mapped TypeScript type information
+ */
+declare function mapColumnType(vendor: DatabaseVendor, dbType: string, nullable?: boolean): MappedType;
+/**
+ * Map all columns in a database schema to TypeScript types.
+ *
+ * Returns a nested map:  `tableName → columnName → MappedType`.
+ *
+ * @param vendor - Database vendor
+ * @param columns - Array of columns with their metadata
+ * @returns Nested map from table to column to mapped type
+ */
+declare function mapSchemaTypes(vendor: DatabaseVendor, columns: Array<{
+    table: string;
+    name: string;
+    type: string;
+    nullable: boolean;
+}>): Map<string, Map<string, MappedType>>;
+/**
+ * Get the full type map for a vendor (useful for documentation / tooling).
+ *
+ * @param vendor - Database vendor
+ * @returns Read-only copy of the vendor's type mapping table
+ */
+declare function getVendorTypeMap(vendor: DatabaseVendor): Readonly<Record<string, string>>;
+
+/**
+ * Schema diff and serialisation utilities.
+ *
+ * Compare two {@link DatabaseSchema} instances and produce a structured
+ * diff report.  Also provide JSON export / import for snapshot testing
+ * and cross-environment schema comparison.
+ *
+ * @module schema/schema-diff
+ */
+
+/** Describes a difference for a single column. */
+interface ColumnDiff {
+    column: string;
+    type: 'added' | 'removed' | 'changed';
+    /** Present when type is `changed` */
+    changes?: Array<{
+        property: string;
+        before: unknown;
+        after: unknown;
+    }>;
+}
+/** Describes a difference for a single table. */
+interface TableDiff {
+    table: string;
+    type: 'added' | 'removed' | 'changed';
+    /** Present when type is `changed` — per-column changes */
+    columns?: ColumnDiff[];
+    /** Present when type is `changed` — primary-key changes */
+    primaryKeyChanged?: {
+        before: string[];
+        after: string[];
+    };
+}
+/** Full diff report between two schemas. */
+interface SchemaDiffResult {
+    /** Whether the schemas are identical */
+    identical: boolean;
+    /** Per-table differences */
+    tables: TableDiff[];
+    /** Summary counts */
+    summary: {
+        tablesAdded: number;
+        tablesRemoved: number;
+        tablesChanged: number;
+        columnsAdded: number;
+        columnsRemoved: number;
+        columnsChanged: number;
+    };
+}
+/**
+ * Compare two database schemas and return a structured diff report.
+ *
+ * The comparison is name-based and case-insensitive. Schema-qualified
+ * names are supported (e.g. `public.users`).
+ *
+ * @param before - The baseline schema
+ * @param after - The schema to compare against the baseline
+ * @returns A structured diff report
+ */
+declare function diffSchemas(before: DatabaseSchema, after: DatabaseSchema): SchemaDiffResult;
+/**
+ * Export a {@link DatabaseSchema} to a JSON string.
+ *
+ * The output is deterministic (keys sorted, 2-space indent) so that it
+ * can be used for snapshot testing.
+ *
+ * @param schema - The schema to serialise
+ * @returns Pretty-printed JSON string
+ */
+declare function exportSchemaToJson(schema: DatabaseSchema): string;
+/**
+ * Import a {@link DatabaseSchema} from a JSON string.
+ *
+ * Performs basic structural validation to ensure the parsed object has the
+ * required shape.
+ *
+ * @param json - JSON string produced by {@link exportSchemaToJson}
+ * @returns Parsed database schema
+ * @throws Error when the JSON is not a valid DatabaseSchema
+ */
+declare function importSchemaFromJson(json: string): DatabaseSchema;
+
+/**
+ * Relational Query Tool - Execute raw SQL queries with parameter binding
+ * @module tools/relational-query
+ */
+/**
+ * Relational Query Tool
+ *
+ * Executes raw SQL queries against relational databases (PostgreSQL, MySQL, SQLite)
+ * with proper parameter binding to prevent SQL injection.
+ *
+ * Features:
+ * - Supports SELECT, INSERT, UPDATE, DELETE, and other SQL statements
+ * - Parameter binding prevents SQL injection
+ * - Supports positional ($1, ?) and named (:name) parameters
+ * - Result formatting to JSON
+ * - Error handling with sanitized messages
+ *
+ * @example
+ * ```typescript
+ * // SELECT with positional parameters
+ * const result = await relationalQuery.invoke({
+ *   sql: 'SELECT * FROM users WHERE id = $1',
+ *   params: [42],
+ *   vendor: 'postgresql',
+ *   connectionString: 'postgresql://user:pass@localhost:5432/mydb'
+ * });
+ *
+ * // INSERT with named parameters
+ * const result = await relationalQuery.invoke({
+ *   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'
+ * });
+ * ```
+ */
+declare const relationalQuery: _agentforge_core.Tool<{
+    connectionString: string;
+    vendor: "postgresql" | "mysql" | "sqlite";
+    sql: string;
+    params?: unknown[] | Record<string, unknown> | undefined;
+}, {
+    success: boolean;
+    rows: unknown[];
+    rowCount: number;
+    executionTime: number;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    rows: never[];
+    rowCount: number;
+    executionTime?: undefined;
+}>;
+
+/**
+ * Type definitions for relational SELECT operations
+ * @module tools/relational-select/types
+ */
+
+/** Re-export of streaming memory usage type from the query layer. */
+type StreamingMemoryUsage = StreamingMemoryUsage$1;
+/**
+ * Optional streaming benchmark metadata.
+ */
+type StreamingBenchmarkMetadata = StreamingBenchmarkResult;
+/**
+ * Streaming execution metadata.
+ */
+interface StreamingMetadata {
+    enabled: true;
+    chunkSize: number;
+    chunkCount: number;
+    sampledRowCount: number;
+    streamedRowCount: number;
+    cancelled: boolean;
+    memoryUsage: StreamingMemoryUsage;
+    benchmark?: StreamingBenchmarkMetadata;
+}
+/**
+ * Tool success response
+ */
+interface SelectSuccessResponse {
+    success: true;
+    rows: unknown[];
+    rowCount: number;
+    executionTime: number;
+    streaming?: StreamingMetadata;
+}
+/**
+ * Tool error response
+ */
+interface SelectErrorResponse {
+    success: false;
+    error: string;
+    rows: [];
+    rowCount: 0;
+}
+/**
+ * Tool response (success or error)
+ */
+type SelectResponse = SelectSuccessResponse | SelectErrorResponse;
+
+/**
+ * Relational SELECT Tool
+ *
+ * Execute type-safe SELECT queries using Drizzle ORM query builder.
+ *
+ * Features:
+ * - Type-safe column selection
+ * - WHERE conditions with multiple operators
+ * - ORDER BY with ascending/descending
+ * - LIMIT and OFFSET for pagination
+ * - Optional chunked streaming mode for large result sets
+ * - Result formatting to JSON
+ * - Error handling with clear messages
+ *
+ * @example
+ * ```typescript
+ * // SELECT with WHERE and ORDER BY
+ * const result = await relationalSelect.invoke({
+ *   table: 'users',
+ *   columns: ['id', 'name', 'email'],
+ *   where: [
+ *     { column: 'status', operator: 'eq', value: 'active' },
+ *     { column: 'age', operator: 'gte', value: 18 }
+ *   ],
+ *   orderBy: [{ column: 'name', direction: 'asc' }],
+ *   limit: 10,
+ *   vendor: 'postgresql',
+ *   connectionString: 'postgresql://user:pass@localhost:5432/mydb'
+ * });
+ * ```
+ */
+declare const relationalSelect: _agentforge_core.Tool<{
+    table: string;
+    connectionString: string;
+    vendor: "postgresql" | "mysql" | "sqlite";
+    limit?: number | undefined;
+    columns?: string[] | undefined;
+    where?: {
+        operator: "eq" | "ne" | "gt" | "lt" | "gte" | "lte" | "like" | "in" | "notIn" | "isNull" | "isNotNull";
+        column: string;
+        value?: string | number | boolean | (string | number)[] | null | undefined;
+    }[] | undefined;
+    orderBy?: {
+        direction: "asc" | "desc";
+        column: string;
+    }[] | undefined;
+    offset?: number | undefined;
+    streaming?: {
+        enabled?: boolean | undefined;
+        maxRows?: number | undefined;
+        chunkSize?: number | undefined;
+        sampleSize?: number | undefined;
+        benchmark?: boolean | undefined;
+    } | undefined;
+}, SelectResponse>;
+
+/**
+ * Type definitions for relational INSERT operations
+ * @module tools/relational-insert/types
+ */
+
+/**
+ * Batch metadata returned by INSERT execution when batch mode is active.
+ */
+interface InsertBatchMetadata {
+    enabled: boolean;
+    batchSize: number;
+    totalItems: number;
+    processedItems: number;
+    successfulItems: number;
+    failedItems: number;
+    totalBatches: number;
+    retries: number;
+    partialSuccess: boolean;
+    failures: BatchFailureDetail[];
+    benchmark?: BatchBenchmarkResult;
+}
+/**
+ * Tool success response.
+ */
+interface InsertSuccessResponse {
+    success: true;
+    rowCount: number;
+    insertedIds: Array<number | string>;
+    rows: unknown[];
+    executionTime: number;
+    batch?: InsertBatchMetadata;
+}
+/**
+ * Tool error response.
+ */
+interface InsertErrorResponse {
+    success: false;
+    error: string;
+    rowCount: 0;
+    insertedIds: [];
+    rows: [];
+}
+/**
+ * Tool response (success or error).
+ */
+type InsertResponse = InsertSuccessResponse | InsertErrorResponse;
+
+/**
+ * Relational INSERT Tool
+ *
+ * Execute type-safe INSERT queries using Drizzle ORM query builder.
+ */
+declare const relationalInsert: _agentforge_core.Tool<{
+    data: Record<string, string | number | boolean | null> | Record<string, string | number | boolean | null>[];
+    table: string;
+    connectionString: string;
+    vendor: "postgresql" | "mysql" | "sqlite";
+    batch?: {
+        enabled?: boolean | undefined;
+        batchSize?: number | undefined;
+        maxRetries?: number | undefined;
+        retryDelayMs?: number | undefined;
+        continueOnError?: boolean | undefined;
+        benchmark?: boolean | undefined;
+    } | undefined;
+    returning?: {
+        mode?: "row" | "none" | "id" | undefined;
+        idColumn?: string | undefined;
+    } | undefined;
+}, InsertResponse>;
+
+/**
+ * Type definitions for relational UPDATE operations
+ * @module tools/relational-update/types
+ */
+
+/**
+ * Batch metadata returned by UPDATE execution when batch mode is active.
+ */
+interface UpdateBatchMetadata {
+    enabled: boolean;
+    batchSize: number;
+    totalItems: number;
+    processedItems: number;
+    successfulItems: number;
+    failedItems: number;
+    totalBatches: number;
+    retries: number;
+    partialSuccess: boolean;
+    failures: BatchFailureDetail[];
+    benchmark?: BatchBenchmarkResult;
+}
+/**
+ * Tool success response.
+ */
+interface UpdateSuccessResponse {
+    success: true;
+    rowCount: number;
+    executionTime: number;
+    batch?: UpdateBatchMetadata;
+}
+/**
+ * Tool error response.
+ */
+interface UpdateErrorResponse {
+    success: false;
+    error: string;
+    rowCount: 0;
+}
+/**
+ * Tool response (success or error).
+ */
+type UpdateResponse = UpdateSuccessResponse | UpdateErrorResponse;
+
+/**
+ * Relational UPDATE Tool
+ *
+ * Execute type-safe UPDATE queries using Drizzle ORM query builder.
+ */
+declare const relationalUpdate: _agentforge_core.Tool<{
+    table: string;
+    connectionString: string;
+    vendor: "postgresql" | "mysql" | "sqlite";
+    data?: Record<string, string | number | boolean | null> | undefined;
+    where?: {
+        operator: "eq" | "ne" | "gt" | "lt" | "gte" | "lte" | "like" | "in" | "notIn" | "isNull" | "isNotNull";
+        column: string;
+        value?: string | number | boolean | (string | number)[] | null | undefined;
+    }[] | undefined;
+    batch?: {
+        enabled?: boolean | undefined;
+        batchSize?: number | undefined;
+        maxRetries?: number | undefined;
+        retryDelayMs?: number | undefined;
+        continueOnError?: boolean | undefined;
+        benchmark?: boolean | undefined;
+    } | undefined;
+    allowFullTableUpdate?: boolean | undefined;
+    optimisticLock?: {
+        column: string;
+        expectedValue: string | number;
+    } | undefined;
+    operations?: {
+        data: Record<string, string | number | boolean | null>;
+        where?: {
+            operator: "eq" | "ne" | "gt" | "lt" | "gte" | "lte" | "like" | "in" | "notIn" | "isNull" | "isNotNull";
+            column: string;
+            value?: string | number | boolean | (string | number)[] | null | undefined;
+        }[] | undefined;
+        allowFullTableUpdate?: boolean | undefined;
+        optimisticLock?: {
+            column: string;
+            expectedValue: string | number;
+        } | undefined;
+    }[] | undefined;
+}, UpdateResponse>;
+
+/**
+ * Type definitions for relational DELETE operations
+ * @module tools/relational-delete/types
+ */
+
+/** Metadata returned after a batched DELETE operation completes. */
+interface DeleteBatchMetadata {
+    enabled: boolean;
+    batchSize: number;
+    totalItems: number;
+    processedItems: number;
+    successfulItems: number;
+    failedItems: number;
+    totalBatches: number;
+    retries: number;
+    partialSuccess: boolean;
+    failures: BatchFailureDetail[];
+    benchmark?: BatchBenchmarkResult;
+}
+/** Successful DELETE response returned to the caller. */
+interface DeleteSuccessResponse {
+    success: true;
+    rowCount: number;
+    executionTime: number;
+    softDeleted: boolean;
+    batch?: DeleteBatchMetadata;
+}
+/** Error DELETE response returned when the operation fails. */
+interface DeleteErrorResponse {
+    success: false;
+    error: string;
+    rowCount: 0;
+    softDeleted: false;
+}
+/** Union type representing either a successful or failed DELETE response. */
+type DeleteResponse = DeleteSuccessResponse | DeleteErrorResponse;
+
+/**
+ * LangGraph tool for type-safe DELETE queries with single and batched operation support.
+ *
+ * Supports WHERE conditions, full-table-delete protection, soft-delete mode,
+ * batch operations with retry logic, and optional cascade hints.
+ */
+declare const relationalDelete: _agentforge_core.Tool<{
+    table: string;
+    connectionString: string;
+    vendor: "postgresql" | "mysql" | "sqlite";
+    where?: {
+        operator: "eq" | "ne" | "gt" | "lt" | "gte" | "lte" | "like" | "in" | "notIn" | "isNull" | "isNotNull";
+        column: string;
+        value?: string | number | boolean | (string | number)[] | null | undefined;
+    }[] | undefined;
+    batch?: {
+        enabled?: boolean | undefined;
+        batchSize?: number | undefined;
+        maxRetries?: number | undefined;
+        retryDelayMs?: number | undefined;
+        continueOnError?: boolean | undefined;
+        benchmark?: boolean | undefined;
+    } | undefined;
+    operations?: {
+        where?: {
+            operator: "eq" | "ne" | "gt" | "lt" | "gte" | "lte" | "like" | "in" | "notIn" | "isNull" | "isNotNull";
+            column: string;
+            value?: string | number | boolean | (string | number)[] | null | undefined;
+        }[] | undefined;
+        allowFullTableDelete?: boolean | undefined;
+        cascade?: boolean | undefined;
+        softDelete?: {
+            value?: string | number | undefined;
+            column?: string | undefined;
+        } | undefined;
+    }[] | undefined;
+    allowFullTableDelete?: boolean | undefined;
+    cascade?: boolean | undefined;
+    softDelete?: {
+        value?: string | number | undefined;
+        column?: string | undefined;
+    } | undefined;
+}, DeleteResponse>;
+
+/**
+ * Relational Get Schema Tool
+ * @module tools/relational-get-schema
+ */
+/**
+ * Relational Get Schema Tool
+ *
+ * Introspects database schema metadata including tables, columns, primary keys,
+ * foreign keys, and indexes for PostgreSQL, MySQL, and SQLite.
+ */
+declare const relationalGetSchema: _agentforge_core.Tool<{
+    connectionString: string;
+    vendor: "postgresql" | "mysql" | "sqlite";
+    database?: string | undefined;
+    tables?: string[] | undefined;
+    cacheTtlMs?: number | undefined;
+    refreshCache?: boolean | undefined;
+}, {
+    success: boolean;
+    schema: DatabaseSchema;
+    summary: {
+        tableCount: number;
+        columnCount: number;
+        foreignKeyCount: number;
+        indexCount: number;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    schema: null;
+    summary?: undefined;
+}>;
+
+/**
+ * File Operations Types
+ *
+ * Type definitions and schemas for file operation tools.
+ */
+
+/**
+ * File reader schema
+ */
+declare const fileReaderSchema: z.ZodObject<{
+    path: z.ZodString;
+    encoding: z.ZodDefault<z.ZodEnum<["utf8", "utf-8", "ascii", "base64", "hex", "binary"]>>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    encoding: "ascii" | "binary" | "base64" | "hex" | "utf-8" | "utf8";
+}, {
+    path: string;
+    encoding?: "ascii" | "binary" | "base64" | "hex" | "utf-8" | "utf8" | undefined;
+}>;
+/**
+ * File writer schema
+ */
+declare const fileWriterSchema: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+    encoding: z.ZodDefault<z.ZodEnum<["utf8", "utf-8", "ascii", "base64", "hex"]>>;
+    createDirs: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    content: string;
+    encoding: "ascii" | "base64" | "hex" | "utf-8" | "utf8";
+    createDirs: boolean;
+}, {
+    path: string;
+    content: string;
+    encoding?: "ascii" | "base64" | "hex" | "utf-8" | "utf8" | undefined;
+    createDirs?: boolean | undefined;
+}>;
+/**
+ * File append schema
+ */
+declare const fileAppendSchema: z.ZodObject<{
+    path: z.ZodString;
+    content: z.ZodString;
+    encoding: z.ZodDefault<z.ZodEnum<["utf8", "utf-8", "ascii"]>>;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+    content: string;
+    encoding: "ascii" | "utf-8" | "utf8";
+}, {
+    path: string;
+    content: string;
+    encoding?: "ascii" | "utf-8" | "utf8" | undefined;
+}>;
+/**
+ * File delete schema
+ */
+declare const fileDeleteSchema: z.ZodObject<{
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+}, {
+    path: string;
+}>;
+/**
+ * File exists schema
+ */
+declare const fileExistsSchema: z.ZodObject<{
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    path: string;
+}, {
+    path: string;
+}>;
+/**
+ * File operations configuration
+ */
+interface FileOperationsConfig {
+    defaultEncoding?: 'utf8' | 'utf-8' | 'ascii' | 'base64' | 'hex';
+    createDirsDefault?: boolean;
+}
+
+/**
+ * File Reader Tool
+ */
+/**
+ * Create file reader tool
+ */
+declare function createFileReaderTool(defaultEncoding?: string): _agentforge_core.Tool<{
+    path: string;
+    encoding?: "ascii" | "binary" | "base64" | "hex" | "utf-8" | "utf8" | undefined;
+}, {
+    success: boolean;
+    data?: {
+        content: string;
+        size: number;
+        path: string;
+        encoding: string;
+    } | undefined;
+    error?: string;
+}>;
+
+/**
+ * File Writer Tool
+ */
+/**
+ * Create file writer tool
+ */
+declare function createFileWriterTool(defaultEncoding?: string, createDirsDefault?: boolean): _agentforge_core.Tool<{
+    path: string;
+    content: string;
+    encoding?: "ascii" | "base64" | "hex" | "utf-8" | "utf8" | undefined;
+    createDirs?: boolean | undefined;
+}, {
+    success: boolean;
+    data?: {
+        path: string;
+        size: number;
+        encoding: string;
+    } | undefined;
+    error?: string;
+}>;
+
+/**
+ * File Append Tool
+ */
+/**
+ * Create file append tool
+ */
+declare function createFileAppendTool(defaultEncoding?: string): _agentforge_core.Tool<{
+    path: string;
+    content: string;
+    encoding?: "ascii" | "utf-8" | "utf8" | undefined;
+}, {
+    success: boolean;
+    data?: {
+        path: string;
+        size: number;
+    } | undefined;
+    error?: string;
+}>;
+
+/**
+ * File Delete Tool
+ */
+/**
+ * Create file delete tool
+ */
+declare function createFileDeleteTool(): _agentforge_core.Tool<{
+    path: string;
+}, {
+    success: boolean;
+    data?: {
+        path: string;
+        message: string;
+    } | undefined;
+    error?: string;
+}>;
+
+/**
+ * File Exists Tool
+ */
+/**
+ * Create file exists tool
+ */
+declare function createFileExistsTool(): _agentforge_core.Tool<{
+    path: string;
+}, {
+    exists: boolean;
+    path: string;
+    isFile: boolean;
+    isDirectory: boolean;
+    size: number;
+    modified: string;
+} | {
+    exists: boolean;
+    path: string;
+    isFile?: undefined;
+    isDirectory?: undefined;
+    size?: undefined;
+    modified?: undefined;
+}>;
+
+/**
+ * Default file operation tool instances
+ */
+declare const fileReader: _agentforge_core.Tool<{
+    path: string;
+    encoding?: "ascii" | "binary" | "base64" | "hex" | "utf-8" | "utf8" | undefined;
+}, {
+    success: boolean;
+    data?: {
+        content: string;
+        size: number;
+        path: string;
+        encoding: string;
+    } | undefined;
+    error?: string;
+}>;
+declare const fileWriter: _agentforge_core.Tool<{
+    path: string;
+    content: string;
+    encoding?: "ascii" | "base64" | "hex" | "utf-8" | "utf8" | undefined;
+    createDirs?: boolean | undefined;
+}, {
+    success: boolean;
+    data?: {
+        path: string;
+        size: number;
+        encoding: string;
+    } | undefined;
+    error?: string;
+}>;
+declare const fileAppend: _agentforge_core.Tool<{
+    path: string;
+    content: string;
+    encoding?: "ascii" | "utf-8" | "utf8" | undefined;
+}, {
+    success: boolean;
+    data?: {
+        path: string;
+        size: number;
+    } | undefined;
+    error?: string;
+}>;
+declare const fileDelete: _agentforge_core.Tool<{
+    path: string;
+}, {
+    success: boolean;
+    data?: {
+        path: string;
+        message: string;
+    } | undefined;
+    error?: string;
+}>;
+declare const fileExists: _agentforge_core.Tool<{
+    path: string;
+}, {
+    exists: boolean;
+    path: string;
+    isFile: boolean;
+    isDirectory: boolean;
+    size: number;
+    modified: string;
+} | {
+    exists: boolean;
+    path: string;
+    isFile?: undefined;
+    isDirectory?: undefined;
+    size?: undefined;
+    modified?: undefined;
+}>;
+/**
+ * Array of all file operation tools
+ */
+declare const fileOperationTools: (_agentforge_core.Tool<{
+    path: string;
+    encoding?: "ascii" | "binary" | "base64" | "hex" | "utf-8" | "utf8" | undefined;
+}, {
+    success: boolean;
+    data?: {
         content: string;
         size: number;
         path: string;
@@ -5447,8 +7098,7 @@ declare const pathNormalizeSchema: z.ZodObject<{
 /**
  * Path utilities configuration
  */
-interface PathUtilitiesConfig {
-}
+type PathUtilitiesConfig = Record<string, never>;
 
 /**
  * Path Join Tool
@@ -5813,8 +7463,7 @@ declare const DateComparisonSchema: z.ZodObject<{
 /**
  * Configuration for date/time tools
  */
-interface DateTimeConfig {
-}
+type DateTimeConfig = Record<string, never>;
 type CurrentDateTimeInput = z.infer<typeof CurrentDateTimeSchema>;
 type DateFormatterInput = z.infer<typeof DateFormatterSchema>;
 type DateArithmeticInput = z.infer<typeof DateArithmeticSchema>;
@@ -6218,11 +7867,11 @@ declare const StringTrimSchema: z.ZodObject<{
     characters: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
     text: string;
-    mode: "both" | "start" | "end";
+    mode: "both" | "end" | "start";
     characters?: string | undefined;
 }, {
     text: string;
-    mode?: "both" | "start" | "end" | undefined;
+    mode?: "both" | "end" | "start" | undefined;
     characters?: string | undefined;
 }>;
 /**
@@ -6305,8 +7954,7 @@ declare const StringLengthSchema: z.ZodObject<{
 /**
  * Configuration for string utility tools
  */
-interface StringUtilitiesConfig {
-}
+type StringUtilitiesConfig = Record<string, never>;
 type StringCaseConverterInput = z.infer<typeof StringCaseConverterSchema>;
 type StringTrimInput = z.infer<typeof StringTrimSchema>;
 type StringReplaceInput = z.infer<typeof StringReplaceSchema>;
@@ -6338,7 +7986,7 @@ declare function createStringCaseConverterTool(): _agentforge_core.Tool<{
  */
 declare function createStringTrimTool(): _agentforge_core.Tool<{
     text: string;
-    mode?: "both" | "start" | "end" | undefined;
+    mode?: "both" | "end" | "start" | undefined;
     characters?: string | undefined;
 }, {
     original: string;
@@ -6435,7 +8083,7 @@ declare const stringCaseConverter: _agentforge_core.Tool<{
 }>;
 declare const stringTrim: _agentforge_core.Tool<{
     text: string;
-    mode?: "both" | "start" | "end" | undefined;
+    mode?: "both" | "end" | "start" | undefined;
     characters?: string | undefined;
 }, {
     original: string;
@@ -6495,7 +8143,7 @@ declare const stringUtilityTools: (_agentforge_core.Tool<{
     targetCase: "title" | "lowercase" | "uppercase" | "camel" | "snake" | "kebab" | "pascal";
 }> | _agentforge_core.Tool<{
     text: string;
-    mode?: "both" | "start" | "end" | undefined;
+    mode?: "both" | "end" | "start" | undefined;
     characters?: string | undefined;
 }, {
     original: string;
@@ -6553,7 +8201,7 @@ declare function createStringUtilityTools(config?: StringUtilitiesConfig): (_age
     targetCase: "title" | "lowercase" | "uppercase" | "camel" | "snake" | "kebab" | "pascal";
 }> | _agentforge_core.Tool<{
     text: string;
-    mode?: "both" | "start" | "end" | undefined;
+    mode?: "both" | "end" | "start" | undefined;
     characters?: string | undefined;
 }, {
     original: string;
@@ -6642,12 +8290,12 @@ declare const RandomNumberSchema: z.ZodObject<{
     integer: z.ZodDefault<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     integer: boolean;
-    min: number;
     max: number;
+    min: number;
 }, {
     integer?: boolean | undefined;
-    min?: number | undefined;
     max?: number | undefined;
+    min?: number | undefined;
 }>;
 /**
  * Schema for statistics tool
@@ -6662,8 +8310,7 @@ declare const StatisticsSchema: z.ZodObject<{
 /**
  * Configuration for math operations tools
  */
-interface MathOperationsConfig {
-}
+type MathOperationsConfig = Record<string, never>;
 type CalculatorInput = z.infer<typeof CalculatorSchema>;
 type MathFunctionsInput = z.infer<typeof MathFunctionsSchema>;
 type RandomNumberInput = z.infer<typeof RandomNumberSchema>;
@@ -6726,8 +8373,8 @@ declare function createMathFunctionsTool(): _agentforge_core.Tool<{
  */
 declare function createRandomNumberTool(): _agentforge_core.Tool<{
     integer?: boolean | undefined;
-    min?: number | undefined;
     max?: number | undefined;
+    min?: number | undefined;
 }, {
     result: number;
     min: number;
@@ -6804,8 +8451,8 @@ declare const mathFunctions: _agentforge_core.Tool<{
 }>;
 declare const randomNumber: _agentforge_core.Tool<{
     integer?: boolean | undefined;
-    min?: number | undefined;
     max?: number | undefined;
+    min?: number | undefined;
 }, {
     result: number;
     min: number;
@@ -6872,8 +8519,8 @@ declare const mathOperationTools: (_agentforge_core.Tool<{
     error?: undefined;
 }> | _agentforge_core.Tool<{
     integer?: boolean | undefined;
-    min?: number | undefined;
     max?: number | undefined;
+    min?: number | undefined;
 }, {
     result: number;
     min: number;
@@ -6942,8 +8589,8 @@ declare function createMathOperationTools(config?: MathOperationsConfig): (_agen
     error?: undefined;
 }> | _agentforge_core.Tool<{
     integer?: boolean | undefined;
-    min?: number | undefined;
     max?: number | undefined;
+    min?: number | undefined;
 }, {
     result: number;
     min: number;
@@ -7048,8 +8695,7 @@ declare const UuidValidatorSchema: z.ZodObject<{
 /**
  * Configuration for validation tools
  */
-interface ValidationConfig {
-}
+type ValidationConfig = Record<string, never>;
 type EmailValidatorInput = z.infer<typeof EmailValidatorSchema>;
 type UrlValidatorSimpleInput = z.infer<typeof UrlValidatorSimpleSchema>;
 type PhoneValidatorInput = z.infer<typeof PhoneValidatorSchema>;
@@ -7435,4 +9081,4 @@ declare const askHumanTool: _agentforge_core.Tool<{
     suggestions?: string[] | undefined;
 }, AskHumanOutput>;
 
-export { type AskHumanInput, AskHumanInputSchema, type AskHumanOutput, type BatchEmbeddingResult, type CalculatorInput, CalculatorSchema, type ConfluenceAuth, type ConfluenceToolsConfig, type CreditCardValidatorInput, CreditCardValidatorSchema, type CsvToolsConfig, type CurrentDateTimeInput, CurrentDateTimeSchema, DEFAULT_RETRY_CONFIG, type DateArithmeticInput, DateArithmeticSchema, type DateComparisonInput, DateComparisonSchema, type DateDifferenceInput, DateDifferenceSchema, type DateFormatterInput, DateFormatterSchema, type DateTimeConfig, type DirectoryOperationsConfig, DuckDuckGoProvider, type EmailValidatorInput, EmailValidatorSchema, type EmbeddingConfig, EmbeddingManager, type EmbeddingProvider, type EmbeddingResult, type EmbeddingRetryConfig, type FileOperationsConfig, type HtmlParserToolsConfig, HttpMethod, type HttpResponse, type HttpToolsConfig, type IEmbeddingProvider, type IpValidatorInput, IpValidatorSchema, type JsonToolsConfig, type MathFunctionsInput, MathFunctionsSchema, type MathOperationsConfig, type Neo4jConfig, type Neo4jNode, type Neo4jPath, type Neo4jRelationship, type Neo4jSchema, type Neo4jToolsConfig, OpenAIEmbeddingProvider, type PathUtilitiesConfig, type PhoneValidatorInput, PhoneValidatorSchema, type RandomNumberInput, RandomNumberSchema, type RetryConfig, type ScraperResult, type ScraperToolsConfig, type SearchProvider, type SearchResult, SerperProvider, type SlackClientConfig, type SlackToolsConfig, type StatisticsInput, StatisticsSchema, type StringCaseConverterInput, StringCaseConverterSchema, type StringJoinInput, StringJoinSchema, type StringLengthInput, StringLengthSchema, type StringReplaceInput, StringReplaceSchema, type StringSplitInput, StringSplitSchema, type StringSubstringInput, StringSubstringSchema, type StringTrimInput, StringTrimSchema, type StringUtilitiesConfig, type TransformerToolsConfig, type UrlValidationResult, type UrlValidatorSimpleInput, UrlValidatorSimpleSchema, type UrlValidatorToolsConfig, type UuidValidatorInput, UuidValidatorSchema, type ValidationConfig, type WebSearchInput, type WebSearchOutput, type XmlToolsConfig, archiveConfluencePage, arrayFilter, arrayFilterSchema, arrayGroupBy, arrayGroupBySchema, arrayMap, arrayMapSchema, arraySort, arraySortSchema, askHumanTool, calculator, confluenceTools, createArrayFilterTool, createArrayGroupByTool, createArrayMapTool, createArraySortTool, createAskHumanTool, createCalculatorTool, createConfluencePage, createConfluenceTools, createCreditCardValidatorTool, createCsvGeneratorTool, createCsvParserTool, createCsvToJsonTool, createCsvTools, createCurrentDateTimeTool, createDateArithmeticTool, createDateComparisonTool, createDateDifferenceTool, createDateFormatterTool, createDateTimeTools, createDirectoryCreateTool, createDirectoryDeleteTool, createDirectoryListTool, createDirectoryOperationTools, createDuckDuckGoProvider, createEmailValidatorTool, createExtractImagesTool, createExtractLinksTool, createFileAppendTool, createFileDeleteTool, createFileExistsTool, createFileOperationTools, createFileReaderTool, createFileSearchTool, createFileWriterTool, createHtmlParserTool, createHtmlParserTools, createHttpTools, createIpValidatorTool, createJsonMergeTool, createJsonParserTool, createJsonQueryTool, createJsonStringifyTool, createJsonToCsvTool, createJsonToXmlTool, createJsonTools, createJsonValidatorTool, createMathFunctionsTool, createMathOperationTools, createNeo4jCreateNodeWithEmbeddingTool, createNeo4jFindNodesTool, createNeo4jGetSchemaTool, createNeo4jQueryTool, createNeo4jTools, createNeo4jTraverseTool, createNeo4jVectorSearchTool, createNeo4jVectorSearchWithEmbeddingTool, createObjectOmitTool, createObjectPickTool, createPathBasenameTool, createPathDirnameTool, createPathExtensionTool, createPathJoinTool, createPathNormalizeTool, createPathParseTool, createPathRelativeTool, createPathResolveTool, createPathUtilityTools, createPhoneValidatorTool, createRandomNumberTool, createScraperTools, createSerperProvider, createSlackTools, createStatisticsTool, createStringCaseConverterTool, createStringJoinTool, createStringLengthTool, createStringReplaceTool, createStringSplitTool, createStringSubstringTool, createStringTrimTool, createStringUtilityTools, createTransformerTools, createUrlBuilderTool, createUrlQueryParserTool, createUrlValidatorSimpleTool, createUrlValidatorTool, createUrlValidatorTools, createUuidValidatorTool, createValidationTools, createWebScraperTool, createXmlGeneratorTool, createXmlParserTool, createXmlToJsonTool, createXmlTools, creditCardValidator, csvGenerator, csvGeneratorSchema, csvParser, csvParserSchema, csvToJson, csvToJsonSchema, csvTools, currentDateTime, dateArithmetic, dateComparison, dateDifference, dateFormatter, dateTimeTools, directoryCreate, directoryCreateSchema, directoryDelete, directoryDeleteSchema, directoryList, directoryListSchema, directoryOperationTools, emailValidator, embeddingManager, extractImages, extractImagesSchema, extractLinks, extractLinksSchema, fileAppend, fileAppendSchema, fileDelete, fileDeleteSchema, fileExists, fileExistsSchema, fileOperationTools, fileReader, fileReaderSchema, fileSearch, fileSearchSchema, fileWriter, fileWriterSchema, generateBatchEmbeddings, generateEmbedding, getCohereApiKey, getConfluencePage, getEmbeddingModel, getEmbeddingProvider, getHuggingFaceApiKey, getOllamaBaseUrl, getOpenAIApiKey, getSlackChannels, getSlackMessages, getSpacePages, getVoyageApiKey, htmlParser, htmlParserSchema, htmlParserTools, httpClient, httpGet, httpGetSchema, httpPost, httpPostSchema, httpRequestSchema, httpTools, initializeEmbeddings, initializeEmbeddingsWithConfig, initializeFromEnv, initializeNeo4jTools, ipValidator, isRetryableError, jsonMerge, jsonMergeSchema, jsonParser, jsonParserSchema, jsonQuery, jsonQuerySchema, jsonStringify, jsonStringifySchema, jsonToCsv, jsonToCsvSchema, jsonToXml, jsonToXmlSchema, jsonTools, jsonValidator, jsonValidatorSchema, listConfluenceSpaces, mathFunctions, mathOperationTools, neo4jCoreTools, neo4jCreateNodeWithEmbedding, neo4jCreateNodeWithEmbeddingSchema, neo4jFindNodes, neo4jFindNodesSchema, neo4jGetSchema, neo4jGetSchemaSchema, neo4jPool, neo4jQuery, neo4jQuerySchema, neo4jTools, neo4jTraverse, neo4jTraverseSchema, neo4jVectorSearch, neo4jVectorSearchSchema, neo4jVectorSearchWithEmbedding, neo4jVectorSearchWithEmbeddingSchema, notifySlack, objectOmit, objectOmitSchema, objectPick, objectPickSchema, pathBasename, pathBasenameSchema, pathDirname, pathDirnameSchema, pathExtension, pathExtensionSchema, pathJoin, pathJoinSchema, pathNormalize, pathNormalizeSchema, pathParse, pathParseSchema, pathRelative, pathRelativeSchema, pathResolve, pathResolveSchema, pathUtilityTools, phoneValidator, randomNumber, retryWithBackoff, scraperTools, searchConfluence, searchResultSchema, sendSlackMessage, slackTools, statistics, stringCaseConverter, stringJoin, stringLength, stringReplace, stringSplit, stringSubstring, stringTrim, stringUtilityTools, transformerTools, updateConfluencePage, urlBuilder, urlBuilderSchema, urlQueryParser, urlQueryParserSchema, urlValidator, urlValidatorSchema, urlValidatorSimple, urlValidatorTools, uuidValidator, validateBatch, validateText, validationTools, webScraper, webScraperSchema, webSearch, webSearchOutputSchema, webSearchSchema, xmlGenerator, xmlGeneratorSchema, xmlParser, xmlParserSchema, xmlToJson, xmlToJsonSchema, xmlTools };
+export { type AskHumanInput, AskHumanInputSchema, type AskHumanOutput, type BatchBenchmarkResult, type BatchEmbeddingResult, type BatchExecutionOptions, type BatchExecutionResult, type BatchExecutionTask, type BatchFailureDetail, type BatchProgressUpdate, type BuiltDeleteQuery, type BuiltInsertQuery, type BuiltUpdateQuery, type CalculatorInput, CalculatorSchema, type ColumnDiff, type ColumnSchema, type ConfluenceAuth, type ConfluenceToolsConfig, type ConnectionConfig, type ConnectionEvent, ConnectionManager, ConnectionState, type CreditCardValidatorInput, CreditCardValidatorSchema, type CsvToolsConfig, type CurrentDateTimeInput, CurrentDateTimeSchema, DEFAULT_BATCH_SIZE, DEFAULT_CHUNK_SIZE, DEFAULT_RETRY_CONFIG, type DatabaseConfig, type DatabaseConnection, type DatabaseSchema, type DatabaseVendor, type DateArithmeticInput, DateArithmeticSchema, type DateComparisonInput, DateComparisonSchema, type DateDifferenceInput, DateDifferenceSchema, type DateFormatterInput, DateFormatterSchema, type DateTimeConfig, type DeleteQueryInput, type DeleteSoftDeleteOptions, type DeleteWhereCondition, type DirectoryOperationsConfig, DuckDuckGoProvider, type EmailValidatorInput, EmailValidatorSchema, type EmbeddingConfig, EmbeddingManager, type EmbeddingProvider, type EmbeddingResult, type EmbeddingRetryConfig, type FileOperationsConfig, type ForeignKeySchema, type HtmlParserToolsConfig, HttpMethod, type HttpResponse, type HttpToolsConfig, type IEmbeddingProvider, type IndexSchema, type InsertData, type InsertQueryInput, type InsertReturningMode, type InsertReturningOptions, type InsertRow, type InsertValue, type IpValidatorInput, IpValidatorSchema, type JsonToolsConfig, MAX_BATCH_SIZE, type MappedType, type MathFunctionsInput, MathFunctionsSchema, type MathOperationsConfig, MissingPeerDependencyError, type MySQLConnectionConfig, type Neo4jConfig, type Neo4jNode, type Neo4jPath, type Neo4jRelationship, type Neo4jSchema, type Neo4jToolsConfig, OpenAIEmbeddingProvider, type PathUtilitiesConfig, type PhoneValidatorInput, PhoneValidatorSchema, type PoolConfig, type PostgreSQLConnectionConfig, type QueryExecutionResult, type QueryInput, type QueryMetadata, type QueryParams, type QueryResult, type RandomNumberInput, RandomNumberSchema, type ReconnectionConfig, type RetryConfig, type SQLiteConnectionConfig, type SchemaDiffResult, type SchemaInspectOptions, SchemaInspector, type SchemaInspectorConfig, type ScraperResult, type ScraperToolsConfig, type SearchProvider, type SearchResult, type SelectOrderBy, type SelectOrderDirection, type SelectQueryInput, type SelectWhereCondition, SerperProvider, type SlackClientConfig, type SlackToolsConfig, type SqlExecutor, type StatisticsInput, StatisticsSchema, type StreamingBenchmarkResult, type StreamingMemoryUsage$1 as StreamingMemoryUsage, type StreamingSelectChunk, type StreamingSelectOptions, type StreamingSelectResult, type StringCaseConverterInput, StringCaseConverterSchema, type StringJoinInput, StringJoinSchema, type StringLengthInput, StringLengthSchema, type StringReplaceInput, StringReplaceSchema, type StringSplitInput, StringSplitSchema, type StringSubstringInput, StringSubstringSchema, type StringTrimInput, StringTrimSchema, type StringUtilitiesConfig, type TableDiff, type TableSchema, type TransactionContext, type TransactionIsolationLevel, type TransactionOptions, type TransformerToolsConfig, type UpdateData, type UpdateOptimisticLock, type UpdateQueryInput, type UpdateValue, type UpdateWhereCondition, type UpdateWhereOperator, type UrlValidationResult, type UrlValidatorSimpleInput, UrlValidatorSimpleSchema, type UrlValidatorToolsConfig, type UuidValidatorInput, UuidValidatorSchema, type ValidationConfig, type ValidationResult, type VendorConnectionConfig, type WebSearchInput, type WebSearchOutput, type XmlToolsConfig, archiveConfluencePage, arrayFilter, arrayFilterSchema, arrayGroupBy, arrayGroupBySchema, arrayMap, arrayMapSchema, arraySort, arraySortSchema, askHumanTool, benchmarkBatchExecution, benchmarkStreamingSelectMemory, buildDeleteQuery, buildInsertQuery, buildSelectQuery, buildUpdateQuery, calculator, checkPeerDependency, confluenceTools, createArrayFilterTool, createArrayGroupByTool, createArrayMapTool, createArraySortTool, createAskHumanTool, createCalculatorTool, createConfluencePage, createConfluenceTools, createCreditCardValidatorTool, createCsvGeneratorTool, createCsvParserTool, createCsvToJsonTool, createCsvTools, createCurrentDateTimeTool, createDateArithmeticTool, createDateComparisonTool, createDateDifferenceTool, createDateFormatterTool, createDateTimeTools, createDirectoryCreateTool, createDirectoryDeleteTool, createDirectoryListTool, createDirectoryOperationTools, createDuckDuckGoProvider, createEmailValidatorTool, createExtractImagesTool, createExtractLinksTool, createFileAppendTool, createFileDeleteTool, createFileExistsTool, createFileOperationTools, createFileReaderTool, createFileSearchTool, createFileWriterTool, createHtmlParserTool, createHtmlParserTools, createHttpTools, createIpValidatorTool, createJsonMergeTool, createJsonParserTool, createJsonQueryTool, createJsonStringifyTool, createJsonToCsvTool, createJsonToXmlTool, createJsonTools, createJsonValidatorTool, createMathFunctionsTool, createMathOperationTools, createNeo4jCreateNodeWithEmbeddingTool, createNeo4jFindNodesTool, createNeo4jGetSchemaTool, createNeo4jQueryTool, createNeo4jTools, createNeo4jTraverseTool, createNeo4jVectorSearchTool, createNeo4jVectorSearchWithEmbeddingTool, createObjectOmitTool, createObjectPickTool, createPathBasenameTool, createPathDirnameTool, createPathExtensionTool, createPathJoinTool, createPathNormalizeTool, createPathParseTool, createPathRelativeTool, createPathResolveTool, createPathUtilityTools, createPhoneValidatorTool, createRandomNumberTool, createScraperTools, createSelectReadableStream, createSerperProvider, createSlackTools, createStatisticsTool, createStringCaseConverterTool, createStringJoinTool, createStringLengthTool, createStringReplaceTool, createStringSplitTool, createStringSubstringTool, createStringTrimTool, createStringUtilityTools, createTransformerTools, createUrlBuilderTool, createUrlQueryParserTool, createUrlValidatorSimpleTool, createUrlValidatorTool, createUrlValidatorTools, createUuidValidatorTool, createValidationTools, createWebScraperTool, createXmlGeneratorTool, createXmlParserTool, createXmlToJsonTool, createXmlTools, creditCardValidator, csvGenerator, csvGeneratorSchema, csvParser, csvParserSchema, csvToJson, csvToJsonSchema, csvTools, currentDateTime, dateArithmetic, dateComparison, dateDifference, dateFormatter, dateTimeTools, diffSchemas, directoryCreate, directoryCreateSchema, directoryDelete, directoryDeleteSchema, directoryList, directoryListSchema, directoryOperationTools, emailValidator, embeddingManager, executeBatchedTask, executeQuery, executeStreamingSelect, exportSchemaToJson, extractImages, extractImagesSchema, extractLinks, extractLinksSchema, fileAppend, fileAppendSchema, fileDelete, fileDeleteSchema, fileExists, fileExistsSchema, fileOperationTools, fileReader, fileReaderSchema, fileSearch, fileSearchSchema, fileWriter, fileWriterSchema, generateBatchEmbeddings, generateEmbedding, getCohereApiKey, getConfluencePage, getEmbeddingModel, getEmbeddingProvider, getHuggingFaceApiKey, getInstallationInstructions, getOllamaBaseUrl, getOpenAIApiKey, getPeerDependencyName, getSlackChannels, getSlackMessages, getSpacePages, getVendorTypeMap, getVoyageApiKey, htmlParser, htmlParserSchema, htmlParserTools, httpClient, httpGet, httpGetSchema, httpPost, httpPostSchema, httpRequestSchema, httpTools, importSchemaFromJson, initializeEmbeddings, initializeEmbeddingsWithConfig, initializeFromEnv, initializeNeo4jTools, ipValidator, isRetryableError, jsonMerge, jsonMergeSchema, jsonParser, jsonParserSchema, jsonQuery, jsonQuerySchema, jsonStringify, jsonStringifySchema, jsonToCsv, jsonToCsvSchema, jsonToXml, jsonToXmlSchema, jsonTools, jsonValidator, jsonValidatorSchema, listConfluenceSpaces, mapColumnType, mapSchemaTypes, mathFunctions, mathOperationTools, neo4jCoreTools, neo4jCreateNodeWithEmbedding, neo4jCreateNodeWithEmbeddingSchema, neo4jFindNodes, neo4jFindNodesSchema, neo4jGetSchema, neo4jGetSchemaSchema, neo4jPool, neo4jQuery, neo4jQuerySchema, neo4jTools, neo4jTraverse, neo4jTraverseSchema, neo4jVectorSearch, neo4jVectorSearchSchema, neo4jVectorSearchWithEmbedding, neo4jVectorSearchWithEmbeddingSchema, notifySlack, objectOmit, objectOmitSchema, objectPick, objectPickSchema, pathBasename, pathBasenameSchema, pathDirname, pathDirnameSchema, pathExtension, pathExtensionSchema, pathJoin, pathJoinSchema, pathNormalize, pathNormalizeSchema, pathParse, pathParseSchema, pathRelative, pathRelativeSchema, pathResolve, pathResolveSchema, pathUtilityTools, phoneValidator, randomNumber, relationalDelete, relationalGetSchema, relationalInsert, relationalQuery, relationalSelect, relationalUpdate, retryWithBackoff, scraperTools, searchConfluence, searchResultSchema, sendSlackMessage, slackTools, statistics, streamSelectChunks, stringCaseConverter, stringJoin, stringLength, stringReplace, stringSplit, stringSubstring, stringTrim, stringUtilityTools, transformerTools, updateConfluencePage, urlBuilder, urlBuilderSchema, urlQueryParser, urlQueryParserSchema, urlValidator, urlValidatorSchema, urlValidatorSimple, urlValidatorTools, uuidValidator, validateBatch, validateColumnTypes, validateColumnsExist, validateTableExists, validateText, validationTools, webScraper, webScraperSchema, webSearch, webSearchOutputSchema, webSearchSchema, withTransaction, xmlGenerator, xmlGeneratorSchema, xmlParser, xmlParserSchema, xmlToJson, xmlToJsonSchema, xmlTools };