@agentforge/tools 0.12.5 → 0.13.0

package/dist/index.d.ts

@@ -1,6 +1,10 @@
 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';
 
 /**
  * HTTP Tools Types
@@ -293,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
  */
@@ -570,8 +573,7 @@ interface UrlValidationResult {
 /**
  * URL validator tools configuration
  */
-interface UrlValidatorToolsConfig {
-}
+type UrlValidatorToolsConfig = Record<string, never>;
 /**
  * URL validator input schema
  */
@@ -1096,10 +1098,68 @@ interface SlackClientConfig {
 /**
  * Default Slack tools using environment variables
  */
-declare const sendSlackMessage: _agentforge_core.Tool<unknown, unknown>;
-declare const notifySlack: _agentforge_core.Tool<unknown, unknown>;
-declare const getSlackChannels: _agentforge_core.Tool<unknown, unknown>;
-declare const getSlackMessages: _agentforge_core.Tool<unknown, unknown>;
+declare const sendSlackMessage: _agentforge_core.Tool<{
+    message: string;
+    channel: string;
+}, {
+    success: boolean;
+    data?: {
+        channel: string | undefined;
+        message: string;
+        timestamp: string | undefined;
+        message_id: string | undefined;
+    } | undefined;
+    error?: string;
+}>;
+declare const notifySlack: _agentforge_core.Tool<{
+    message: string;
+    channel: string;
+    mentions?: string[] | undefined;
+}, {
+    success: boolean;
+    data?: {
+        channel: string | undefined;
+        message: string;
+        mentions: string[];
+        timestamp: string | undefined;
+        notification_id: string | undefined;
+    } | undefined;
+    error?: string;
+}>;
+declare const getSlackChannels: _agentforge_core.Tool<{
+    include_private?: boolean | undefined;
+}, {
+    success: boolean;
+    data?: {
+        count: number;
+        channels: {
+            id: string | undefined;
+            name: string | undefined;
+            is_private: boolean;
+            num_members: number;
+        }[];
+    } | undefined;
+    error?: string;
+}>;
+declare const getSlackMessages: _agentforge_core.Tool<{
+    channel: string;
+    limit?: number | undefined;
+}, {
+    success: boolean;
+    data?: {
+        channel: string;
+        count: number;
+        messages: {
+            user: string;
+            text: string;
+            timestamp: string | undefined;
+            thread_ts: string | undefined;
+            type: string | undefined;
+            subtype: string | undefined;
+        }[];
+    } | undefined;
+    error?: string;
+}>;
 /**
  * Export all Slack tools
  *
@@ -1107,7 +1167,65 @@ declare const getSlackMessages: _agentforge_core.Tool<unknown, unknown>;
  * - 2 write tools: send-slack-message, notify-slack
  * - 2 read tools: get-slack-channels, get-slack-messages
  */
-declare const slackTools: _agentforge_core.Tool<unknown, unknown>[];
+declare const slackTools: (_agentforge_core.Tool<{
+    message: string;
+    channel: string;
+}, {
+    success: boolean;
+    data?: {
+        channel: string | undefined;
+        message: string;
+        timestamp: string | undefined;
+        message_id: string | undefined;
+    } | undefined;
+    error?: string;
+}> | _agentforge_core.Tool<{
+    message: string;
+    channel: string;
+    mentions?: string[] | undefined;
+}, {
+    success: boolean;
+    data?: {
+        channel: string | undefined;
+        message: string;
+        mentions: string[];
+        timestamp: string | undefined;
+        notification_id: string | undefined;
+    } | undefined;
+    error?: string;
+}> | _agentforge_core.Tool<{
+    include_private?: boolean | undefined;
+}, {
+    success: boolean;
+    data?: {
+        count: number;
+        channels: {
+            id: string | undefined;
+            name: string | undefined;
+            is_private: boolean;
+            num_members: number;
+        }[];
+    } | undefined;
+    error?: string;
+}> | _agentforge_core.Tool<{
+    channel: string;
+    limit?: number | undefined;
+}, {
+    success: boolean;
+    data?: {
+        channel: string;
+        count: number;
+        messages: {
+            user: string;
+            text: string;
+            timestamp: string | undefined;
+            thread_ts: string | undefined;
+            type: string | undefined;
+            subtype: string | undefined;
+        }[];
+    } | undefined;
+    error?: string;
+}>)[];
 /**
  * Create Slack tools with custom configuration
  *
@@ -1145,10 +1263,68 @@ declare const slackTools: _agentforge_core.Tool<unknown, unknown>[];
  * ```
  */
 declare function createSlackTools(config?: SlackToolsConfig): {
-    sendMessage: _agentforge_core.Tool<unknown, unknown>;
-    notify: _agentforge_core.Tool<unknown, unknown>;
-    getChannels: _agentforge_core.Tool<unknown, unknown>;
-    getMessages: _agentforge_core.Tool<unknown, unknown>;
+    sendMessage: _agentforge_core.Tool<{
+        message: string;
+        channel: string;
+    }, {
+        success: boolean;
+        data?: {
+            channel: string | undefined;
+            message: string;
+            timestamp: string | undefined;
+            message_id: string | undefined;
+        } | undefined;
+        error?: string;
+    }>;
+    notify: _agentforge_core.Tool<{
+        message: string;
+        channel: string;
+        mentions?: string[] | undefined;
+    }, {
+        success: boolean;
+        data?: {
+            channel: string | undefined;
+            message: string;
+            mentions: string[];
+            timestamp: string | undefined;
+            notification_id: string | undefined;
+        } | undefined;
+        error?: string;
+    }>;
+    getChannels: _agentforge_core.Tool<{
+        include_private?: boolean | undefined;
+    }, {
+        success: boolean;
+        data?: {
+            count: number;
+            channels: {
+                id: string | undefined;
+                name: string | undefined;
+                is_private: boolean;
+                num_members: number;
+            }[];
+        } | undefined;
+        error?: string;
+    }>;
+    getMessages: _agentforge_core.Tool<{
+        channel: string;
+        limit?: number | undefined;
+    }, {
+        success: boolean;
+        data?: {
+            channel: string;
+            count: number;
+            messages: {
+                user: string;
+                text: string;
+                timestamp: string | undefined;
+                thread_ts: string | undefined;
+                type: string | undefined;
+                subtype: string | undefined;
+            }[];
+        } | undefined;
+        error?: string;
+    }>;
 };
 
 /**
@@ -1192,13 +1368,35 @@ interface ConfluenceAuth {
 /**
  * Default Confluence tools using environment variables
  */
-declare const searchConfluence: _agentforge_core.Tool<unknown, unknown>;
-declare const getConfluencePage: _agentforge_core.Tool<unknown, unknown>;
-declare const listConfluenceSpaces: _agentforge_core.Tool<unknown, unknown>;
-declare const getSpacePages: _agentforge_core.Tool<unknown, unknown>;
-declare const createConfluencePage: _agentforge_core.Tool<unknown, unknown>;
-declare const updateConfluencePage: _agentforge_core.Tool<unknown, unknown>;
-declare const archiveConfluencePage: _agentforge_core.Tool<unknown, unknown>;
+declare const searchConfluence: _agentforge_core.Tool<{
+    query: string;
+    limit?: number | undefined;
+}, string>;
+declare const getConfluencePage: _agentforge_core.Tool<{
+    page_id: string;
+}, string>;
+declare const listConfluenceSpaces: _agentforge_core.Tool<{
+    limit?: number | undefined;
+}, string>;
+declare const getSpacePages: _agentforge_core.Tool<{
+    space_key: string;
+    limit?: number | undefined;
+}, string>;
+declare const createConfluencePage: _agentforge_core.Tool<{
+    title: string;
+    content: string;
+    space_key: string;
+    parent_page_id?: string | undefined;
+}, string>;
+declare const updateConfluencePage: _agentforge_core.Tool<{
+    title: string;
+    content: string;
+    page_id: string;
+}, string>;
+declare const archiveConfluencePage: _agentforge_core.Tool<{
+    page_id: string;
+    reason?: string | undefined;
+}, string>;
 /**
  * Export all Confluence tools
  *
@@ -1206,7 +1404,29 @@ declare const archiveConfluencePage: _agentforge_core.Tool<unknown, unknown>;
  * - 4 read tools: search, get-page, list-spaces, get-space-pages
  * - 3 write tools: create-page, update-page, archive-page
  */
-declare const confluenceTools: _agentforge_core.Tool<unknown, unknown>[];
+declare const confluenceTools: (_agentforge_core.Tool<{
+    query: string;
+    limit?: number | undefined;
+}, string> | _agentforge_core.Tool<{
+    page_id: string;
+}, string> | _agentforge_core.Tool<{
+    limit?: number | undefined;
+}, string> | _agentforge_core.Tool<{
+    space_key: string;
+    limit?: number | undefined;
+}, string> | _agentforge_core.Tool<{
+    title: string;
+    content: string;
+    space_key: string;
+    parent_page_id?: string | undefined;
+}, string> | _agentforge_core.Tool<{
+    title: string;
+    content: string;
+    page_id: string;
+}, string> | _agentforge_core.Tool<{
+    page_id: string;
+    reason?: string | undefined;
+}, string>)[];
 /**
  * Create Confluence tools with custom configuration
  *
@@ -1240,13 +1460,35 @@ declare const confluenceTools: _agentforge_core.Tool<unknown, unknown>[];
  * ```
  */
 declare function createConfluenceTools(config?: ConfluenceToolsConfig): {
-    searchConfluence: _agentforge_core.Tool<unknown, unknown>;
-    getConfluencePage: _agentforge_core.Tool<unknown, unknown>;
-    listConfluenceSpaces: _agentforge_core.Tool<unknown, unknown>;
-    getSpacePages: _agentforge_core.Tool<unknown, unknown>;
-    createConfluencePage: _agentforge_core.Tool<unknown, unknown>;
-    updateConfluencePage: _agentforge_core.Tool<unknown, unknown>;
-    archiveConfluencePage: _agentforge_core.Tool<unknown, unknown>;
+    searchConfluence: _agentforge_core.Tool<{
+        query: string;
+        limit?: number | undefined;
+    }, string>;
+    getConfluencePage: _agentforge_core.Tool<{
+        page_id: string;
+    }, string>;
+    listConfluenceSpaces: _agentforge_core.Tool<{
+        limit?: number | undefined;
+    }, string>;
+    getSpacePages: _agentforge_core.Tool<{
+        space_key: string;
+        limit?: number | undefined;
+    }, string>;
+    createConfluencePage: _agentforge_core.Tool<{
+        title: string;
+        content: string;
+        space_key: string;
+        parent_page_id?: string | undefined;
+    }, string>;
+    updateConfluencePage: _agentforge_core.Tool<{
+        title: string;
+        content: string;
+        page_id: string;
+    }, string>;
+    archiveConfluencePage: _agentforge_core.Tool<{
+        page_id: string;
+        reason?: string | undefined;
+    }, string>;
 };
 
 /**
@@ -2390,8 +2632,7 @@ declare const objectOmitSchema: z.ZodObject<{
 /**
  * Transformer tools configuration
  */
-interface TransformerToolsConfig {
-}
+type TransformerToolsConfig = Record<string, never>;
 
 /**
  * Array Filter Tool
@@ -2411,202 +2652,3678 @@ declare function createArrayFilterTool(): _agentforge_core.Tool<{
 }>;
 
 /**
- * Array Map Tool
+ * Array Map Tool
+ */
+/**
+ * Create array map tool
+ */
+declare function createArrayMapTool(): _agentforge_core.Tool<{
+    array: any[];
+    properties: string[];
+}, {
+    mapped: any[];
+    count: number;
+}>;
+
+/**
+ * Array Sort Tool
+ */
+/**
+ * Create array sort tool
+ */
+declare function createArraySortTool(): _agentforge_core.Tool<{
+    array: any[];
+    property: string;
+    order?: "asc" | "desc" | undefined;
+}, {
+    sorted: any[];
+    count: number;
+}>;
+
+/**
+ * Array Group By Tool
+ */
+/**
+ * Create array group by tool
+ */
+declare function createArrayGroupByTool(): _agentforge_core.Tool<{
+    array: any[];
+    property: string;
+}, {
+    groups: Record<string, any[]>;
+    groupCount: number;
+    totalItems: number;
+}>;
+
+/**
+ * Object Pick Tool
+ */
+/**
+ * Create object pick tool
+ */
+declare function createObjectPickTool(): _agentforge_core.Tool<{
+    object: Record<string, any>;
+    properties: string[];
+}, Record<string, any>>;
+
+/**
+ * Object Omit Tool
+ */
+/**
+ * Create object omit tool
+ */
+declare function createObjectOmitTool(): _agentforge_core.Tool<{
+    object: Record<string, any>;
+    properties: string[];
+}, Record<string, any>>;
+
+/**
+ * Default array filter tool instance
+ */
+declare const arrayFilter: _agentforge_core.Tool<{
+    array: any[];
+    property: string;
+    operator: "equals" | "not-equals" | "greater-than" | "less-than" | "contains" | "starts-with" | "ends-with";
+    value?: any;
+}, {
+    filtered: any[];
+    originalCount: number;
+    filteredCount: number;
+}>;
+/**
+ * Default array map tool instance
+ */
+declare const arrayMap: _agentforge_core.Tool<{
+    array: any[];
+    properties: string[];
+}, {
+    mapped: any[];
+    count: number;
+}>;
+/**
+ * Default array sort tool instance
+ */
+declare const arraySort: _agentforge_core.Tool<{
+    array: any[];
+    property: string;
+    order?: "asc" | "desc" | undefined;
+}, {
+    sorted: any[];
+    count: number;
+}>;
+/**
+ * Default array group by tool instance
+ */
+declare const arrayGroupBy: _agentforge_core.Tool<{
+    array: any[];
+    property: string;
+}, {
+    groups: Record<string, any[]>;
+    groupCount: number;
+    totalItems: number;
+}>;
+/**
+ * Default object pick tool instance
+ */
+declare const objectPick: _agentforge_core.Tool<{
+    object: Record<string, any>;
+    properties: string[];
+}, Record<string, any>>;
+/**
+ * Default object omit tool instance
+ */
+declare const objectOmit: _agentforge_core.Tool<{
+    object: Record<string, any>;
+    properties: string[];
+}, Record<string, any>>;
+/**
+ * All transformer tools
+ */
+declare const transformerTools: (_agentforge_core.Tool<{
+    array: any[];
+    property: string;
+    operator: "equals" | "not-equals" | "greater-than" | "less-than" | "contains" | "starts-with" | "ends-with";
+    value?: any;
+}, {
+    filtered: any[];
+    originalCount: number;
+    filteredCount: number;
+}> | _agentforge_core.Tool<{
+    array: any[];
+    properties: string[];
+}, {
+    mapped: any[];
+    count: number;
+}> | _agentforge_core.Tool<{
+    array: any[];
+    property: string;
+    order?: "asc" | "desc" | undefined;
+}, {
+    sorted: any[];
+    count: number;
+}> | _agentforge_core.Tool<{
+    array: any[];
+    property: string;
+}, {
+    groups: Record<string, any[]>;
+    groupCount: number;
+    totalItems: number;
+}> | _agentforge_core.Tool<{
+    object: Record<string, any>;
+    properties: string[];
+}, Record<string, any>>)[];
+/**
+ * Create transformer tools with custom configuration
+ */
+declare function createTransformerTools(config?: TransformerToolsConfig): (_agentforge_core.Tool<{
+    array: any[];
+    property: string;
+    operator: "equals" | "not-equals" | "greater-than" | "less-than" | "contains" | "starts-with" | "ends-with";
+    value?: any;
+}, {
+    filtered: any[];
+    originalCount: number;
+    filteredCount: number;
+}> | _agentforge_core.Tool<{
+    array: any[];
+    properties: string[];
+}, {
+    mapped: any[];
+    count: number;
+}> | _agentforge_core.Tool<{
+    array: any[];
+    property: string;
+    order?: "asc" | "desc" | undefined;
+}, {
+    sorted: any[];
+    count: number;
+}> | _agentforge_core.Tool<{
+    array: any[];
+    property: string;
+}, {
+    groups: Record<string, any[]>;
+    groupCount: number;
+    totalItems: number;
+}> | _agentforge_core.Tool<{
+    object: Record<string, any>;
+    properties: string[];
+}, Record<string, any>>)[];
+
+/**
+ * Neo4j Tools Types
+ *
+ * Type definitions and schemas for Neo4j graph database tools.
+ */
+
+/**
+ * Neo4j connection configuration
+ */
+interface Neo4jConfig {
+    uri: string;
+    username: string;
+    password: string;
+    database?: string;
+    maxConnectionPoolSize?: number;
+    connectionTimeout?: number;
+}
+/**
+ * Neo4j query schema
+ */
+declare const neo4jQuerySchema: z.ZodObject<{
+    cypher: z.ZodString;
+    parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    database: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    cypher: string;
+    parameters?: Record<string, any> | undefined;
+    database?: string | undefined;
+}, {
+    cypher: string;
+    parameters?: Record<string, any> | undefined;
+    database?: string | undefined;
+}>;
+/**
+ * Neo4j get schema input schema
+ */
+declare const neo4jGetSchemaSchema: z.ZodObject<{
+    database: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    database?: string | undefined;
+}, {
+    database?: string | undefined;
+}>;
+/**
+ * Neo4j find nodes schema
+ */
+declare const neo4jFindNodesSchema: z.ZodObject<{
+    label: z.ZodString;
+    properties: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    database: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    label: string;
+    properties?: Record<string, any> | undefined;
+    database?: string | undefined;
+}, {
+    label: string;
+    limit?: number | undefined;
+    properties?: Record<string, any> | undefined;
+    database?: string | undefined;
+}>;
+/**
+ * Neo4j traverse schema
+ */
+declare const neo4jTraverseSchema: z.ZodObject<{
+    startNodeId: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    relationshipType: z.ZodOptional<z.ZodString>;
+    direction: z.ZodDefault<z.ZodEnum<["outgoing", "incoming", "both"]>>;
+    maxDepth: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+    database: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    startNodeId: string | number;
+    direction: "outgoing" | "incoming" | "both";
+    maxDepth: number;
+    database?: string | undefined;
+    relationshipType?: string | undefined;
+}, {
+    startNodeId: string | number;
+    limit?: number | undefined;
+    database?: string | undefined;
+    relationshipType?: string | undefined;
+    direction?: "outgoing" | "incoming" | "both" | undefined;
+    maxDepth?: number | undefined;
+}>;
+/**
+ * Neo4j vector search schema
+ */
+declare const neo4jVectorSearchSchema: z.ZodObject<{
+    indexName: z.ZodString;
+    queryVector: z.ZodArray<z.ZodNumber, "many">;
+    limit: z.ZodDefault<z.ZodNumber>;
+    database: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    indexName: string;
+    queryVector: number[];
+    database?: string | undefined;
+}, {
+    indexName: string;
+    queryVector: number[];
+    limit?: number | undefined;
+    database?: string | undefined;
+}>;
+/**
+ * Neo4j vector search with embedding schema
+ */
+declare const neo4jVectorSearchWithEmbeddingSchema: z.ZodObject<{
+    indexName: z.ZodString;
+    queryText: z.ZodString;
+    limit: z.ZodDefault<z.ZodNumber>;
+    model: z.ZodOptional<z.ZodString>;
+    database: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    indexName: string;
+    queryText: string;
+    database?: string | undefined;
+    model?: string | undefined;
+}, {
+    indexName: string;
+    queryText: string;
+    limit?: number | undefined;
+    database?: string | undefined;
+    model?: string | undefined;
+}>;
+/**
+ * Neo4j create node with embedding schema
+ */
+declare const neo4jCreateNodeWithEmbeddingSchema: z.ZodObject<{
+    label: z.ZodString;
+    properties: z.ZodRecord<z.ZodString, z.ZodAny>;
+    textProperty: z.ZodString;
+    embeddingProperty: z.ZodDefault<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    database: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    properties: Record<string, any>;
+    label: string;
+    textProperty: string;
+    embeddingProperty: string;
+    database?: string | undefined;
+    model?: string | undefined;
+}, {
+    properties: Record<string, any>;
+    label: string;
+    textProperty: string;
+    database?: string | undefined;
+    model?: string | undefined;
+    embeddingProperty?: string | undefined;
+}>;
+/**
+ * Neo4j node result
+ */
+interface Neo4jNode {
+    identity: string | number;
+    labels: string[];
+    properties: Record<string, any>;
+}
+/**
+ * Neo4j relationship result
+ */
+interface Neo4jRelationship {
+    identity: string | number;
+    type: string;
+    start: string | number;
+    end: string | number;
+    properties: Record<string, any>;
+}
+/**
+ * Neo4j path result
+ */
+interface Neo4jPath {
+    start: Neo4jNode;
+    end: Neo4jNode;
+    segments: Array<{
+        start: Neo4jNode;
+        relationship: Neo4jRelationship;
+        end: Neo4jNode;
+    }>;
+    length: number;
+}
+/**
+ * Neo4j schema information
+ */
+interface Neo4jSchema {
+    nodeLabels: string[];
+    relationshipTypes: string[];
+    propertyKeys: string[];
+    constraints: Array<{
+        label?: string;
+        type: string;
+        properties: string[];
+    }>;
+    indexes: Array<{
+        label?: string;
+        type: string;
+        properties: string[];
+    }>;
+}
+/**
+ * Neo4j tools configuration
+ */
+interface Neo4jToolsConfig {
+    uri?: string;
+    username?: string;
+    password?: string;
+    database?: string;
+    maxConnectionPoolSize?: number;
+    connectionTimeout?: number;
+}
+
+/**
+ * Neo4j Connection Pool Management
+ *
+ * Manages Neo4j driver connections with pooling and health checks.
+ */
+
+/**
+ * Neo4j connection pool singleton
+ */
+declare class Neo4jConnectionPool {
+    private driver;
+    private config;
+    /**
+     * Initialize the connection pool
+     */
+    initialize(config: Neo4jConfig): Promise<void>;
+    /**
+     * Verify connectivity to Neo4j
+     */
+    verifyConnectivity(): Promise<void>;
+    /**
+     * Get a session for executing queries
+     */
+    getSession(database?: string): Session;
+    /**
+     * Execute a query with automatic session management
+     */
+    executeQuery<T = any>(cypher: string, parameters?: Record<string, any>, database?: string): Promise<T[]>;
+    /**
+     * Execute a read query
+     */
+    executeReadQuery<T = any>(cypher: string, parameters?: Record<string, any>, database?: string): Promise<T[]>;
+    /**
+     * Execute a write query
+     */
+    executeWriteQuery<T = any>(cypher: string, parameters?: Record<string, any>, database?: string): Promise<T[]>;
+    /**
+     * Check if driver is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Get current configuration
+     */
+    getConfig(): Neo4jConfig | null;
+    /**
+     * Close the connection pool
+     */
+    close(): Promise<void>;
+}
+/**
+ * Global connection pool instance
+ */
+declare const neo4jPool: Neo4jConnectionPool;
+/**
+ * Initialize Neo4j connection from environment variables
+ */
+declare function initializeFromEnv(): Promise<void>;
+
+/**
+ * Embedding Generation Types
+ *
+ * Types and interfaces for embedding generation providers
+ */
+/**
+ * Supported embedding providers
+ */
+type EmbeddingProvider = 'openai' | 'cohere' | 'huggingface' | 'voyage' | 'ollama';
+/**
+ * Configuration for embedding generation
+ */
+interface EmbeddingConfig {
+    provider: EmbeddingProvider;
+    model: string;
+    apiKey: string;
+    dimensions?: number;
+}
+/**
+ * Result from embedding generation
+ */
+interface EmbeddingResult {
+    embedding: number[];
+    model: string;
+    dimensions: number;
+    usage?: {
+        promptTokens: number;
+        totalTokens: number;
+    };
+}
+/**
+ * Batch embedding result
+ */
+interface BatchEmbeddingResult {
+    embeddings: number[][];
+    model: string;
+    dimensions: number;
+    usage?: {
+        promptTokens: number;
+        totalTokens: number;
+    };
+}
+/**
+ * Base interface for embedding providers
+ */
+interface IEmbeddingProvider {
+    readonly name: EmbeddingProvider;
+    readonly defaultModel: string;
+    /**
+     * Check if provider is available (API key configured)
+     */
+    isAvailable(): boolean;
+    /**
+     * Generate embedding for a single text
+     */
+    generateEmbedding(text: string, model?: string): Promise<EmbeddingResult>;
+    /**
+     * Generate embeddings for multiple texts (batch)
+     */
+    generateBatchEmbeddings(texts: string[], model?: string): Promise<BatchEmbeddingResult>;
+}
+/**
+ * Retry configuration for embedding API calls
+ */
+interface EmbeddingRetryConfig {
+    maxRetries: number;
+    initialDelay: number;
+    maxDelay: number;
+    backoffMultiplier: number;
+}
+
+/**
+ * Embedding Utilities
+ *
+ * Utility functions for embedding generation
+ */
+
+/**
+ * Default retry configuration for embedding API calls
+ */
+declare const DEFAULT_RETRY_CONFIG: EmbeddingRetryConfig;
+/**
+ * Check if error is retryable (network errors, timeouts, 5xx errors, rate limits)
+ */
+declare function isRetryableError(error: any): boolean;
+/**
+ * Retry an async function with exponential backoff
+ */
+declare function retryWithBackoff<T>(fn: () => Promise<T>, config?: EmbeddingRetryConfig): Promise<T>;
+/**
+ * Get OpenAI API key from environment
+ */
+declare function getOpenAIApiKey(): string | undefined;
+/**
+ * Get Cohere API key from environment
+ */
+declare function getCohereApiKey(): string | undefined;
+/**
+ * Get HuggingFace API key from environment
+ */
+declare function getHuggingFaceApiKey(): string | undefined;
+/**
+ * Get Voyage AI API key from environment
+ */
+declare function getVoyageApiKey(): string | undefined;
+/**
+ * Get Ollama base URL from environment (defaults to localhost)
+ */
+declare function getOllamaBaseUrl(): string;
+/**
+ * Get embedding provider from environment (defaults to 'openai')
+ */
+declare function getEmbeddingProvider(): string;
+/**
+ * Get embedding model from environment
+ */
+declare function getEmbeddingModel(): string | undefined;
+/**
+ * Validate text for embedding generation
+ */
+declare function validateText(text: string): void;
+/**
+ * Validate batch of texts
+ */
+declare function validateBatch(texts: string[]): void;
+
+/**
+ * Embedding Manager
+ *
+ * Manages embedding generation across different providers
+ */
+
+/**
+ * Singleton embedding manager
+ */
+declare class EmbeddingManager {
+    private provider;
+    private config;
+    /**
+     * Initialize with configuration
+     */
+    initialize(config: EmbeddingConfig): void;
+    /**
+     * Initialize from environment variables
+     */
+    initializeFromEnv(): void;
+    /**
+     * Check if manager is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Get current provider
+     */
+    getProvider(): IEmbeddingProvider;
+    /**
+     * Get current configuration
+     */
+    getConfig(): EmbeddingConfig;
+    /**
+     * Generate embedding for a single text
+     */
+    generateEmbedding(text: string, model?: string): Promise<EmbeddingResult>;
+    /**
+     * Generate embeddings for multiple texts (batch)
+     */
+    generateBatchEmbeddings(texts: string[], model?: string): Promise<BatchEmbeddingResult>;
+    /**
+     * Get default model for a provider
+     */
+    private getDefaultModel;
+    /**
+     * Create a provider instance
+     */
+    private createProvider;
+    /**
+     * Reset the manager (for testing)
+     */
+    reset(): void;
+}
+/**
+ * Singleton instance
+ */
+declare const embeddingManager: EmbeddingManager;
+/**
+ * Initialize embedding manager from environment variables
+ */
+declare function initializeEmbeddings(): void;
+/**
+ * Initialize embedding manager with custom configuration
+ */
+declare function initializeEmbeddingsWithConfig(config: EmbeddingConfig): void;
+/**
+ * Generate embedding for a single text
+ */
+declare function generateEmbedding(text: string, model?: string): Promise<EmbeddingResult>;
+/**
+ * Generate embeddings for multiple texts (batch)
+ */
+declare function generateBatchEmbeddings(texts: string[], model?: string): Promise<BatchEmbeddingResult>;
+
+/**
+ * OpenAI Embedding Provider
+ *
+ * Generate embeddings using OpenAI's embedding models.
+ * Requires OPENAI_API_KEY environment variable.
+ * Get your API key at: https://platform.openai.com/api-keys
+ */
+
+/**
+ * OpenAI embedding provider implementation
+ */
+declare class OpenAIEmbeddingProvider implements IEmbeddingProvider {
+    readonly name: "openai";
+    readonly defaultModel = "text-embedding-3-small";
+    private apiKey;
+    private readonly baseURL;
+    constructor(apiKey?: string);
+    /**
+     * Check if OpenAI is available (API key is set)
+     */
+    isAvailable(): boolean;
+    /**
+     * Generate embedding for a single text
+     */
+    generateEmbedding(text: string, model?: string): Promise<EmbeddingResult>;
+    /**
+     * Generate embeddings for multiple texts (batch)
+     */
+    generateBatchEmbeddings(texts: string[], model?: string): Promise<BatchEmbeddingResult>;
+}
+
+/**
+ * Neo4j Query Tool
+ *
+ * Execute arbitrary Cypher queries against Neo4j database.
+ */
+/**
+ * Create Neo4j query tool
+ */
+declare function createNeo4jQueryTool(): _agentforge_core.Tool<{
+    cypher: string;
+    parameters?: Record<string, any> | undefined;
+    database?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    data?: undefined;
+    recordCount?: undefined;
+    summary?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    data: any[];
+    recordCount: number;
+    summary: {
+        query: string;
+        parameters: Record<string, any> | undefined;
+        counters: {
+            nodesCreated: number;
+            nodesDeleted: number;
+            relationshipsCreated: number;
+            relationshipsDeleted: number;
+            propertiesSet: number;
+        };
+    };
+    error?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: string;
+    data?: undefined;
+    recordCount?: undefined;
+    summary?: undefined;
+}>;
+
+/**
+ * Neo4j Get Schema Tool
+ *
+ * Introspect the Neo4j graph schema to understand structure.
+ */
+/**
+ * Create Neo4j get schema tool
+ */
+declare function createNeo4jGetSchemaTool(): _agentforge_core.Tool<{
+    database?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    schema?: undefined;
+    summary?: undefined;
+} | {
+    success: boolean;
+    schema: {
+        nodeLabels: any[];
+        relationshipTypes: any[];
+        propertyKeys: any[];
+        constraints: {
+            name: any;
+            type: any;
+            entityType: any;
+            labelsOrTypes: any;
+            properties: any;
+        }[];
+        indexes: {
+            name: any;
+            type: any;
+            entityType: any;
+            labelsOrTypes: any;
+            properties: any;
+        }[];
+    };
+    summary: {
+        totalLabels: number;
+        totalRelationshipTypes: number;
+        totalPropertyKeys: number;
+        totalConstraints: number;
+        totalIndexes: number;
+    };
+    error?: undefined;
+}>;
+
+/**
+ * Neo4j Find Nodes Tool
+ *
+ * Find nodes by label and properties.
+ */
+/**
+ * Create Neo4j find nodes tool
+ */
+declare function createNeo4jFindNodesTool(): _agentforge_core.Tool<{
+    label: string;
+    limit?: number | undefined;
+    properties?: Record<string, any> | undefined;
+    database?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    nodes?: undefined;
+    count?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    nodes: any[];
+    count: number;
+    query: {
+        label: string;
+        properties: Record<string, any> | undefined;
+        limit: number | undefined;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: {
+        label: string;
+        properties: Record<string, any> | undefined;
+        limit?: undefined;
+    };
+    nodes?: undefined;
+    count?: undefined;
+}>;
+
+/**
+ * Neo4j Traverse Tool
+ *
+ * Traverse the graph from a starting node following relationships.
+ */
+/**
+ * Create Neo4j traverse tool
+ */
+declare function createNeo4jTraverseTool(): _agentforge_core.Tool<{
+    startNodeId: string | number;
+    limit?: number | undefined;
+    database?: string | undefined;
+    relationshipType?: string | undefined;
+    direction?: "outgoing" | "incoming" | "both" | undefined;
+    maxDepth?: number | undefined;
+}, {
+    success: boolean;
+    error: string;
+    paths?: undefined;
+    count?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    paths: {
+        start: any;
+        end: any;
+        relationships: any;
+        depth: any;
+    }[];
+    count: number;
+    query: {
+        startNodeId: string | number;
+        relationshipType: string | undefined;
+        direction: "outgoing" | "incoming" | "both" | undefined;
+        maxDepth: number | undefined;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: {
+        startNodeId: string | number;
+        relationshipType: string | undefined;
+        direction: "outgoing" | "incoming" | "both" | undefined;
+        maxDepth?: undefined;
+    };
+    paths?: undefined;
+    count?: undefined;
+}>;
+
+/**
+ * Neo4j Vector Search Tool
+ *
+ * Perform semantic search using vector indexes for GraphRAG applications.
+ */
+/**
+ * Create Neo4j vector search tool
+ */
+declare function createNeo4jVectorSearchTool(): _agentforge_core.Tool<{
+    indexName: string;
+    queryVector: number[];
+    limit?: number | undefined;
+    database?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    results?: undefined;
+    count?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    results: {
+        node: any;
+        score: any;
+    }[];
+    count: number;
+    query: {
+        indexName: string;
+        vectorDimension: number;
+        limit: number | undefined;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: {
+        indexName: string;
+        vectorDimension: number;
+        limit?: undefined;
+    };
+    results?: undefined;
+    count?: undefined;
+}>;
+
+/**
+ * Neo4j Vector Search with Embedding Tool
+ *
+ * Perform semantic search by automatically generating embeddings from text.
+ * This tool combines embedding generation with vector search for easier GraphRAG.
+ */
+/**
+ * Create Neo4j vector search with embedding tool
+ */
+declare function createNeo4jVectorSearchWithEmbeddingTool(): _agentforge_core.Tool<{
+    indexName: string;
+    queryText: string;
+    limit?: number | undefined;
+    database?: string | undefined;
+    model?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    results?: undefined;
+    count?: undefined;
+    query?: undefined;
+    embedding?: undefined;
+} | {
+    success: boolean;
+    results: {
+        node: any;
+        score: any;
+    }[];
+    count: number;
+    query: {
+        text: string;
+        indexName: string;
+        embeddingModel: string;
+        vectorDimension: number;
+        limit: number | undefined;
+    };
+    embedding: {
+        model: string;
+        dimensions: number;
+        usage: {
+            promptTokens: number;
+            totalTokens: number;
+        } | undefined;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: {
+        text: string;
+        indexName: string;
+        embeddingModel?: undefined;
+        vectorDimension?: undefined;
+        limit?: undefined;
+    };
+    results?: undefined;
+    count?: undefined;
+    embedding?: undefined;
+}>;
+
+/**
+ * Neo4j Create Node with Embedding Tool
+ *
+ * Create a node with automatic embedding generation from text content.
+ * This tool simplifies GraphRAG setup by handling embedding generation automatically.
+ */
+/**
+ * Create Neo4j create node with embedding tool
+ */
+declare function createNeo4jCreateNodeWithEmbeddingTool(): _agentforge_core.Tool<{
+    properties: Record<string, any>;
+    label: string;
+    textProperty: string;
+    database?: string | undefined;
+    model?: string | undefined;
+    embeddingProperty?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    node?: undefined;
+    nodeId?: undefined;
+    embedding?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    node: any;
+    nodeId: any;
+    embedding: {
+        model: string;
+        dimensions: number;
+        property: string;
+        usage: {
+            promptTokens: number;
+            totalTokens: number;
+        } | undefined;
+    };
+    message: string;
+    error?: undefined;
+}>;
+
+/**
+ * Default Neo4j query tool instance
+ */
+declare const neo4jQuery: _agentforge_core.Tool<{
+    cypher: string;
+    parameters?: Record<string, any> | undefined;
+    database?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    data?: undefined;
+    recordCount?: undefined;
+    summary?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    data: any[];
+    recordCount: number;
+    summary: {
+        query: string;
+        parameters: Record<string, any> | undefined;
+        counters: {
+            nodesCreated: number;
+            nodesDeleted: number;
+            relationshipsCreated: number;
+            relationshipsDeleted: number;
+            propertiesSet: number;
+        };
+    };
+    error?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: string;
+    data?: undefined;
+    recordCount?: undefined;
+    summary?: undefined;
+}>;
+/**
+ * Default Neo4j get schema tool instance
+ */
+declare const neo4jGetSchema: _agentforge_core.Tool<{
+    database?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    schema?: undefined;
+    summary?: undefined;
+} | {
+    success: boolean;
+    schema: {
+        nodeLabels: any[];
+        relationshipTypes: any[];
+        propertyKeys: any[];
+        constraints: {
+            name: any;
+            type: any;
+            entityType: any;
+            labelsOrTypes: any;
+            properties: any;
+        }[];
+        indexes: {
+            name: any;
+            type: any;
+            entityType: any;
+            labelsOrTypes: any;
+            properties: any;
+        }[];
+    };
+    summary: {
+        totalLabels: number;
+        totalRelationshipTypes: number;
+        totalPropertyKeys: number;
+        totalConstraints: number;
+        totalIndexes: number;
+    };
+    error?: undefined;
+}>;
+/**
+ * Default Neo4j find nodes tool instance
+ */
+declare const neo4jFindNodes: _agentforge_core.Tool<{
+    label: string;
+    limit?: number | undefined;
+    properties?: Record<string, any> | undefined;
+    database?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    nodes?: undefined;
+    count?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    nodes: any[];
+    count: number;
+    query: {
+        label: string;
+        properties: Record<string, any> | undefined;
+        limit: number | undefined;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: {
+        label: string;
+        properties: Record<string, any> | undefined;
+        limit?: undefined;
+    };
+    nodes?: undefined;
+    count?: undefined;
+}>;
+/**
+ * Default Neo4j traverse tool instance
+ */
+declare const neo4jTraverse: _agentforge_core.Tool<{
+    startNodeId: string | number;
+    limit?: number | undefined;
+    database?: string | undefined;
+    relationshipType?: string | undefined;
+    direction?: "outgoing" | "incoming" | "both" | undefined;
+    maxDepth?: number | undefined;
+}, {
+    success: boolean;
+    error: string;
+    paths?: undefined;
+    count?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    paths: {
+        start: any;
+        end: any;
+        relationships: any;
+        depth: any;
+    }[];
+    count: number;
+    query: {
+        startNodeId: string | number;
+        relationshipType: string | undefined;
+        direction: "outgoing" | "incoming" | "both" | undefined;
+        maxDepth: number | undefined;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: {
+        startNodeId: string | number;
+        relationshipType: string | undefined;
+        direction: "outgoing" | "incoming" | "both" | undefined;
+        maxDepth?: undefined;
+    };
+    paths?: undefined;
+    count?: undefined;
+}>;
+/**
+ * Default Neo4j vector search tool instance
+ */
+declare const neo4jVectorSearch: _agentforge_core.Tool<{
+    indexName: string;
+    queryVector: number[];
+    limit?: number | undefined;
+    database?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    results?: undefined;
+    count?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    results: {
+        node: any;
+        score: any;
+    }[];
+    count: number;
+    query: {
+        indexName: string;
+        vectorDimension: number;
+        limit: number | undefined;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: {
+        indexName: string;
+        vectorDimension: number;
+        limit?: undefined;
+    };
+    results?: undefined;
+    count?: undefined;
+}>;
+/**
+ * Default Neo4j vector search with embedding tool instance
+ */
+declare const neo4jVectorSearchWithEmbedding: _agentforge_core.Tool<{
+    indexName: string;
+    queryText: string;
+    limit?: number | undefined;
+    database?: string | undefined;
+    model?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    results?: undefined;
+    count?: undefined;
+    query?: undefined;
+    embedding?: undefined;
+} | {
+    success: boolean;
+    results: {
+        node: any;
+        score: any;
+    }[];
+    count: number;
+    query: {
+        text: string;
+        indexName: string;
+        embeddingModel: string;
+        vectorDimension: number;
+        limit: number | undefined;
+    };
+    embedding: {
+        model: string;
+        dimensions: number;
+        usage: {
+            promptTokens: number;
+            totalTokens: number;
+        } | undefined;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: {
+        text: string;
+        indexName: string;
+        embeddingModel?: undefined;
+        vectorDimension?: undefined;
+        limit?: undefined;
+    };
+    results?: undefined;
+    count?: undefined;
+    embedding?: undefined;
+}>;
+/**
+ * Default Neo4j create node with embedding tool instance
+ */
+declare const neo4jCreateNodeWithEmbedding: _agentforge_core.Tool<{
+    properties: Record<string, any>;
+    label: string;
+    textProperty: string;
+    database?: string | undefined;
+    model?: string | undefined;
+    embeddingProperty?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    node?: undefined;
+    nodeId?: undefined;
+    embedding?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    node: any;
+    nodeId: any;
+    embedding: {
+        model: string;
+        dimensions: number;
+        property: string;
+        usage: {
+            promptTokens: number;
+            totalTokens: number;
+        } | undefined;
+    };
+    message: string;
+    error?: undefined;
+}>;
+/**
+ * All Neo4j tools (including embedding-enabled tools)
+ */
+declare const neo4jTools: (_agentforge_core.Tool<{
+    cypher: string;
+    parameters?: Record<string, any> | undefined;
+    database?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    data?: undefined;
+    recordCount?: undefined;
+    summary?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    data: any[];
+    recordCount: number;
+    summary: {
+        query: string;
+        parameters: Record<string, any> | undefined;
+        counters: {
+            nodesCreated: number;
+            nodesDeleted: number;
+            relationshipsCreated: number;
+            relationshipsDeleted: number;
+            propertiesSet: number;
+        };
+    };
+    error?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: string;
+    data?: undefined;
+    recordCount?: undefined;
+    summary?: undefined;
+}> | _agentforge_core.Tool<{
+    database?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    schema?: undefined;
+    summary?: undefined;
+} | {
+    success: boolean;
+    schema: {
+        nodeLabels: any[];
+        relationshipTypes: any[];
+        propertyKeys: any[];
+        constraints: {
+            name: any;
+            type: any;
+            entityType: any;
+            labelsOrTypes: any;
+            properties: any;
+        }[];
+        indexes: {
+            name: any;
+            type: any;
+            entityType: any;
+            labelsOrTypes: any;
+            properties: any;
+        }[];
+    };
+    summary: {
+        totalLabels: number;
+        totalRelationshipTypes: number;
+        totalPropertyKeys: number;
+        totalConstraints: number;
+        totalIndexes: number;
+    };
+    error?: undefined;
+}> | _agentforge_core.Tool<{
+    label: string;
+    limit?: number | undefined;
+    properties?: Record<string, any> | undefined;
+    database?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    nodes?: undefined;
+    count?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    nodes: any[];
+    count: number;
+    query: {
+        label: string;
+        properties: Record<string, any> | undefined;
+        limit: number | undefined;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: {
+        label: string;
+        properties: Record<string, any> | undefined;
+        limit?: undefined;
+    };
+    nodes?: undefined;
+    count?: undefined;
+}> | _agentforge_core.Tool<{
+    startNodeId: string | number;
+    limit?: number | undefined;
+    database?: string | undefined;
+    relationshipType?: string | undefined;
+    direction?: "outgoing" | "incoming" | "both" | undefined;
+    maxDepth?: number | undefined;
+}, {
+    success: boolean;
+    error: string;
+    paths?: undefined;
+    count?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    paths: {
+        start: any;
+        end: any;
+        relationships: any;
+        depth: any;
+    }[];
+    count: number;
+    query: {
+        startNodeId: string | number;
+        relationshipType: string | undefined;
+        direction: "outgoing" | "incoming" | "both" | undefined;
+        maxDepth: number | undefined;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: {
+        startNodeId: string | number;
+        relationshipType: string | undefined;
+        direction: "outgoing" | "incoming" | "both" | undefined;
+        maxDepth?: undefined;
+    };
+    paths?: undefined;
+    count?: undefined;
+}> | _agentforge_core.Tool<{
+    indexName: string;
+    queryVector: number[];
+    limit?: number | undefined;
+    database?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    results?: undefined;
+    count?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    results: {
+        node: any;
+        score: any;
+    }[];
+    count: number;
+    query: {
+        indexName: string;
+        vectorDimension: number;
+        limit: number | undefined;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: {
+        indexName: string;
+        vectorDimension: number;
+        limit?: undefined;
+    };
+    results?: undefined;
+    count?: undefined;
+}> | _agentforge_core.Tool<{
+    indexName: string;
+    queryText: string;
+    limit?: number | undefined;
+    database?: string | undefined;
+    model?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    results?: undefined;
+    count?: undefined;
+    query?: undefined;
+    embedding?: undefined;
+} | {
+    success: boolean;
+    results: {
+        node: any;
+        score: any;
+    }[];
+    count: number;
+    query: {
+        text: string;
+        indexName: string;
+        embeddingModel: string;
+        vectorDimension: number;
+        limit: number | undefined;
+    };
+    embedding: {
+        model: string;
+        dimensions: number;
+        usage: {
+            promptTokens: number;
+            totalTokens: number;
+        } | undefined;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: {
+        text: string;
+        indexName: string;
+        embeddingModel?: undefined;
+        vectorDimension?: undefined;
+        limit?: undefined;
+    };
+    results?: undefined;
+    count?: undefined;
+    embedding?: undefined;
+}> | _agentforge_core.Tool<{
+    properties: Record<string, any>;
+    label: string;
+    textProperty: string;
+    database?: string | undefined;
+    model?: string | undefined;
+    embeddingProperty?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    node?: undefined;
+    nodeId?: undefined;
+    embedding?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    node: any;
+    nodeId: any;
+    embedding: {
+        model: string;
+        dimensions: number;
+        property: string;
+        usage: {
+            promptTokens: number;
+            totalTokens: number;
+        } | undefined;
+    };
+    message: string;
+    error?: undefined;
+}>)[];
+/**
+ * Core Neo4j tools (without embedding features)
+ */
+declare const neo4jCoreTools: (_agentforge_core.Tool<{
+    cypher: string;
+    parameters?: Record<string, any> | undefined;
+    database?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    data?: undefined;
+    recordCount?: undefined;
+    summary?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    data: any[];
+    recordCount: number;
+    summary: {
+        query: string;
+        parameters: Record<string, any> | undefined;
+        counters: {
+            nodesCreated: number;
+            nodesDeleted: number;
+            relationshipsCreated: number;
+            relationshipsDeleted: number;
+            propertiesSet: number;
+        };
+    };
+    error?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: string;
+    data?: undefined;
+    recordCount?: undefined;
+    summary?: undefined;
+}> | _agentforge_core.Tool<{
+    database?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    schema?: undefined;
+    summary?: undefined;
+} | {
+    success: boolean;
+    schema: {
+        nodeLabels: any[];
+        relationshipTypes: any[];
+        propertyKeys: any[];
+        constraints: {
+            name: any;
+            type: any;
+            entityType: any;
+            labelsOrTypes: any;
+            properties: any;
+        }[];
+        indexes: {
+            name: any;
+            type: any;
+            entityType: any;
+            labelsOrTypes: any;
+            properties: any;
+        }[];
+    };
+    summary: {
+        totalLabels: number;
+        totalRelationshipTypes: number;
+        totalPropertyKeys: number;
+        totalConstraints: number;
+        totalIndexes: number;
+    };
+    error?: undefined;
+}> | _agentforge_core.Tool<{
+    label: string;
+    limit?: number | undefined;
+    properties?: Record<string, any> | undefined;
+    database?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    nodes?: undefined;
+    count?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    nodes: any[];
+    count: number;
+    query: {
+        label: string;
+        properties: Record<string, any> | undefined;
+        limit: number | undefined;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: {
+        label: string;
+        properties: Record<string, any> | undefined;
+        limit?: undefined;
+    };
+    nodes?: undefined;
+    count?: undefined;
+}> | _agentforge_core.Tool<{
+    startNodeId: string | number;
+    limit?: number | undefined;
+    database?: string | undefined;
+    relationshipType?: string | undefined;
+    direction?: "outgoing" | "incoming" | "both" | undefined;
+    maxDepth?: number | undefined;
+}, {
+    success: boolean;
+    error: string;
+    paths?: undefined;
+    count?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    paths: {
+        start: any;
+        end: any;
+        relationships: any;
+        depth: any;
+    }[];
+    count: number;
+    query: {
+        startNodeId: string | number;
+        relationshipType: string | undefined;
+        direction: "outgoing" | "incoming" | "both" | undefined;
+        maxDepth: number | undefined;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: {
+        startNodeId: string | number;
+        relationshipType: string | undefined;
+        direction: "outgoing" | "incoming" | "both" | undefined;
+        maxDepth?: undefined;
+    };
+    paths?: undefined;
+    count?: undefined;
+}> | _agentforge_core.Tool<{
+    indexName: string;
+    queryVector: number[];
+    limit?: number | undefined;
+    database?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    results?: undefined;
+    count?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    results: {
+        node: any;
+        score: any;
+    }[];
+    count: number;
+    query: {
+        indexName: string;
+        vectorDimension: number;
+        limit: number | undefined;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: {
+        indexName: string;
+        vectorDimension: number;
+        limit?: undefined;
+    };
+    results?: undefined;
+    count?: undefined;
+}>)[];
+/**
+ * Create Neo4j tools with custom configuration
+ */
+declare function createNeo4jTools(config?: Neo4jToolsConfig, includeEmbeddingTools?: boolean): (_agentforge_core.Tool<{
+    cypher: string;
+    parameters?: Record<string, any> | undefined;
+    database?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    data?: undefined;
+    recordCount?: undefined;
+    summary?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    data: any[];
+    recordCount: number;
+    summary: {
+        query: string;
+        parameters: Record<string, any> | undefined;
+        counters: {
+            nodesCreated: number;
+            nodesDeleted: number;
+            relationshipsCreated: number;
+            relationshipsDeleted: number;
+            propertiesSet: number;
+        };
+    };
+    error?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: string;
+    data?: undefined;
+    recordCount?: undefined;
+    summary?: undefined;
+}> | _agentforge_core.Tool<{
+    database?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    schema?: undefined;
+    summary?: undefined;
+} | {
+    success: boolean;
+    schema: {
+        nodeLabels: any[];
+        relationshipTypes: any[];
+        propertyKeys: any[];
+        constraints: {
+            name: any;
+            type: any;
+            entityType: any;
+            labelsOrTypes: any;
+            properties: any;
+        }[];
+        indexes: {
+            name: any;
+            type: any;
+            entityType: any;
+            labelsOrTypes: any;
+            properties: any;
+        }[];
+    };
+    summary: {
+        totalLabels: number;
+        totalRelationshipTypes: number;
+        totalPropertyKeys: number;
+        totalConstraints: number;
+        totalIndexes: number;
+    };
+    error?: undefined;
+}> | _agentforge_core.Tool<{
+    label: string;
+    limit?: number | undefined;
+    properties?: Record<string, any> | undefined;
+    database?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    nodes?: undefined;
+    count?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    nodes: any[];
+    count: number;
+    query: {
+        label: string;
+        properties: Record<string, any> | undefined;
+        limit: number | undefined;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: {
+        label: string;
+        properties: Record<string, any> | undefined;
+        limit?: undefined;
+    };
+    nodes?: undefined;
+    count?: undefined;
+}> | _agentforge_core.Tool<{
+    startNodeId: string | number;
+    limit?: number | undefined;
+    database?: string | undefined;
+    relationshipType?: string | undefined;
+    direction?: "outgoing" | "incoming" | "both" | undefined;
+    maxDepth?: number | undefined;
+}, {
+    success: boolean;
+    error: string;
+    paths?: undefined;
+    count?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    paths: {
+        start: any;
+        end: any;
+        relationships: any;
+        depth: any;
+    }[];
+    count: number;
+    query: {
+        startNodeId: string | number;
+        relationshipType: string | undefined;
+        direction: "outgoing" | "incoming" | "both" | undefined;
+        maxDepth: number | undefined;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: {
+        startNodeId: string | number;
+        relationshipType: string | undefined;
+        direction: "outgoing" | "incoming" | "both" | undefined;
+        maxDepth?: undefined;
+    };
+    paths?: undefined;
+    count?: undefined;
+}> | _agentforge_core.Tool<{
+    indexName: string;
+    queryVector: number[];
+    limit?: number | undefined;
+    database?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    results?: undefined;
+    count?: undefined;
+    query?: undefined;
+} | {
+    success: boolean;
+    results: {
+        node: any;
+        score: any;
+    }[];
+    count: number;
+    query: {
+        indexName: string;
+        vectorDimension: number;
+        limit: number | undefined;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: {
+        indexName: string;
+        vectorDimension: number;
+        limit?: undefined;
+    };
+    results?: undefined;
+    count?: undefined;
+}> | _agentforge_core.Tool<{
+    indexName: string;
+    queryText: string;
+    limit?: number | undefined;
+    database?: string | undefined;
+    model?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    results?: undefined;
+    count?: undefined;
+    query?: undefined;
+    embedding?: undefined;
+} | {
+    success: boolean;
+    results: {
+        node: any;
+        score: any;
+    }[];
+    count: number;
+    query: {
+        text: string;
+        indexName: string;
+        embeddingModel: string;
+        vectorDimension: number;
+        limit: number | undefined;
+    };
+    embedding: {
+        model: string;
+        dimensions: number;
+        usage: {
+            promptTokens: number;
+            totalTokens: number;
+        } | undefined;
+    };
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    query: {
+        text: string;
+        indexName: string;
+        embeddingModel?: undefined;
+        vectorDimension?: undefined;
+        limit?: undefined;
+    };
+    results?: undefined;
+    count?: undefined;
+    embedding?: undefined;
+}> | _agentforge_core.Tool<{
+    properties: Record<string, any>;
+    label: string;
+    textProperty: string;
+    database?: string | undefined;
+    model?: string | undefined;
+    embeddingProperty?: string | undefined;
+}, {
+    success: boolean;
+    error: string;
+    node?: undefined;
+    nodeId?: undefined;
+    embedding?: undefined;
+    message?: undefined;
+} | {
+    success: boolean;
+    node: any;
+    nodeId: any;
+    embedding: {
+        model: string;
+        dimensions: number;
+        property: string;
+        usage: {
+            promptTokens: number;
+            totalTokens: number;
+        } | undefined;
+    };
+    message: string;
+    error?: undefined;
+}>)[];
+/**
+ * Initialize Neo4j tools from environment variables
+ *
+ * Required environment variables:
+ * - NEO4J_URI: Neo4j connection URI (e.g., bolt://localhost:7687)
+ * - NEO4J_USER: Neo4j username
+ * - NEO4J_PASSWORD: Neo4j password
+ *
+ * Optional environment variables:
+ * - NEO4J_DATABASE: Database name (defaults to 'neo4j')
+ *
+ * For embedding-enabled tools, also set:
+ * - OPENAI_API_KEY: OpenAI API key for embedding generation
+ * - EMBEDDING_MODEL: Embedding model to use (defaults to 'text-embedding-3-small')
+ * - EMBEDDING_PROVIDER: Embedding provider (defaults to 'openai')
+ */
+declare function initializeNeo4jTools(): Promise<void>;
+
+/**
+ * Shared types for relational database operations
+ * @module types
+ */
+
+/**
+ * Supported database vendors
+ */
+type DatabaseVendor = 'postgresql' | 'mysql' | 'sqlite';
+/**
+ * Database connection configuration
+ */
+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;
+    };
+}
+/**
+ * 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
+ */
+interface QueryMetadata {
+    /** Number of rows affected */
+    rowCount?: number;
+    /** Execution time in milliseconds */
+    executionTime?: number;
+    /** Additional vendor-specific metadata */
+    [key: string]: unknown;
+}
+/**
+ * Query result with data and metadata
+ */
+interface QueryResult<T = unknown> {
+    /** Query result data */
+    data: T[];
+    /** Query metadata */
+    metadata: QueryMetadata;
+}
+
+/**
+ * Runtime peer dependency checker for database drivers
+ * @module utils/peer-dependency-checker
+ */
+
+/**
+ * Error thrown when a required peer dependency is missing
+ */
+declare class MissingPeerDependencyError extends Error {
+    readonly vendor: DatabaseVendor;
+    readonly packageName: string;
+    constructor(vendor: DatabaseVendor, packageName: string);
+}
+/**
+ * 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;
+/**
+ * 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 getPeerDependencyName(vendor: DatabaseVendor): string;
+/**
+ * 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;
+
+/**
+ * Query execution types for relational databases
+ * @module query/types
+ */
+
+/**
+ * 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>;
+/**
+ * Query execution input
+ */
+interface QueryInput {
+    /** SQL query string */
+    sql: string;
+    /** Query parameters for parameter binding */
+    params?: QueryParams;
+    /** Database vendor */
+    vendor: DatabaseVendor;
+}
+/**
+ * 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;
+}
+/**
+ * Minimal SQL executor abstraction.
+ * Used by ConnectionManager and transaction contexts.
+ */
+interface SqlExecutor {
+    execute(query: SQL): Promise<unknown>;
+}
+
+/**
+ * Connection configuration types for relational databases
+ * @module connection/types
+ */
+
+/**
+ * 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
+ */
+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;
+}
+/**
+ * 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.
+ */
+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;
+}
+/**
+ * Union type for vendor-specific connection configurations
+ */
+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
  */
 /**
- * Create array map tool
+ * 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 function createArrayMapTool(): _agentforge_core.Tool<{
-    array: any[];
-    properties: string[];
+declare const relationalQuery: _agentforge_core.Tool<{
+    connectionString: string;
+    vendor: "postgresql" | "mysql" | "sqlite";
+    sql: string;
+    params?: unknown[] | Record<string, unknown> | undefined;
 }, {
-    mapped: any[];
-    count: number;
+    success: boolean;
+    rows: unknown[];
+    rowCount: number;
+    executionTime: number;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+    rows: never[];
+    rowCount: number;
+    executionTime?: undefined;
 }>;
 
 /**
- * Array Sort Tool
+ * 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;
 /**
- * Create array sort tool
+ * Optional streaming benchmark metadata.
  */
-declare function createArraySortTool(): _agentforge_core.Tool<{
-    array: any[];
-    property: string;
-    order?: "asc" | "desc" | undefined;
-}, {
-    sorted: any[];
-    count: number;
-}>;
-
+type StreamingBenchmarkMetadata = StreamingBenchmarkResult;
 /**
- * Array Group By Tool
+ * Streaming execution metadata.
  */
+interface StreamingMetadata {
+    enabled: true;
+    chunkSize: number;
+    chunkCount: number;
+    sampledRowCount: number;
+    streamedRowCount: number;
+    cancelled: boolean;
+    memoryUsage: StreamingMemoryUsage;
+    benchmark?: StreamingBenchmarkMetadata;
+}
 /**
- * Create array group by tool
+ * Tool success response
  */
-declare function createArrayGroupByTool(): _agentforge_core.Tool<{
-    array: any[];
-    property: string;
-}, {
-    groups: Record<string, any[]>;
-    groupCount: number;
-    totalItems: number;
-}>;
-
+interface SelectSuccessResponse {
+    success: true;
+    rows: unknown[];
+    rowCount: number;
+    executionTime: number;
+    streaming?: StreamingMetadata;
+}
 /**
- * Object Pick Tool
+ * Tool error response
  */
+interface SelectErrorResponse {
+    success: false;
+    error: string;
+    rows: [];
+    rowCount: 0;
+}
 /**
- * Create object pick tool
+ * Tool response (success or error)
  */
-declare function createObjectPickTool(): _agentforge_core.Tool<{
-    object: Record<string, any>;
-    properties: string[];
-}, Record<string, any>>;
+type SelectResponse = SelectSuccessResponse | SelectErrorResponse;
 
 /**
- * Object Omit Tool
+ * 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>;
+
 /**
- * Create object omit tool
+ * Type definitions for relational INSERT operations
+ * @module tools/relational-insert/types
  */
-declare function createObjectOmitTool(): _agentforge_core.Tool<{
-    object: Record<string, any>;
-    properties: string[];
-}, Record<string, any>>;
 
 /**
- * Default array filter tool instance
+ * Batch metadata returned by INSERT execution when batch mode is active.
  */
-declare const arrayFilter: _agentforge_core.Tool<{
-    array: any[];
-    property: string;
-    operator: "equals" | "not-equals" | "greater-than" | "less-than" | "contains" | "starts-with" | "ends-with";
-    value?: any;
-}, {
-    filtered: any[];
-    originalCount: number;
-    filteredCount: number;
-}>;
+interface InsertBatchMetadata {
+    enabled: boolean;
+    batchSize: number;
+    totalItems: number;
+    processedItems: number;
+    successfulItems: number;
+    failedItems: number;
+    totalBatches: number;
+    retries: number;
+    partialSuccess: boolean;
+    failures: BatchFailureDetail[];
+    benchmark?: BatchBenchmarkResult;
+}
 /**
- * Default array map tool instance
+ * Tool success response.
  */
-declare const arrayMap: _agentforge_core.Tool<{
-    array: any[];
-    properties: string[];
-}, {
-    mapped: any[];
-    count: number;
-}>;
+interface InsertSuccessResponse {
+    success: true;
+    rowCount: number;
+    insertedIds: Array<number | string>;
+    rows: unknown[];
+    executionTime: number;
+    batch?: InsertBatchMetadata;
+}
 /**
- * Default array sort tool instance
+ * Tool error response.
  */
-declare const arraySort: _agentforge_core.Tool<{
-    array: any[];
-    property: string;
-    order?: "asc" | "desc" | undefined;
-}, {
-    sorted: any[];
-    count: number;
-}>;
+interface InsertErrorResponse {
+    success: false;
+    error: string;
+    rowCount: 0;
+    insertedIds: [];
+    rows: [];
+}
 /**
- * Default array group by tool instance
+ * Tool response (success or error).
  */
-declare const arrayGroupBy: _agentforge_core.Tool<{
-    array: any[];
-    property: string;
-}, {
-    groups: Record<string, any[]>;
-    groupCount: number;
+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;
+}
 /**
- * Default object pick tool instance
+ * Tool success response.
  */
-declare const objectPick: _agentforge_core.Tool<{
-    object: Record<string, any>;
-    properties: string[];
-}, Record<string, any>>;
+interface UpdateSuccessResponse {
+    success: true;
+    rowCount: number;
+    executionTime: number;
+    batch?: UpdateBatchMetadata;
+}
 /**
- * Default object omit tool instance
+ * Tool error response.
  */
-declare const objectOmit: _agentforge_core.Tool<{
-    object: Record<string, any>;
-    properties: string[];
-}, Record<string, any>>;
+interface UpdateErrorResponse {
+    success: false;
+    error: string;
+    rowCount: 0;
+}
 /**
- * All transformer tools
+ * Tool response (success or error).
  */
-declare const transformerTools: (_agentforge_core.Tool<{
-    array: any[];
-    property: string;
-    operator: "equals" | "not-equals" | "greater-than" | "less-than" | "contains" | "starts-with" | "ends-with";
-    value?: any;
-}, {
-    filtered: any[];
-    originalCount: number;
-    filteredCount: number;
-}> | _agentforge_core.Tool<{
-    array: any[];
-    properties: string[];
-}, {
-    mapped: any[];
-    count: number;
-}> | _agentforge_core.Tool<{
-    array: any[];
-    property: string;
-    order?: "asc" | "desc" | undefined;
-}, {
-    sorted: any[];
-    count: number;
-}> | _agentforge_core.Tool<{
-    array: any[];
-    property: string;
-}, {
-    groups: Record<string, any[]>;
-    groupCount: number;
+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;
-}> | _agentforge_core.Tool<{
-    object: Record<string, any>;
-    properties: string[];
-}, Record<string, any>>)[];
+    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;
+
 /**
- * Create transformer tools with custom configuration
+ * 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
  */
-declare function createTransformerTools(config?: TransformerToolsConfig): (_agentforge_core.Tool<{
-    array: any[];
-    property: string;
-    operator: "equals" | "not-equals" | "greater-than" | "less-than" | "contains" | "starts-with" | "ends-with";
-    value?: any;
-}, {
-    filtered: any[];
-    originalCount: number;
-    filteredCount: number;
-}> | _agentforge_core.Tool<{
-    array: any[];
-    properties: string[];
-}, {
-    mapped: any[];
-    count: number;
-}> | _agentforge_core.Tool<{
-    array: any[];
-    property: string;
-    order?: "asc" | "desc" | undefined;
-}, {
-    sorted: any[];
-    count: number;
-}> | _agentforge_core.Tool<{
-    array: any[];
-    property: string;
-}, {
-    groups: Record<string, any[]>;
-    groupCount: number;
-    totalItems: number;
-}> | _agentforge_core.Tool<{
-    object: Record<string, any>;
-    properties: string[];
-}, Record<string, any>>)[];
+/**
+ * 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
@@ -3381,8 +7098,7 @@ declare const pathNormalizeSchema: z.ZodObject<{
 /**
  * Path utilities configuration
  */
-interface PathUtilitiesConfig {
-}
+type PathUtilitiesConfig = Record<string, never>;
 
 /**
  * Path Join Tool
@@ -3747,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>;
@@ -4152,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;
 }>;
 /**
@@ -4239,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>;
@@ -4272,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;
@@ -4369,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;
@@ -4429,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;
@@ -4487,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;
@@ -4576,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
@@ -4596,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>;
@@ -4660,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;
@@ -4738,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;
@@ -4806,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;
@@ -4876,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;
@@ -4982,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>;
@@ -5369,4 +9081,4 @@ declare const askHumanTool: _agentforge_core.Tool<{
     suggestions?: string[] | undefined;
 }, AskHumanOutput>;
 
-export { type AskHumanInput, AskHumanInputSchema, type AskHumanOutput, type CalculatorInput, CalculatorSchema, type ConfluenceAuth, type ConfluenceToolsConfig, type CreditCardValidatorInput, CreditCardValidatorSchema, type CsvToolsConfig, type CurrentDateTimeInput, CurrentDateTimeSchema, type DateArithmeticInput, DateArithmeticSchema, type DateComparisonInput, DateComparisonSchema, type DateDifferenceInput, DateDifferenceSchema, type DateFormatterInput, DateFormatterSchema, type DateTimeConfig, type DirectoryOperationsConfig, DuckDuckGoProvider, type EmailValidatorInput, EmailValidatorSchema, type FileOperationsConfig, type HtmlParserToolsConfig, HttpMethod, type HttpResponse, type HttpToolsConfig, type IpValidatorInput, IpValidatorSchema, type JsonToolsConfig, type MathFunctionsInput, MathFunctionsSchema, type MathOperationsConfig, 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, 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, extractImages, extractImagesSchema, extractLinks, extractLinksSchema, fileAppend, fileAppendSchema, fileDelete, fileDeleteSchema, fileExists, fileExistsSchema, fileOperationTools, fileReader, fileReaderSchema, fileSearch, fileSearchSchema, fileWriter, fileWriterSchema, getConfluencePage, getSlackChannels, getSlackMessages, getSpacePages, htmlParser, htmlParserSchema, htmlParserTools, httpClient, httpGet, httpGetSchema, httpPost, httpPostSchema, httpRequestSchema, httpTools, ipValidator, jsonMerge, jsonMergeSchema, jsonParser, jsonParserSchema, jsonQuery, jsonQuerySchema, jsonStringify, jsonStringifySchema, jsonToCsv, jsonToCsvSchema, jsonToXml, jsonToXmlSchema, jsonTools, jsonValidator, jsonValidatorSchema, listConfluenceSpaces, mathFunctions, mathOperationTools, notifySlack, objectOmit, objectOmitSchema, objectPick, objectPickSchema, pathBasename, pathBasenameSchema, pathDirname, pathDirnameSchema, pathExtension, pathExtensionSchema, pathJoin, pathJoinSchema, pathNormalize, pathNormalizeSchema, pathParse, pathParseSchema, pathRelative, pathRelativeSchema, pathResolve, pathResolveSchema, pathUtilityTools, phoneValidator, randomNumber, 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, 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 };