@neverinfamous/postgres-mcp 1.2.0 → 2.0.0

package/dist/adapters/postgresql/tools/jsonb/basic.js

@@ -3,9 +3,12 @@
  *
  * Core JSONB operations including extract, set, insert, delete, contains, path query, aggregation, and type checks.
  */
-import { z } from "zod";
+import { z, ZodError } from "zod";
 import { readOnly, write } from "../../../../utils/annotations.js";
 import { getToolIcons } from "../../../../utils/icons.js";
+import { formatPostgresError } from "../core/error-helpers.js";
+import { sanitizeWhereClause } from "../../../../utils/where-clause.js";
+import { sanitizeTableName, sanitizeIdentifier, } from "../../../../utils/identifiers.js";
 import { 
 // Base schemas (for MCP inputSchema visibility)
 JsonbExtractSchemaBase, JsonbSetSchemaBase, JsonbContainsSchemaBase, JsonbPathQuerySchemaBase, JsonbInsertSchemaBase, JsonbDeleteSchemaBase, JsonbTypeofSchemaBase, JsonbKeysSchemaBase, JsonbStripNullsSchemaBase, JsonbAggSchemaBase, 
@@ -22,6 +25,28 @@ JsonbExtractOutputSchema, JsonbSetOutputSchema, JsonbInsertOutputSchema, JsonbDe
 function toJsonString(value) {
     return JSON.stringify(value);
 }
+/**
+ * Resolve table and schema for JSONB tools.
+ * Validates schema existence when non-public, returns schema-qualified table name.
+ * Returns [qualifiedTable, null] on success, or [null, errorResponse] on failure.
+ */
+async function resolveJsonbTable(adapter, table, schema) {
+    const schemaName = schema ?? "public";
+    // Validate schema existence for non-public schemas
+    if (schemaName !== "public") {
+        const schemaResult = await adapter.executeQuery(`SELECT 1 FROM information_schema.schemata WHERE schema_name = $1`, [schemaName]);
+        if (!schemaResult.rows || schemaResult.rows.length === 0) {
+            return [
+                null,
+                {
+                    success: false,
+                    error: `Schema '${schemaName}' does not exist. Use pg_list_objects with type 'table' to see available schemas.`,
+                },
+            ];
+        }
+    }
+    return [sanitizeTableName(table, schemaName), null];
+}
 export function createJsonbExtractTool(adapter) {
     return {
         name: "pg_jsonb_extract",
@@ -32,50 +57,72 @@ export function createJsonbExtractTool(adapter) {
         annotations: readOnly("JSONB Extract"),
         icons: getToolIcons("jsonb", readOnly("JSONB Extract")),
         handler: async (params, _context) => {
-            const parsed = JsonbExtractSchema.parse(params);
-            const whereClause = parsed.where ? ` WHERE ${parsed.where}` : "";
-            const limitClause = parsed.limit !== undefined ? ` LIMIT ${String(parsed.limit)}` : "";
-            // Use normalizePathToArray for PostgreSQL #> operator
-            const pathArray = normalizePathToArray(parsed.path);
-            // After preprocess and refine, table and column are guaranteed set
-            const table = parsed.table ?? parsed.tableName;
-            const column = parsed.column ?? parsed.col;
-            if (!table || !column) {
-                throw new Error("table and column are required");
-            }
-            // Build select expression with optional additional columns
-            let selectExpr = `"${column}" #> $1 as extracted_value`;
-            if (parsed.select !== undefined && parsed.select.length > 0) {
-                const additionalCols = parsed.select
-                    .map((c) => {
-                    // Handle expressions vs simple column names
-                    const needsQuote = !c.includes("->") &&
-                        !c.includes("(") &&
-                        !c.includes("::") &&
-                        /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(c);
-                    return needsQuote ? `"${c}"` : c;
-                })
-                    .join(", ");
-                selectExpr = `${additionalCols}, ${selectExpr}`;
-            }
-            const sql = `SELECT ${selectExpr} FROM "${table}"${whereClause}${limitClause}`;
-            const result = await adapter.executeQuery(sql, [pathArray]);
-            // If select columns were provided, return full row objects
-            if (parsed.select !== undefined && parsed.select.length > 0) {
-                const rows = result.rows?.map((r) => {
-                    // Rename extracted_value back to 'value' for consistency
-                    const row = {};
-                    for (const [key, val] of Object.entries(r)) {
-                        if (key === "extracted_value") {
-                            row["value"] = val;
-                        }
-                        else {
-                            row[key] = val;
+            try {
+                const parsed = JsonbExtractSchema.parse(params);
+                const whereClause = parsed.where
+                    ? ` WHERE ${sanitizeWhereClause(parsed.where)}`
+                    : "";
+                const limitClause = parsed.limit !== undefined ? ` LIMIT ${String(parsed.limit)}` : "";
+                // Use normalizePathToArray for PostgreSQL #> operator
+                const pathArray = normalizePathToArray(parsed.path);
+                // After preprocess and refine, table and column are guaranteed set
+                const table = parsed.table ?? parsed.tableName;
+                const column = parsed.column ?? parsed.col;
+                if (!table || !column) {
+                    return { success: false, error: "table and column are required" };
+                }
+                // Validate schema and build qualified table name
+                const [qualifiedTable, tableError] = await resolveJsonbTable(adapter, table, parsed.schema);
+                if (tableError)
+                    return tableError;
+                // Build select expression with optional additional columns
+                let selectExpr = `${sanitizeIdentifier(column)} #> $1 as extracted_value`;
+                if (parsed.select !== undefined && parsed.select.length > 0) {
+                    const additionalCols = parsed.select
+                        .map((c) => {
+                        // Handle expressions vs simple column names
+                        const needsQuote = !c.includes("->") &&
+                            !c.includes("(") &&
+                            !c.includes("::") &&
+                            /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(c);
+                        return needsQuote ? `"${c}"` : c;
+                    })
+                        .join(", ");
+                    selectExpr = `${additionalCols}, ${selectExpr}`;
+                }
+                const sql = `SELECT ${selectExpr} FROM ${qualifiedTable}${whereClause}${limitClause}`;
+                const result = await adapter.executeQuery(sql, [pathArray]);
+                // If select columns were provided, return full row objects
+                if (parsed.select !== undefined && parsed.select.length > 0) {
+                    const rows = result.rows?.map((r) => {
+                        // Rename extracted_value back to 'value' for consistency
+                        const row = {};
+                        for (const [key, val] of Object.entries(r)) {
+                            if (key === "extracted_value") {
+                                row["value"] = val;
+                            }
+                            else {
+                                row[key] = val;
+                            }
                         }
+                        return row;
+                    });
+                    const allNulls = rows?.every((r) => r["value"] === null) ?? false;
+                    const response = {
+                        rows,
+                        count: rows?.length ?? 0,
+                    };
+                    if (allNulls && (rows?.length ?? 0) > 0) {
+                        response.hint =
+                            "All values are null - path may not exist in data. Use pg_jsonb_typeof to check.";
                     }
-                    return row;
-                });
-                const allNulls = rows?.every((r) => r["value"] === null) ?? false;
+                    return response;
+                }
+                // Original behavior: return just the extracted values
+                // Wrap each value in an object with 'value' key for consistency with select mode
+                const rows = result.rows?.map((r) => ({ value: r["extracted_value"] }));
+                // Check if all results are null (path may not exist)
+                const allNulls = rows?.every((r) => r.value === null) ?? false;
                 const response = {
                     rows,
                     count: rows?.length ?? 0,
@@ -86,20 +133,14 @@ export function createJsonbExtractTool(adapter) {
                 }
                 return response;
             }
-            // Original behavior: return just the extracted values
-            // Wrap each value in an object with 'value' key for consistency with select mode
-            const rows = result.rows?.map((r) => ({ value: r["extracted_value"] }));
-            // Check if all results are null (path may not exist)
-            const allNulls = rows?.every((r) => r.value === null) ?? false;
-            const response = {
-                rows,
-                count: rows?.length ?? 0,
-            };
-            if (allNulls && (rows?.length ?? 0) > 0) {
-                response.hint =
-                    "All values are null - path may not exist in data. Use pg_jsonb_typeof to check.";
+            catch (error) {
+                return {
+                    success: false,
+                    error: formatPostgresError(error, {
+                        tool: "pg_jsonb_extract",
+                    }),
+                };
             }
-            return response;
         },
     };
 }
@@ -113,72 +154,92 @@ export function createJsonbSetTool(adapter) {
         annotations: write("JSONB Set"),
         icons: getToolIcons("jsonb", write("JSONB Set")),
         handler: async (params, _context) => {
-            const parsed = JsonbSetSchema.parse(params);
-            // Resolve table/column from optional aliases
-            const table = parsed.table ?? parsed.tableName;
-            const column = parsed.column ?? parsed.col;
-            if (!table || !column) {
-                throw new Error("table and column are required");
-            }
-            const { value, where, createMissing } = parsed;
-            // Normalize path to array format
-            const path = normalizePathToArray(parsed.path);
-            // Validate required 'where' parameter
-            if (!where || where.trim() === "") {
-                throw new Error('pg_jsonb_set requires a WHERE clause to identify rows to update. Example: where: "id = 1"');
-            }
-            // Validate value is provided (undefined would set column to null)
-            if (value === undefined) {
-                throw new Error("pg_jsonb_set requires a value parameter. To remove a key, use pg_jsonb_delete instead.");
-            }
-            const createFlag = createMissing !== false;
-            // Handle empty path - replace entire column value
-            if (path.length === 0) {
-                const sql = `UPDATE "${table}" SET "${column}" = $1::jsonb WHERE ${where}`;
-                const result = await adapter.executeQuery(sql, [toJsonString(value)]);
-                return {
-                    rowsAffected: result.rowsAffected,
-                    hint: "Replaced entire column value (empty path)",
-                };
+            try {
+                const parsed = JsonbSetSchema.parse(params);
+                // Resolve table/column from optional aliases
+                const table = parsed.table ?? parsed.tableName;
+                const column = parsed.column ?? parsed.col;
+                if (!table || !column) {
+                    return { success: false, error: "table and column are required" };
+                }
+                const { value, where, createMissing } = parsed;
+                // Validate schema and build qualified table name
+                const [qualifiedTable, tableError] = await resolveJsonbTable(adapter, table, parsed.schema);
+                if (tableError)
+                    return tableError;
+                // Normalize path to array format
+                const path = normalizePathToArray(parsed.path);
+                // Validate required 'where' parameter
+                if (!where || where.trim() === "") {
+                    return {
+                        success: false,
+                        error: 'pg_jsonb_set requires a WHERE clause to identify rows to update. Example: where: "id = 1"',
+                    };
+                }
+                // Validate value is provided (undefined would set column to null)
+                if (value === undefined) {
+                    return {
+                        success: false,
+                        error: "pg_jsonb_set requires a value parameter. To remove a key, use pg_jsonb_delete instead.",
+                    };
+                }
+                const createFlag = createMissing !== false;
+                // Handle empty path - replace entire column value
+                if (path.length === 0) {
+                    const sql = `UPDATE ${qualifiedTable} SET "${column}" = $1::jsonb WHERE ${sanitizeWhereClause(where)}`;
+                    const result = await adapter.executeQuery(sql, [toJsonString(value)]);
+                    return {
+                        rowsAffected: result.rowsAffected,
+                        hint: "Replaced entire column value (empty path)",
+                    };
+                }
+                // For deep nested paths with createMissing=true, build intermediate objects
+                // PostgreSQL's jsonb_set only creates one level, so we nest calls for deep paths
+                let sql;
+                if (createFlag && path.length > 1) {
+                    // Build nested jsonb_set calls to ensure each intermediate path exists
+                    // Start with COALESCE to handle NULL columns
+                    let expr = `COALESCE("${column}", '{}'::jsonb)`;
+                    // For each intermediate level, wrap in jsonb_set to initialize to {}
+                    for (let i = 0; i < path.length - 1; i++) {
+                        const subPath = path.slice(0, i + 1);
+                        const pathStr = "{" + subPath.join(",") + "}";
+                        // Use COALESCE on the extraction from current expr, not original column
+                        // This properly chains the nested creation
+                        expr = `jsonb_set(${expr}, '${pathStr}'::text[], COALESCE((${expr}) #> '${pathStr}'::text[], '{}'::jsonb), true)`;
+                    }
+                    // Final set with actual value
+                    const fullPathStr = "{" + path.join(",") + "}";
+                    expr = `jsonb_set(${expr}, '${fullPathStr}'::text[], $1::jsonb, true)`;
+                    sql = `UPDATE ${qualifiedTable} SET "${column}" = ${expr} WHERE ${sanitizeWhereClause(where)}`;
+                    const result = await adapter.executeQuery(sql, [toJsonString(value)]);
+                    return {
+                        rowsAffected: result.rowsAffected,
+                        hint: "rowsAffected counts matched rows, not path creations",
+                    };
+                }
+                else {
+                    // Use COALESCE to handle NULL columns - initialize to empty object
+                    sql = `UPDATE ${qualifiedTable} SET "${column}" = jsonb_set(COALESCE("${column}", '{}'::jsonb), $1, $2::jsonb, $3) WHERE ${sanitizeWhereClause(where)}`;
+                    const result = await adapter.executeQuery(sql, [
+                        path,
+                        toJsonString(value),
+                        createFlag,
+                    ]);
+                    const hint = createFlag
+                        ? "NULL columns initialized to {}; createMissing creates path if absent"
+                        : "createMissing=false: path must exist or value won't be set";
+                    return { rowsAffected: result.rowsAffected, hint };
+                }
             }
-            // For deep nested paths with createMissing=true, build intermediate objects
-            // PostgreSQL's jsonb_set only creates one level, so we nest calls for deep paths
-            let sql;
-            if (createFlag && path.length > 1) {
-                // Build nested jsonb_set calls to ensure each intermediate path exists
-                // Start with COALESCE to handle NULL columns
-                let expr = `COALESCE("${column}", '{}'::jsonb)`;
-                // For each intermediate level, wrap in jsonb_set to initialize to {}
-                for (let i = 0; i < path.length - 1; i++) {
-                    const subPath = path.slice(0, i + 1);
-                    const pathStr = "{" + subPath.join(",") + "}";
-                    // Use COALESCE on the extraction from current expr, not original column
-                    // This properly chains the nested creation
-                    expr = `jsonb_set(${expr}, '${pathStr}'::text[], COALESCE((${expr}) #> '${pathStr}'::text[], '{}'::jsonb), true)`;
-                }
-                // Final set with actual value
-                const fullPathStr = "{" + path.join(",") + "}";
-                expr = `jsonb_set(${expr}, '${fullPathStr}'::text[], $1::jsonb, true)`;
-                sql = `UPDATE "${table}" SET "${column}" = ${expr} WHERE ${where}`;
-                const result = await adapter.executeQuery(sql, [toJsonString(value)]);
+            catch (error) {
                 return {
-                    rowsAffected: result.rowsAffected,
-                    hint: "rowsAffected counts matched rows, not path creations",
+                    success: false,
+                    error: formatPostgresError(error, {
+                        tool: "pg_jsonb_set",
+                    }),
                 };
             }
-            else {
-                // Use COALESCE to handle NULL columns - initialize to empty object
-                sql = `UPDATE "${table}" SET "${column}" = jsonb_set(COALESCE("${column}", '{}'::jsonb), $1, $2::jsonb, $3) WHERE ${where}`;
-                const result = await adapter.executeQuery(sql, [
-                    path,
-                    toJsonString(value),
-                    createFlag,
-                ]);
-                const hint = createFlag
-                    ? "NULL columns initialized to {}; createMissing creates path if absent"
-                    : "createMissing=false: path must exist or value won't be set";
-                return { rowsAffected: result.rowsAffected, hint };
-            }
         },
     };
 }
@@ -192,52 +253,68 @@ export function createJsonbInsertTool(adapter) {
         annotations: write("JSONB Insert"),
         icons: getToolIcons("jsonb", write("JSONB Insert")),
         handler: async (params, _context) => {
-            const parsed = JsonbInsertSchema.parse(params);
-            // Resolve table/column from optional aliases
-            const table = parsed.table ?? parsed.tableName;
-            const column = parsed.column ?? parsed.col;
-            if (!table || !column) {
-                throw new Error("table and column are required");
-            }
-            // Normalize path - convert numeric segments to numbers for PostgreSQL
-            const path = normalizePathForInsert(parsed.path);
-            // Validate required 'where' parameter
-            if (!parsed.where || parsed.where.trim() === "") {
-                throw new Error('pg_jsonb_insert requires a WHERE clause to identify rows to update. Example: where: "id = 1"');
-            }
-            // Check for NULL columns first - jsonb_insert requires existing array context
-            const checkSql = `SELECT COUNT(*) as null_count FROM "${table}" WHERE ${parsed.where} AND "${column}" IS NULL`;
-            const checkResult = await adapter.executeQuery(checkSql);
-            const nullCount = Number(checkResult.rows?.[0]?.["null_count"] ?? 0);
-            if (nullCount > 0) {
-                throw new Error(`pg_jsonb_insert cannot operate on NULL columns. Use pg_jsonb_set to initialize the column first: pg_jsonb_set({table: "${table}", column: "${column}", path: "myarray", value: [], where: "..."})`);
-            }
-            // Validate target path points to an array, not an object
-            // Get the parent path (one level up from where we're inserting)
-            const parentPath = path.slice(0, -1);
-            if (parentPath.length === 0) {
-                // Inserting at root level - check column type
-                const typeCheckSql = `SELECT jsonb_typeof("${column}") as type FROM "${table}" WHERE ${parsed.where} LIMIT 1`;
-                const typeResult = await adapter.executeQuery(typeCheckSql);
-                const columnType = typeResult.rows?.[0]?.["type"];
-                if (columnType && columnType !== "array") {
-                    throw new Error(`pg_jsonb_insert requires an array target. Column contains '${columnType}'. Use pg_jsonb_set for objects.`);
+            try {
+                const parsed = JsonbInsertSchema.parse(params);
+                // Resolve table/column from optional aliases
+                const table = parsed.table ?? parsed.tableName;
+                const column = parsed.column ?? parsed.col;
+                if (!table || !column) {
+                    return { success: false, error: "table and column are required" };
                 }
-            }
-            else {
-                // Check the parent path type
-                const typeCheckSql = `SELECT jsonb_typeof("${column}" #> $1) as type FROM "${table}" WHERE ${parsed.where} LIMIT 1`;
-                const parentPathStrings = parentPath.map((p) => String(p));
-                const typeResult = await adapter.executeQuery(typeCheckSql, [
-                    parentPathStrings,
-                ]);
-                const targetType = typeResult.rows?.[0]?.["type"];
-                if (targetType && targetType !== "array") {
-                    throw new Error(`pg_jsonb_insert requires an array target. Path '${parentPathStrings.join(".")}' contains '${targetType}'. Use pg_jsonb_set for objects.`);
+                // Validate schema and build qualified table name
+                const [qualifiedTable, tableError] = await resolveJsonbTable(adapter, table, parsed.schema);
+                if (tableError)
+                    return tableError;
+                // Normalize path - convert numeric segments to numbers for PostgreSQL
+                const path = normalizePathForInsert(parsed.path);
+                // Validate required 'where' parameter
+                if (!parsed.where || parsed.where.trim() === "") {
+                    return {
+                        success: false,
+                        error: 'pg_jsonb_insert requires a WHERE clause to identify rows to update. Example: where: "id = 1"',
+                    };
                 }
-            }
-            const sql = `UPDATE "${table}" SET "${column}" = jsonb_insert("${column}", $1, $2::jsonb, $3) WHERE ${parsed.where}`;
-            try {
+                // Check for NULL columns first - jsonb_insert requires existing array context
+                const checkSql = `SELECT COUNT(*) as null_count FROM ${qualifiedTable} WHERE ${sanitizeWhereClause(parsed.where)} AND "${column}" IS NULL`;
+                const checkResult = await adapter.executeQuery(checkSql);
+                const nullCount = Number(checkResult.rows?.[0]?.["null_count"] ?? 0);
+                if (nullCount > 0) {
+                    return {
+                        success: false,
+                        error: `pg_jsonb_insert cannot operate on NULL columns. Use pg_jsonb_set to initialize the column first: pg_jsonb_set({table: "${table}", column: "${column}", path: "myarray", value: [], where: "..."})`,
+                    };
+                }
+                // Validate target path points to an array, not an object
+                // Get the parent path (one level up from where we're inserting)
+                const parentPath = path.slice(0, -1);
+                if (parentPath.length === 0) {
+                    // Inserting at root level - check column type
+                    const typeCheckSql = `SELECT jsonb_typeof("${column}") as type FROM ${qualifiedTable} WHERE ${sanitizeWhereClause(parsed.where)} LIMIT 1`;
+                    const typeResult = await adapter.executeQuery(typeCheckSql);
+                    const columnType = typeResult.rows?.[0]?.["type"];
+                    if (columnType && columnType !== "array") {
+                        return {
+                            success: false,
+                            error: `pg_jsonb_insert requires an array target. Column contains '${columnType}'. Use pg_jsonb_set for objects.`,
+                        };
+                    }
+                }
+                else {
+                    // Check the parent path type
+                    const typeCheckSql = `SELECT jsonb_typeof("${column}" #> $1) as type FROM ${qualifiedTable} WHERE ${sanitizeWhereClause(parsed.where)} LIMIT 1`;
+                    const parentPathStrings = parentPath.map((p) => String(p));
+                    const typeResult = await adapter.executeQuery(typeCheckSql, [
+                        parentPathStrings,
+                    ]);
+                    const targetType = typeResult.rows?.[0]?.["type"];
+                    if (targetType && targetType !== "array") {
+                        return {
+                            success: false,
+                            error: `pg_jsonb_insert requires an array target. Path '${parentPathStrings.join(".")}' contains '${targetType}'. Use pg_jsonb_set for objects.`,
+                        };
+                    }
+                }
+                const sql = `UPDATE ${qualifiedTable} SET "${column}" = jsonb_insert("${column}", $1, $2::jsonb, $3) WHERE ${sanitizeWhereClause(parsed.where)}`;
                 const result = await adapter.executeQuery(sql, [
                     path,
                     toJsonString(parsed.value),
@@ -246,16 +323,27 @@ export function createJsonbInsertTool(adapter) {
                 return { rowsAffected: result.rowsAffected };
             }
             catch (error) {
-                // Improve PostgreSQL error messages
+                // Improve specific PostgreSQL error messages
                 if (error instanceof Error &&
                     error.message.includes("cannot replace existing key")) {
-                    throw new Error(`pg_jsonb_insert is for arrays only. For objects, use pg_jsonb_set. If updating an existing array element, use pg_jsonb_set.`);
+                    return {
+                        success: false,
+                        error: `pg_jsonb_insert is for arrays only. For objects, use pg_jsonb_set. If updating an existing array element, use pg_jsonb_set.`,
+                    };
                 }
                 if (error instanceof Error &&
                     error.message.includes("path element is not an integer")) {
-                    throw new Error(`pg_jsonb_insert requires numeric index for array position. Use array format with number: ["tags", 0] not ["tags", "0"] or "tags.0"`);
+                    return {
+                        success: false,
+                        error: `pg_jsonb_insert requires numeric index for array position. Use array format with number: ["tags", 0] not ["tags", "0"] or "tags.0"`,
+                    };
                 }
-                throw error;
+                return {
+                    success: false,
+                    error: formatPostgresError(error, {
+                        tool: "pg_jsonb_insert",
+                    }),
+                };
             }
         },
     };
@@ -270,62 +358,72 @@ export function createJsonbDeleteTool(adapter) {
         annotations: write("JSONB Delete"),
         icons: getToolIcons("jsonb", write("JSONB Delete")),
         handler: async (params, _context) => {
-            const parsed = JsonbDeleteSchema.parse(params);
-            // Resolve table/column from optional aliases
-            const table = parsed.table ?? parsed.tableName;
-            const column = parsed.column ?? parsed.col;
-            if (!table || !column) {
-                throw new Error("table and column are required");
-            }
-            // Validate required 'where' parameter
-            if (!parsed.where || parsed.where.trim() === "") {
-                throw new Error('pg_jsonb_delete requires a WHERE clause to identify rows to update. Example: where: "id = 1"');
-            }
-            // Validate path is not empty
-            if (parsed.path === "" ||
-                (Array.isArray(parsed.path) && parsed.path.length === 0)) {
-                throw new Error("pg_jsonb_delete requires a non-empty path. Provide a key name or path to delete.");
-            }
-            // Determine if path should be treated as nested (array path) or single key
-            // - Array paths: ["a", "b"], ["0"], [1]
-            // - Bare number: 0, 1 (treat as array index)
-            // - Dot notation: "a.b.c"
-            // - Numeric string: "0", "1" (treat as array index)
-            // - Single key: "mykey" (use - operator, not #-)
-            let pathForPostgres;
-            let useArrayOperator = false;
-            if (typeof parsed.path === "number") {
-                // Bare number - treat as array index
-                pathForPostgres = [String(parsed.path)];
-                useArrayOperator = true;
-            }
-            else if (Array.isArray(parsed.path)) {
-                // Already an array - normalize to string array
-                pathForPostgres = normalizePathToArray(parsed.path);
-                useArrayOperator = true;
-            }
-            else if (parsed.path.includes(".")) {
-                // Dot notation - convert to array
-                pathForPostgres = parsed.path.split(".").filter((p) => p !== "");
-                useArrayOperator = true;
-            }
-            else if (/^\d+$/.test(parsed.path)) {
-                // Pure numeric string - treat as array index
-                pathForPostgres = [parsed.path];
-                useArrayOperator = true;
+            try {
+                const parsed = JsonbDeleteSchema.parse(params);
+                // Resolve table/column from optional aliases
+                const table = parsed.table ?? parsed.tableName;
+                const column = parsed.column ?? parsed.col;
+                if (!table || !column) {
+                    return { success: false, error: "table and column are required" };
+                }
+                // Validate schema and build qualified table name
+                const [qualifiedTable, tableError] = await resolveJsonbTable(adapter, table, parsed.schema);
+                if (tableError)
+                    return tableError;
+                // Validate required 'where' parameter
+                if (!parsed.where || parsed.where.trim() === "") {
+                    return {
+                        success: false,
+                        error: 'pg_jsonb_delete requires a WHERE clause to identify rows to update. Example: where: "id = 1"',
+                    };
+                }
+                // Validate path is not empty
+                if (parsed.path === "" ||
+                    (Array.isArray(parsed.path) && parsed.path.length === 0)) {
+                    return {
+                        success: false,
+                        error: "pg_jsonb_delete requires a non-empty path. Provide a key name or path to delete.",
+                    };
+                }
+                // Determine if path should be treated as nested (array path) or single key
+                let pathForPostgres;
+                let useArrayOperator;
+                if (typeof parsed.path === "number") {
+                    pathForPostgres = [String(parsed.path)];
+                    useArrayOperator = true;
+                }
+                else if (Array.isArray(parsed.path)) {
+                    pathForPostgres = normalizePathToArray(parsed.path);
+                    useArrayOperator = true;
+                }
+                else if (parsed.path.includes(".")) {
+                    pathForPostgres = parsed.path.split(".").filter((p) => p !== "");
+                    useArrayOperator = true;
+                }
+                else if (/^\d+$/.test(parsed.path)) {
+                    pathForPostgres = [parsed.path];
+                    useArrayOperator = true;
+                }
+                else {
+                    pathForPostgres = parsed.path;
+                    useArrayOperator = false;
+                }
+                const pathExpr = useArrayOperator ? `#- $1` : `- $1`;
+                const sql = `UPDATE ${qualifiedTable} SET "${column}" = "${column}" ${pathExpr} WHERE ${sanitizeWhereClause(parsed.where)}`;
+                const result = await adapter.executeQuery(sql, [pathForPostgres]);
+                return {
+                    rowsAffected: result.rowsAffected,
+                    hint: "rowsAffected counts matched rows, not whether key existed",
+                };
             }
-            else {
-                // Single key - use simple - operator
-                pathForPostgres = parsed.path;
-                useArrayOperator = false;
+            catch (error) {
+                return {
+                    success: false,
+                    error: formatPostgresError(error, {
+                        tool: "pg_jsonb_delete",
+                    }),
+                };
             }
-            const pathExpr = useArrayOperator ? `#- $1` : `- $1`;
-            const sql = `UPDATE "${table}" SET "${column}" = "${column}" ${pathExpr} WHERE ${parsed.where}`;
-            const result = await adapter.executeQuery(sql, [pathForPostgres]);
-            return {
-                rowsAffected: result.rowsAffected,
-                hint: "rowsAffected counts matched rows, not whether key existed",
-            };
         },
     };
 }
@@ -339,38 +437,90 @@ export function createJsonbContainsTool(adapter) {
         annotations: readOnly("JSONB Contains"),
         icons: getToolIcons("jsonb", readOnly("JSONB Contains")),
         handler: async (params, _context) => {
-            const parsed = JsonbContainsSchema.parse(params);
-            // Resolve table/column from optional aliases
-            const table = parsed.table ?? parsed.tableName;
-            const column = parsed.column ?? parsed.col;
-            if (!table || !column) {
-                throw new Error("table and column are required");
+            try {
+                const parsed = JsonbContainsSchema.parse(params);
+                // Resolve table/column from optional aliases
+                const table = parsed.table ?? parsed.tableName;
+                const column = parsed.column ?? parsed.col;
+                if (!table || !column) {
+                    return { success: false, error: "table and column are required" };
+                }
+                // Validate schema and build qualified table name
+                const [qualifiedTable, tableError] = await resolveJsonbTable(adapter, table, parsed.schema);
+                if (tableError)
+                    return tableError;
+                const { select, where } = parsed;
+                // Parse JSON string values from MCP clients
+                const value = parseJsonbValue(parsed.value);
+                // Apply default limit (100) to prevent large payloads
+                const DEFAULT_LIMIT = 100;
+                const requestedLimit = parsed.limit;
+                const effectiveLimit = requestedLimit === 0 ? 0 : (requestedLimit ?? DEFAULT_LIMIT);
+                const selectCols = select !== undefined && select.length > 0
+                    ? select
+                        .map((item) => {
+                        const { expr, alias } = parseSelectAlias(item);
+                        // Simple column names get quoted; expressions pass through
+                        const needsQuote = !expr.includes("->") &&
+                            !expr.includes("(") &&
+                            !expr.includes("::") &&
+                            /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(expr);
+                        const exprStr = needsQuote ? `"${expr}"` : expr;
+                        // Only add AS alias when an explicit alias was provided
+                        return alias !== expr &&
+                            alias !==
+                                expr
+                                    .replace(/[^\w]/g, "_")
+                                    .replace(/_+/g, "_")
+                                    .replace(/^_|_$/g, "")
+                            ? `${exprStr} AS "${alias}"`
+                            : exprStr;
+                    })
+                        .join(", ")
+                    : "*";
+                // Build WHERE clause combining containment check with optional filter
+                const containsClause = `"${column}" @> $1::jsonb`;
+                const whereClause = where ? ` AND ${sanitizeWhereClause(where)}` : "";
+                const baseSql = `SELECT ${selectCols} FROM ${qualifiedTable} WHERE ${containsClause}${whereClause}`;
+                // Fetch limit+1 rows to detect truncation without a separate count query
+                const fetchLimit = effectiveLimit > 0 ? effectiveLimit + 1 : 0;
+                const sql = fetchLimit > 0 ? `${baseSql} LIMIT ${String(fetchLimit)}` : baseSql;
+                const result = await adapter.executeQuery(sql, [toJsonString(value)]);
+                const allRows = result.rows ?? [];
+                const isTruncated = effectiveLimit > 0 && allRows.length > effectiveLimit;
+                const rows = isTruncated ? allRows.slice(0, effectiveLimit) : allRows;
+                // Warn if empty object was passed (matches all rows)
+                const isEmptyObject = typeof value === "object" &&
+                    value !== null &&
+                    !Array.isArray(value) &&
+                    Object.keys(value).length === 0;
+                const response = {
+                    rows,
+                    count: rows.length,
+                };
+                if (isTruncated) {
+                    response.truncated = true;
+                    // Get exact total count
+                    const countSql = `SELECT COUNT(*) as total FROM ${qualifiedTable} WHERE ${containsClause}${whereClause}`;
+                    const countResult = await adapter.executeQuery(countSql, [
+                        toJsonString(value),
+                    ]);
+                    response.totalCount = Number(countResult.rows?.[0]?.["total"] ?? rows.length);
+                }
+                if (isEmptyObject) {
+                    response.warning =
+                        "Empty {} matches ALL rows - this is PostgreSQL containment semantics";
+                }
+                return response;
             }
-            const { select, where } = parsed;
-            // Parse JSON string values from MCP clients
-            const value = parseJsonbValue(parsed.value);
-            const selectCols = select !== undefined && select.length > 0
-                ? select.map((c) => `"${c}"`).join(", ")
-                : "*";
-            // Build WHERE clause combining containment check with optional filter
-            const containsClause = `"${column}" @> $1::jsonb`;
-            const whereClause = where ? ` AND ${where}` : "";
-            const sql = `SELECT ${selectCols} FROM "${table}" WHERE ${containsClause}${whereClause}`;
-            const result = await adapter.executeQuery(sql, [toJsonString(value)]);
-            // Warn if empty object was passed (matches all rows)
-            const isEmptyObject = typeof value === "object" &&
-                value !== null &&
-                !Array.isArray(value) &&
-                Object.keys(value).length === 0;
-            const response = {
-                rows: result.rows,
-                count: result.rows?.length ?? 0,
-            };
-            if (isEmptyObject) {
-                response.warning =
-                    "Empty {} matches ALL rows - this is PostgreSQL containment semantics";
+            catch (error) {
+                return {
+                    success: false,
+                    error: formatPostgresError(error, {
+                        tool: "pg_jsonb_contains",
+                    }),
+                };
             }
-            return response;
         },
     };
 }
@@ -384,20 +534,65 @@ export function createJsonbPathQueryTool(adapter) {
         annotations: readOnly("JSONB Path Query"),
         icons: getToolIcons("jsonb", readOnly("JSONB Path Query")),
         handler: async (params, _context) => {
-            const parsed = JsonbPathQuerySchema.parse(params);
-            // Resolve table/column from optional aliases
-            const table = parsed.table ?? parsed.tableName;
-            const column = parsed.column ?? parsed.col;
-            if (!table || !column) {
-                throw new Error("table and column are required");
+            try {
+                const parsed = JsonbPathQuerySchema.parse(params);
+                // Resolve table/column from optional aliases
+                const table = parsed.table ?? parsed.tableName;
+                const column = parsed.column ?? parsed.col;
+                if (!table || !column) {
+                    return { success: false, error: "table and column are required" };
+                }
+                // Validate schema and build qualified table name
+                const [qualifiedTable, tableError] = await resolveJsonbTable(adapter, table, parsed.schema);
+                if (tableError)
+                    return tableError;
+                const { path, vars, where } = parsed;
+                const whereClause = where ? ` WHERE ${sanitizeWhereClause(where)}` : "";
+                const varsJson = vars ? JSON.stringify(vars) : "{}";
+                // Apply default limit (100) to prevent large payloads
+                const DEFAULT_LIMIT = 100;
+                const requestedLimit = parsed.limit;
+                const effectiveLimit = requestedLimit === 0 ? 0 : (requestedLimit ?? DEFAULT_LIMIT);
+                const baseSql = `SELECT jsonb_path_query("${column}", $1::jsonpath, $2::jsonb) as result FROM ${qualifiedTable}${whereClause}`;
+                // Fetch limit+1 rows to detect truncation without a separate count query
+                const fetchLimit = effectiveLimit > 0 ? effectiveLimit + 1 : 0;
+                const sql = fetchLimit > 0 ? `${baseSql} LIMIT ${String(fetchLimit)}` : baseSql;
+                const result = await adapter.executeQuery(sql, [path, varsJson]);
+                const allResults = result.rows?.map((r) => r["result"]) ?? [];
+                const isTruncated = effectiveLimit > 0 && allResults.length > effectiveLimit;
+                const results = isTruncated
+                    ? allResults.slice(0, effectiveLimit)
+                    : allResults;
+                const response = { results, count: results.length };
+                if (isTruncated) {
+                    response.truncated = true;
+                    // Get exact total count
+                    const countSql = `SELECT COUNT(*) as total FROM (SELECT jsonb_path_query("${column}", $1::jsonpath, $2::jsonb) FROM ${qualifiedTable}${whereClause}) sub`;
+                    const countResult = await adapter.executeQuery(countSql, [
+                        path,
+                        varsJson,
+                    ]);
+                    response.totalCount = Number(countResult.rows?.[0]?.["total"] ?? results.length);
+                }
+                return response;
+            }
+            catch (error) {
+                // JSONPath-specific: invalid syntax
+                if (error instanceof Error &&
+                    /syntax error/i.test(error.message) &&
+                    /jsonpath/i.test(error.message)) {
+                    return {
+                        success: false,
+                        error: `Invalid JSONPath syntax. Use $.key, $.array[*], or $.* ? (@.field > 10) syntax.`,
+                    };
+                }
+                return {
+                    success: false,
+                    error: formatPostgresError(error, {
+                        tool: "pg_jsonb_path_query",
+                    }),
+                };
             }
-            const { path, vars, where } = parsed;
-            const whereClause = where ? ` WHERE ${where}` : "";
-            const varsJson = vars ? JSON.stringify(vars) : "{}";
-            const sql = `SELECT jsonb_path_query("${column}", $1::jsonpath, $2::jsonb) as result FROM "${table}"${whereClause}`;
-            const result = await adapter.executeQuery(sql, [path, varsJson]);
-            const results = result.rows?.map((r) => r["result"]);
-            return { results, count: results?.length ?? 0 };
         },
     };
 }
@@ -433,67 +628,79 @@ export function createJsonbAggTool(adapter) {
         annotations: readOnly("JSONB Aggregate"),
         icons: getToolIcons("jsonb", readOnly("JSONB Aggregate")),
         handler: async (params, _context) => {
-            // Parse with preprocess schema to resolve aliases (tableName→table, filter→where)
-            const parsed = JsonbAggSchema.parse(params);
-            const table = parsed.table;
-            if (!table) {
-                throw new Error("table is required");
-            }
-            // Build select expression with proper alias handling
-            let selectExpr;
-            if (parsed.select !== undefined && parsed.select.length > 0) {
-                // Parse each select item for potential aliases
-                const selectParts = parsed.select.map((item) => {
-                    const { expr, alias } = parseSelectAlias(item);
-                    // Detect if expression needs quoting (simple column names vs expressions)
-                    const needsQuote = !expr.includes("->") &&
-                        !expr.includes("(") &&
-                        !expr.includes("::") &&
-                        /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(expr);
-                    const exprStr = needsQuote ? `"${expr}"` : expr;
-                    return `'${alias}', ${exprStr}`;
-                });
-                selectExpr = `jsonb_build_object(${selectParts.join(", ")})`;
-            }
-            else {
-                selectExpr = "to_jsonb(t.*)";
+            try {
+                // Parse with preprocess schema to resolve aliases (tableName→table, filter→where)
+                const parsed = JsonbAggSchema.parse(params);
+                const table = parsed.table;
+                if (!table) {
+                    return { success: false, error: "table is required" };
+                }
+                // Validate schema and build qualified table name
+                const [qualifiedTable, tableError] = await resolveJsonbTable(adapter, table, parsed.schema);
+                if (tableError)
+                    return tableError;
+                // Build select expression with proper alias handling
+                let selectExpr;
+                if (parsed.select !== undefined && parsed.select.length > 0) {
+                    const selectParts = parsed.select.map((item) => {
+                        const { expr, alias } = parseSelectAlias(item);
+                        const needsQuote = !expr.includes("->") &&
+                            !expr.includes("(") &&
+                            !expr.includes("::") &&
+                            /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(expr);
+                        const exprStr = needsQuote ? `"${expr}"` : expr;
+                        return `'${alias}', ${exprStr}`;
+                    });
+                    selectExpr = `jsonb_build_object(${selectParts.join(", ")})`;
+                }
+                else {
+                    selectExpr = "to_jsonb(t.*)";
+                }
+                const whereClause = parsed.where
+                    ? ` WHERE ${sanitizeWhereClause(parsed.where)}`
+                    : "";
+                const orderByClause = parsed.orderBy
+                    ? ` ORDER BY ${parsed.orderBy}`
+                    : "";
+                const limitClause = parsed.limit !== undefined ? ` LIMIT ${String(parsed.limit)}` : "";
+                const hasJsonbOperator = parsed.groupBy?.includes("->") ?? false;
+                if (parsed.groupBy) {
+                    const groupExpr = hasJsonbOperator
+                        ? parsed.groupBy
+                        : `"${parsed.groupBy}"`;
+                    const groupClause = ` GROUP BY ${groupExpr}`;
+                    const aggOrderBy = parsed.orderBy
+                        ? ` ORDER BY ${parsed.orderBy}`
+                        : "";
+                    const sql = `SELECT ${groupExpr} as group_key, jsonb_agg(${selectExpr}${aggOrderBy}) as items FROM ${qualifiedTable} t${whereClause}${groupClause}${limitClause}`;
+                    const result = await adapter.executeQuery(sql);
+                    return {
+                        result: result.rows,
+                        count: result.rows?.length ?? 0,
+                        grouped: true,
+                    };
+                }
+                else {
+                    const innerSql = `SELECT * FROM ${qualifiedTable} t${whereClause}${orderByClause}${limitClause}`;
+                    const sql = `SELECT jsonb_agg(${selectExpr.replace(/\bt\./g, "sub.")}) as result FROM (${innerSql}) sub`;
+                    const result = await adapter.executeQuery(sql);
+                    const arr = result.rows?.[0]?.["result"] ?? [];
+                    const count = Array.isArray(arr) ? arr.length : 0;
+                    const response = { result: arr, count, grouped: false };
+                    if (count === 0) {
+                        response.hint = "No rows matched - returns empty array []";
+                    }
+                    return response;
+                }
             }
-            const whereClause = parsed.where ? ` WHERE ${parsed.where}` : "";
-            const orderByClause = parsed.orderBy ? ` ORDER BY ${parsed.orderBy}` : "";
-            const limitClause = parsed.limit !== undefined ? ` LIMIT ${String(parsed.limit)}` : "";
-            // Support raw JSONB expressions (containing -> or ->> operators) without quoting
-            const hasJsonbOperator = parsed.groupBy?.includes("->") ?? false;
-            if (parsed.groupBy) {
-                // Return all groups with their aggregated items
-                // For grouped queries, we use a subquery to apply ordering before aggregation
-                const groupExpr = hasJsonbOperator
-                    ? parsed.groupBy
-                    : `"${parsed.groupBy}"`;
-                const groupClause = ` GROUP BY ${groupExpr}`;
-                // Apply ordering within each group using ORDER BY inside jsonb_agg
-                const aggOrderBy = parsed.orderBy ? ` ORDER BY ${parsed.orderBy}` : "";
-                const sql = `SELECT ${groupExpr} as group_key, jsonb_agg(${selectExpr}${aggOrderBy}) as items FROM "${table}" t${whereClause}${groupClause}${limitClause}`;
-                const result = await adapter.executeQuery(sql);
-                // Return grouped result with group_key and items per group
+            catch (error) {
                 return {
-                    result: result.rows,
-                    count: result.rows?.length ?? 0,
-                    grouped: true,
+                    success: false,
+                    error: formatPostgresError(error, {
+                        tool: "pg_jsonb_agg",
+                    }),
                 };
             }
-            else {
-                // For non-grouped, use subquery to apply limit/order before aggregation
-                const innerSql = `SELECT * FROM "${table}" t${whereClause}${orderByClause}${limitClause}`;
-                const sql = `SELECT jsonb_agg(${selectExpr.replace(/\bt\./g, "sub.")}) as result FROM (${innerSql}) sub`;
-                const result = await adapter.executeQuery(sql);
-                const arr = result.rows?.[0]?.["result"] ?? [];
-                const count = Array.isArray(arr) ? arr.length : 0;
-                const response = { result: arr, count, grouped: false };
-                if (count === 0) {
-                    response.hint = "No rows matched - returns empty array []";
-                }
-                return response;
-            }
         },
     };
 }
@@ -526,22 +733,32 @@ export function createJsonbObjectTool(adapter) {
         annotations: readOnly("JSONB Object"),
         icons: getToolIcons("jsonb", readOnly("JSONB Object")),
         handler: async (params, _context) => {
-            // Parse the input
-            const parsed = JsonbObjectSchema.parse(params);
-            // Support multiple parameter names: data, object, pairs (in priority order)
-            const pairs = parsed.data ?? parsed.object ?? parsed.pairs ?? {};
-            const entries = Object.entries(pairs);
-            // Handle empty pairs - return empty object
-            if (entries.length === 0) {
-                return { object: {} };
+            try {
+                // Parse the input
+                const parsed = JsonbObjectSchema.parse(params);
+                // Support multiple parameter names: data, object, pairs (in priority order)
+                const pairs = parsed.data ?? parsed.object ?? parsed.pairs ?? {};
+                const entries = Object.entries(pairs);
+                // Handle empty pairs - return empty object
+                if (entries.length === 0) {
+                    return { object: {} };
+                }
+                const args = entries.flatMap(([k, v]) => [k, toJsonString(v)]);
+                const placeholders = entries
+                    .map((_, i) => `$${String(i * 2 + 1)}::text, $${String(i * 2 + 2)}::jsonb`)
+                    .join(", ");
+                const sql = `SELECT jsonb_build_object(${placeholders}) as result`;
+                const result = await adapter.executeQuery(sql, args);
+                return { object: result.rows?.[0]?.["result"] ?? {} };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: formatPostgresError(error, {
+                        tool: "pg_jsonb_object",
+                    }),
+                };
             }
-            const args = entries.flatMap(([k, v]) => [k, toJsonString(v)]);
-            const placeholders = entries
-                .map((_, i) => `$${String(i * 2 + 1)}::text, $${String(i * 2 + 2)}::jsonb`)
-                .join(", ");
-            const sql = `SELECT jsonb_build_object(${placeholders}) as result`;
-            const result = await adapter.executeQuery(sql, args);
-            return { object: result.rows?.[0]?.["result"] ?? {} };
         },
     };
 }
@@ -567,18 +784,28 @@ export function createJsonbArrayTool(adapter) {
         annotations: readOnly("JSONB Array"),
         icons: getToolIcons("jsonb", readOnly("JSONB Array")),
         handler: async (params, _context) => {
-            const parsed = params;
-            // Support both 'values' and 'elements' parameter names
-            const values = parsed.values ?? parsed.elements ?? [];
-            if (values.length === 0) {
-                return { array: [] };
+            try {
+                const parsed = params;
+                // Support both 'values' and 'elements' parameter names
+                const values = parsed.values ?? parsed.elements ?? [];
+                if (values.length === 0) {
+                    return { array: [] };
+                }
+                const placeholders = values
+                    .map((_, i) => `$${String(i + 1)}::jsonb`)
+                    .join(", ");
+                const sql = `SELECT jsonb_build_array(${placeholders}) as result`;
+                const result = await adapter.executeQuery(sql, values.map((v) => toJsonString(v)));
+                return { array: result.rows?.[0]?.["result"] };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: formatPostgresError(error, {
+                        tool: "pg_jsonb_array",
+                    }),
+                };
             }
-            const placeholders = values
-                .map((_, i) => `$${String(i + 1)}::jsonb`)
-                .join(", ");
-            const sql = `SELECT jsonb_build_array(${placeholders}) as result`;
-            const result = await adapter.executeQuery(sql, values.map((v) => toJsonString(v)));
-            return { array: result.rows?.[0]?.["result"] };
         },
     };
 }
@@ -592,16 +819,22 @@ export function createJsonbKeysTool(adapter) {
         annotations: readOnly("JSONB Keys"),
         icons: getToolIcons("jsonb", readOnly("JSONB Keys")),
         handler: async (params, _context) => {
-            // Parse with preprocess schema to resolve aliases (tableName→table, col→column, filter→where)
-            const parsed = JsonbKeysSchema.parse(params);
-            const table = parsed.table;
-            const column = parsed.column;
-            if (!table || !column) {
-                throw new Error("table and column are required");
-            }
-            const whereClause = parsed.where ? ` WHERE ${parsed.where}` : "";
-            const sql = `SELECT DISTINCT jsonb_object_keys("${column}") as key FROM "${table}"${whereClause}`;
             try {
+                // Parse with preprocess schema to resolve aliases (tableName→table, col→column, filter→where)
+                const parsed = JsonbKeysSchema.parse(params);
+                const table = parsed.table;
+                const column = parsed.column;
+                if (!table || !column) {
+                    return { success: false, error: "table and column are required" };
+                }
+                // Validate schema and build qualified table name
+                const [qualifiedTable, tableError] = await resolveJsonbTable(adapter, table, parsed.schema);
+                if (tableError)
+                    return tableError;
+                const whereClause = parsed.where
+                    ? ` WHERE ${sanitizeWhereClause(parsed.where)}`
+                    : "";
+                const sql = `SELECT DISTINCT jsonb_object_keys("${column}") as key FROM ${qualifiedTable}${whereClause}`;
                 const result = await adapter.executeQuery(sql);
                 const keys = result.rows?.map((r) => r["key"]);
                 return {
@@ -614,9 +847,17 @@ export function createJsonbKeysTool(adapter) {
                 // Improve error for array columns
                 if (error instanceof Error &&
                     error.message.includes("cannot call jsonb_object_keys")) {
-                    throw new Error(`pg_jsonb_keys requires object columns. For array columns, use pg_jsonb_normalize with mode: 'array'.`);
+                    return {
+                        success: false,
+                        error: `pg_jsonb_keys requires object columns. For array columns, use pg_jsonb_normalize with mode: 'array'.`,
+                    };
                 }
-                throw error;
+                return {
+                    success: false,
+                    error: formatPostgresError(error, {
+                        tool: "pg_jsonb_keys",
+                    }),
+                };
             }
         },
     };
@@ -631,32 +872,63 @@ export function createJsonbStripNullsTool(adapter) {
         annotations: write("JSONB Strip Nulls"),
         icons: getToolIcons("jsonb", write("JSONB Strip Nulls")),
         handler: async (params, _context) => {
-            // Parse with preprocess schema to resolve aliases (tableName→table, col→column, filter→where)
-            const parsed = JsonbStripNullsSchema.parse(params);
-            const table = parsed.table;
-            const column = parsed.column;
-            const whereClause = parsed.where;
-            if (!table || !column) {
-                throw new Error("table and column are required");
-            }
-            // Validate required 'where' parameter before SQL execution
-            if (!whereClause || whereClause.trim() === "") {
-                throw new Error('pg_jsonb_strip_nulls requires a WHERE clause to identify rows to update. Example: where: "id = 1"');
+            try {
+                // Parse with preprocess schema to resolve aliases (tableName→table, col→column, filter→where)
+                // Wrap in try-catch to intercept Zod .refine() errors (e.g., missing WHERE)
+                let parsed;
+                try {
+                    parsed = JsonbStripNullsSchema.parse(params);
+                }
+                catch (error) {
+                    if (error instanceof ZodError) {
+                        const messages = error.issues.map((i) => i.message).join("; ");
+                        return {
+                            success: false,
+                            error: `pg_jsonb_strip_nulls validation error: ${messages}`,
+                        };
+                    }
+                    throw error;
+                }
+                const table = parsed.table;
+                const column = parsed.column;
+                const whereClause = parsed.where;
+                if (!table || !column) {
+                    return { success: false, error: "table and column are required" };
+                }
+                // Validate schema and build qualified table name
+                const [qualifiedTable, tableError] = await resolveJsonbTable(adapter, table, parsed.schema);
+                if (tableError)
+                    return tableError;
+                // Validate required 'where' parameter before SQL execution
+                if (!whereClause || whereClause.trim() === "") {
+                    return {
+                        success: false,
+                        error: 'pg_jsonb_strip_nulls requires a WHERE clause to identify rows to update. Example: where: "id = 1"',
+                    };
+                }
+                if (parsed.preview === true) {
+                    // Preview mode - show before/after without modifying
+                    const previewSql = `SELECT "${column}" as before, jsonb_strip_nulls("${column}") as after FROM ${qualifiedTable} WHERE ${sanitizeWhereClause(whereClause)}`;
+                    const result = await adapter.executeQuery(previewSql);
+                    return {
+                        preview: true,
+                        rows: result.rows,
+                        count: result.rows?.length ?? 0,
+                        hint: "No changes made - preview only",
+                    };
+                }
+                const sql = `UPDATE ${qualifiedTable} SET "${column}" = jsonb_strip_nulls("${column}") WHERE ${sanitizeWhereClause(whereClause)}`;
+                const result = await adapter.executeQuery(sql);
+                return { rowsAffected: result.rowsAffected };
             }
-            if (parsed.preview === true) {
-                // Preview mode - show before/after without modifying
-                const previewSql = `SELECT "${column}" as before, jsonb_strip_nulls("${column}") as after FROM "${table}" WHERE ${whereClause}`;
-                const result = await adapter.executeQuery(previewSql);
+            catch (error) {
                 return {
-                    preview: true,
-                    rows: result.rows,
-                    count: result.rows?.length ?? 0,
-                    hint: "No changes made - preview only",
+                    success: false,
+                    error: formatPostgresError(error, {
+                        tool: "pg_jsonb_strip_nulls",
+                    }),
                 };
             }
-            const sql = `UPDATE "${table}" SET "${column}" = jsonb_strip_nulls("${column}") WHERE ${whereClause}`;
-            const result = await adapter.executeQuery(sql);
-            return { rowsAffected: result.rowsAffected };
         },
     };
 }
@@ -670,26 +942,42 @@ export function createJsonbTypeofTool(adapter) {
         annotations: readOnly("JSONB Typeof"),
         icons: getToolIcons("jsonb", readOnly("JSONB Typeof")),
         handler: async (params, _context) => {
-            // Parse with preprocess schema to resolve aliases (tableName→table, col→column, filter→where)
-            const parsed = JsonbTypeofSchema.parse(params);
-            const table = parsed.table;
-            const column = parsed.column;
-            if (!table || !column) {
-                throw new Error("table and column are required");
+            try {
+                // Parse with preprocess schema to resolve aliases (tableName→table, col→column, filter→where)
+                const parsed = JsonbTypeofSchema.parse(params);
+                const table = parsed.table;
+                const column = parsed.column;
+                if (!table || !column) {
+                    return { success: false, error: "table and column are required" };
+                }
+                // Validate schema and build qualified table name
+                const [qualifiedTable, tableError] = await resolveJsonbTable(adapter, table, parsed.schema);
+                if (tableError)
+                    return tableError;
+                const whereClause = parsed.where
+                    ? ` WHERE ${sanitizeWhereClause(parsed.where)}`
+                    : "";
+                // Normalize path to array format (accepts both string and array)
+                const pathArray = parsed.path !== undefined
+                    ? normalizePathToArray(parsed.path)
+                    : undefined;
+                const pathExpr = pathArray !== undefined ? ` #> $1` : "";
+                // Include column IS NULL check to disambiguate NULL column vs null path result
+                const sql = `SELECT jsonb_typeof("${column}"${pathExpr}) as type, ("${column}" IS NULL) as column_null FROM ${qualifiedTable}${whereClause}`;
+                const queryParams = pathArray ? [pathArray] : [];
+                const result = await adapter.executeQuery(sql, queryParams);
+                const types = result.rows?.map((r) => r["type"]);
+                const columnNull = result.rows?.some((r) => r["column_null"] === true) ?? false;
+                return { types, count: types?.length ?? 0, columnNull };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: formatPostgresError(error, {
+                        tool: "pg_jsonb_typeof",
+                    }),
+                };
             }
-            const whereClause = parsed.where ? ` WHERE ${parsed.where}` : "";
-            // Normalize path to array format (accepts both string and array)
-            const pathArray = parsed.path !== undefined
-                ? normalizePathToArray(parsed.path)
-                : undefined;
-            const pathExpr = pathArray !== undefined ? ` #> $1` : "";
-            // Include column IS NULL check to disambiguate NULL column vs null path result
-            const sql = `SELECT jsonb_typeof("${column}"${pathExpr}) as type, ("${column}" IS NULL) as column_null FROM "${table}"${whereClause}`;
-            const queryParams = pathArray ? [pathArray] : [];
-            const result = await adapter.executeQuery(sql, queryParams);
-            const types = result.rows?.map((r) => r["type"]);
-            const columnNull = result.rows?.some((r) => r["column_null"] === true) ?? false;
-            return { types, count: types?.length ?? 0, columnNull };
         },
     };
 }