@neverinfamous/postgres-mcp 2.0.0 → 2.2.0

package/dist/adapters/postgresql/tools/partman/management.js

@@ -6,6 +6,7 @@
 import { z } from "zod";
 import { readOnly, write } from "../../../../utils/annotations.js";
 import { getToolIcons } from "../../../../utils/icons.js";
+import { formatPostgresError } from "../core/error-helpers.js";
 import { PartmanCreateParentSchema, PartmanCreateParentSchemaBase, PartmanRunMaintenanceSchema, PartmanRunMaintenanceSchemaBase, PartmanShowPartitionsSchema, PartmanShowPartitionsSchemaBase, PartmanShowConfigSchema, PartmanShowConfigSchemaBase, DEPRECATED_INTERVALS, 
 // Output schemas
 PartmanCreateExtensionOutputSchema, PartmanCreateParentOutputSchema, PartmanRunMaintenanceOutputSchema, PartmanShowPartitionsOutputSchema, PartmanShowConfigOutputSchema, } from "../../schemas/index.js";
@@ -35,8 +36,18 @@ export function createPartmanExtensionTool(adapter) {
         annotations: write("Create Partman Extension"),
         icons: getToolIcons("partman", write("Create Partman Extension")),
         handler: async (_params, _context) => {
-            await adapter.executeQuery("CREATE EXTENSION IF NOT EXISTS pg_partman");
-            return { success: true, message: "pg_partman extension enabled" };
+            try {
+                await adapter.executeQuery("CREATE EXTENSION IF NOT EXISTS pg_partman");
+                return { success: true, message: "pg_partman extension enabled" };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: formatPostgresError(error, {
+                        tool: "pg_partman_create_extension",
+                    }),
+                };
+            }
         },
     };
 }
@@ -66,171 +77,184 @@ A startPartition far in the past (e.g., '2024-01-01' with daily intervals) creat
         annotations: write("Create Partition Parent"),
         icons: getToolIcons("partman", write("Create Partition Parent")),
         handler: async (params, _context) => {
-            const { parentTable, controlColumn, interval, premake, startPartition, templateTable, epochType, defaultPartition, } = PartmanCreateParentSchema.parse(params);
-            // Validate required parameters with clear error messages
-            if (!parentTable || !controlColumn || !interval) {
-                const missing = [];
-                if (!parentTable)
-                    missing.push("parentTable");
-                if (!controlColumn)
-                    missing.push("controlColumn (or control)");
-                if (!interval)
-                    missing.push("interval");
-                return {
-                    success: false,
-                    error: `Missing required parameters: ${missing.join(", ")}.`,
-                    hint: 'Example: pg_partman_create_parent({ parentTable: "public.events", controlColumn: "created_at", interval: "1 month" })',
-                    aliases: { control: "controlColumn" },
-                };
-            }
-            // Check for deprecated interval keywords and return structured error
-            const deprecatedReplacement = DEPRECATED_INTERVALS[interval.toLowerCase()];
-            if (deprecatedReplacement) {
-                return {
-                    success: false,
-                    error: `Deprecated interval '${interval}'. Use PostgreSQL interval syntax instead: '${deprecatedReplacement}'.`,
-                    hint: "Valid examples: '1 day', '1 week', '1 month', '3 months', '1 year'. Do NOT use keywords like 'daily' or 'monthly'.",
-                };
-            }
-            // At this point, all required params are guaranteed to be defined
-            const validatedParentTable = parentTable;
-            const validatedControlColumn = controlColumn;
-            const validatedInterval = interval;
-            // Note: pg_partman defaults to 'range' type, which is correct for most uses
-            const args = [
-                `p_parent_table := '${validatedParentTable}'`,
-                `p_control := '${validatedControlColumn}'`,
-                `p_interval := '${validatedInterval}'`,
-            ];
-            if (premake !== undefined) {
-                args.push(`p_premake := ${String(premake)}`);
-            }
-            if (startPartition !== undefined) {
-                // pg_partman 5.x doesn't interpret 'now' as a timestamp literal.
-                // Resolve 'now' to NOW()::text so pg_partman receives an actual timestamp string.
-                if (startPartition.toLowerCase() === "now") {
-                    args.push(`p_start_partition := NOW()::text`);
-                }
-                else {
-                    args.push(`p_start_partition := '${startPartition}'`);
-                }
-            }
-            if (templateTable !== undefined) {
-                args.push(`p_template_table := '${templateTable}'`);
-            }
-            if (epochType !== undefined) {
-                args.push(`p_epoch := '${epochType}'`);
-            }
-            if (defaultPartition !== undefined) {
-                args.push(`p_default_table := ${String(defaultPartition)}`);
-            }
-            const partmanSchema = await getPartmanSchema(adapter);
-            const sql = `SELECT ${partmanSchema}.create_parent(${args.join(", ")})`;
             try {
-                await adapter.executeQuery(sql);
-            }
-            catch (e) {
-                const errorMsg = e instanceof Error ? e.message : String(e);
-                // Wrap common PostgreSQL/pg_partman errors with clearer messages
-                if (errorMsg.includes("duplicate key") ||
-                    errorMsg.includes("already exists in part_config")) {
+                const { parentTable, controlColumn, interval, premake, startPartition, templateTable, epochType, defaultPartition, } = PartmanCreateParentSchema.parse(params);
+                // Validate required parameters with clear error messages
+                if (!parentTable || !controlColumn || !interval) {
+                    const missing = [];
+                    if (!parentTable)
+                        missing.push("parentTable");
+                    if (!controlColumn)
+                        missing.push("controlColumn (or control)");
+                    if (!interval)
+                        missing.push("interval");
                     return {
                         success: false,
-                        error: `Table '${validatedParentTable}' is already managed by pg_partman.`,
-                        hint: "Use pg_partman_show_config to view existing configuration. " +
-                            "To recreate: use pg_partman_undo_partition first, or if the table was dropped, clean up with: " +
-                            `DELETE FROM ${partmanSchema}.part_config WHERE parent_table = '${validatedParentTable}';`,
+                        error: `Missing required parameters: ${missing.join(", ")}.`,
+                        hint: 'Example: pg_partman_create_parent({ parentTable: "public.events", controlColumn: "created_at", interval: "1 month" })',
+                        aliases: { control: "controlColumn" },
                     };
                 }
-                if (errorMsg.includes("does not exist") &&
-                    errorMsg.includes("relation")) {
+                // Check for deprecated interval keywords and return structured error
+                const deprecatedReplacement = DEPRECATED_INTERVALS[interval.toLowerCase()];
+                if (deprecatedReplacement) {
                     return {
                         success: false,
-                        error: `Table '${validatedParentTable}' does not exist.`,
-                        hint: "Create the parent table first with appropriate columns, then call pg_partman_create_parent.",
+                        error: `Deprecated interval '${interval}'. Use PostgreSQL interval syntax instead: '${deprecatedReplacement}'.`,
+                        hint: "Valid examples: '1 day', '1 week', '1 month', '3 months', '1 year'. Do NOT use keywords like 'daily' or 'monthly'.",
                     };
                 }
-                if (errorMsg.includes("Unable to find given parent table")) {
-                    return {
-                        success: false,
-                        error: `Table '${validatedParentTable}' does not exist.`,
-                        hint: "Create the parent table first with PARTITION BY clause, then call pg_partman_create_parent.",
-                    };
+                // At this point, all required params are guaranteed to be defined
+                const validatedParentTable = parentTable;
+                const validatedControlColumn = controlColumn;
+                const validatedInterval = interval;
+                // Note: pg_partman defaults to 'range' type, which is correct for most uses
+                const args = [
+                    `p_parent_table := '${validatedParentTable}'`,
+                    `p_control := '${validatedControlColumn}'`,
+                    `p_interval := '${validatedInterval}'`,
+                ];
+                // premake is passed directly to pg_partman create_parent
+                // Guard against NaN from z.coerce.number("abc")
+                if (premake !== undefined && !isNaN(premake)) {
+                    args.push(`p_premake := ${String(premake)}`);
                 }
-                // Check 'is not partitioned' BEFORE 'NOT NULL' - if table isn't partitioned, that's the primary issue
-                if (errorMsg.includes("is not partitioned")) {
-                    return {
-                        success: false,
-                        error: `Table '${validatedParentTable}' is not a partitioned table.`,
-                        hint: "Create the table with PARTITION BY clause. Example: CREATE TABLE events (ts TIMESTAMPTZ NOT NULL, ...) PARTITION BY RANGE (ts);",
-                    };
+                if (startPartition !== undefined) {
+                    // pg_partman 5.x doesn't interpret 'now' as a timestamp literal.
+                    // Resolve 'now' to NOW()::text so pg_partman receives an actual timestamp string.
+                    if (startPartition.toLowerCase() === "now") {
+                        args.push(`p_start_partition := NOW()::text`);
+                    }
+                    else {
+                        args.push(`p_start_partition := '${startPartition}'`);
+                    }
                 }
-                if (errorMsg.includes("cannot be null") ||
-                    errorMsg.includes("NOT NULL")) {
-                    return {
-                        success: false,
-                        error: `Control column '${validatedControlColumn}' must have a NOT NULL constraint.`,
-                        hint: "Add NOT NULL constraint to the control column. Example: ALTER TABLE events ALTER COLUMN ts SET NOT NULL;",
-                    };
+                if (templateTable !== undefined) {
+                    args.push(`p_template_table := '${templateTable}'`);
                 }
-                // Catch pg_partman's partition type requirement error
-                if (errorMsg.includes("ranged or list partitioned") ||
-                    errorMsg.includes("must have created the given parent table")) {
-                    return {
-                        success: false,
-                        error: `Table '${validatedParentTable}' must be created as RANGE or LIST partitioned before calling createParent.`,
-                        hint: "Create the table with PARTITION BY RANGE or PARTITION BY LIST clause first. " +
-                            "Example: CREATE TABLE events (ts TIMESTAMPTZ NOT NULL, ...) PARTITION BY RANGE (ts);",
-                    };
+                if (epochType !== undefined) {
+                    args.push(`p_epoch := '${epochType}'`);
                 }
-                // Catch invalid interval format error with user-friendly message
-                if (errorMsg.includes("invalid input syntax for type interval")) {
-                    return {
-                        success: false,
-                        error: `Invalid interval format: '${validatedInterval}'.`,
-                        hint: "Use PostgreSQL interval syntax. Valid examples: '1 day', '1 week', '1 month', '3 months', '1 year'. " +
-                            "Do NOT use keywords like 'daily' or 'monthly'.",
-                        examples: [
-                            "1 day",
-                            "1 week",
-                            "2 weeks",
-                            "1 month",
-                            "3 months",
-                            "1 year",
-                        ],
-                    };
+                if (defaultPartition !== undefined) {
+                    args.push(`p_default_table := ${String(defaultPartition)}`);
                 }
-                throw e; // Re-throw other errors
-            }
-            // pg_partman's create_parent only registers the partition set - it doesn't always create child partitions
-            // We call run_maintenance to attempt to create initial partitions, but this may fail in some cases
-            // (e.g., when no startPartition is specified and the control column has no existing data to determine ranges)
-            let maintenanceRan = false;
-            try {
-                const maintenanceSql = `SELECT ${partmanSchema}.run_maintenance(p_parent_table := '${validatedParentTable}')`;
-                await adapter.executeQuery(maintenanceSql);
-                maintenanceRan = true;
+                const partmanSchema = await getPartmanSchema(adapter);
+                const sql = `SELECT ${partmanSchema}.create_parent(${args.join(", ")})`;
+                try {
+                    await adapter.executeQuery(sql);
+                }
+                catch (e) {
+                    const errorMsg = e instanceof Error ? e.message : String(e);
+                    // Wrap common PostgreSQL/pg_partman errors with clearer messages
+                    if (errorMsg.includes("duplicate key") ||
+                        errorMsg.includes("already exists in part_config")) {
+                        return {
+                            success: false,
+                            error: `Table '${validatedParentTable}' is already managed by pg_partman.`,
+                            hint: "Use pg_partman_show_config to view existing configuration. " +
+                                "To recreate: use pg_partman_undo_partition first, or if the table was dropped, clean up with: " +
+                                `DELETE FROM ${partmanSchema}.part_config WHERE parent_table = '${validatedParentTable}';`,
+                        };
+                    }
+                    if (errorMsg.includes("does not exist") &&
+                        errorMsg.includes("relation")) {
+                        return {
+                            success: false,
+                            error: `Table '${validatedParentTable}' does not exist.`,
+                            hint: "Create the parent table first with appropriate columns, then call pg_partman_create_parent.",
+                        };
+                    }
+                    if (errorMsg.includes("Unable to find given parent table")) {
+                        return {
+                            success: false,
+                            error: `Table '${validatedParentTable}' does not exist.`,
+                            hint: "Create the parent table first with PARTITION BY clause, then call pg_partman_create_parent.",
+                        };
+                    }
+                    // Check 'is not partitioned' BEFORE 'NOT NULL' - if table isn't partitioned, that's the primary issue
+                    if (errorMsg.includes("is not partitioned")) {
+                        return {
+                            success: false,
+                            error: `Table '${validatedParentTable}' is not a partitioned table.`,
+                            hint: "Create the table with PARTITION BY clause. Example: CREATE TABLE events (ts TIMESTAMPTZ NOT NULL, ...) PARTITION BY RANGE (ts);",
+                        };
+                    }
+                    if (errorMsg.includes("cannot be null") ||
+                        errorMsg.includes("NOT NULL")) {
+                        return {
+                            success: false,
+                            error: `Control column '${validatedControlColumn}' must have a NOT NULL constraint.`,
+                            hint: "Add NOT NULL constraint to the control column. Example: ALTER TABLE events ALTER COLUMN ts SET NOT NULL;",
+                        };
+                    }
+                    // Catch pg_partman's partition type requirement error
+                    if (errorMsg.includes("ranged or list partitioned") ||
+                        errorMsg.includes("must have created the given parent table")) {
+                        return {
+                            success: false,
+                            error: `Table '${validatedParentTable}' must be created as RANGE or LIST partitioned before calling createParent.`,
+                            hint: "Create the table with PARTITION BY RANGE or PARTITION BY LIST clause first. " +
+                                "Example: CREATE TABLE events (ts TIMESTAMPTZ NOT NULL, ...) PARTITION BY RANGE (ts);",
+                        };
+                    }
+                    // Catch invalid interval format error with user-friendly message
+                    if (errorMsg.includes("invalid input syntax for type interval")) {
+                        return {
+                            success: false,
+                            error: `Invalid interval format: '${validatedInterval}'.`,
+                            hint: "Use PostgreSQL interval syntax. Valid examples: '1 day', '1 week', '1 month', '3 months', '1 year'. " +
+                                "Do NOT use keywords like 'daily' or 'monthly'.",
+                            examples: [
+                                "1 day",
+                                "1 week",
+                                "2 weeks",
+                                "1 month",
+                                "3 months",
+                                "1 year",
+                            ],
+                        };
+                    }
+                    // Re-throw other errors — outer catch will format them
+                    throw e;
+                }
+                // pg_partman's create_parent only registers the partition set - it doesn't always create child partitions
+                // We call run_maintenance to attempt to create initial partitions, but this may fail in some cases
+                // (e.g., when no startPartition is specified and the control column has no existing data to determine ranges)
+                let maintenanceRan = false;
+                try {
+                    const maintenanceSql = `SELECT ${partmanSchema}.run_maintenance(p_parent_table := '${validatedParentTable}')`;
+                    await adapter.executeQuery(maintenanceSql);
+                    maintenanceRan = true;
+                }
+                catch {
+                    // Maintenance may fail for new partition sets without data - this is expected
+                }
+                return {
+                    success: true,
+                    parentTable: validatedParentTable,
+                    controlColumn: validatedControlColumn,
+                    interval: validatedInterval,
+                    premake: premake !== undefined && !isNaN(premake) ? premake : 4,
+                    maintenanceRan,
+                    // Suppress raw maintenanceError - the message/hint explains the situation clearly
+                    message: maintenanceRan
+                        ? `Partition set created for ${validatedParentTable} on column ${validatedControlColumn}. Initial partitions created.`
+                        : `Partition set registered for ${validatedParentTable} on column ${validatedControlColumn}. ` +
+                            `No child partitions created yet - pg_partman needs data or a startPartition that matches the control column type.`,
+                    hint: !maintenanceRan
+                        ? 'For DATE columns, use a date like "2024-01-01". For TIMESTAMP columns, "now" works. ' +
+                            "Otherwise, insert data first and run pg_partman_run_maintenance."
+                        : undefined,
+                };
             }
-            catch {
-                // Maintenance may fail for new partition sets without data - this is expected
+            catch (error) {
+                return {
+                    success: false,
+                    error: formatPostgresError(error, {
+                        tool: "pg_partman_create_parent",
+                    }),
+                };
             }
-            return {
-                success: true,
-                parentTable: validatedParentTable,
-                controlColumn: validatedControlColumn,
-                interval: validatedInterval,
-                premake: premake ?? 4,
-                maintenanceRan,
-                // Suppress raw maintenanceError - the message/hint explains the situation clearly
-                message: maintenanceRan
-                    ? `Partition set created for ${validatedParentTable} on column ${validatedControlColumn}. Initial partitions created.`
-                    : `Partition set registered for ${validatedParentTable} on column ${validatedControlColumn}. ` +
-                        `No child partitions created yet - pg_partman needs data or a startPartition that matches the control column type.`,
-                hint: !maintenanceRan
-                    ? 'For DATE columns, use a date like "2024-01-01". For TIMESTAMP columns, "now" works. ' +
-                        "Otherwise, insert data first and run pg_partman_run_maintenance."
-                    : undefined,
-            };
         },
     };
 }
@@ -249,134 +273,144 @@ Maintains all partition sets if no specific parent table is specified.`,
         annotations: write("Run Partition Maintenance"),
         icons: getToolIcons("partman", write("Run Partition Maintenance")),
         handler: async (params, _context) => {
-            const { parentTable, analyze } = PartmanRunMaintenanceSchema.parse(params);
-            const partmanSchema = await getPartmanSchema(adapter);
-            // If specific table provided, validate and run maintenance directly
-            if (parentTable !== undefined) {
-                // Check if table has a pg_partman configuration
-                const configCheck = await adapter.executeQuery(`SELECT 1 FROM ${partmanSchema}.part_config WHERE parent_table = $1`, [parentTable]);
-                if ((configCheck.rows?.length ?? 0) === 0) {
-                    return {
-                        success: false,
-                        parentTable,
-                        error: `Table '${parentTable}' is not managed by pg_partman.`,
-                        hint: "Use pg_partman_create_parent to set up partitioning, or pg_partman_show_config to list managed tables.",
-                    };
-                }
-                const args = [`p_parent_table := '${parentTable}'`];
-                if (analyze !== undefined) {
-                    args.push(`p_analyze := ${String(analyze)}`);
-                }
-                try {
-                    const sql = `SELECT ${partmanSchema}.run_maintenance(${args.join(", ")})`;
-                    await adapter.executeQuery(sql);
-                    return {
-                        success: true,
-                        parentTable,
-                        analyze: analyze ?? true,
-                        message: `Maintenance completed for ${parentTable}`,
-                    };
-                }
-                catch (e) {
-                    // Extract clean error message (first line only, remove PL/pgSQL context)
-                    let errorMsg = e instanceof Error ? e.message : String(e);
-                    const fullError = errorMsg;
-                    errorMsg = errorMsg.split("\n")[0] ?? errorMsg;
-                    errorMsg = errorMsg.replace(/\s+CONTEXT:.*$/i, "").trim();
-                    // Catch pg_partman internal errors about NULL child tables
-                    if (fullError.includes("Child table given does not exist") ||
-                        fullError.includes("<NULL>")) {
+            try {
+                const { parentTable, analyze } = PartmanRunMaintenanceSchema.parse(params);
+                const partmanSchema = await getPartmanSchema(adapter);
+                // If specific table provided, validate and run maintenance directly
+                if (parentTable !== undefined) {
+                    // Check if table has a pg_partman configuration
+                    const configCheck = await adapter.executeQuery(`SELECT 1 FROM ${partmanSchema}.part_config WHERE parent_table = $1`, [parentTable]);
+                    if ((configCheck.rows?.length ?? 0) === 0) {
                         return {
                             success: false,
                             parentTable,
-                            error: "Partition set has no child partitions yet.",
-                            hint: "For new partition sets, ensure startPartition is valid for your data. " +
-                                "Insert data first, then run maintenance, or specify a valid startPartition when creating the parent.",
+                            error: `Table '${parentTable}' is not managed by pg_partman.`,
+                            hint: "Use pg_partman_create_parent to set up partitioning, or pg_partman_show_config to list managed tables.",
+                        };
+                    }
+                    const args = [`p_parent_table := '${parentTable}'`];
+                    if (analyze !== undefined) {
+                        args.push(`p_analyze := ${String(analyze)}`);
+                    }
+                    try {
+                        const sql = `SELECT ${partmanSchema}.run_maintenance(${args.join(", ")})`;
+                        await adapter.executeQuery(sql);
+                        return {
+                            success: true,
+                            parentTable,
+                            analyze: analyze ?? true,
+                            message: `Maintenance completed for ${parentTable}`,
+                        };
+                    }
+                    catch (e) {
+                        // Extract clean error message (first line only, remove PL/pgSQL context)
+                        let errorMsg = e instanceof Error ? e.message : String(e);
+                        const fullError = errorMsg;
+                        errorMsg = errorMsg.split("\n")[0] ?? errorMsg;
+                        errorMsg = errorMsg.replace(/\s+CONTEXT:.*$/i, "").trim();
+                        // Catch pg_partman internal errors about NULL child tables
+                        if (fullError.includes("Child table given does not exist") ||
+                            fullError.includes("<NULL>")) {
+                            return {
+                                success: false,
+                                parentTable,
+                                error: "Partition set has no child partitions yet.",
+                                hint: "For new partition sets, ensure startPartition is valid for your data. " +
+                                    "Insert data first, then run maintenance, or specify a valid startPartition when creating the parent.",
+                            };
+                        }
+                        // Return clean error response instead of throwing with stack trace
+                        return {
+                            success: false,
+                            parentTable,
+                            error: errorMsg,
+                            hint: "Check that the parent table exists, is properly partitioned, and has valid pg_partman configuration. " +
+                                "Use pg_partman_show_config to verify configuration.",
                         };
                     }
-                    // Return clean error response instead of throwing with stack trace
-                    return {
-                        success: false,
-                        parentTable,
-                        error: errorMsg,
-                        hint: "Check that the parent table exists, is properly partitioned, and has valid pg_partman configuration. " +
-                            "Use pg_partman_show_config to verify configuration.",
-                    };
                 }
-            }
-            // For all partition sets, iterate ourselves to handle orphaned configs gracefully
-            const configsResult = await adapter.executeQuery(`
+                // For all partition sets, iterate ourselves to handle orphaned configs gracefully
+                const configsResult = await adapter.executeQuery(`
                 SELECT parent_table FROM ${partmanSchema}.part_config
             `);
-            const configs = configsResult.rows ?? [];
-            const maintained = [];
-            const orphanedTables = [];
-            const errors = [];
-            for (const config of configs) {
-                const table = config["parent_table"];
-                // Check if table still exists
-                const [schema, tableName] = table.includes(".")
-                    ? [table.split(".")[0], table.split(".")[1]]
-                    : ["public", table];
-                const tableExistsResult = await adapter.executeQuery(`
+                const configs = configsResult.rows ?? [];
+                const maintained = [];
+                const orphanedTables = [];
+                const errors = [];
+                for (const config of configs) {
+                    const table = config["parent_table"];
+                    // Check if table still exists
+                    const [schema, tableName] = table.includes(".")
+                        ? [table.split(".")[0], table.split(".")[1]]
+                        : ["public", table];
+                    const tableExistsResult = await adapter.executeQuery(`
                     SELECT 1 FROM information_schema.tables
                     WHERE table_schema = $1 AND table_name = $2
                 `, [schema, tableName]);
-                if ((tableExistsResult.rows?.length ?? 0) === 0) {
-                    orphanedTables.push(table);
-                    continue;
-                }
-                // Run maintenance for this table
-                try {
-                    const args = [`p_parent_table := '${table}'`];
-                    if (analyze !== undefined) {
-                        args.push(`p_analyze := ${String(analyze)}`);
+                    if ((tableExistsResult.rows?.length ?? 0) === 0) {
+                        orphanedTables.push(table);
+                        continue;
                     }
-                    const sql = `SELECT ${partmanSchema}.run_maintenance(${args.join(", ")})`;
-                    await adapter.executeQuery(sql);
-                    maintained.push(table);
-                }
-                catch (error) {
-                    // Extract clean error message (first line only, remove PL/pgSQL context)
-                    let reason = error instanceof Error ? error.message : "Unknown error";
-                    reason = reason.split("\n")[0] ?? reason;
-                    reason = reason.replace(/\s+CONTEXT:.*$/i, "").trim();
-                    // Improve NULL child error with actionable guidance
-                    if (reason.includes("Child table") && reason.includes("NULL")) {
-                        reason =
-                            "No child partitions exist yet. For empty tables, ensure startPartition was set when creating the partition set. " +
-                                'TIP: Use pg_partman_create_parent with startPartition (e.g., "now" or a specific date) to bootstrap partitions.';
+                    // Run maintenance for this table
+                    try {
+                        const args = [`p_parent_table := '${table}'`];
+                        if (analyze !== undefined) {
+                            args.push(`p_analyze := ${String(analyze)}`);
+                        }
+                        const sql = `SELECT ${partmanSchema}.run_maintenance(${args.join(", ")})`;
+                        await adapter.executeQuery(sql);
+                        maintained.push(table);
+                    }
+                    catch (error) {
+                        // Extract clean error message (first line only, remove PL/pgSQL context)
+                        let reason = error instanceof Error ? error.message : "Unknown error";
+                        reason = reason.split("\n")[0] ?? reason;
+                        reason = reason.replace(/\s+CONTEXT:.*$/i, "").trim();
+                        // Improve NULL child error with actionable guidance
+                        if (reason.includes("Child table") && reason.includes("NULL")) {
+                            reason =
+                                "No child partitions exist yet. For empty tables, ensure startPartition was set when creating the partition set. " +
+                                    'TIP: Use pg_partman_create_parent with startPartition (e.g., "now" or a specific date) to bootstrap partitions.';
+                        }
+                        errors.push({
+                            table,
+                            reason,
+                        });
                     }
-                    errors.push({
-                        table,
-                        reason,
-                    });
                 }
+                // Determine success status
+                const skippedCount = orphanedTables.length + errors.length;
+                const allFailed = maintained.length === 0 && skippedCount > 0;
+                const partial = maintained.length > 0 && skippedCount > 0;
+                return {
+                    success: !allFailed,
+                    partial: partial ? true : undefined,
+                    parentTable: "all",
+                    analyze: analyze ?? true,
+                    maintained,
+                    orphaned: orphanedTables.length > 0
+                        ? {
+                            count: orphanedTables.length,
+                            tables: orphanedTables,
+                            hint: `Remove orphaned configs: DELETE FROM ${partmanSchema}.part_config WHERE parent_table = '<table_name>';`,
+                        }
+                        : undefined,
+                    errors: errors.length > 0 ? errors : undefined,
+                    message: allFailed
+                        ? `Maintenance failed for all ${String(skippedCount)} partition sets due to errors.`
+                        : skippedCount > 0
+                            ? `Maintenance completed for ${String(maintained.length)} partition sets. ${String(skippedCount)} skipped (${String(orphanedTables.length)} orphaned, ${String(errors.length)} errors).`
+                            : `Maintenance completed for all ${String(maintained.length)} partition sets`,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: formatPostgresError(error, {
+                        tool: "pg_partman_run_maintenance",
+                    }),
+                };
             }
-            // Determine success status
-            const skippedCount = orphanedTables.length + errors.length;
-            const allFailed = maintained.length === 0 && skippedCount > 0;
-            const partial = maintained.length > 0 && skippedCount > 0;
-            return {
-                success: !allFailed,
-                partial: partial ? true : undefined,
-                parentTable: "all",
-                analyze: analyze ?? true,
-                maintained,
-                orphaned: orphanedTables.length > 0
-                    ? {
-                        count: orphanedTables.length,
-                        tables: orphanedTables,
-                        hint: `Remove orphaned configs: DELETE FROM ${partmanSchema}.part_config WHERE parent_table = '<table_name>';`,
-                    }
-                    : undefined,
-                errors: errors.length > 0 ? errors : undefined,
-                message: allFailed
-                    ? `Maintenance failed for all ${String(skippedCount)} partition sets due to errors.`
-                    : skippedCount > 0
-                        ? `Maintenance completed for ${String(maintained.length)} partition sets. ${String(skippedCount)} skipped (${String(orphanedTables.length)} orphaned, ${String(errors.length)} errors).`
-                        : `Maintenance completed for all ${String(maintained.length)} partition sets`,
-            };
         },
     };
 }
@@ -395,62 +429,73 @@ export function createPartmanShowPartitionsTool(adapter) {
         annotations: readOnly("Show Partman Partitions"),
         icons: getToolIcons("partman", readOnly("Show Partman Partitions")),
         handler: async (params, _context) => {
-            const parsed = PartmanShowPartitionsSchema.parse(params);
-            const { parentTable, includeDefault, order } = parsed;
-            const limit = parsed.limit ?? DEFAULT_PARTITION_LIMIT;
-            // parentTable is required - provide clear error if missing
-            if (!parentTable) {
-                return {
-                    success: false,
-                    error: 'parentTable parameter is required. Specify the parent table (e.g., "public.events") to list its partitions.',
-                    hint: "Use pg_partman_show_config to list all partition sets first.",
-                };
-            }
-            const orderDir = order === "desc" ? "DESC" : "ASC";
-            const includeDefaultVal = includeDefault ?? false;
-            const partmanSchema = await getPartmanSchema(adapter);
-            // First check if table is managed by pg_partman
-            const configCheck = await adapter.executeQuery(`SELECT 1 FROM ${partmanSchema}.part_config WHERE parent_table = $1`, [parentTable]);
-            if ((configCheck.rows?.length ?? 0) === 0) {
-                return {
-                    success: false,
-                    error: `Table '${parentTable}' is not managed by pg_partman.`,
-                    hint: "Use pg_partman_create_parent to set up partitioning, or pg_partman_show_config to list managed tables.",
-                };
-            }
-            // First get total count for pagination
-            const countSql = `
+            try {
+                const parsed = PartmanShowPartitionsSchema.parse(params);
+                const { parentTable, includeDefault, order } = parsed;
+                const rawLimit = parsed.limit ?? DEFAULT_PARTITION_LIMIT;
+                const limit = isNaN(rawLimit) ? DEFAULT_PARTITION_LIMIT : rawLimit;
+                // parentTable is required - provide clear error if missing
+                if (!parentTable) {
+                    return {
+                        success: false,
+                        error: 'parentTable parameter is required. Specify the parent table (e.g., "public.events") to list its partitions.',
+                        hint: "Use pg_partman_show_config to list all partition sets first.",
+                    };
+                }
+                const orderDir = order === "desc" ? "DESC" : "ASC";
+                const includeDefaultVal = includeDefault ?? false;
+                const partmanSchema = await getPartmanSchema(adapter);
+                // First check if table is managed by pg_partman
+                const configCheck = await adapter.executeQuery(`SELECT 1 FROM ${partmanSchema}.part_config WHERE parent_table = $1`, [parentTable]);
+                if ((configCheck.rows?.length ?? 0) === 0) {
+                    return {
+                        success: false,
+                        error: `Table '${parentTable}' is not managed by pg_partman.`,
+                        hint: "Use pg_partman_create_parent to set up partitioning, or pg_partman_show_config to list managed tables.",
+                    };
+                }
+                // First get total count for pagination
+                const countSql = `
                 SELECT COUNT(*) as total FROM ${partmanSchema}.show_partitions(
                     p_parent_table := '${parentTable}',
                     p_include_default := ${String(includeDefaultVal)},
                     p_order := '${orderDir}'
                 )
             `;
-            const countResult = await adapter.executeQuery(countSql);
-            const totalCount = Number(countResult.rows?.[0]?.["total"] ?? 0);
-            // Apply limit (0 means no limit)
-            const applyLimit = limit > 0;
-            let sql = `
+                const countResult = await adapter.executeQuery(countSql);
+                const totalCount = Number(countResult.rows?.[0]?.["total"] ?? 0);
+                // Apply limit (0 means no limit)
+                const applyLimit = limit > 0;
+                let sql = `
                 SELECT * FROM ${partmanSchema}.show_partitions(
                     p_parent_table := '${parentTable}',
                     p_include_default := ${String(includeDefaultVal)},
                     p_order := '${orderDir}'
                 )
             `;
-            if (applyLimit) {
-                sql += ` LIMIT ${String(limit)}`;
+                if (applyLimit) {
+                    sql += ` LIMIT ${String(limit)}`;
+                }
+                const result = await adapter.executeQuery(sql);
+                const partitions = result.rows ?? [];
+                const truncated = applyLimit && totalCount > limit;
+                return {
+                    success: true,
+                    parentTable,
+                    partitions,
+                    count: partitions.length,
+                    truncated,
+                    totalCount,
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: formatPostgresError(error, {
+                        tool: "pg_partman_show_partitions",
+                    }),
+                };
             }
-            const result = await adapter.executeQuery(sql);
-            const partitions = result.rows ?? [];
-            const truncated = applyLimit && totalCount > limit;
-            return {
-                success: true,
-                parentTable,
-                partitions,
-                count: partitions.length,
-                truncated,
-                totalCount,
-            };
         },
     };
 }
@@ -467,90 +512,100 @@ export function createPartmanShowConfigTool(adapter) {
         annotations: readOnly("Show Partman Config"),
         icons: getToolIcons("partman", readOnly("Show Partman Config")),
         handler: async (params, _context) => {
-            const parsed = PartmanShowConfigSchema.parse(params);
-            const partmanSchema = await getPartmanSchema(adapter);
-            // Dynamically detect available columns to handle different pg_partman versions
-            const columnsResult = await adapter.executeQuery(`
+            try {
+                const parsed = PartmanShowConfigSchema.parse(params);
+                const partmanSchema = await getPartmanSchema(adapter);
+                // Dynamically detect available columns to handle different pg_partman versions
+                const columnsResult = await adapter.executeQuery(`
                 SELECT column_name
                 FROM information_schema.columns
                 WHERE table_schema = $1 AND table_name = 'part_config'
             `, [partmanSchema]);
-            const availableColumns = new Set((columnsResult.rows ?? []).map((r) => r["column_name"]));
-            // Build column list based on what's available
-            const baseColumns = [
-                "parent_table",
-                "control",
-                "partition_interval",
-                "partition_type",
-                "premake",
-                "automatic_maintenance",
-                "template_table",
-                "retention",
-                "retention_keep_table",
-                "epoch",
-                "default_table",
-            ];
-            // Add inherit_fk only if it exists (not in all pg_partman versions)
-            const columns = baseColumns.filter((c) => availableColumns.has(c));
-            if (availableColumns.has("inherit_fk")) {
-                columns.push("inherit_fk");
-            }
-            // Get total count first for pagination
-            let countSql = `SELECT COUNT(*) as total FROM ${partmanSchema}.part_config`;
-            const countParams = [];
-            if (parsed.parentTable !== undefined) {
-                countSql += " WHERE parent_table = $1";
-                countParams.push(parsed.parentTable);
-            }
-            const countResult = await adapter.executeQuery(countSql, countParams);
-            const totalCount = Number(countResult.rows?.[0]?.["total"] ?? 0);
-            // Apply limit (default 50, 0 means no limit)
-            const limit = parsed.limit ?? 50;
-            const applyLimit = limit > 0;
-            let sql = `SELECT ${columns.join(", ")} FROM ${partmanSchema}.part_config`;
-            const queryParams = [];
-            if (parsed.parentTable !== undefined) {
-                sql += " WHERE parent_table = $1";
-                queryParams.push(parsed.parentTable);
-            }
-            sql += " ORDER BY parent_table";
-            if (applyLimit) {
-                sql += ` LIMIT ${String(limit)}`;
-            }
-            const result = await adapter.executeQuery(sql, queryParams);
-            const configs = result.rows ?? [];
-            // Check each config to see if parent table still exists (orphaned detection)
-            const configsWithStatus = await Promise.all(configs.map(async (config) => {
-                const parentTable = config["parent_table"];
-                const [schema, tableName] = parentTable.includes(".")
-                    ? [parentTable.split(".")[0], parentTable.split(".")[1]]
-                    : ["public", parentTable];
-                const tableExistsResult = await adapter.executeQuery(`
+                const availableColumns = new Set((columnsResult.rows ?? []).map((r) => r["column_name"]));
+                // Build column list based on what's available
+                const baseColumns = [
+                    "parent_table",
+                    "control",
+                    "partition_interval",
+                    "partition_type",
+                    "premake",
+                    "automatic_maintenance",
+                    "template_table",
+                    "retention",
+                    "retention_keep_table",
+                    "epoch",
+                    "default_table",
+                ];
+                // Add inherit_fk only if it exists (not in all pg_partman versions)
+                const columns = baseColumns.filter((c) => availableColumns.has(c));
+                if (availableColumns.has("inherit_fk")) {
+                    columns.push("inherit_fk");
+                }
+                // Get total count first for pagination
+                let countSql = `SELECT COUNT(*) as total FROM ${partmanSchema}.part_config`;
+                const countParams = [];
+                if (parsed.parentTable !== undefined) {
+                    countSql += " WHERE parent_table = $1";
+                    countParams.push(parsed.parentTable);
+                }
+                const countResult = await adapter.executeQuery(countSql, countParams);
+                const totalCount = Number(countResult.rows?.[0]?.["total"] ?? 0);
+                // Apply limit (default 50, 0 means no limit)
+                const rawLimit = parsed.limit ?? 50;
+                const limit = isNaN(rawLimit) ? 50 : rawLimit;
+                const applyLimit = limit > 0;
+                let sql = `SELECT ${columns.join(", ")} FROM ${partmanSchema}.part_config`;
+                const queryParams = [];
+                if (parsed.parentTable !== undefined) {
+                    sql += " WHERE parent_table = $1";
+                    queryParams.push(parsed.parentTable);
+                }
+                sql += " ORDER BY parent_table";
+                if (applyLimit) {
+                    sql += ` LIMIT ${String(limit)}`;
+                }
+                const result = await adapter.executeQuery(sql, queryParams);
+                const configs = result.rows ?? [];
+                // Check each config to see if parent table still exists (orphaned detection)
+                const configsWithStatus = await Promise.all(configs.map(async (config) => {
+                    const parentTable = config["parent_table"];
+                    const [schema, tableName] = parentTable.includes(".")
+                        ? [parentTable.split(".")[0], parentTable.split(".")[1]]
+                        : ["public", parentTable];
+                    const tableExistsResult = await adapter.executeQuery(`
                         SELECT 1 FROM information_schema.tables
                         WHERE table_schema = $1 AND table_name = $2
                     `, [schema, tableName]);
-                const orphaned = (tableExistsResult.rows?.length ?? 0) === 0;
-                return { ...config, orphaned };
-            }));
-            const orphanedCount = configsWithStatus.filter((c) => c.orphaned).length;
-            const truncated = applyLimit && totalCount > limit;
-            // Provide hint if a specific table was requested but not found
-            let notFoundHint;
-            if (parsed.parentTable !== undefined && configsWithStatus.length === 0) {
-                notFoundHint = `Table '${parsed.parentTable}' is not managed by pg_partman. Use pg_partman_create_parent to set up partitioning.`;
+                    const orphaned = (tableExistsResult.rows?.length ?? 0) === 0;
+                    return { ...config, orphaned };
+                }));
+                const orphanedCount = configsWithStatus.filter((c) => c.orphaned).length;
+                const truncated = applyLimit && totalCount > limit;
+                // Provide hint if a specific table was requested but not found
+                let notFoundHint;
+                if (parsed.parentTable !== undefined &&
+                    configsWithStatus.length === 0) {
+                    notFoundHint = `Table '${parsed.parentTable}' is not managed by pg_partman. Use pg_partman_create_parent to set up partitioning.`;
+                }
+                return {
+                    configs: configsWithStatus,
+                    count: configsWithStatus.length,
+                    truncated,
+                    totalCount,
+                    orphanedCount: orphanedCount > 0 ? orphanedCount : undefined,
+                    hint: notFoundHint ??
+                        (orphanedCount > 0
+                            ? `${String(orphanedCount)} orphaned config(s) found - parent table no longer exists. ` +
+                                `To clean up, use raw SQL: DELETE FROM ${partmanSchema}.part_config WHERE parent_table = '<table_name>';`
+                            : undefined),
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: formatPostgresError(error, { tool: "pg_partman_show_config" }),
+                };
             }
-            return {
-                configs: configsWithStatus,
-                count: configsWithStatus.length,
-                truncated,
-                totalCount,
-                orphanedCount: orphanedCount > 0 ? orphanedCount : undefined,
-                hint: notFoundHint ??
-                    (orphanedCount > 0
-                        ? `${String(orphanedCount)} orphaned config(s) found - parent table no longer exists. ` +
-                            `To clean up, use raw SQL: DELETE FROM ${partmanSchema}.part_config WHERE parent_table = '<table_name>';`
-                        : undefined),
-            };
         },
     };
 }