@neverinfamous/postgres-mcp 2.0.0 → 2.2.0

package/dist/adapters/postgresql/tools/performance/stats.js

@@ -4,6 +4,7 @@
 import { z } from "zod";
 import { readOnly } from "../../../../utils/annotations.js";
 import { getToolIcons } from "../../../../utils/icons.js";
+import { formatPostgresError } from "../core/error-helpers.js";
 import { IndexStatsOutputSchema, TableStatsOutputSchema, StatStatementsOutputSchema, StatActivityOutputSchema, UnusedIndexesOutputSchema, DuplicateIndexesOutputSchema, VacuumStatsOutputSchema, QueryPlanStatsOutputSchema, } from "../../schemas/index.js";
 // Helper to handle undefined params (allows tools to be called without {})
 const defaultToEmpty = (val) => val ?? {};
@@ -41,7 +42,7 @@ export function createIndexStatsTool(adapter) {
         table: z.string().optional().describe("Table name to filter indexes"),
         schema: z.string().optional().describe("Schema name to filter indexes"),
         limit: z
-            .number()
+            .any()
             .optional()
             .describe("Max rows to return (default: 50, use 0 for all)"),
     });
@@ -55,61 +56,76 @@ export function createIndexStatsTool(adapter) {
         annotations: readOnly("Index Stats"),
         icons: getToolIcons("performance", readOnly("Index Stats")),
         handler: async (params, _context) => {
-            const parsed = IndexStatsSchemaLocal.parse(params);
-            let { table, schema } = parsed;
-            // Parse schema from table if it contains a dot (e.g., 'myschema.orders')
-            if (table?.includes(".")) {
-                const parts = table.split(".");
-                schema = schema ?? parts[0];
-                table = parts[1] ?? table;
-            }
-            const limit = parsed.limit === 0 ? null : (parsed.limit ?? 50);
-            // P154: Validate table/schema existence before querying
-            const validationError = await validatePerformanceTableExists(adapter, table, schema);
-            if (validationError !== null) {
-                return { success: false, error: validationError };
-            }
-            let whereClause = "schemaname NOT IN ('pg_catalog', 'information_schema')";
-            const queryParams = [];
-            if (schema) {
-                queryParams.push(schema);
-                whereClause += ` AND schemaname = $${String(queryParams.length)}`;
-            }
-            if (table) {
-                queryParams.push(table);
-                whereClause += ` AND relname = $${String(queryParams.length)}`;
-            }
-            const sql = `SELECT schemaname, relname as table_name, indexrelname as index_name,
+            try {
+                const parsed = IndexStatsSchemaLocal.parse(params);
+                let { table, schema } = parsed;
+                // Parse schema from table if it contains a dot (e.g., 'myschema.orders')
+                if (table?.includes(".")) {
+                    const parts = table.split(".");
+                    schema = schema ?? parts[0];
+                    table = parts[1] ?? table;
+                }
+                const rawLimit = Number(parsed.limit);
+                const limit = parsed.limit === undefined
+                    ? 50
+                    : isNaN(rawLimit)
+                        ? 50
+                        : rawLimit === 0
+                            ? null
+                            : rawLimit;
+                // P154: Validate table/schema existence before querying
+                const validationError = await validatePerformanceTableExists(adapter, table, schema);
+                if (validationError !== null) {
+                    return { success: false, error: validationError };
+                }
+                let whereClause = "schemaname NOT IN ('pg_catalog', 'information_schema')";
+                const queryParams = [];
+                if (schema) {
+                    queryParams.push(schema);
+                    whereClause += ` AND schemaname = $${String(queryParams.length)}`;
+                }
+                if (table) {
+                    queryParams.push(table);
+                    whereClause += ` AND relname = $${String(queryParams.length)}`;
+                }
+                const sql = `SELECT schemaname, relname as table_name, indexrelname as index_name,
                         idx_scan as scans, idx_tup_read as tuples_read, idx_tup_fetch as tuples_fetched,
                         pg_size_pretty(pg_relation_size(indexrelid)) as size
                         FROM pg_stat_user_indexes
                         WHERE ${whereClause}
                         ORDER BY idx_scan DESC
                         ${limit !== null ? `LIMIT ${String(limit)}` : ""}`;
-            const result = await adapter.executeQuery(sql, queryParams);
-            // Coerce numeric fields to JavaScript numbers
-            const indexes = (result.rows ?? []).map((row) => ({
-                ...row,
-                scans: toNum(row["scans"]),
-                tuples_read: toNum(row["tuples_read"]),
-                tuples_fetched: toNum(row["tuples_fetched"]),
-            }));
-            const response = {
-                indexes,
-                count: indexes.length,
-            };
-            // Add totalCount if results were limited
-            if (limit !== null && indexes.length === limit) {
-                const countSql = `SELECT COUNT(*) as total FROM pg_stat_user_indexes WHERE ${whereClause}`;
-                const countResult = await adapter.executeQuery(countSql, queryParams);
-                response["totalCount"] = toNum(countResult.rows?.[0]?.["total"]);
-                response["truncated"] = true;
+                const result = await adapter.executeQuery(sql, queryParams);
+                // Coerce numeric fields to JavaScript numbers
+                const indexes = (result.rows ?? []).map((row) => ({
+                    ...row,
+                    scans: toNum(row["scans"]),
+                    tuples_read: toNum(row["tuples_read"]),
+                    tuples_fetched: toNum(row["tuples_fetched"]),
+                }));
+                const response = {
+                    indexes,
+                    count: indexes.length,
+                };
+                // Add totalCount if results were limited
+                if (limit !== null && indexes.length === limit) {
+                    const countSql = `SELECT COUNT(*) as total FROM pg_stat_user_indexes WHERE ${whereClause}`;
+                    const countResult = await adapter.executeQuery(countSql, queryParams);
+                    response["totalCount"] = toNum(countResult.rows?.[0]?.["total"]);
+                    response["truncated"] = true;
+                }
+                else {
+                    response["truncated"] = false;
+                    response["totalCount"] = indexes.length;
+                }
+                return response;
             }
-            else {
-                response["truncated"] = false;
-                response["totalCount"] = indexes.length;
+            catch (error) {
+                return {
+                    success: false,
+                    error: formatPostgresError(error, { tool: "pg_index_stats" }),
+                };
             }
-            return response;
         },
     };
 }
@@ -118,7 +134,7 @@ export function createTableStatsTool(adapter) {
         table: z.string().optional().describe("Table name (all tables if omitted)"),
         schema: z.string().optional().describe("Schema name"),
         limit: z
-            .number()
+            .any()
             .optional()
             .describe("Max rows to return (default: 50, use 0 for all)"),
     });
@@ -132,31 +148,39 @@ export function createTableStatsTool(adapter) {
         annotations: readOnly("Table Stats"),
         icons: getToolIcons("performance", readOnly("Table Stats")),
         handler: async (params, _context) => {
-            const parsed = TableStatsSchemaLocal.parse(params);
-            let { table, schema } = parsed;
-            // Parse schema from table if it contains a dot (e.g., 'myschema.orders')
-            if (table?.includes(".")) {
-                const parts = table.split(".");
-                schema = schema ?? parts[0];
-                table = parts[1] ?? table;
-            }
-            const limit = parsed.limit === 0 ? null : (parsed.limit ?? 50);
-            // P154: Validate table/schema existence before querying
-            const validationError = await validatePerformanceTableExists(adapter, table, schema);
-            if (validationError !== null) {
-                return { success: false, error: validationError };
-            }
-            let whereClause = "schemaname NOT IN ('pg_catalog', 'information_schema')";
-            const queryParams = [];
-            if (schema) {
-                queryParams.push(schema);
-                whereClause += ` AND schemaname = $${String(queryParams.length)}`;
-            }
-            if (table) {
-                queryParams.push(table);
-                whereClause += ` AND relname = $${String(queryParams.length)}`;
-            }
-            const sql = `SELECT schemaname, relname as table_name,
+            try {
+                const parsed = TableStatsSchemaLocal.parse(params);
+                let { table, schema } = parsed;
+                // Parse schema from table if it contains a dot (e.g., 'myschema.orders')
+                if (table?.includes(".")) {
+                    const parts = table.split(".");
+                    schema = schema ?? parts[0];
+                    table = parts[1] ?? table;
+                }
+                const rawLimit = Number(parsed.limit);
+                const limit = parsed.limit === undefined
+                    ? 50
+                    : isNaN(rawLimit)
+                        ? 50
+                        : rawLimit === 0
+                            ? null
+                            : rawLimit;
+                // P154: Validate table/schema existence before querying
+                const validationError = await validatePerformanceTableExists(adapter, table, schema);
+                if (validationError !== null) {
+                    return { success: false, error: validationError };
+                }
+                let whereClause = "schemaname NOT IN ('pg_catalog', 'information_schema')";
+                const queryParams = [];
+                if (schema) {
+                    queryParams.push(schema);
+                    whereClause += ` AND schemaname = $${String(queryParams.length)}`;
+                }
+                if (table) {
+                    queryParams.push(table);
+                    whereClause += ` AND relname = $${String(queryParams.length)}`;
+                }
+                const sql = `SELECT schemaname, relname as table_name,
                         seq_scan, seq_tup_read, idx_scan, idx_tup_fetch,
                         n_tup_ins as inserts, n_tup_upd as updates, n_tup_del as deletes,
                         n_live_tup as live_tuples, n_dead_tup as dead_tuples,
@@ -165,43 +189,50 @@ export function createTableStatsTool(adapter) {
                         WHERE ${whereClause}
                         ORDER BY seq_scan DESC
                         ${limit !== null ? `LIMIT ${String(limit)}` : ""}`;
-            const result = await adapter.executeQuery(sql, queryParams);
-            // Coerce numeric fields to JavaScript numbers
-            const tables = (result.rows ?? []).map((row) => ({
-                ...row,
-                seq_scan: toNum(row["seq_scan"]),
-                seq_tup_read: toNum(row["seq_tup_read"]),
-                idx_scan: toNum(row["idx_scan"]),
-                idx_tup_fetch: toNum(row["idx_tup_fetch"]),
-                inserts: toNum(row["inserts"]),
-                updates: toNum(row["updates"]),
-                deletes: toNum(row["deletes"]),
-                live_tuples: toNum(row["live_tuples"]),
-                dead_tuples: toNum(row["dead_tuples"]),
-            }));
-            // Get total count if limited
-            const response = {
-                tables,
-                count: tables.length,
-            };
-            if (limit !== null && tables.length === limit) {
-                const countSql = `SELECT COUNT(*) as total FROM pg_stat_user_tables WHERE ${whereClause}`;
-                const countResult = await adapter.executeQuery(countSql, queryParams);
-                response["totalCount"] = toNum(countResult.rows?.[0]?.["total"]);
-                response["truncated"] = true;
+                const result = await adapter.executeQuery(sql, queryParams);
+                // Coerce numeric fields to JavaScript numbers
+                const tables = (result.rows ?? []).map((row) => ({
+                    ...row,
+                    seq_scan: toNum(row["seq_scan"]),
+                    seq_tup_read: toNum(row["seq_tup_read"]),
+                    idx_scan: toNum(row["idx_scan"]),
+                    idx_tup_fetch: toNum(row["idx_tup_fetch"]),
+                    inserts: toNum(row["inserts"]),
+                    updates: toNum(row["updates"]),
+                    deletes: toNum(row["deletes"]),
+                    live_tuples: toNum(row["live_tuples"]),
+                    dead_tuples: toNum(row["dead_tuples"]),
+                }));
+                // Get total count if limited
+                const response = {
+                    tables,
+                    count: tables.length,
+                };
+                if (limit !== null && tables.length === limit) {
+                    const countSql = `SELECT COUNT(*) as total FROM pg_stat_user_tables WHERE ${whereClause}`;
+                    const countResult = await adapter.executeQuery(countSql, queryParams);
+                    response["totalCount"] = toNum(countResult.rows?.[0]?.["total"]);
+                    response["truncated"] = true;
+                }
+                else {
+                    response["truncated"] = false;
+                    response["totalCount"] = tables.length;
+                }
+                return response;
             }
-            else {
-                response["truncated"] = false;
-                response["totalCount"] = tables.length;
+            catch (error) {
+                return {
+                    success: false,
+                    error: formatPostgresError(error, { tool: "pg_table_stats" }),
+                };
             }
-            return response;
         },
     };
 }
 export function createStatStatementsTool(adapter) {
     const StatStatementsSchemaBase = z.object({
         limit: z
-            .number()
+            .any()
             .optional()
             .describe("Max statements to return (default: 20, use 0 for all)"),
         orderBy: z
@@ -219,36 +250,51 @@ export function createStatStatementsTool(adapter) {
         annotations: readOnly("Query Statistics"),
         icons: getToolIcons("performance", readOnly("Query Statistics")),
         handler: async (params, _context) => {
-            const parsed = StatStatementsSchema.parse(params);
-            const limit = parsed.limit === 0 ? null : (parsed.limit ?? 20);
-            const orderBy = parsed.orderBy ?? "total_time";
-            const sql = `SELECT query, calls, total_exec_time as total_time,
+            try {
+                const parsed = StatStatementsSchema.parse(params);
+                const rawLimit = Number(parsed.limit);
+                const limit = parsed.limit === undefined
+                    ? 20
+                    : isNaN(rawLimit)
+                        ? 20
+                        : rawLimit === 0
+                            ? null
+                            : rawLimit;
+                const orderBy = parsed.orderBy ?? "total_time";
+                const sql = `SELECT query, calls, total_exec_time as total_time,
                         mean_exec_time as mean_time, rows,
                         shared_blks_hit, shared_blks_read
                         FROM pg_stat_statements
                         ORDER BY ${orderBy === "total_time" ? "total_exec_time" : orderBy} DESC
                         ${limit !== null ? `LIMIT ${String(limit)}` : ""}`;
-            const result = await adapter.executeQuery(sql);
-            // Coerce numeric fields to JavaScript numbers
-            const statements = (result.rows ?? []).map((row) => ({
-                ...row,
-                calls: toNum(row["calls"]),
-                rows: toNum(row["rows"]),
-                shared_blks_hit: toNum(row["shared_blks_hit"]),
-                shared_blks_read: toNum(row["shared_blks_read"]),
-            }));
-            const response = {
-                statements,
-                count: statements.length,
-            };
-            // Add totalCount if results were limited
-            if (limit !== null && statements.length === limit) {
-                const countSql = `SELECT COUNT(*) as total FROM pg_stat_statements`;
-                const countResult = await adapter.executeQuery(countSql);
-                response["totalCount"] = toNum(countResult.rows?.[0]?.["total"]);
-                response["truncated"] = true;
+                const result = await adapter.executeQuery(sql);
+                // Coerce numeric fields to JavaScript numbers
+                const statements = (result.rows ?? []).map((row) => ({
+                    ...row,
+                    calls: toNum(row["calls"]),
+                    rows: toNum(row["rows"]),
+                    shared_blks_hit: toNum(row["shared_blks_hit"]),
+                    shared_blks_read: toNum(row["shared_blks_read"]),
+                }));
+                const response = {
+                    statements,
+                    count: statements.length,
+                };
+                // Add totalCount if results were limited
+                if (limit !== null && statements.length === limit) {
+                    const countSql = `SELECT COUNT(*) as total FROM pg_stat_statements`;
+                    const countResult = await adapter.executeQuery(countSql);
+                    response["totalCount"] = toNum(countResult.rows?.[0]?.["total"]);
+                    response["truncated"] = true;
+                }
+                return response;
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: formatPostgresError(error, { tool: "pg_stat_statements" }),
+                };
             }
-            return response;
         },
     };
 }
@@ -266,9 +312,10 @@ export function createStatActivityTool(adapter) {
         annotations: readOnly("Activity Stats"),
         icons: getToolIcons("performance", readOnly("Activity Stats")),
         handler: async (params, _context) => {
-            const parsed = StatActivitySchema.parse(params);
-            const idleClause = parsed.includeIdle === true ? "" : "AND state != 'idle'";
-            const sql = `SELECT pid, usename, datname, client_addr, state,
+            try {
+                const parsed = StatActivitySchema.parse(params);
+                const idleClause = parsed.includeIdle === true ? "" : "AND state != 'idle'";
+                const sql = `SELECT pid, usename, datname, client_addr, state,
                         query_start, state_change,
                         now() - query_start as duration,
                         query
@@ -277,16 +324,23 @@ export function createStatActivityTool(adapter) {
                           AND backend_type = 'client backend'
                           ${idleClause}
                         ORDER BY query_start`;
-            const result = await adapter.executeQuery(sql);
-            // Count background workers for metadata
-            const bgResult = await adapter.executeQuery(`SELECT COUNT(*)::int as count FROM pg_stat_activity
+                const result = await adapter.executeQuery(sql);
+                // Count background workers for metadata
+                const bgResult = await adapter.executeQuery(`SELECT COUNT(*)::int as count FROM pg_stat_activity
          WHERE pid != pg_backend_pid() AND backend_type != 'client backend'`);
-            const bgCount = bgResult.rows?.[0]?.["count"] ?? 0;
-            return {
-                connections: result.rows,
-                count: result.rows?.length ?? 0,
-                backgroundWorkers: bgCount,
-            };
+                const bgCount = bgResult.rows?.[0]?.["count"] ?? 0;
+                return {
+                    connections: result.rows,
+                    count: result.rows?.length ?? 0,
+                    backgroundWorkers: bgCount,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: formatPostgresError(error, { tool: "pg_stat_activity" }),
+                };
+            }
         },
     };
 }
@@ -301,7 +355,7 @@ export function createUnusedIndexesTool(adapter) {
             .optional()
             .describe('Minimum index size to include (e.g., "1 MB")'),
         limit: z
-            .number()
+            .any()
             .optional()
             .describe("Max indexes to return (default: 20, use 0 for all)"),
         summary: z
@@ -319,24 +373,32 @@ export function createUnusedIndexesTool(adapter) {
         annotations: readOnly("Unused Indexes"),
         icons: getToolIcons("performance", readOnly("Unused Indexes")),
         handler: async (params, _context) => {
-            const parsed = UnusedIndexesSchema.parse(params);
-            const limit = parsed.limit === 0 ? null : (parsed.limit ?? 20);
-            // P154: Validate schema existence before querying
-            if (parsed.schema !== undefined) {
-                const validationError = await validatePerformanceTableExists(adapter, undefined, parsed.schema);
-                if (validationError !== null) {
-                    return { success: false, error: validationError };
+            try {
+                const parsed = UnusedIndexesSchema.parse(params);
+                const rawLimit = Number(parsed.limit);
+                const limit = parsed.limit === undefined
+                    ? 20
+                    : isNaN(rawLimit)
+                        ? 20
+                        : rawLimit === 0
+                            ? null
+                            : rawLimit;
+                // P154: Validate schema existence before querying
+                if (parsed.schema !== undefined) {
+                    const validationError = await validatePerformanceTableExists(adapter, undefined, parsed.schema);
+                    if (validationError !== null) {
+                        return { success: false, error: validationError };
+                    }
                 }
-            }
-            let whereClause = "schemaname NOT IN ('pg_catalog', 'information_schema') AND idx_scan = 0";
-            const queryParams = [];
-            if (parsed.schema !== undefined) {
-                queryParams.push(parsed.schema);
-                whereClause += ` AND schemaname = $${String(queryParams.length)}`;
-            }
-            // Summary mode - return aggregated stats
-            if (parsed.summary === true) {
-                const summarySql = `SELECT schemaname,
+                let whereClause = "schemaname NOT IN ('pg_catalog', 'information_schema') AND idx_scan = 0";
+                const queryParams = [];
+                if (parsed.schema !== undefined) {
+                    queryParams.push(parsed.schema);
+                    whereClause += ` AND schemaname = $${String(queryParams.length)}`;
+                }
+                // Summary mode - return aggregated stats
+                if (parsed.summary === true) {
+                    const summarySql = `SELECT schemaname,
                               COUNT(*) as unused_count,
                               pg_size_pretty(SUM(pg_relation_size(indexrelid))) as total_size,
                               SUM(pg_relation_size(indexrelid)) as total_size_bytes
@@ -345,24 +407,24 @@ export function createUnusedIndexesTool(adapter) {
                               ${parsed.minSize !== undefined ? `AND pg_relation_size(indexrelid) >= pg_size_bytes('${parsed.minSize}')` : ""}
                               GROUP BY schemaname
                               ORDER BY SUM(pg_relation_size(indexrelid)) DESC`;
-                const summaryResult = await adapter.executeQuery(summarySql, queryParams);
-                const bySchema = (summaryResult.rows ?? []).map((row) => ({
-                    schema: row["schemaname"],
-                    unusedCount: toNum(row["unused_count"]),
-                    totalSize: row["total_size"],
-                    totalSizeBytes: toNum(row["total_size_bytes"]),
-                }));
-                const totalCount = bySchema.reduce((sum, s) => sum + (s.unusedCount ?? 0), 0);
-                const totalBytes = bySchema.reduce((sum, s) => sum + (s.totalSizeBytes ?? 0), 0);
-                return {
-                    summary: true,
-                    bySchema,
-                    totalCount,
-                    totalSizeBytes: totalBytes,
-                    hint: "Use summary=false or omit to see individual indexes.",
-                };
-            }
-            const sql = `SELECT schemaname, relname as table_name, indexrelname as index_name,
+                    const summaryResult = await adapter.executeQuery(summarySql, queryParams);
+                    const bySchema = (summaryResult.rows ?? []).map((row) => ({
+                        schema: row["schemaname"],
+                        unusedCount: toNum(row["unused_count"]),
+                        totalSize: row["total_size"],
+                        totalSizeBytes: toNum(row["total_size_bytes"]),
+                    }));
+                    const totalCount = bySchema.reduce((sum, s) => sum + (s.unusedCount ?? 0), 0);
+                    const totalBytes = bySchema.reduce((sum, s) => sum + (s.totalSizeBytes ?? 0), 0);
+                    return {
+                        summary: true,
+                        bySchema,
+                        totalCount,
+                        totalSizeBytes: totalBytes,
+                        hint: "Use summary=false or omit to see individual indexes.",
+                    };
+                }
+                const sql = `SELECT schemaname, relname as table_name, indexrelname as index_name,
                         idx_scan as scans, idx_tup_read as tuples_read,
                         pg_size_pretty(pg_relation_size(indexrelid)) as size,
                         pg_relation_size(indexrelid) as size_bytes
@@ -371,28 +433,35 @@ export function createUnusedIndexesTool(adapter) {
                         ${parsed.minSize !== undefined ? `AND pg_relation_size(indexrelid) >= pg_size_bytes('${parsed.minSize}')` : ""}
                         ORDER BY pg_relation_size(indexrelid) DESC
                         ${limit !== null ? `LIMIT ${String(limit)}` : ""}`;
-            const result = await adapter.executeQuery(sql, queryParams);
-            // Coerce numeric fields to JavaScript numbers
-            const unusedIndexes = (result.rows ?? []).map((row) => ({
-                ...row,
-                scans: toNum(row["scans"]),
-                tuples_read: toNum(row["tuples_read"]),
-                size_bytes: toNum(row["size_bytes"]),
-            }));
-            const response = {
-                unusedIndexes,
-                count: unusedIndexes.length,
-                hint: "These indexes have never been used. Consider removing them to save disk space and improve write performance.",
-            };
-            // Add totalCount if results were limited
-            if (limit !== null && unusedIndexes.length === limit) {
-                const countSql = `SELECT COUNT(*) as total FROM pg_stat_user_indexes WHERE ${whereClause}
+                const result = await adapter.executeQuery(sql, queryParams);
+                // Coerce numeric fields to JavaScript numbers
+                const unusedIndexes = (result.rows ?? []).map((row) => ({
+                    ...row,
+                    scans: toNum(row["scans"]),
+                    tuples_read: toNum(row["tuples_read"]),
+                    size_bytes: toNum(row["size_bytes"]),
+                }));
+                const response = {
+                    unusedIndexes,
+                    count: unusedIndexes.length,
+                    hint: "These indexes have never been used. Consider removing them to save disk space and improve write performance.",
+                };
+                // Add totalCount if results were limited
+                if (limit !== null && unusedIndexes.length === limit) {
+                    const countSql = `SELECT COUNT(*) as total FROM pg_stat_user_indexes WHERE ${whereClause}
                           ${parsed.minSize !== undefined ? `AND pg_relation_size(indexrelid) >= pg_size_bytes('${parsed.minSize}')` : ""}`;
-                const countResult = await adapter.executeQuery(countSql, queryParams);
-                response["totalCount"] = toNum(countResult.rows?.[0]?.["total"]);
-                response["truncated"] = true;
+                    const countResult = await adapter.executeQuery(countSql, queryParams);
+                    response["totalCount"] = toNum(countResult.rows?.[0]?.["total"]);
+                    response["truncated"] = true;
+                }
+                return response;
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: formatPostgresError(error, { tool: "pg_unused_indexes" }),
+                };
             }
-            return response;
         },
     };
 }
@@ -403,7 +472,7 @@ export function createDuplicateIndexesTool(adapter) {
             .optional()
             .describe("Schema to filter (default: all user schemas)"),
         limit: z
-            .number()
+            .any()
             .optional()
             .describe("Max rows to return (default: 50, use 0 for all)"),
     });
@@ -417,22 +486,30 @@ export function createDuplicateIndexesTool(adapter) {
         annotations: readOnly("Duplicate Indexes"),
         icons: getToolIcons("performance", readOnly("Duplicate Indexes")),
         handler: async (params, _context) => {
-            const parsed = DuplicateIndexesSchema.parse(params);
-            const limit = parsed.limit === 0 ? null : (parsed.limit ?? 50);
-            // P154: Validate schema existence before querying
-            if (parsed.schema !== undefined) {
-                const validationError = await validatePerformanceTableExists(adapter, undefined, parsed.schema);
-                if (validationError !== null) {
-                    return { success: false, error: validationError };
+            try {
+                const parsed = DuplicateIndexesSchema.parse(params);
+                const rawLimit = Number(parsed.limit);
+                const limit = parsed.limit === undefined
+                    ? 50
+                    : isNaN(rawLimit)
+                        ? 50
+                        : rawLimit === 0
+                            ? null
+                            : rawLimit;
+                // P154: Validate schema existence before querying
+                if (parsed.schema !== undefined) {
+                    const validationError = await validatePerformanceTableExists(adapter, undefined, parsed.schema);
+                    if (validationError !== null) {
+                        return { success: false, error: validationError };
+                    }
                 }
-            }
-            const queryParams = [];
-            const schemaFilter = parsed.schema !== undefined
-                ? (queryParams.push(parsed.schema),
-                    `AND n.nspname = $${String(queryParams.length)}`)
-                : "AND n.nspname NOT IN ('pg_catalog', 'information_schema')";
-            // Find indexes with the same leading column(s) on the same table
-            const sql = `WITH index_cols AS (
+                const queryParams = [];
+                const schemaFilter = parsed.schema !== undefined
+                    ? (queryParams.push(parsed.schema),
+                        `AND n.nspname = $${String(queryParams.length)}`)
+                    : "AND n.nspname NOT IN ('pg_catalog', 'information_schema')";
+                // Find indexes with the same leading column(s) on the same table
+                const sql = `WITH index_cols AS (
                 SELECT
                     n.nspname as schemaname,
                     t.relname as tablename,
@@ -467,16 +544,16 @@ export function createDuplicateIndexesTool(adapter) {
                     OR b.columns[1:array_length(a.columns, 1)] = a.columns)
             ORDER BY a.schemaname, a.tablename, a.size_bytes DESC
             ${limit !== null ? `LIMIT ${String(limit)}` : ""}`;
-            const result = await adapter.executeQuery(sql, queryParams);
-            const duplicates = result.rows ?? [];
-            const response = {
-                duplicateIndexes: duplicates,
-                count: duplicates.length,
-                hint: "EXACT_DUPLICATE: Remove one. OVERLAPPING/SUBSET: Smaller index may be redundant.",
-            };
-            // Add totalCount if results were limited
-            if (limit !== null && duplicates.length === limit) {
-                const countSql = `WITH index_cols AS (
+                const result = await adapter.executeQuery(sql, queryParams);
+                const duplicates = result.rows ?? [];
+                const response = {
+                    duplicateIndexes: duplicates,
+                    count: duplicates.length,
+                    hint: "EXACT_DUPLICATE: Remove one. OVERLAPPING/SUBSET: Smaller index may be redundant.",
+                };
+                // Add totalCount if results were limited
+                if (limit !== null && duplicates.length === limit) {
+                    const countSql = `WITH index_cols AS (
                   SELECT
                       n.nspname as schemaname,
                       t.relname as tablename,
@@ -500,11 +577,18 @@ export function createDuplicateIndexesTool(adapter) {
                   AND (a.columns = b.columns
                       OR a.columns[1:array_length(b.columns, 1)] = b.columns
                       OR b.columns[1:array_length(a.columns, 1)] = a.columns)`;
-                const countResult = await adapter.executeQuery(countSql, queryParams);
-                response["totalCount"] = toNum(countResult.rows?.[0]?.["total"]);
-                response["truncated"] = true;
+                    const countResult = await adapter.executeQuery(countSql, queryParams);
+                    response["totalCount"] = toNum(countResult.rows?.[0]?.["total"]);
+                    response["truncated"] = true;
+                }
+                return response;
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: formatPostgresError(error, { tool: "pg_duplicate_indexes" }),
+                };
             }
-            return response;
         },
     };
 }
@@ -513,7 +597,7 @@ export function createVacuumStatsTool(adapter) {
         schema: z.string().optional().describe("Schema to filter"),
         table: z.string().optional().describe("Table name to filter"),
         limit: z
-            .number()
+            .any()
             .optional()
             .describe("Max rows to return (default: 50, use 0 for all)"),
     });
@@ -527,32 +611,40 @@ export function createVacuumStatsTool(adapter) {
         annotations: readOnly("Vacuum Stats"),
         icons: getToolIcons("performance", readOnly("Vacuum Stats")),
         handler: async (params, _context) => {
-            const parsed = VacuumStatsSchema.parse(params);
-            let table = parsed.table;
-            let schema = parsed.schema;
-            // Parse schema from table if it contains a dot (e.g., 'myschema.orders')
-            if (table?.includes(".")) {
-                const parts = table.split(".");
-                schema = schema ?? parts[0];
-                table = parts[1] ?? table;
-            }
-            const limit = parsed.limit === 0 ? null : (parsed.limit ?? 50);
-            let whereClause = "schemaname NOT IN ('pg_catalog', 'information_schema')";
-            const queryParams = [];
-            if (schema !== undefined) {
-                queryParams.push(schema);
-                whereClause += ` AND schemaname = $${String(queryParams.length)}`;
-            }
-            if (table !== undefined) {
-                queryParams.push(table);
-                whereClause += ` AND relname = $${String(queryParams.length)}`;
-            }
-            // P154: Validate table/schema existence before querying
-            const validationError = await validatePerformanceTableExists(adapter, table, schema);
-            if (validationError !== null) {
-                return { success: false, error: validationError };
-            }
-            const sql = `SELECT
+            try {
+                const parsed = VacuumStatsSchema.parse(params);
+                let table = parsed.table;
+                let schema = parsed.schema;
+                // Parse schema from table if it contains a dot (e.g., 'myschema.orders')
+                if (table?.includes(".")) {
+                    const parts = table.split(".");
+                    schema = schema ?? parts[0];
+                    table = parts[1] ?? table;
+                }
+                const rawLimit = Number(parsed.limit);
+                const limit = parsed.limit === undefined
+                    ? 50
+                    : isNaN(rawLimit)
+                        ? 50
+                        : rawLimit === 0
+                            ? null
+                            : rawLimit;
+                let whereClause = "schemaname NOT IN ('pg_catalog', 'information_schema')";
+                const queryParams = [];
+                if (schema !== undefined) {
+                    queryParams.push(schema);
+                    whereClause += ` AND schemaname = $${String(queryParams.length)}`;
+                }
+                if (table !== undefined) {
+                    queryParams.push(table);
+                    whereClause += ` AND relname = $${String(queryParams.length)}`;
+                }
+                // P154: Validate table/schema existence before querying
+                const validationError = await validatePerformanceTableExists(adapter, table, schema);
+                if (validationError !== null) {
+                    return { success: false, error: validationError };
+                }
+                const sql = `SELECT
                 s.schemaname, s.relname as table_name,
                 s.n_live_tup as live_tuples, s.n_dead_tup as dead_tuples,
                 CASE WHEN s.n_live_tup > 0 THEN round((100.0 * s.n_dead_tup / s.n_live_tup)::numeric, 2) ELSE 0 END as dead_pct,
@@ -572,45 +664,52 @@ export function createVacuumStatsTool(adapter) {
                 WHERE ${whereClause.replace(/schemaname/g, "s.schemaname").replace(/relname/g, "s.relname")}
                 ORDER BY s.n_dead_tup DESC
                 ${limit !== null ? `LIMIT ${String(limit)}` : ""}`;
-            const result = await adapter.executeQuery(sql, queryParams);
-            // Coerce numeric fields to JavaScript numbers
-            const tables = (result.rows ?? []).map((row) => ({
-                ...row,
-                live_tuples: toNum(row["live_tuples"]),
-                dead_tuples: toNum(row["dead_tuples"]),
-                dead_pct: toNum(row["dead_pct"]),
-                vacuum_count: toNum(row["vacuum_count"]),
-                autovacuum_count: toNum(row["autovacuum_count"]),
-                analyze_count: toNum(row["analyze_count"]),
-                autoanalyze_count: toNum(row["autoanalyze_count"]),
-            }));
-            const response = {
-                tables,
-                count: tables.length,
-            };
-            // Add totalCount if results were limited
-            if (limit !== null && tables.length === limit) {
-                const countSql = `SELECT COUNT(*) as total FROM pg_stat_user_tables WHERE ${whereClause}`;
-                const countResult = await adapter.executeQuery(countSql, queryParams);
-                response["totalCount"] = toNum(countResult.rows?.[0]?.["total"]);
-                response["truncated"] = true;
+                const result = await adapter.executeQuery(sql, queryParams);
+                // Coerce numeric fields to JavaScript numbers
+                const tables = (result.rows ?? []).map((row) => ({
+                    ...row,
+                    live_tuples: toNum(row["live_tuples"]),
+                    dead_tuples: toNum(row["dead_tuples"]),
+                    dead_pct: toNum(row["dead_pct"]),
+                    vacuum_count: toNum(row["vacuum_count"]),
+                    autovacuum_count: toNum(row["autovacuum_count"]),
+                    analyze_count: toNum(row["analyze_count"]),
+                    autoanalyze_count: toNum(row["autoanalyze_count"]),
+                }));
+                const response = {
+                    tables,
+                    count: tables.length,
+                };
+                // Add totalCount if results were limited
+                if (limit !== null && tables.length === limit) {
+                    const countSql = `SELECT COUNT(*) as total FROM pg_stat_user_tables WHERE ${whereClause}`;
+                    const countResult = await adapter.executeQuery(countSql, queryParams);
+                    response["totalCount"] = toNum(countResult.rows?.[0]?.["total"]);
+                    response["truncated"] = true;
+                }
+                else {
+                    response["truncated"] = false;
+                    response["totalCount"] = tables.length;
+                }
+                return response;
             }
-            else {
-                response["truncated"] = false;
-                response["totalCount"] = tables.length;
+            catch (error) {
+                return {
+                    success: false,
+                    error: formatPostgresError(error, { tool: "pg_vacuum_stats" }),
+                };
             }
-            return response;
         },
     };
 }
 export function createQueryPlanStatsTool(adapter) {
     const QueryPlanStatsSchemaBase = z.object({
         limit: z
-            .number()
+            .any()
             .optional()
             .describe("Number of queries to return (default: 20, use 0 for all)"),
         truncateQuery: z
-            .number()
+            .any()
             .optional()
             .describe("Max query length in chars (default: 100, use 0 for full text)"),
     });
@@ -624,11 +723,26 @@ export function createQueryPlanStatsTool(adapter) {
         annotations: readOnly("Query Plan Stats"),
         icons: getToolIcons("performance", readOnly("Query Plan Stats")),
         handler: async (params, _context) => {
-            const parsed = QueryPlanStatsSchema.parse(params);
-            const limit = parsed.limit === 0 ? null : (parsed.limit ?? 20);
-            const truncateLen = parsed.truncateQuery === 0 ? null : (parsed.truncateQuery ?? 100);
-            // Check if pg_stat_statements is available with planning time columns
-            const sql = `SELECT
+            try {
+                const parsed = QueryPlanStatsSchema.parse(params);
+                const rawLimit = Number(parsed.limit);
+                const limit = parsed.limit === undefined
+                    ? 20
+                    : isNaN(rawLimit)
+                        ? 20
+                        : rawLimit === 0
+                            ? null
+                            : rawLimit;
+                const rawTruncate = Number(parsed.truncateQuery);
+                const truncateLen = parsed.truncateQuery === undefined
+                    ? 100
+                    : isNaN(rawTruncate)
+                        ? 100
+                        : rawTruncate === 0
+                            ? null
+                            : rawTruncate;
+                // Check if pg_stat_statements is available with planning time columns
+                const sql = `SELECT
                 query,
                 calls,
                 total_plan_time,
@@ -651,42 +765,49 @@ export function createQueryPlanStatsTool(adapter) {
                 FROM pg_stat_statements
                 ORDER BY total_plan_time + total_exec_time DESC
                 ${limit !== null ? `LIMIT ${String(limit)}` : ""}`;
-            const result = await adapter.executeQuery(sql);
-            // Coerce numeric fields to JavaScript numbers and optionally truncate query
-            const queryPlanStats = (result.rows ?? []).map((row) => {
-                const queryVal = row["query"];
-                const query = typeof queryVal === "string" ? queryVal : "";
-                const truncatedQuery = truncateLen !== null && query.length > truncateLen
-                    ? query.substring(0, truncateLen) + "..."
-                    : query;
+                const result = await adapter.executeQuery(sql);
+                // Coerce numeric fields to JavaScript numbers and optionally truncate query
+                const queryPlanStats = (result.rows ?? []).map((row) => {
+                    const queryVal = row["query"];
+                    const query = typeof queryVal === "string" ? queryVal : "";
+                    const truncatedQuery = truncateLen !== null && query.length > truncateLen
+                        ? query.substring(0, truncateLen) + "..."
+                        : query;
+                    return {
+                        query: truncatedQuery,
+                        queryTruncated: truncateLen !== null && query.length > truncateLen,
+                        calls: toNum(row["calls"]),
+                        total_plan_time: row["total_plan_time"],
+                        mean_plan_time: row["mean_plan_time"],
+                        total_exec_time: row["total_exec_time"],
+                        mean_exec_time: row["mean_exec_time"],
+                        rows: toNum(row["rows"]),
+                        plan_pct: toNum(row["plan_pct"]),
+                        cache_hit_pct: toNum(row["cache_hit_pct"]),
+                        shared_blks_hit: toNum(row["shared_blks_hit"]),
+                        shared_blks_read: toNum(row["shared_blks_read"]),
+                    };
+                });
+                const response = {
+                    queryPlanStats,
+                    count: queryPlanStats.length,
+                    hint: "High plan_pct indicates queries spending significant time in planning. Consider prepared statements.",
+                };
+                // Add totalCount if results were limited
+                if (limit !== null && queryPlanStats.length === limit) {
+                    const countSql = `SELECT COUNT(*) as total FROM pg_stat_statements`;
+                    const countResult = await adapter.executeQuery(countSql);
+                    response["totalCount"] = toNum(countResult.rows?.[0]?.["total"]);
+                    response["truncated"] = true;
+                }
+                return response;
+            }
+            catch (error) {
                 return {
-                    query: truncatedQuery,
-                    queryTruncated: truncateLen !== null && query.length > truncateLen,
-                    calls: toNum(row["calls"]),
-                    total_plan_time: row["total_plan_time"],
-                    mean_plan_time: row["mean_plan_time"],
-                    total_exec_time: row["total_exec_time"],
-                    mean_exec_time: row["mean_exec_time"],
-                    rows: toNum(row["rows"]),
-                    plan_pct: toNum(row["plan_pct"]),
-                    cache_hit_pct: toNum(row["cache_hit_pct"]),
-                    shared_blks_hit: toNum(row["shared_blks_hit"]),
-                    shared_blks_read: toNum(row["shared_blks_read"]),
+                    success: false,
+                    error: formatPostgresError(error, { tool: "pg_query_plan_stats" }),
                 };
-            });
-            const response = {
-                queryPlanStats,
-                count: queryPlanStats.length,
-                hint: "High plan_pct indicates queries spending significant time in planning. Consider prepared statements.",
-            };
-            // Add totalCount if results were limited
-            if (limit !== null && queryPlanStats.length === limit) {
-                const countSql = `SELECT COUNT(*) as total FROM pg_stat_statements`;
-                const countResult = await adapter.executeQuery(countSql);
-                response["totalCount"] = toNum(countResult.rows?.[0]?.["total"]);
-                response["truncated"] = true;
             }
-            return response;
         },
     };
 }