@blackbox_ai/blackbox-cli-core 0.0.7 → 0.8.1

package/dist/src/tools/sql_db.js

@@ -0,0 +1,1033 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import pg from 'pg';
+import { MongoClient } from 'mongodb';
+import { createClient } from 'redis';
+import { ToolNames } from './tool-names.js';
+import { ToolErrorType } from './tool-error.js';
+import { BaseDeclarativeTool, BaseToolInvocation, Kind, } from './tools.js';
+async function loadMysqlPromiseModule() {
+    try {
+        // eslint-disable-next-line import/no-internal-modules
+        const mod = await import('mysql2/promise');
+        return mod.default ?? mod;
+    }
+    catch (_error) {
+        const message = _error instanceof Error ? _error.message : String(_error);
+        throw new Error(`MySQL driver failed to load (${message}). ` +
+            `If you don't need MySQL, ignore this. Otherwise reinstall dependencies (mysql2 requires lru.min and seq-queue).`);
+    }
+}
+const CAUTION_PROMPT = `Carefully understand the database and the fields. Make sure you have an accurate understanding of the fields and the values.
+If required, run further queries with 'sql_db_query' to have a full understanding. Run as many query as needed to confirm the results and provide accurate information to the user.
+
+Note: To avoid timeout. Unless explicitly asked, Do not run global count operation.`;
+/**
+ * Singleton database session manager (supports PostgreSQL, MySQL, MongoDB, and Redis)
+ */
+export class SqlSessionManager {
+    pgPool;
+    mysqlPool;
+    mongoClient;
+    mongoDb;
+    redisClient;
+    connectionString;
+    dbType;
+    static instance;
+    constructor() { }
+    static getInstance() {
+        if (!SqlSessionManager.instance) {
+            SqlSessionManager.instance = new SqlSessionManager();
+        }
+        return SqlSessionManager.instance;
+    }
+    async connect(connectionString, dbType, includeSchema = true, mongoDbName) {
+        if (dbType === 'mongodb' && !mongoDbName) {
+            throw new Error('MongoDB database name is required. Get the database name from the user if its not mentioned.Then, try again.');
+        }
+        console.log(`Connecting to ${dbType.toUpperCase()} database...`);
+        if (this.connectionString === connectionString && this.dbType === dbType) {
+            console.log('Reusing existing connection pool');
+            if (!includeSchema) {
+                return {
+                    success: true,
+                    message: 'Already connected to database',
+                };
+            }
+            // Fetch fresh schema
+            try {
+                const schema = await this.fetchSchema(mongoDbName);
+                return {
+                    success: true,
+                    message: 'Already connected to database',
+                    schema,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    message: 'Connected but failed to fetch schema',
+                    error: error instanceof Error ? error.message : String(error),
+                };
+            }
+        }
+        // Close existing connection if different
+        if (this.pgPool || this.mysqlPool || this.mongoClient || this.redisClient) {
+            await this.disconnect();
+        }
+        try {
+            this.dbType = dbType;
+            this.connectionString = connectionString;
+            if (dbType === 'postgres') {
+                this.pgPool = new pg.Pool({
+                    connectionString,
+                    max: 10,
+                    idleTimeoutMillis: 30000,
+                    connectionTimeoutMillis: 10000,
+                });
+                // Test connection
+                const client = await this.pgPool.connect();
+                try {
+                    await client.query('SELECT NOW()');
+                    console.log('PostgreSQL connection successful');
+                }
+                finally {
+                    client.release();
+                }
+            }
+            else if (dbType === 'mysql') {
+                // Parse connection string for MySQL
+                const url = new URL(connectionString);
+                const mysql = (await loadMysqlPromiseModule());
+                this.mysqlPool = mysql.createPool({
+                    host: url.hostname,
+                    port: url.port ? parseInt(url.port, 10) : 3306,
+                    user: url.username,
+                    password: url.password,
+                    database: url.pathname.slice(1), // Remove leading /
+                    waitForConnections: true,
+                    connectionLimit: 10,
+                    queueLimit: 0,
+                    connectTimeout: 10000,
+                });
+                // Test connection
+                const connection = await this.mysqlPool.getConnection();
+                try {
+                    await connection.query('SELECT NOW()');
+                    console.log('MySQL connection successful');
+                }
+                finally {
+                    connection.release();
+                }
+            }
+            else if (dbType === 'mongodb') {
+                // Parse connection string for MongoDB
+                this.mongoClient = new MongoClient(connectionString);
+                await this.mongoClient.connect();
+                // Get database name from connection string or use default
+                const url = new URL(connectionString);
+                const dbName = mongoDbName || url.pathname.slice(1);
+                this.mongoDb = this.mongoClient.db(dbName);
+                // Test connection
+                await this.mongoDb.command({ ping: 1 });
+                console.log('MongoDB connection successful');
+            }
+            else if (dbType === 'redis') {
+                const normalizeRedisUrl = (url, useTls) => {
+                    if (useTls) {
+                        return url.startsWith('redis://')
+                            ? url.replace(/^redis:\/\//, 'rediss://')
+                            : url;
+                    }
+                    return url.startsWith('rediss://')
+                        ? url.replace(/^rediss:\/\//, 'redis://')
+                        : url;
+                };
+                const connectRedis = async (url) => {
+                    const client = createClient({ url });
+                    client.on('error', (error) => {
+                        console.warn(`Redis client error: ${error instanceof Error ? error.message : String(error)}`);
+                    });
+                    await client.connect();
+                    return client;
+                };
+                const primaryUrl = normalizeRedisUrl(connectionString, true);
+                const fallbackUrl = normalizeRedisUrl(connectionString, false);
+                try {
+                    // Try TLS first
+                    this.redisClient = await connectRedis(primaryUrl);
+                }
+                catch (_error) {
+                    if (this.redisClient) {
+                        await this.redisClient.quit().catch(() => { });
+                        this.redisClient = undefined;
+                    }
+                    // Retry without TLS
+                    this.redisClient = await connectRedis(fallbackUrl);
+                }
+                if (!this.redisClient) {
+                    throw new Error('Failed to initialize Redis client');
+                }
+                // Test connection
+                await this.redisClient.ping();
+                console.log('Redis connection successful');
+            }
+            else {
+                throw new Error(`Unsupported database type: ${dbType}`);
+            }
+            if (!includeSchema) {
+                return {
+                    success: true,
+                    message: `Successfully connected to ${dbType.toUpperCase()} database`,
+                };
+            }
+            // Fetch schema information
+            const schema = await this.fetchSchema(mongoDbName);
+            return {
+                success: true,
+                message: `Successfully connected to ${dbType.toUpperCase()} database`,
+                schema,
+            };
+        }
+        catch (error) {
+            const errorMessage = `Failed to connect to database: ${error instanceof Error ? error.message : String(error)}`;
+            console.error(`[Error] ${errorMessage}`);
+            this.pgPool = undefined;
+            this.mysqlPool = undefined;
+            this.connectionString = undefined;
+            this.dbType = undefined;
+            return {
+                success: false,
+                message: errorMessage,
+                error: errorMessage,
+            };
+        }
+    }
+    async fetchSchema(mongoDbName) {
+        if (!this.dbType) {
+            throw new Error('Not connected to database');
+        }
+        if (this.dbType === 'postgres') {
+            return this.fetchPostgresSchema();
+        }
+        else if (this.dbType === 'mysql') {
+            return this.fetchMySQLSchema();
+        }
+        else if (this.dbType === 'mongodb') {
+            return this.fetchMongoDBSchema(mongoDbName);
+        }
+        else if (this.dbType === 'redis') {
+            return this.fetchRedisSchema();
+        }
+        throw new Error(`Unsupported database type for schema fetch: ${this.dbType}`);
+    }
+    async fetchPostgresSchema() {
+        if (!this.pgPool) {
+            throw new Error('Not connected to PostgreSQL database');
+        }
+        const client = await this.pgPool.connect();
+        try {
+            // Get list of tables
+            const tablesResult = await client.query(`SELECT table_name, table_schema 
+         FROM information_schema.tables 
+         WHERE table_schema NOT IN ('pg_catalog', 'information_schema')
+         ORDER BY table_schema, table_name`);
+            const tables = tablesResult.rows;
+            // Get columns for each table
+            const columns = {};
+            for (const table of tables) {
+                const key = `${table.table_schema}.${table.table_name}`;
+                // Get columns
+                const columnsResult = await client.query(`SELECT column_name, data_type, is_nullable
+           FROM information_schema.columns
+           WHERE table_schema = $1 AND table_name = $2
+           ORDER BY ordinal_position`, [table.table_schema, table.table_name]);
+                columns[key] = columnsResult.rows;
+            }
+            return {
+                tables,
+                columns,
+            };
+        }
+        finally {
+            client.release();
+        }
+    }
+    async fetchMySQLSchema() {
+        if (!this.mysqlPool) {
+            throw new Error('Not connected to MySQL database');
+        }
+        const connection = await this.mysqlPool.getConnection();
+        try {
+            // Get current database
+            const [dbResult] = await connection.query('SELECT DATABASE() as db');
+            const dbRows = dbResult;
+            const currentDb = dbRows[0]?.db || '';
+            // Get list of tables
+            const [tablesResult] = await connection.query(`SELECT table_name, table_schema 
+         FROM information_schema.tables 
+         WHERE table_schema = ?
+         ORDER BY table_name`, [currentDb]);
+            const tablesRows = tablesResult;
+            const tables = tablesRows.map((row) => ({
+                table_name: row.table_name || row.TABLE_NAME || '',
+                table_schema: row.table_schema || row.TABLE_SCHEMA || '',
+            }));
+            // Get columns for each table
+            const columns = {};
+            for (const table of tables) {
+                const key = `${table.table_schema}.${table.table_name}`;
+                // Get columns
+                const [columnsResult] = await connection.query(`SELECT column_name, data_type, is_nullable
+           FROM information_schema.columns
+           WHERE table_schema = ? AND table_name = ?
+           ORDER BY ordinal_position`, [table.table_schema, table.table_name]);
+                const columnsRows = columnsResult;
+                columns[key] = columnsRows.map((col) => ({
+                    column_name: col.column_name || col.COLUMN_NAME || '',
+                    data_type: col.data_type || col.DATA_TYPE || '',
+                    is_nullable: col.is_nullable || col.IS_NULLABLE || '',
+                }));
+            }
+            return {
+                tables,
+                columns,
+            };
+        }
+        finally {
+            connection.release();
+        }
+    }
+    async fetchMongoDBSchema(mongoDbName) {
+        if (!this.mongoDb) {
+            throw new Error('Not connected to MongoDB database');
+        }
+        try {
+            if (!this.mongoClient) {
+                throw new Error('MongoDB client is not initialized');
+            }
+            let dbNames = [];
+            if (mongoDbName) {
+                dbNames = [mongoDbName];
+            }
+            else {
+                dbNames = [this.mongoDb.databaseName];
+            }
+            // Sample documents from each collection to infer schema
+            const collections = [];
+            const sampleDocuments = {};
+            for (const dbName of dbNames) {
+                const db = this.mongoClient.db(dbName);
+                const collectionsResult = await db
+                    .listCollections({}, { nameOnly: true, authorizedCollections: true })
+                    .toArray();
+                for (const col of collectionsResult) {
+                    collections.push({
+                        collection_name: col.name,
+                        database_name: dbName,
+                    });
+                }
+                for (const col of collectionsResult) {
+                    const key = `${dbName}.${col.name}`;
+                    // Sample a document to infer fields
+                    const sampleDoc = await db.collection(col.name).findOne();
+                    sampleDocuments[key] = [sampleDoc];
+                }
+            }
+            return {
+                tables: [],
+                collections,
+                sampleDocuments,
+            };
+        }
+        catch (error) {
+            console.error('Error fetching MongoDB schema:', error);
+            throw error;
+        }
+    }
+    async fetchRedisSchema() {
+        if (!this.redisClient) {
+            throw new Error('Not connected to Redis database');
+        }
+        try {
+            // Redis doesn't have a traditional schema
+            // We'll scan for a minimal sample of keys and get their types
+            const keyInfo = [];
+            const limitPerType = 3;
+            const maxScans = 20;
+            const maxSamples = limitPerType * 6;
+            const typeCounts = {};
+            let cursor = 0;
+            let scans = 0;
+            while (scans < maxScans && keyInfo.length < maxSamples) {
+                const scanResult = await this.redisClient.scan(cursor, {
+                    MATCH: '*',
+                    COUNT: 200,
+                });
+                cursor = scanResult.cursor;
+                scans += 1;
+                for (const key of scanResult.keys) {
+                    const type = await this.redisClient.type(key);
+                    const count = typeCounts[type] || 0;
+                    if (count >= limitPerType) {
+                        continue;
+                    }
+                    keyInfo.push({ key, type });
+                    typeCounts[type] = count + 1;
+                    if (keyInfo.length >= maxSamples) {
+                        break;
+                    }
+                }
+                if (cursor === 0) {
+                    break;
+                }
+            }
+            // Group by type
+            const typeGroups = {};
+            for (const info of keyInfo) {
+                typeGroups[info.type] = (typeGroups[info.type] || 0) + 1;
+            }
+            const redisKeys = [];
+            for (const type of Object.keys(typeGroups)) {
+                const keys = keyInfo.filter((k) => k.type === type).slice(0, limitPerType).map((k) => k.key);
+                for (const key of keys) {
+                    try {
+                        let values = [];
+                        if (type === 'string') {
+                            const value = await this.redisClient.get(key);
+                            values = value === null ? [] : [value];
+                        }
+                        else if (type === 'hash') {
+                            const value = await this.redisClient.hGetAll(key);
+                            const entries = Object.entries(value).slice(0, 3);
+                            values = [Object.fromEntries(entries)];
+                        }
+                        else if (type === 'list') {
+                            values = await this.redisClient.lRange(key, 0, 2);
+                        }
+                        else if (type === 'set') {
+                            values = (await this.redisClient.sMembers(key)).slice(0, 3);
+                        }
+                        else if (type === 'zset') {
+                            values = await this.redisClient.zRange(key, 0, 2);
+                        }
+                        else if (type === 'stream') {
+                            values = await this.redisClient.xRange(key, '-', '+', { COUNT: 3 });
+                        }
+                        redisKeys.push({ key, type, values });
+                    }
+                    catch (_) {
+                        redisKeys.push({ key, type, values: [] });
+                    }
+                }
+            }
+            return {
+                tables: [],
+                redisKeys,
+            };
+        }
+        catch (error) {
+            console.error('Error fetching Redis schema:', error);
+            throw error;
+        }
+    }
+    async query(sql) {
+        if (!this.dbType) {
+            return {
+                success: false,
+                message: 'Not connected to database. Please connect first using sql_db_connect.',
+                error: 'No active database connection',
+            };
+        }
+        if (this.dbType === 'postgres') {
+            return this.queryPostgres(sql);
+        }
+        else if (this.dbType === 'mysql') {
+            return this.queryMySQL(sql);
+        }
+        else if (this.dbType === 'mongodb') {
+            return this.queryMongoDB(sql);
+        }
+        else if (this.dbType === 'redis') {
+            return this.queryRedis(sql);
+        }
+        return {
+            success: false,
+            message: `Unsupported database type for queries: ${this.dbType}`,
+            error: `Unsupported database type: ${this.dbType}`,
+        };
+    }
+    async queryPostgres(sql) {
+        if (!this.pgPool) {
+            return {
+                success: false,
+                message: 'Not connected to PostgreSQL database.',
+                error: 'No active database connection',
+            };
+        }
+        const client = await this.pgPool.connect();
+        try {
+            console.log('Executing readonly query on PostgreSQL...');
+            // Start a readonly transaction
+            await client.query('BEGIN TRANSACTION READ ONLY');
+            try {
+                const result = await client.query(sql);
+                await client.query('COMMIT');
+                console.log(`Query executed successfully, returned ${result.rowCount} rows`);
+                return {
+                    success: true,
+                    message: `Query executed successfully, returned ${result.rowCount || 0} rows`,
+                    rows: result.rows,
+                    rowCount: result.rowCount || 0,
+                };
+            }
+            catch (queryError) {
+                await client.query('ROLLBACK').catch(() => { });
+                throw queryError;
+            }
+        }
+        catch (error) {
+            const errorMessage = `Query execution failed: ${error instanceof Error ? error.message : String(error)}`;
+            console.error(`[Error] ${errorMessage}`);
+            return {
+                success: false,
+                message: errorMessage,
+                error: errorMessage,
+            };
+        }
+        finally {
+            client.release();
+        }
+    }
+    async queryMySQL(sql) {
+        if (!this.mysqlPool) {
+            return {
+                success: false,
+                message: 'Not connected to MySQL database.',
+                error: 'No active database connection',
+            };
+        }
+        const connection = await this.mysqlPool.getConnection();
+        try {
+            console.log('Executing readonly query on MySQL...');
+            // Start a readonly transaction
+            await connection.query('START TRANSACTION READ ONLY');
+            try {
+                const [rows] = await connection.query(sql);
+                await connection.query('COMMIT');
+                const rowsArray = Array.isArray(rows) ? rows : [];
+                console.log(`Query executed successfully, returned ${rowsArray.length} rows`);
+                return {
+                    success: true,
+                    message: `Query executed successfully, returned ${rowsArray.length} rows`,
+                    rows: rowsArray,
+                    rowCount: rowsArray.length,
+                };
+            }
+            catch (queryError) {
+                await connection.query('ROLLBACK').catch(() => { });
+                throw queryError;
+            }
+        }
+        catch (error) {
+            const errorMessage = `Query execution failed: ${error instanceof Error ? error.message : String(error)}`;
+            console.error(`[Error] ${errorMessage}`);
+            return {
+                success: false,
+                message: errorMessage,
+                error: errorMessage,
+            };
+        }
+        finally {
+            connection.release();
+        }
+    }
+    async queryMongoDB(queryString) {
+        if (!this.mongoDb) {
+            return {
+                success: false,
+                message: 'Not connected to MongoDB database.',
+                error: 'No active database connection',
+            };
+        }
+        try {
+            console.log('Executing query on MongoDB...');
+            // Parse the query string as JSON
+            // Expected format: { "collection": "collectionName", "operation": "find", "query": {...}, "options": {...} }
+            const queryObj = JSON.parse(queryString);
+            if (!queryObj.collection) {
+                throw new Error('Missing "collection" field in query');
+            }
+            const collection = this.mongoDb.collection(queryObj.collection);
+            const operation = queryObj.operation || 'find';
+            const query = queryObj.query || {};
+            const options = queryObj.options || {};
+            let rows = [];
+            if (operation === 'find') {
+                const limit = options.limit || 100; // Default limit
+                rows = await collection.find(query).limit(limit).toArray();
+            }
+            else if (operation === 'aggregate') {
+                const pipeline = Array.isArray(queryObj.query)
+                    ? queryObj.query
+                    : Array.isArray(queryObj.pipeline)
+                        ? queryObj.pipeline
+                        : [];
+                rows = await collection.aggregate(pipeline, options).toArray();
+            }
+            else if (operation === 'count' || operation === 'countDocuments') {
+                const count = await collection.countDocuments(query);
+                rows = [{ count }];
+            }
+            else if (operation === 'distinct') {
+                const field = queryObj.field;
+                if (!field) {
+                    throw new Error('Missing "field" for distinct operation');
+                }
+                const distinctValues = await collection.distinct(field, query);
+                rows = distinctValues.map((value) => ({ value }));
+            }
+            else {
+                throw new Error(`Unsupported MongoDB operation: ${operation}`);
+            }
+            console.log(`Query executed successfully, returned ${rows.length} documents`);
+            return {
+                success: true,
+                message: `Query executed successfully, returned ${rows.length} documents`,
+                rows,
+                rowCount: rows.length,
+            };
+        }
+        catch (error) {
+            const errorMessage = `Query execution failed: ${error instanceof Error ? error.message : String(error)}`;
+            console.error(`[Error] ${errorMessage}`);
+            return {
+                success: false,
+                message: errorMessage,
+                error: errorMessage,
+            };
+        }
+    }
+    async queryRedis(commandString) {
+        if (!this.redisClient) {
+            return {
+                success: false,
+                message: 'Not connected to Redis database.',
+                error: 'No active database connection',
+            };
+        }
+        try {
+            console.log('Executing command on Redis...');
+            // Parse the command string as JSON
+            // Expected format: { "command": "GET", "args": ["key"] }
+            const commandObj = JSON.parse(commandString);
+            if (!commandObj.command) {
+                throw new Error('Missing "command" field in query');
+            }
+            const command = commandObj.command.toLowerCase();
+            const args = commandObj.args || [];
+            let result;
+            let rows = [];
+            // Execute common Redis commands
+            if (command === 'get') {
+                result = await this.redisClient.get(args[0]);
+                rows = [{ key: args[0], value: result }];
+            }
+            else if (command === 'mget') {
+                result = await this.redisClient.mGet(args);
+                rows = args.map((key, index) => ({ key, value: result[index] }));
+            }
+            else if (command === 'keys') {
+                const keys = await this.redisClient.keys(args[0] || '*');
+                rows = keys.slice(0, 100).map((key) => ({ key })); // Limit to 100
+            }
+            else if (command === 'scan') {
+                const cursor = parseInt(args[0] || '0', 10);
+                const pattern = args[1] || '*';
+                const count = parseInt(args[2] || '10', 10);
+                const scanResult = await this.redisClient.scan(cursor, { MATCH: pattern, COUNT: count });
+                rows = [{ cursor: scanResult.cursor, keys: scanResult.keys }];
+            }
+            else if (command === 'hgetall') {
+                result = await this.redisClient.hGetAll(args[0]);
+                rows = Object.entries(result).map(([field, value]) => ({ field, value }));
+            }
+            else if (command === 'lrange') {
+                const start = parseInt(args[1] || '0', 10);
+                const stop = parseInt(args[2] || '-1', 10);
+                result = await this.redisClient.lRange(args[0], start, stop);
+                rows = result.map((value, index) => ({ index: start + index, value }));
+            }
+            else if (command === 'smembers') {
+                result = await this.redisClient.sMembers(args[0]);
+                rows = result.map((value) => ({ value }));
+            }
+            else if (command === 'zrange') {
+                const start = parseInt(args[1] || '0', 10);
+                const stop = parseInt(args[2] || '-1', 10);
+                result = await this.redisClient.zRange(args[0], start, stop);
+                rows = result.map((value, index) => ({ index: start + index, value }));
+            }
+            else if (command === 'ttl') {
+                result = await this.redisClient.ttl(args[0]);
+                rows = [{ key: args[0], ttl: result }];
+            }
+            else if (command === 'type') {
+                result = await this.redisClient.type(args[0]);
+                rows = [{ key: args[0], type: result }];
+            }
+            else {
+                throw new Error(`Unsupported Redis command: ${command}. Use common read commands like GET, KEYS, HGETALL, LRANGE, etc.`);
+            }
+            console.log(`Command executed successfully, returned ${rows.length} results`);
+            return {
+                success: true,
+                message: `Command executed successfully, returned ${rows.length} results`,
+                rows,
+                rowCount: rows.length,
+            };
+        }
+        catch (error) {
+            const errorMessage = `Command execution failed: ${error instanceof Error ? error.message : String(error)}`;
+            console.error(`[Error] ${errorMessage}`);
+            return {
+                success: false,
+                message: errorMessage,
+                error: errorMessage,
+            };
+        }
+    }
+    async disconnect() {
+        if (this.pgPool) {
+            console.log('Closing PostgreSQL connection pool...');
+            try {
+                await this.pgPool.end();
+                console.log('PostgreSQL connection pool closed successfully');
+            }
+            catch (error) {
+                console.warn(`Error closing PostgreSQL connection pool: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (this.mysqlPool) {
+            console.log('Closing MySQL connection pool...');
+            try {
+                await this.mysqlPool.end();
+                console.log('MySQL connection pool closed successfully');
+            }
+            catch (error) {
+                console.warn(`Error closing MySQL connection pool: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (this.mongoClient) {
+            console.log('Closing MongoDB connection...');
+            try {
+                await this.mongoClient.close();
+                console.log('MongoDB connection closed successfully');
+            }
+            catch (error) {
+                console.warn(`Error closing MongoDB connection: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (this.redisClient) {
+            console.log('Closing Redis connection...');
+            try {
+                await this.redisClient.quit();
+                console.log('Redis connection closed successfully');
+            }
+            catch (error) {
+                console.warn(`Error closing Redis connection: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        this.pgPool = undefined;
+        this.mysqlPool = undefined;
+        this.mongoClient = undefined;
+        this.mongoDb = undefined;
+        this.redisClient = undefined;
+        this.connectionString = undefined;
+        this.dbType = undefined;
+    }
+    isConnected() {
+        return !!(this.pgPool || this.mysqlPool || this.mongoClient || this.redisClient);
+    }
+    getDatabaseType() {
+        return this.dbType;
+    }
+}
+class SqlDbConnectToolInvocation extends BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    getDescription() {
+        return `Connecting to ${this.params.type.toUpperCase()} database`;
+    }
+    async execute() {
+        const session = SqlSessionManager.getInstance();
+        const connectionString = this.params.connectionString || process.env['DB_CONNECTION_URI'];
+        if (!connectionString) {
+            return {
+                llmContent: 'DB_CONNECTION_URI is not configured. Run `/db configure` to set it, then retry this request.',
+                returnDisplay: 'DB_CONNECTION_URI is not configured. Run /db configure and try again.',
+            };
+        }
+        if (this.params.type === 'postgres') {
+            try {
+                const url = new URL(connectionString);
+                if (!url.pathname || url.pathname === '/' || url.pathname === '') {
+                    return {
+                        llmContent: 'PostgreSQL connection URI is missing a database name (path). Ask the user the name of DB and try again. ',
+                        returnDisplay: 'PostgreSQL connection URI missing database name. Ask the user the name of DB and try again',
+                    };
+                }
+            }
+            catch {
+                // If parsing fails, let the underlying connection attempt surface details.
+            }
+        }
+        const result = await session.connect(connectionString, this.params.type, this.params.includeSchema ?? true, this.params.mongoDbName ?? undefined);
+        const maxSchemaTokens = 50000 * 3;
+        console.log('[SqlDbConnectTool] Connection completed', {
+            success: result.success,
+            dbType: this.params.type,
+            tableCount: result.schema?.tables.length || 0,
+        });
+        if (!result.success) {
+            return {
+                llmContent: result.message,
+                returnDisplay: result.message,
+                error: {
+                    message: result.error || result.message,
+                    type: ToolErrorType.SQL_CONNECTION_ERROR,
+                },
+            };
+        }
+        // Format schema information for LLM
+        let schemaInfo = `${result.message}\n\n`;
+        if (result.schema) {
+            schemaInfo += `Found ${result.schema.tables.length} tables:\n\n`;
+            for (const table of result.schema.tables) {
+                const key = `${table.table_schema}.${table.table_name}`;
+                const columns = result.schema.columns?.[key] || [];
+                schemaInfo += `**${key}**\n`;
+                schemaInfo += `Columns (${columns.length}):\n`;
+                for (const col of columns) {
+                    schemaInfo += `  - ${col.column_name}: ${col.data_type}${col.is_nullable === 'NO' ? ' NOT NULL' : ''}\n`;
+                }
+                schemaInfo += `\n`;
+            }
+            if (result.schema.tables.length > 0) {
+                schemaInfo += `\n\n ${CAUTION_PROMPT}`;
+            }
+            if (result.schema.collections) {
+                schemaInfo += `Collections (${result.schema.collections.length}):\n\n`;
+                for (const col of result.schema.collections) {
+                    schemaInfo += `  - ${col.collection_name} in ${col.database_name}\n`;
+                }
+                schemaInfo += '\n';
+            }
+            if (result.schema.sampleDocuments) {
+                schemaInfo += `Sample documents:\n\n`;
+                for (const key in result.schema.sampleDocuments) {
+                    const doc = result.schema.sampleDocuments[key];
+                    schemaInfo += `  - Collection: ${key}\n`;
+                    schemaInfo += `    - Sample Document: ${JSON.stringify(doc)}\n`;
+                }
+                schemaInfo += `\n\n ${CAUTION_PROMPT}`;
+            }
+            if (result.schema.redisKeys) {
+                schemaInfo += `Redis keys:\n\n`;
+                for (const key of result.schema.redisKeys) {
+                    schemaInfo += `  - Key: ${key.key}\n`;
+                    schemaInfo += `    - Type: ${key.type}\n`;
+                    schemaInfo += `    - Values: ${JSON.stringify(key.values)}\n`;
+                }
+                schemaInfo += `\n\n ${CAUTION_PROMPT}`;
+            }
+        }
+        // truncate the schema info to 50000 tokens
+        if (schemaInfo.length > maxSchemaTokens) {
+            schemaInfo = schemaInfo.slice(0, maxSchemaTokens) + '\n\n... [truncated]';
+            schemaInfo += '\n\n[Schema truncated to prevent context overflow. Use sql_db_query to get more data as needed.]';
+        }
+        return {
+            llmContent: schemaInfo,
+            returnDisplay: result.message,
+        };
+    }
+}
+export class SqlDbConnectTool extends BaseDeclarativeTool {
+    config;
+    static Name = ToolNames.SQL_DB_CONNECT;
+    // @ts-expect-error - Required by base class pattern
+    constructor(config) {
+        super(SqlDbConnectTool.Name, 'SqlDbConnect', 'Connects to a database (PostgreSQL, MySQL, MongoDB, or Redis) and returns the schema details. The connection persists for subsequent queries. Connection string formats: postgresql://user:password@host:port/database, mysql://user:password@host:port/database, mongodb://user:password@host:port/database, redis://user:password@host:port/database', Kind.Execute, {
+            type: 'object',
+            properties: {
+                connectionString: {
+                    type: 'string',
+                    description: 'Database connection string. If omitted, DB_CONNECTION_URI environment variable will be used.',
+                },
+                type: {
+                    type: 'string',
+                    enum: ['postgres', 'mysql', 'mongodb', 'redis'],
+                    description: 'Database type: "postgres", "mysql", "mongodb", or "redis"',
+                },
+                mongoDbName: {
+                    type: 'string',
+                    description: 'MongoDB database name to connect to (required for MongoDB type). If not provided, assume the current database.',
+                },
+                includeSchema: {
+                    type: 'boolean',
+                    description: 'Whether to fetch and return database schema information (default: true)',
+                },
+            },
+            required: ['type'],
+        }, true);
+        this.config = config;
+    }
+    validateToolParamValues(params) {
+        const connectionString = params.connectionString?.trim() || process.env['DB_CONNECTION_URI'];
+        if (!connectionString) {
+            return 'DB_CONNECTION_URI is not set. Run /db configure or provide connectionString.';
+        }
+        if (!params.type) {
+            return 'Database type parameter is required (postgres, mysql, mongodb, or redis)';
+        }
+        const validTypes = ['postgres', 'mysql', 'mongodb', 'redis'];
+        if (!validTypes.includes(params.type)) {
+            return `Database type must be one of: ${validTypes.join(', ')}`;
+        }
+        // Basic validation based on type
+        if (params.type === 'postgres') {
+            if (!connectionString.startsWith('postgres://') &&
+                !connectionString.startsWith('postgresql://')) {
+                return 'PostgreSQL connection string must start with postgresql:// or postgres://';
+            }
+        }
+        else if (params.type === 'mysql') {
+            if (!connectionString.startsWith('mysql://')) {
+                return 'MySQL connection string must start with mysql://';
+            }
+        }
+        else if (params.type === 'mongodb') {
+            if (!connectionString.startsWith('mongodb://') &&
+                !connectionString.startsWith('mongodb+srv://')) {
+                return 'MongoDB connection string must start with mongodb:// or mongodb+srv://';
+            }
+        }
+        else if (params.type === 'redis') {
+            if (!connectionString.startsWith('redis://') &&
+                !connectionString.startsWith('rediss://')) {
+                return 'Redis connection string must start with redis:// or rediss://';
+            }
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new SqlDbConnectToolInvocation(params);
+    }
+}
+class SqlDbQueryToolInvocation extends BaseToolInvocation {
+    constructor(params) {
+        super(params);
+    }
+    getDescription() {
+        const preview = this.params.sql.length > 100
+            ? this.params.sql.substring(0, 100) + '...'
+            : this.params.sql;
+        return `Executing query: ${preview}`;
+    }
+    async execute() {
+        const session = SqlSessionManager.getInstance();
+        if (!session.isConnected()) {
+            return {
+                llmContent: 'Not connected to database. Please use sql_db_connect first.',
+                returnDisplay: 'Not connected to database',
+                error: {
+                    message: 'No active database connection',
+                    type: ToolErrorType.SQL_CONNECTION_ERROR,
+                },
+            };
+        }
+        const maxResultTokens = 50000 * 3;
+        const result = await session.query(this.params.sql);
+        const dbType = session.getDatabaseType();
+        console.log('[SqlDbQueryTool] Query completed', {
+            success: result.success,
+            dbType,
+            rowCount: result.rowCount || 0,
+        });
+        if (!result.success) {
+            return {
+                llmContent: result.message,
+                returnDisplay: result.message,
+                error: {
+                    message: result.error || result.message,
+                    type: ToolErrorType.SQL_QUERY_ERROR,
+                },
+            };
+        }
+        // Format results for LLM
+        let output = `${result.message}\n\n`;
+        if (result.rows && result.rows.length > 0) {
+            // Show results as formatted JSON
+            output += '```json\n';
+            output += JSON.stringify(result.rows, null, 2);
+            output += '\n```\n';
+            // truncate the json to 50000 tokens
+            if (output.length > maxResultTokens) {
+                output = output.slice(0, maxResultTokens) + '\n\n... [truncated]';
+                output += '\n\n[Result truncated to prevent context overflow. To see more results, use a more specific query.]';
+            }
+            else {
+                output += `\n(Showing all ${result.rowCount} rows)\n`;
+            }
+        }
+        else {
+            output += 'No rows returned.\n';
+        }
+        output += `\n\n Note: Now analyze and think through the results to decide the next steps to respond to the user's request accurately. If necessary, use sql_db_query to get more data as needed for better analysis.`;
+        return {
+            llmContent: output.trim(),
+            returnDisplay: result.message,
+        };
+    }
+}
+export class SqlDbQueryTool extends BaseDeclarativeTool {
+    config;
+    static Name = ToolNames.SQL_DB_QUERY;
+    // @ts-expect-error - Required by base class pattern
+    constructor(config) {
+        super(SqlDbQueryTool.Name, 'SqlDbQuery', 'Executes a query on the connected database. For SQL databases (PostgreSQL/MySQL): use SQL SELECT statements. For MongoDB: use JSON format {"collection":"name","operation":"find","query":{...}}. For Redis: use JSON format {"command":"GET","args":["key"]}. SQL queries run in READ ONLY mode.', Kind.Execute, {
+            type: 'object',
+            properties: {
+                sql: {
+                    type: 'string',
+                    description: 'The query to execute. For SQL: SELECT statements. For MongoDB: JSON with collection, operation (find/aggregate/count/distinct), query, options. For Redis: JSON with command (GET/KEYS/HGETALL/LRANGE/etc) and args array.',
+                },
+            },
+            required: ['sql'],
+        }, true);
+        this.config = config;
+    }
+    validateToolParamValues(params) {
+        if (!params.sql || params.sql.trim() === '') {
+            return 'SQL parameter must be non-empty';
+        }
+        // Warn about potentially dangerous queries (but allow them since we use READ ONLY transaction)
+        const sqlLower = params.sql.trim().toLowerCase();
+        const dangerousKeywords = ['insert', 'update', 'delete', 'drop', 'create', 'alter', 'truncate'];
+        for (const keyword of dangerousKeywords) {
+            if (sqlLower.includes(keyword)) {
+                console.warn(`[Warning] Query contains '${keyword}' but will run in READ ONLY transaction`);
+            }
+        }
+        return null;
+    }
+    createInvocation(params) {
+        return new SqlDbQueryToolInvocation(params);
+    }
+}
+//# sourceMappingURL=sql_db.js.map