@neverinfamous/postgres-mcp 1.1.0 → 1.3.0

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

@@ -3,9 +3,10 @@
  *
  * Core spatial tools: extension, geometry_column, point_in_polygon, distance, buffer, intersection, bounding_box, spatial_index.
  */
-import { z } from "zod";
+import { z, ZodError } from "zod";
 import { readOnly, write } from "../../../../utils/annotations.js";
 import { getToolIcons } from "../../../../utils/icons.js";
+import { parsePostgresError, formatPostgresError, } from "../core/error-helpers.js";
 import { sanitizeIdentifier, sanitizeTableName, } from "../../../../utils/identifiers.js";
 import { GeometryColumnSchemaBase, GeometryColumnSchema, GeometryDistanceSchemaBase, GeometryDistanceSchema, PointInPolygonSchemaBase, PointInPolygonSchema, SpatialIndexSchemaBase, SpatialIndexSchema, BufferSchemaBase, BufferSchema, IntersectionSchemaBase, IntersectionSchema, BoundingBoxSchemaBase, BoundingBoxSchema, 
 // Output schemas
@@ -102,47 +103,65 @@ export function createPointInPolygonTool(adapter) {
         annotations: readOnly("Point in Polygon"),
         icons: getToolIcons("postgis", readOnly("Point in Polygon")),
         handler: async (params, _context) => {
-            const { table, column, point, schema } = PointInPolygonSchema.parse(params ?? {});
-            const schemaName = schema ?? "public";
-            const tableName = sanitizeTableName(table, schemaName !== "public" ? schemaName : undefined);
-            const columnName = sanitizeIdentifier(column);
-            // Check geometry type and warn if not polygon
-            const typeCheckSql = `SELECT DISTINCT GeometryType(${columnName}) as geom_type FROM ${tableName} WHERE ${columnName} IS NOT NULL LIMIT 1`;
-            const typeResult = await adapter.executeQuery(typeCheckSql);
-            const geomType = typeResult.rows?.[0]?.["geom_type"];
-            const isPolygonType = geomType?.toUpperCase()?.includes("POLYGON") ?? false;
-            // Get non-geometry columns to avoid returning raw WKB
-            const colQuery = `
-        SELECT column_name FROM information_schema.columns 
-        WHERE table_schema = $1 AND table_name = $2 
-        AND udt_name NOT IN ('geometry', 'geography')
-        ORDER BY ordinal_position
-      `;
-            const colResult = await adapter.executeQuery(colQuery, [
-                schemaName,
-                table,
-            ]);
-            const nonGeomCols = (colResult.rows ?? [])
-                .map((row) => sanitizeIdentifier(String(row["column_name"])))
-                .join(", ");
-            // Select non-geometry columns + readable geometry representation
-            const selectCols = nonGeomCols.length > 0
-                ? `${nonGeomCols}, ST_AsText(${columnName}) as geometry_text`
-                : `ST_AsText(${columnName}) as geometry_text`;
-            const sql = `SELECT ${selectCols}
-                        FROM ${tableName}
-                        WHERE ST_Contains(${columnName}, ST_SetSRID(ST_MakePoint($1, $2), 4326))`;
-            const result = await adapter.executeQuery(sql, [point.lng, point.lat]);
-            const response = {
-                containingPolygons: result.rows,
-                count: result.rows?.length ?? 0,
-            };
-            // Add warning if geometry type is not polygon
-            if (!isPolygonType && geomType !== undefined) {
-                response["warning"] =
-                    `Column "${column}" contains ${geomType} geometries, not polygons. ST_Contains requires polygons to produce meaningful results.`;
+            try {
+                const { table, column, point, schema } = PointInPolygonSchema.parse(params ?? {});
+                const schemaName = schema ?? "public";
+                const tableName = sanitizeTableName(table, schemaName !== "public" ? schemaName : undefined);
+                const columnName = sanitizeIdentifier(column);
+                // Check geometry type and warn if not polygon
+                const typeCheckSql = `SELECT DISTINCT GeometryType(${columnName}) as geom_type FROM ${tableName} WHERE ${columnName} IS NOT NULL LIMIT 1`;
+                const typeResult = await adapter.executeQuery(typeCheckSql);
+                const geomType = typeResult.rows?.[0]?.["geom_type"];
+                const isPolygonType = geomType?.toUpperCase()?.includes("POLYGON") ?? false;
+                // Get non-geometry columns to avoid returning raw WKB
+                const colQuery = `
+          SELECT column_name FROM information_schema.columns 
+          WHERE table_schema = $1 AND table_name = $2 
+          AND udt_name NOT IN ('geometry', 'geography')
+          ORDER BY ordinal_position
+        `;
+                const colResult = await adapter.executeQuery(colQuery, [
+                    schemaName,
+                    table,
+                ]);
+                const nonGeomCols = (colResult.rows ?? [])
+                    .map((row) => sanitizeIdentifier(String(row["column_name"])))
+                    .join(", ");
+                // Select non-geometry columns + readable geometry representation
+                const selectCols = nonGeomCols.length > 0
+                    ? `${nonGeomCols}, ST_AsText(${columnName}) as geometry_text`
+                    : `ST_AsText(${columnName}) as geometry_text`;
+                const sql = `SELECT ${selectCols}
+                          FROM ${tableName}
+                          WHERE ST_Contains(${columnName}, ST_SetSRID(ST_MakePoint($1, $2), 4326))`;
+                const result = await adapter.executeQuery(sql, [point.lng, point.lat]);
+                const response = {
+                    containingPolygons: result.rows,
+                    count: result.rows?.length ?? 0,
+                };
+                // Add warning if geometry type is not polygon
+                if (!isPolygonType && geomType !== undefined) {
+                    response["warning"] =
+                        `Column "${column}" contains ${geomType} geometries, not polygons. ST_Contains requires polygons to produce meaningful results.`;
+                }
+                return response;
+            }
+            catch (error) {
+                if (error instanceof ZodError) {
+                    return {
+                        success: false,
+                        error: error.issues.map((i) => i.message).join("; "),
+                    };
+                }
+                return {
+                    success: false,
+                    error: formatPostgresError(error, {
+                        tool: "pg_point_in_polygon",
+                        table: params?.["table"] ??
+                            undefined,
+                    }),
+                };
             }
-            return response;
         },
     };
 }
@@ -156,34 +175,35 @@ export function createDistanceTool(adapter) {
         annotations: readOnly("Distance Search"),
         icons: getToolIcons("postgis", readOnly("Distance Search")),
         handler: async (params, _context) => {
-            const { table, column, point, limit, maxDistance, schema } = GeometryDistanceSchema.parse(params);
-            const schemaName = schema ?? "public";
-            const tableName = sanitizeTableName(table, schemaName !== "public" ? schemaName : undefined);
-            const columnName = sanitizeIdentifier(column);
-            const limitVal = limit ?? 10;
-            const distanceFilter = maxDistance !== undefined && maxDistance > 0
-                ? `WHERE distance_meters <= ${String(maxDistance)}`
-                : "";
-            // Get non-geometry columns to avoid returning raw WKB
-            const colQuery = `
-        SELECT column_name FROM information_schema.columns 
-        WHERE table_schema = $1 AND table_name = $2 
-        AND udt_name NOT IN ('geometry', 'geography')
-        ORDER BY ordinal_position
-      `;
-            const colResult = await adapter.executeQuery(colQuery, [
-                schemaName,
-                table,
-            ]);
-            const nonGeomCols = (colResult.rows ?? [])
-                .map((row) => sanitizeIdentifier(String(row["column_name"])))
-                .join(", ");
-            // Select non-geometry columns + readable geometry representation + distance
-            const selectCols = nonGeomCols.length > 0
-                ? `${nonGeomCols}, ST_AsText(${columnName}) as geometry_text, ST_Distance(${columnName}::geography, ST_SetSRID(ST_MakePoint($1, $2), 4326)::geography) as distance_meters`
-                : `ST_AsText(${columnName}) as geometry_text, ST_Distance(${columnName}::geography, ST_SetSRID(ST_MakePoint($1, $2), 4326)::geography) as distance_meters`;
-            // Use CTE for consistent distance calculation and filtering
-            const sql = `WITH distances AS (
+            try {
+                const { table, column, point, limit, maxDistance, schema } = GeometryDistanceSchema.parse(params);
+                const schemaName = schema ?? "public";
+                const tableName = sanitizeTableName(table, schemaName !== "public" ? schemaName : undefined);
+                const columnName = sanitizeIdentifier(column);
+                const limitVal = limit ?? 10;
+                const distanceFilter = maxDistance !== undefined && maxDistance > 0
+                    ? `WHERE distance_meters <= ${String(maxDistance)}`
+                    : "";
+                // Get non-geometry columns to avoid returning raw WKB
+                const colQuery = `
+          SELECT column_name FROM information_schema.columns 
+          WHERE table_schema = $1 AND table_name = $2 
+          AND udt_name NOT IN ('geometry', 'geography')
+          ORDER BY ordinal_position
+        `;
+                const colResult = await adapter.executeQuery(colQuery, [
+                    schemaName,
+                    table,
+                ]);
+                const nonGeomCols = (colResult.rows ?? [])
+                    .map((row) => sanitizeIdentifier(String(row["column_name"])))
+                    .join(", ");
+                // Select non-geometry columns + readable geometry representation + distance
+                const selectCols = nonGeomCols.length > 0
+                    ? `${nonGeomCols}, ST_AsText(${columnName}) as geometry_text, ST_Distance(${columnName}::geography, ST_SetSRID(ST_MakePoint($1, $2), 4326)::geography) as distance_meters`
+                    : `ST_AsText(${columnName}) as geometry_text, ST_Distance(${columnName}::geography, ST_SetSRID(ST_MakePoint($1, $2), 4326)::geography) as distance_meters`;
+                // Use CTE for consistent distance calculation and filtering
+                const sql = `WITH distances AS (
                 SELECT ${selectCols}
                 FROM ${tableName}
             )
@@ -191,8 +211,25 @@ export function createDistanceTool(adapter) {
             ${distanceFilter}
             ORDER BY distance_meters
             LIMIT ${String(limitVal)}`;
-            const result = await adapter.executeQuery(sql, [point.lng, point.lat]);
-            return { results: result.rows, count: result.rows?.length ?? 0 };
+                const result = await adapter.executeQuery(sql, [point.lng, point.lat]);
+                return { results: result.rows, count: result.rows?.length ?? 0 };
+            }
+            catch (error) {
+                if (error instanceof ZodError) {
+                    return {
+                        success: false,
+                        error: error.issues.map((i) => i.message).join("; "),
+                    };
+                }
+                return {
+                    success: false,
+                    error: formatPostgresError(error, {
+                        tool: "pg_distance",
+                        table: params?.["table"] ??
+                            undefined,
+                    }),
+                };
+            }
         },
     };
 }
@@ -206,85 +243,14 @@ export function createBufferTool(adapter) {
         annotations: readOnly("Buffer Zone"),
         icons: getToolIcons("postgis", readOnly("Buffer Zone")),
         handler: async (params, _context) => {
-            const parsed = BufferSchema.parse(params ?? {});
-            const whereClause = parsed.where !== undefined ? ` WHERE ${parsed.where}` : "";
-            const schemaName = parsed.schema ?? "public";
-            const qualifiedTable = sanitizeTableName(parsed.table, schemaName !== "public" ? schemaName : undefined);
-            const columnName = sanitizeIdentifier(parsed.column);
-            // Default limit of 50 to prevent large payloads, use limit: 0 for all
-            const effectiveLimit = parsed.limit ?? 50;
-            // Get non-geometry columns to avoid returning raw WKB
-            const colQuery = `
-        SELECT column_name FROM information_schema.columns 
-        WHERE table_schema = $1 AND table_name = $2 
-        AND udt_name NOT IN ('geometry', 'geography')
-        ORDER BY ordinal_position
-      `;
-            const colResult = await adapter.executeQuery(colQuery, [
-                schemaName,
-                parsed.table,
-            ]);
-            const nonGeomCols = (colResult.rows ?? [])
-                .map((row) => sanitizeIdentifier(String(row["column_name"])))
-                .join(", ");
-            // Default simplify of 10m reduces polygon points for LLM-friendly payloads
-            // User can set simplify: 0 to disable or higher values for more aggressive reduction
-            const effectiveSimplify = parsed.simplify ?? 10;
-            // Build buffer expression with simplification (applied by default)
-            let bufferExpr = `ST_Buffer(${columnName}::geography, $1)::geometry`;
-            if (effectiveSimplify > 0) {
-                // SimplifyPreserveTopology maintains valid geometries
-                bufferExpr = `ST_SimplifyPreserveTopology(${bufferExpr}, ${String(effectiveSimplify)})`;
-            }
-            // Select non-geometry columns + readable geometry representations
-            const selectCols = nonGeomCols.length > 0
-                ? `${nonGeomCols}, ST_AsText(${columnName}) as geometry_text, ST_AsGeoJSON(${bufferExpr}) as buffer_geojson`
-                : `ST_AsText(${columnName}) as geometry_text, ST_AsGeoJSON(${bufferExpr}) as buffer_geojson`;
-            const limitClause = effectiveLimit > 0 ? ` LIMIT ${String(effectiveLimit)}` : "";
-            const sql = `SELECT ${selectCols} FROM ${qualifiedTable}${whereClause}${limitClause}`;
-            const result = await adapter.executeQuery(sql, [parsed.distance]);
-            // Build response with truncation indicators if default limit was applied
-            const response = { results: result.rows };
-            // When using default limit, check if more rows exist
-            if (parsed.limit === undefined && effectiveLimit > 0) {
-                const countSql = `SELECT COUNT(*) as cnt FROM ${qualifiedTable}${whereClause}`;
-                const countResult = await adapter.executeQuery(countSql);
-                const totalCount = Number(countResult.rows?.[0]?.["cnt"] ?? 0);
-                if (totalCount > effectiveLimit) {
-                    response["truncated"] = true;
-                    response["totalCount"] = totalCount;
-                    response["limit"] = effectiveLimit;
-                }
-            }
-            // Add simplify indicator if simplification was applied
-            if (effectiveSimplify > 0) {
-                response["simplified"] = true;
-                response["simplifyTolerance"] = effectiveSimplify;
-            }
-            return response;
-        },
-    };
-}
-export function createIntersectionTool(adapter) {
-    return {
-        name: "pg_intersection",
-        description: "Find geometries that intersect with a given geometry. Auto-detects SRID from target column if not specified.",
-        group: "postgis",
-        inputSchema: IntersectionSchemaBase, // Base schema for MCP visibility
-        outputSchema: IntersectionOutputSchema,
-        annotations: readOnly("Intersection Search"),
-        icons: getToolIcons("postgis", readOnly("Intersection Search")),
-        handler: async (params, _context) => {
-            const parsed = IntersectionSchema.parse(params ?? {});
-            const schemaName = parsed.schema ?? "public";
-            const qualifiedTable = sanitizeTableName(parsed.table, schemaName !== "public" ? schemaName : undefined);
-            const columnName = sanitizeIdentifier(parsed.column);
-            // Build select columns - user-specified or non-geometry columns to avoid raw WKB
-            let selectCols;
-            if (parsed.select !== undefined && parsed.select.length > 0) {
-                selectCols = parsed.select.map((c) => sanitizeIdentifier(c)).join(", ");
-            }
-            else {
+            try {
+                const parsed = BufferSchema.parse(params ?? {});
+                const whereClause = parsed.where !== undefined ? ` WHERE ${parsed.where}` : "";
+                const schemaName = parsed.schema ?? "public";
+                const qualifiedTable = sanitizeTableName(parsed.table, schemaName !== "public" ? schemaName : undefined);
+                const columnName = sanitizeIdentifier(parsed.column);
+                // Default limit of 50 to prevent large payloads, use limit: 0 for all
+                const effectiveLimit = parsed.limit ?? 50;
                 // Get non-geometry columns to avoid returning raw WKB
                 const colQuery = `
           SELECT column_name FROM information_schema.columns 
@@ -299,54 +265,163 @@ export function createIntersectionTool(adapter) {
                 const nonGeomCols = (colResult.rows ?? [])
                     .map((row) => sanitizeIdentifier(String(row["column_name"])))
                     .join(", ");
-                selectCols =
-                    nonGeomCols.length > 0
-                        ? `${nonGeomCols}, ST_AsText(${columnName}) as geometry_text`
-                        : `ST_AsText(${columnName}) as geometry_text`;
-            }
-            const isGeoJson = parsed.geometry.trim().startsWith("{");
-            // Auto-detect SRID from column if not provided and using WKT
-            let srid = parsed.srid;
-            if (!isGeoJson && srid === undefined) {
-                // Query the column's SRID from geometry_columns or geography_columns
-                const sridQuery = `
-                    SELECT srid FROM geometry_columns 
-                    WHERE f_table_schema = $1 AND f_table_name = $2 AND f_geometry_column = $3
-                    UNION
-                    SELECT srid FROM geography_columns 
-                    WHERE f_table_schema = $1 AND f_table_name = $2 AND f_geography_column = $3
-                    LIMIT 1
-                `;
-                const sridResult = await adapter.executeQuery(sridQuery, [
-                    schemaName,
-                    parsed.table,
-                    parsed.column,
-                ]);
-                const sridValue = sridResult.rows?.[0]?.["srid"];
-                if (sridValue !== undefined && sridValue !== null) {
-                    srid = Number(sridValue);
+                // Default simplify of 10m reduces polygon points for LLM-friendly payloads
+                // User can set simplify: 0 to disable or higher values for more aggressive reduction
+                const effectiveSimplify = parsed.simplify ?? 10;
+                // Build buffer expression with simplification (applied by default)
+                let bufferExpr = `ST_Buffer(${columnName}::geography, $1)::geometry`;
+                if (effectiveSimplify > 0) {
+                    // SimplifyPreserveTopology maintains valid geometries
+                    bufferExpr = `ST_SimplifyPreserveTopology(${bufferExpr}, ${String(effectiveSimplify)})`;
+                }
+                // Select non-geometry columns + readable geometry representations
+                const selectCols = nonGeomCols.length > 0
+                    ? `${nonGeomCols}, ST_AsText(${columnName}) as geometry_text, ST_AsGeoJSON(${bufferExpr}) as buffer_geojson`
+                    : `ST_AsText(${columnName}) as geometry_text, ST_AsGeoJSON(${bufferExpr}) as buffer_geojson`;
+                const limitClause = effectiveLimit > 0 ? ` LIMIT ${String(effectiveLimit)}` : "";
+                const sql = `SELECT ${selectCols} FROM ${qualifiedTable}${whereClause}${limitClause}`;
+                const result = await adapter.executeQuery(sql, [parsed.distance]);
+                // Build response with truncation indicators if default limit was applied
+                const response = { results: result.rows };
+                // Check if results were truncated (works for both default and explicit limits)
+                if (effectiveLimit > 0) {
+                    const countSql = `SELECT COUNT(*) as cnt FROM ${qualifiedTable}${whereClause}`;
+                    const countResult = await adapter.executeQuery(countSql);
+                    const totalCount = Number(countResult.rows?.[0]?.["cnt"] ?? 0);
+                    if (totalCount > effectiveLimit) {
+                        response["truncated"] = true;
+                        response["totalCount"] = totalCount;
+                        response["limit"] = effectiveLimit;
+                    }
+                }
+                // Add simplify indicator if simplification was applied
+                if (effectiveSimplify > 0) {
+                    response["simplified"] = true;
+                    response["simplifyTolerance"] = effectiveSimplify;
                 }
+                return response;
             }
-            // Build geometry expression with SRID if available
-            let geomExpr;
-            if (isGeoJson) {
-                geomExpr = `ST_GeomFromGeoJSON($1)`;
+            catch (error) {
+                if (error instanceof ZodError) {
+                    return {
+                        success: false,
+                        error: error.issues.map((i) => i.message).join("; "),
+                    };
+                }
+                return {
+                    success: false,
+                    error: formatPostgresError(error, {
+                        tool: "pg_buffer",
+                        table: params?.["table"] ??
+                            undefined,
+                    }),
+                };
             }
-            else if (srid !== undefined) {
-                geomExpr = `ST_SetSRID(ST_GeomFromText($1), ${String(srid)})`;
+        },
+    };
+}
+export function createIntersectionTool(adapter) {
+    return {
+        name: "pg_intersection",
+        description: "Find geometries that intersect with a given geometry. Auto-detects SRID from target column if not specified.",
+        group: "postgis",
+        inputSchema: IntersectionSchemaBase, // Base schema for MCP visibility
+        outputSchema: IntersectionOutputSchema,
+        annotations: readOnly("Intersection Search"),
+        icons: getToolIcons("postgis", readOnly("Intersection Search")),
+        handler: async (params, _context) => {
+            try {
+                const parsed = IntersectionSchema.parse(params ?? {});
+                const schemaName = parsed.schema ?? "public";
+                const qualifiedTable = sanitizeTableName(parsed.table, schemaName !== "public" ? schemaName : undefined);
+                const columnName = sanitizeIdentifier(parsed.column);
+                // Build select columns - user-specified or non-geometry columns to avoid raw WKB
+                let selectCols;
+                if (parsed.select !== undefined && parsed.select.length > 0) {
+                    selectCols = parsed.select
+                        .map((c) => sanitizeIdentifier(c))
+                        .join(", ");
+                }
+                else {
+                    // Get non-geometry columns to avoid returning raw WKB
+                    const colQuery = `
+            SELECT column_name FROM information_schema.columns 
+            WHERE table_schema = $1 AND table_name = $2 
+            AND udt_name NOT IN ('geometry', 'geography')
+            ORDER BY ordinal_position
+          `;
+                    const colResult = await adapter.executeQuery(colQuery, [
+                        schemaName,
+                        parsed.table,
+                    ]);
+                    const nonGeomCols = (colResult.rows ?? [])
+                        .map((row) => sanitizeIdentifier(String(row["column_name"])))
+                        .join(", ");
+                    selectCols =
+                        nonGeomCols.length > 0
+                            ? `${nonGeomCols}, ST_AsText(${columnName}) as geometry_text`
+                            : `ST_AsText(${columnName}) as geometry_text`;
+                }
+                const isGeoJson = parsed.geometry.trim().startsWith("{");
+                // Auto-detect SRID from column if not provided and using WKT
+                let srid = parsed.srid;
+                if (!isGeoJson && srid === undefined) {
+                    // Query the column's SRID from geometry_columns or geography_columns
+                    const sridQuery = `
+                      SELECT srid FROM geometry_columns 
+                      WHERE f_table_schema = $1 AND f_table_name = $2 AND f_geometry_column = $3
+                      UNION
+                      SELECT srid FROM geography_columns 
+                      WHERE f_table_schema = $1 AND f_table_name = $2 AND f_geography_column = $3
+                      LIMIT 1
+                  `;
+                    const sridResult = await adapter.executeQuery(sridQuery, [
+                        schemaName,
+                        parsed.table,
+                        parsed.column,
+                    ]);
+                    const sridValue = sridResult.rows?.[0]?.["srid"];
+                    if (sridValue !== undefined && sridValue !== null) {
+                        srid = Number(sridValue);
+                    }
+                }
+                // Build geometry expression with SRID if available
+                let geomExpr;
+                if (isGeoJson) {
+                    geomExpr = `ST_GeomFromGeoJSON($1)`;
+                }
+                else if (srid !== undefined) {
+                    geomExpr = `ST_SetSRID(ST_GeomFromText($1), ${String(srid)})`;
+                }
+                else {
+                    geomExpr = `ST_GeomFromText($1)`;
+                }
+                const sql = `SELECT ${selectCols}
+                          FROM ${qualifiedTable}
+                          WHERE ST_Intersects(${columnName}, ${geomExpr})`;
+                const result = await adapter.executeQuery(sql, [parsed.geometry]);
+                return {
+                    intersecting: result.rows,
+                    count: result.rows?.length ?? 0,
+                    sridUsed: srid ?? "none (explicit SRID in geometry or GeoJSON)",
+                };
             }
-            else {
-                geomExpr = `ST_GeomFromText($1)`;
+            catch (error) {
+                if (error instanceof ZodError) {
+                    return {
+                        success: false,
+                        error: error.issues.map((i) => i.message).join("; "),
+                    };
+                }
+                return {
+                    success: false,
+                    error: formatPostgresError(error, {
+                        tool: "pg_intersection",
+                        table: params?.["table"] ??
+                            undefined,
+                    }),
+                };
             }
-            const sql = `SELECT ${selectCols}
-                        FROM ${qualifiedTable}
-                        WHERE ST_Intersects(${columnName}, ${geomExpr})`;
-            const result = await adapter.executeQuery(sql, [parsed.geometry]);
-            return {
-                intersecting: result.rows,
-                count: result.rows?.length ?? 0,
-                sridUsed: srid ?? "none (explicit SRID in geometry or GeoJSON)",
-            };
         },
     };
 }
@@ -360,64 +435,91 @@ export function createBoundingBoxTool(adapter) {
         annotations: readOnly("Bounding Box Search"),
         icons: getToolIcons("postgis", readOnly("Bounding Box Search")),
         handler: async (params, _context) => {
-            const parsed = BoundingBoxSchema.parse(params ?? {});
-            const schemaName = parsed.schema ?? "public";
-            const qualifiedTable = sanitizeTableName(parsed.table, schemaName !== "public" ? schemaName : undefined);
-            const columnName = sanitizeIdentifier(parsed.column);
-            // Build select columns - user-specified or non-geometry columns to avoid raw WKB
-            let selectCols;
-            if (parsed.select !== undefined && parsed.select.length > 0) {
-                selectCols = parsed.select.map((c) => sanitizeIdentifier(c)).join(", ");
-            }
-            else {
-                // Get non-geometry columns to avoid returning raw WKB
-                const colQuery = `
-          SELECT column_name FROM information_schema.columns 
-          WHERE table_schema = $1 AND table_name = $2 
-          AND udt_name NOT IN ('geometry', 'geography')
-          ORDER BY ordinal_position
-        `;
-                const colResult = await adapter.executeQuery(colQuery, [
-                    schemaName,
-                    parsed.table,
+            try {
+                const parsed = BoundingBoxSchema.parse(params ?? {});
+                const schemaName = parsed.schema ?? "public";
+                const qualifiedTable = sanitizeTableName(parsed.table, schemaName !== "public" ? schemaName : undefined);
+                const columnName = sanitizeIdentifier(parsed.column);
+                // Build select columns - user-specified or non-geometry columns to avoid raw WKB
+                let selectCols;
+                if (parsed.select !== undefined && parsed.select.length > 0) {
+                    selectCols = parsed.select
+                        .map((c) => sanitizeIdentifier(c))
+                        .join(", ");
+                }
+                else {
+                    // Get non-geometry columns to avoid returning raw WKB
+                    const colQuery = `
+            SELECT column_name FROM information_schema.columns 
+            WHERE table_schema = $1 AND table_name = $2 
+            AND udt_name NOT IN ('geometry', 'geography')
+            ORDER BY ordinal_position
+          `;
+                    const colResult = await adapter.executeQuery(colQuery, [
+                        schemaName,
+                        parsed.table,
+                    ]);
+                    selectCols = (colResult.rows ?? [])
+                        .map((row) => sanitizeIdentifier(String(row["column_name"])))
+                        .join(", ");
+                    // If no columns found, table likely doesn't exist
+                    if (selectCols.length === 0) {
+                        return {
+                            success: false,
+                            error: `Table or view '${parsed.table}' not found in schema '${schemaName}'. Use pg_list_tables to see available tables.`,
+                        };
+                    }
+                }
+                // Auto-correct swapped bounds
+                const corrections = [];
+                let actualMinLng = parsed.minLng;
+                let actualMaxLng = parsed.maxLng;
+                let actualMinLat = parsed.minLat;
+                let actualMaxLat = parsed.maxLat;
+                if (parsed.minLng > parsed.maxLng) {
+                    actualMinLng = parsed.maxLng;
+                    actualMaxLng = parsed.minLng;
+                    corrections.push("minLng/maxLng were swapped");
+                }
+                if (parsed.minLat > parsed.maxLat) {
+                    actualMinLat = parsed.maxLat;
+                    actualMaxLat = parsed.minLat;
+                    corrections.push("minLat/maxLat were swapped");
+                }
+                const sql = `SELECT ${selectCols}, ST_AsText(${columnName}) as geometry_text
+                          FROM ${qualifiedTable}
+                          WHERE ${columnName} && ST_MakeEnvelope($1, $2, $3, $4, 4326)`;
+                const result = await adapter.executeQuery(sql, [
+                    actualMinLng,
+                    actualMinLat,
+                    actualMaxLng,
+                    actualMaxLat,
                 ]);
-                selectCols = (colResult.rows ?? [])
-                    .map((row) => sanitizeIdentifier(String(row["column_name"])))
-                    .join(", ");
-            }
-            // Auto-correct swapped bounds
-            const corrections = [];
-            let actualMinLng = parsed.minLng;
-            let actualMaxLng = parsed.maxLng;
-            let actualMinLat = parsed.minLat;
-            let actualMaxLat = parsed.maxLat;
-            if (parsed.minLng > parsed.maxLng) {
-                actualMinLng = parsed.maxLng;
-                actualMaxLng = parsed.minLng;
-                corrections.push("minLng/maxLng were swapped");
-            }
-            if (parsed.minLat > parsed.maxLat) {
-                actualMinLat = parsed.maxLat;
-                actualMaxLat = parsed.minLat;
-                corrections.push("minLat/maxLat were swapped");
+                const response = {
+                    results: result.rows,
+                    count: result.rows?.length ?? 0,
+                };
+                if (corrections.length > 0) {
+                    response["note"] = `Auto-corrected: ${corrections.join(", ")}`;
+                }
+                return response;
             }
-            const sql = `SELECT ${selectCols}, ST_AsText(${columnName}) as geometry_text
-                        FROM ${qualifiedTable}
-                        WHERE ${columnName} && ST_MakeEnvelope($1, $2, $3, $4, 4326)`;
-            const result = await adapter.executeQuery(sql, [
-                actualMinLng,
-                actualMinLat,
-                actualMaxLng,
-                actualMaxLat,
-            ]);
-            const response = {
-                results: result.rows,
-                count: result.rows?.length ?? 0,
-            };
-            if (corrections.length > 0) {
-                response["note"] = `Auto-corrected: ${corrections.join(", ")}`;
+            catch (error) {
+                if (error instanceof ZodError) {
+                    return {
+                        success: false,
+                        error: error.issues.map((i) => i.message).join("; "),
+                    };
+                }
+                return {
+                    success: false,
+                    error: formatPostgresError(error, {
+                        tool: "pg_bounding_box",
+                        table: params?.["table"] ??
+                            undefined,
+                    }),
+                };
             }
-            return response;
         },
     };
 }
@@ -481,7 +583,15 @@ export function createSpatialIndexTool(adapter) {
             }
             // Always use IF NOT EXISTS to prevent unclear PostgreSQL errors
             const sql = `CREATE INDEX IF NOT EXISTS ${indexName} ON ${qualifiedTable} USING GIST (${columnName})`;
-            await adapter.executeQuery(sql);
+            try {
+                await adapter.executeQuery(sql);
+            }
+            catch (error) {
+                throw parsePostgresError(error, {
+                    tool: "pg_spatial_index",
+                    table,
+                });
+            }
             return { success: true, index: indexNameRaw, table, column };
         },
     };