@neverinfamous/postgres-mcp 1.2.0 → 2.0.0

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

@@ -5,6 +5,8 @@
  */
 import { readOnly } 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 { 
 // Base schemas for MCP visibility
 StatsDescriptiveSchemaBase, StatsPercentilesSchemaBase, StatsCorrelationSchemaBase, StatsRegressionSchemaBase, 
@@ -28,61 +30,69 @@ export function createStatsDescriptiveTool(adapter) {
         annotations: readOnly("Descriptive Statistics"),
         icons: getToolIcons("stats", readOnly("Descriptive Statistics")),
         handler: async (params, _context) => {
-            const { table, column, schema, where, params: queryParams, groupBy, } = StatsDescriptiveSchema.parse(params);
-            const schemaPrefix = schema ? `"${schema}".` : "";
-            const whereClause = where ? `WHERE ${where}` : "";
-            // Validate column is numeric type
-            const typeCheckQuery = `
-                SELECT data_type 
-                FROM information_schema.columns 
-                WHERE table_schema = '${schema ?? "public"}' 
-                AND table_name = '${table}'
-                AND column_name = '${column}'
+            try {
+                const { table, column, schema, where, params: queryParams, groupBy, } = StatsDescriptiveSchema.parse(params);
+                const schemaPrefix = schema ? `"${schema}".` : "";
+                const whereClause = where ? `WHERE ${sanitizeWhereClause(where)}` : "";
+                // Validate column is numeric type
+                const typeCheckQuery = `
+                SELECT data_type
+                FROM information_schema.columns
+                WHERE table_schema = $1
+                AND table_name = $2
+                AND column_name = $3
             `;
-            const typeResult = await adapter.executeQuery(typeCheckQuery);
-            const typeRow = typeResult.rows?.[0];
-            if (!typeRow) {
-                // Check if table exists
-                const tableCheckQuery = `
-                    SELECT 1 FROM information_schema.tables 
-                    WHERE table_schema = '${schema ?? "public"}' AND table_name = '${table}'
+                const typeResult = await adapter.executeQuery(typeCheckQuery, [
+                    schema ?? "public",
+                    table,
+                    column,
+                ]);
+                const typeRow = typeResult.rows?.[0];
+                if (!typeRow) {
+                    // Check if table exists
+                    const tableCheckQuery = `
+                    SELECT 1 FROM information_schema.tables
+                    WHERE table_schema = $1 AND table_name = $2
                 `;
-                const tableResult = await adapter.executeQuery(tableCheckQuery);
-                if (tableResult.rows?.length === 0) {
-                    throw new Error(`Table "${schema ?? "public"}.${table}" not found`);
+                    const tableResult = await adapter.executeQuery(tableCheckQuery, [
+                        schema ?? "public",
+                        table,
+                    ]);
+                    if (tableResult.rows?.length === 0) {
+                        throw new Error(`Table "${schema ?? "public"}.${table}" not found`);
+                    }
+                    throw new Error(`Column "${column}" not found in table "${schema ?? "public"}.${table}"`);
                 }
-                throw new Error(`Column "${column}" not found in table "${schema ?? "public"}.${table}"`);
-            }
-            const numericTypes = [
-                "integer",
-                "bigint",
-                "smallint",
-                "numeric",
-                "decimal",
-                "real",
-                "double precision",
-                "money",
-            ];
-            if (!numericTypes.includes(typeRow.data_type)) {
-                throw new Error(`Column "${column}" is type "${typeRow.data_type}" but must be a numeric type for statistical analysis`);
-            }
-            // Helper to map stats row to numeric object
-            const mapStats = (row) => ({
-                count: Number(row["count"]),
-                min: row["min"] !== null ? Number(row["min"]) : null,
-                max: row["max"] !== null ? Number(row["max"]) : null,
-                avg: row["avg"] !== null ? Number(row["avg"]) : null,
-                stddev: row["stddev"] !== null ? Number(row["stddev"]) : null,
-                variance: row["variance"] !== null ? Number(row["variance"]) : null,
-                sum: row["sum"] !== null ? Number(row["sum"]) : null,
-                mode: row["mode"] !== null && row["mode"] !== undefined
-                    ? Number(row["mode"])
-                    : null,
-            });
-            if (groupBy !== undefined) {
-                // Grouped statistics
-                const sql = `
-                    SELECT 
+                const numericTypes = [
+                    "integer",
+                    "bigint",
+                    "smallint",
+                    "numeric",
+                    "decimal",
+                    "real",
+                    "double precision",
+                    "money",
+                ];
+                if (!numericTypes.includes(typeRow.data_type)) {
+                    throw new Error(`Column "${column}" is type "${typeRow.data_type}" but must be a numeric type for statistical analysis`);
+                }
+                // Helper to map stats row to numeric object
+                const mapStats = (row) => ({
+                    count: Number(row["count"]),
+                    min: row["min"] !== null ? Number(row["min"]) : null,
+                    max: row["max"] !== null ? Number(row["max"]) : null,
+                    avg: row["avg"] !== null ? Number(row["avg"]) : null,
+                    stddev: row["stddev"] !== null ? Number(row["stddev"]) : null,
+                    variance: row["variance"] !== null ? Number(row["variance"]) : null,
+                    sum: row["sum"] !== null ? Number(row["sum"]) : null,
+                    mode: row["mode"] !== null && row["mode"] !== undefined
+                        ? Number(row["mode"])
+                        : null,
+                });
+                if (groupBy !== undefined) {
+                    // Grouped statistics
+                    const sql = `
+                    SELECT
                         "${groupBy}" as group_key,
                         COUNT("${column}") as count,
                         MIN("${column}") as min,
@@ -97,25 +107,25 @@ export function createStatsDescriptiveTool(adapter) {
                     GROUP BY "${groupBy}"
                     ORDER BY "${groupBy}"
                 `;
-                const result = await adapter.executeQuery(sql, ...(queryParams !== undefined && queryParams.length > 0
-                    ? [queryParams]
-                    : []));
-                const rows = result.rows ?? [];
-                const groups = rows.map((row) => ({
-                    groupKey: row["group_key"],
-                    statistics: mapStats(row),
-                }));
-                return {
-                    table: `${schema ?? "public"}.${table}`,
-                    column,
-                    groupBy,
-                    groups,
-                    count: groups.length,
-                };
-            }
-            // Ungrouped statistics (original behavior)
-            const sql = `
-                SELECT 
+                    const result = await adapter.executeQuery(sql, ...(queryParams !== undefined && queryParams.length > 0
+                        ? [queryParams]
+                        : []));
+                    const rows = result.rows ?? [];
+                    const groups = rows.map((row) => ({
+                        groupKey: row["group_key"],
+                        statistics: mapStats(row),
+                    }));
+                    return {
+                        table: `${schema ?? "public"}.${table}`,
+                        column,
+                        groupBy,
+                        groups,
+                        count: groups.length,
+                    };
+                }
+                // Ungrouped statistics (original behavior)
+                const sql = `
+                SELECT
                     COUNT("${column}") as count,
                     MIN("${column}") as min,
                     MAX("${column}") as max,
@@ -127,17 +137,24 @@ export function createStatsDescriptiveTool(adapter) {
                 FROM ${schemaPrefix}"${table}"
                 ${whereClause}
             `;
-            const result = await adapter.executeQuery(sql, ...(queryParams !== undefined && queryParams.length > 0
-                ? [queryParams]
-                : []));
-            const stats = result.rows?.[0];
-            if (!stats)
-                throw new Error("No stats found");
-            return {
-                table: `${schema ?? "public"}.${table}`,
-                column,
-                statistics: mapStats(stats),
-            };
+                const result = await adapter.executeQuery(sql, ...(queryParams !== undefined && queryParams.length > 0
+                    ? [queryParams]
+                    : []));
+                const stats = result.rows?.[0];
+                if (!stats)
+                    throw new Error("No stats found");
+                return {
+                    table: `${schema ?? "public"}.${table}`,
+                    column,
+                    statistics: mapStats(stats),
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: formatPostgresError(error, { tool: "pg_stats_descriptive" }),
+                };
+            }
         },
     };
 }
@@ -157,21 +174,28 @@ async function validateNumericColumn(adapter, table, column, schema) {
         "money",
     ];
     const typeCheckQuery = `
-    SELECT data_type 
-    FROM information_schema.columns 
-    WHERE table_schema = '${schema}' 
-    AND table_name = '${table}'
-    AND column_name = '${column}'
+    SELECT data_type
+    FROM information_schema.columns
+    WHERE table_schema = $1
+    AND table_name = $2
+    AND column_name = $3
   `;
-    const typeResult = await adapter.executeQuery(typeCheckQuery);
+    const typeResult = await adapter.executeQuery(typeCheckQuery, [
+        schema,
+        table,
+        column,
+    ]);
     const typeRow = typeResult.rows?.[0];
     if (!typeRow) {
         // Check if table exists
         const tableCheckQuery = `
-      SELECT 1 FROM information_schema.tables 
-      WHERE table_schema = '${schema}' AND table_name = '${table}'
+      SELECT 1 FROM information_schema.tables
+      WHERE table_schema = $1 AND table_name = $2
     `;
-        const tableResult = await adapter.executeQuery(tableCheckQuery);
+        const tableResult = await adapter.executeQuery(tableCheckQuery, [
+            schema,
+            table,
+        ]);
         if (tableResult.rows?.length === 0) {
             throw new Error(`Table "${schema}.${table}" not found`);
         }
@@ -194,33 +218,34 @@ export function createStatsPercentilesTool(adapter) {
         annotations: readOnly("Percentiles"),
         icons: getToolIcons("stats", readOnly("Percentiles")),
         handler: async (params, _context) => {
-            const parsed = StatsPercentilesSchema.parse(params);
-            const { table, column, percentiles, schema, where, params: queryParams, groupBy, _percentileScaleWarning, } = parsed;
-            const schemaName = schema ?? "public";
-            // Validate column exists and is numeric
-            await validateNumericColumn(adapter, table, column, schemaName);
-            const pctiles = percentiles ?? [0.25, 0.5, 0.75];
-            const schemaPrefix = schema ? `"${schema}".` : "";
-            const whereClause = where ? `WHERE ${where}` : "";
-            const percentileSelects = pctiles
-                .map((p) => `PERCENTILE_CONT(${String(p)}) WITHIN GROUP (ORDER BY "${column}") as p${String(Math.round(p * 100))}`)
-                .join(",\n                    ");
-            // Helper to map row to percentile results (round to 6 decimal places to avoid floating-point artifacts)
-            const mapPercentiles = (row) => {
-                const result = {};
-                for (const p of pctiles) {
-                    const key = `p${String(Math.round(p * 100))}`;
-                    const val = row[key] !== null && row[key] !== undefined
-                        ? Number(row[key])
-                        : null;
-                    result[key] = val !== null ? Math.round(val * 1e6) / 1e6 : null;
-                }
-                return result;
-            };
-            if (groupBy !== undefined) {
-                // Grouped percentiles
-                const sql = `
-                    SELECT 
+            try {
+                const parsed = StatsPercentilesSchema.parse(params);
+                const { table, column, percentiles, schema, where, params: queryParams, groupBy, _percentileScaleWarning, } = parsed;
+                const schemaName = schema ?? "public";
+                // Validate column exists and is numeric
+                await validateNumericColumn(adapter, table, column, schemaName);
+                const pctiles = percentiles ?? [0.25, 0.5, 0.75];
+                const schemaPrefix = schema ? `"${schema}".` : "";
+                const whereClause = where ? `WHERE ${sanitizeWhereClause(where)}` : "";
+                const percentileSelects = pctiles
+                    .map((p) => `PERCENTILE_CONT(${String(p)}) WITHIN GROUP (ORDER BY "${column}") as p${String(Math.round(p * 100))}`)
+                    .join(",\n                    ");
+                // Helper to map row to percentile results (round to 6 decimal places to avoid floating-point artifacts)
+                const mapPercentiles = (row) => {
+                    const result = {};
+                    for (const p of pctiles) {
+                        const key = `p${String(Math.round(p * 100))}`;
+                        const val = row[key] !== null && row[key] !== undefined
+                            ? Number(row[key])
+                            : null;
+                        result[key] = val !== null ? Math.round(val * 1e6) / 1e6 : null;
+                    }
+                    return result;
+                };
+                if (groupBy !== undefined) {
+                    // Grouped percentiles
+                    const sql = `
+                    SELECT
                         "${groupBy}" as group_key,
                         ${percentileSelects}
                     FROM ${schemaPrefix}"${table}"
@@ -228,20 +253,42 @@ export function createStatsPercentilesTool(adapter) {
                     GROUP BY "${groupBy}"
                     ORDER BY "${groupBy}"
                 `;
+                    const result = await adapter.executeQuery(sql, ...(queryParams !== undefined && queryParams.length > 0
+                        ? [queryParams]
+                        : []));
+                    const rows = result.rows ?? [];
+                    const groups = rows.map((row) => ({
+                        groupKey: row["group_key"],
+                        percentiles: mapPercentiles(row),
+                    }));
+                    const response = {
+                        table: `${schema ?? "public"}.${table}`,
+                        column,
+                        groupBy,
+                        groups,
+                        count: groups.length,
+                    };
+                    // Include warning if mixed scales were detected
+                    if (_percentileScaleWarning) {
+                        response["warning"] = _percentileScaleWarning;
+                    }
+                    return response;
+                }
+                // Ungrouped percentiles
+                const sql = `
+                SELECT
+                    ${percentileSelects}
+                FROM ${schemaPrefix}"${table}"
+                ${whereClause}
+            `;
                 const result = await adapter.executeQuery(sql, ...(queryParams !== undefined && queryParams.length > 0
                     ? [queryParams]
                     : []));
-                const rows = result.rows ?? [];
-                const groups = rows.map((row) => ({
-                    groupKey: row["group_key"],
-                    percentiles: mapPercentiles(row),
-                }));
+                const row = result.rows?.[0] ?? {};
                 const response = {
                     table: `${schema ?? "public"}.${table}`,
                     column,
-                    groupBy,
-                    groups,
-                    count: groups.length,
+                    percentiles: mapPercentiles(row),
                 };
                 // Include warning if mixed scales were detected
                 if (_percentileScaleWarning) {
@@ -249,27 +296,12 @@ export function createStatsPercentilesTool(adapter) {
                 }
                 return response;
             }
-            // Ungrouped percentiles
-            const sql = `
-                SELECT 
-                    ${percentileSelects}
-                FROM ${schemaPrefix}"${table}"
-                ${whereClause}
-            `;
-            const result = await adapter.executeQuery(sql, ...(queryParams !== undefined && queryParams.length > 0
-                ? [queryParams]
-                : []));
-            const row = result.rows?.[0] ?? {};
-            const response = {
-                table: `${schema ?? "public"}.${table}`,
-                column,
-                percentiles: mapPercentiles(row),
-            };
-            // Include warning if mixed scales were detected
-            if (_percentileScaleWarning) {
-                response["warning"] = _percentileScaleWarning;
+            catch (error) {
+                return {
+                    success: false,
+                    error: formatPostgresError(error, { tool: "pg_stats_percentiles" }),
+                };
             }
-            return response;
         },
     };
 }
@@ -286,76 +318,53 @@ export function createStatsCorrelationTool(adapter) {
         annotations: readOnly("Correlation Analysis"),
         icons: getToolIcons("stats", readOnly("Correlation Analysis")),
         handler: async (params, _context) => {
-            const parsed = StatsCorrelationSchema.parse(params);
-            const { table, column1, column2, schema, where, params: queryParams, groupBy, } = parsed;
-            const schemaPrefix = schema ? `"${schema}".` : "";
-            const whereClause = where ? `WHERE ${where}` : "";
-            // Validate both columns are numeric types
-            const numericTypes = [
-                "integer",
-                "bigint",
-                "smallint",
-                "numeric",
-                "decimal",
-                "real",
-                "double precision",
-                "money",
-            ];
-            for (const col of [column1, column2]) {
-                const typeCheckQuery = `
-                    SELECT data_type 
-                    FROM information_schema.columns 
-                    WHERE table_schema = '${schema ?? "public"}' 
-                    AND table_name = '${table}'
-                    AND column_name = '${col}'
-                `;
-                const typeResult = await adapter.executeQuery(typeCheckQuery);
-                const typeRow = typeResult.rows?.[0];
-                if (!typeRow) {
-                    throw new Error(`Column "${col}" not found in table "${schema ?? "public"}.${table}"`);
-                }
-                if (!numericTypes.includes(typeRow.data_type)) {
-                    throw new Error(`Column "${col}" is type "${typeRow.data_type}" but must be numeric for correlation analysis`);
-                }
-            }
-            // Helper to interpret correlation
-            const interpretCorr = (corr) => {
-                if (corr === null)
-                    return "N/A";
-                const absCorr = Math.abs(corr);
-                let interpretation;
-                if (absCorr >= 0.9)
-                    interpretation = "Very strong";
-                else if (absCorr >= 0.7)
-                    interpretation = "Strong";
-                else if (absCorr >= 0.5)
-                    interpretation = "Moderate";
-                else if (absCorr >= 0.3)
-                    interpretation = "Weak";
-                else
-                    interpretation = "Very weak or no correlation";
-                interpretation += corr < 0 ? " (negative)" : " (positive)";
-                return interpretation;
-            };
-            // Helper to map row to correlation result
-            const mapCorrelation = (row) => {
-                const corr = row["correlation"] !== null ? Number(row["correlation"]) : null;
-                return {
-                    correlation: corr,
-                    interpretation: interpretCorr(corr),
-                    covariancePopulation: row["covariance_pop"] !== null
-                        ? Number(row["covariance_pop"])
-                        : null,
-                    covarianceSample: row["covariance_sample"] !== null
-                        ? Number(row["covariance_sample"])
-                        : null,
-                    sampleSize: Number(row["sample_size"]),
+            try {
+                const parsed = StatsCorrelationSchema.parse(params);
+                const { table, column1, column2, schema, where, params: queryParams, groupBy, } = parsed;
+                const schemaName = schema ?? "public";
+                const schemaPrefix = schema ? `"${schema}".` : "";
+                const whereClause = where ? `WHERE ${sanitizeWhereClause(where)}` : "";
+                // Validate both columns exist and are numeric (with table-first error checking)
+                await validateNumericColumn(adapter, table, column1, schemaName);
+                await validateNumericColumn(adapter, table, column2, schemaName);
+                // Helper to interpret correlation
+                const interpretCorr = (corr) => {
+                    if (corr === null)
+                        return "N/A";
+                    const absCorr = Math.abs(corr);
+                    let interpretation;
+                    if (absCorr >= 0.9)
+                        interpretation = "Very strong";
+                    else if (absCorr >= 0.7)
+                        interpretation = "Strong";
+                    else if (absCorr >= 0.5)
+                        interpretation = "Moderate";
+                    else if (absCorr >= 0.3)
+                        interpretation = "Weak";
+                    else
+                        interpretation = "Very weak or no correlation";
+                    interpretation += corr < 0 ? " (negative)" : " (positive)";
+                    return interpretation;
                 };
-            };
-            if (groupBy !== undefined) {
-                // Grouped correlation
-                const sql = `
-                    SELECT 
+                // Helper to map row to correlation result
+                const mapCorrelation = (row) => {
+                    const corr = row["correlation"] !== null ? Number(row["correlation"]) : null;
+                    return {
+                        correlation: corr,
+                        interpretation: interpretCorr(corr),
+                        covariancePopulation: row["covariance_pop"] !== null
+                            ? Number(row["covariance_pop"])
+                            : null,
+                        covarianceSample: row["covariance_sample"] !== null
+                            ? Number(row["covariance_sample"])
+                            : null,
+                        sampleSize: Number(row["sample_size"]),
+                    };
+                };
+                if (groupBy !== undefined) {
+                    // Grouped correlation
+                    const sql = `
+                    SELECT
                         "${groupBy}" as group_key,
                         CORR("${column1}", "${column2}")::numeric(10,6) as correlation,
                         COVAR_POP("${column1}", "${column2}")::numeric(20,6) as covariance_pop,
@@ -366,25 +375,25 @@ export function createStatsCorrelationTool(adapter) {
                     GROUP BY "${groupBy}"
                     ORDER BY "${groupBy}"
                 `;
-                const result = await adapter.executeQuery(sql, ...(queryParams !== undefined && queryParams.length > 0
-                    ? [queryParams]
-                    : []));
-                const rows = result.rows ?? [];
-                const groups = rows.map((row) => ({
-                    groupKey: row["group_key"],
-                    ...mapCorrelation(row),
-                }));
-                return {
-                    table: `${schema ?? "public"}.${table}`,
-                    columns: [column1, column2],
-                    groupBy,
-                    groups,
-                    count: groups.length,
-                };
-            }
-            // Ungrouped correlation
-            const sql = `
-                SELECT 
+                    const result = await adapter.executeQuery(sql, ...(queryParams !== undefined && queryParams.length > 0
+                        ? [queryParams]
+                        : []));
+                    const rows = result.rows ?? [];
+                    const groups = rows.map((row) => ({
+                        groupKey: row["group_key"],
+                        ...mapCorrelation(row),
+                    }));
+                    return {
+                        table: `${schema ?? "public"}.${table}`,
+                        columns: [column1, column2],
+                        groupBy,
+                        groups,
+                        count: groups.length,
+                    };
+                }
+                // Ungrouped correlation
+                const sql = `
+                SELECT
                     CORR("${column1}", "${column2}")::numeric(10,6) as correlation,
                     COVAR_POP("${column1}", "${column2}")::numeric(20,6) as covariance_pop,
                     COVAR_SAMP("${column1}", "${column2}")::numeric(20,6) as covariance_sample,
@@ -392,22 +401,29 @@ export function createStatsCorrelationTool(adapter) {
                 FROM ${schemaPrefix}"${table}"
                 ${whereClause}
             `;
-            const result = await adapter.executeQuery(sql, ...(queryParams !== undefined && queryParams.length > 0
-                ? [queryParams]
-                : []));
-            const row = result.rows?.[0];
-            if (!row)
-                throw new Error("No correlation data found");
-            const response = {
-                table: `${schema ?? "public"}.${table}`,
-                columns: [column1, column2],
-                ...mapCorrelation(row),
-            };
-            // Add note for self-correlation
-            if (column1 === column2) {
-                response["note"] = "Self-correlation always equals 1.0";
+                const result = await adapter.executeQuery(sql, ...(queryParams !== undefined && queryParams.length > 0
+                    ? [queryParams]
+                    : []));
+                const row = result.rows?.[0];
+                if (!row)
+                    throw new Error("No correlation data found");
+                const response = {
+                    table: `${schema ?? "public"}.${table}`,
+                    columns: [column1, column2],
+                    ...mapCorrelation(row),
+                };
+                // Add note for self-correlation
+                if (column1 === column2) {
+                    response["note"] = "Self-correlation always equals 1.0";
+                }
+                return response;
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: formatPostgresError(error, { tool: "pg_stats_correlation" }),
+                };
             }
-            return response;
         },
     };
 }
@@ -424,38 +440,39 @@ export function createStatsRegressionTool(adapter) {
         annotations: readOnly("Linear Regression"),
         icons: getToolIcons("stats", readOnly("Linear Regression")),
         handler: async (params, _context) => {
-            const parsed = StatsRegressionSchema.parse(params);
-            const { table, xColumn, yColumn, schema, where, params: queryParams, groupBy, } = parsed;
-            const schemaName = schema ?? "public";
-            const schemaPrefix = schema ? `"${schema}".` : "";
-            const whereClause = where ? `WHERE ${where}` : "";
-            // Validate both columns exist and are numeric
-            await validateNumericColumn(adapter, table, xColumn, schemaName);
-            await validateNumericColumn(adapter, table, yColumn, schemaName);
-            // Helper to map row to regression result
-            const mapRegression = (row) => {
-                const slope = row["slope"] !== null ? Number(row["slope"]) : null;
-                const intercept = row["intercept"] !== null ? Number(row["intercept"]) : null;
-                const rSquared = row["r_squared"] !== null ? Number(row["r_squared"]) : null;
-                let equation = "N/A";
-                if (slope !== null && intercept !== null) {
-                    const sign = intercept >= 0 ? "+" : "-";
-                    equation = `y = ${slope.toFixed(4)}x ${sign} ${Math.abs(intercept).toFixed(4)}`;
-                }
-                return {
-                    slope,
-                    intercept,
-                    rSquared,
-                    equation,
-                    avgX: row["avg_x"] !== null ? Number(row["avg_x"]) : null,
-                    avgY: row["avg_y"] !== null ? Number(row["avg_y"]) : null,
-                    sampleSize: Number(row["sample_size"]),
+            try {
+                const parsed = StatsRegressionSchema.parse(params);
+                const { table, xColumn, yColumn, schema, where, params: queryParams, groupBy, } = parsed;
+                const schemaName = schema ?? "public";
+                const schemaPrefix = schema ? `"${schema}".` : "";
+                const whereClause = where ? `WHERE ${sanitizeWhereClause(where)}` : "";
+                // Validate both columns exist and are numeric
+                await validateNumericColumn(adapter, table, xColumn, schemaName);
+                await validateNumericColumn(adapter, table, yColumn, schemaName);
+                // Helper to map row to regression result
+                const mapRegression = (row) => {
+                    const slope = row["slope"] !== null ? Number(row["slope"]) : null;
+                    const intercept = row["intercept"] !== null ? Number(row["intercept"]) : null;
+                    const rSquared = row["r_squared"] !== null ? Number(row["r_squared"]) : null;
+                    let equation = "N/A";
+                    if (slope !== null && intercept !== null) {
+                        const sign = intercept >= 0 ? "+" : "-";
+                        equation = `y = ${slope.toFixed(4)}x ${sign} ${Math.abs(intercept).toFixed(4)}`;
+                    }
+                    return {
+                        slope,
+                        intercept,
+                        rSquared,
+                        equation,
+                        avgX: row["avg_x"] !== null ? Number(row["avg_x"]) : null,
+                        avgY: row["avg_y"] !== null ? Number(row["avg_y"]) : null,
+                        sampleSize: Number(row["sample_size"]),
+                    };
                 };
-            };
-            if (groupBy !== undefined) {
-                // Grouped regression
-                const sql = `
-                    SELECT 
+                if (groupBy !== undefined) {
+                    // Grouped regression
+                    const sql = `
+                    SELECT
                         "${groupBy}" as group_key,
                         REGR_SLOPE("${yColumn}", "${xColumn}")::numeric(20,6) as slope,
                         REGR_INTERCEPT("${yColumn}", "${xColumn}")::numeric(20,6) as intercept,
@@ -468,26 +485,26 @@ export function createStatsRegressionTool(adapter) {
                     GROUP BY "${groupBy}"
                     ORDER BY "${groupBy}"
                 `;
-                const result = await adapter.executeQuery(sql, ...(queryParams !== undefined && queryParams.length > 0
-                    ? [queryParams]
-                    : []));
-                const rows = result.rows ?? [];
-                const groups = rows.map((row) => ({
-                    groupKey: row["group_key"],
-                    regression: mapRegression(row),
-                }));
-                return {
-                    table: `${schema ?? "public"}.${table}`,
-                    xColumn,
-                    yColumn,
-                    groupBy,
-                    groups,
-                    count: groups.length,
-                };
-            }
-            // Ungrouped regression
-            const sql = `
-                SELECT 
+                    const result = await adapter.executeQuery(sql, ...(queryParams !== undefined && queryParams.length > 0
+                        ? [queryParams]
+                        : []));
+                    const rows = result.rows ?? [];
+                    const groups = rows.map((row) => ({
+                        groupKey: row["group_key"],
+                        regression: mapRegression(row),
+                    }));
+                    return {
+                        table: `${schema ?? "public"}.${table}`,
+                        xColumn,
+                        yColumn,
+                        groupBy,
+                        groups,
+                        count: groups.length,
+                    };
+                }
+                // Ungrouped regression
+                const sql = `
+                SELECT
                     REGR_SLOPE("${yColumn}", "${xColumn}")::numeric(20,6) as slope,
                     REGR_INTERCEPT("${yColumn}", "${xColumn}")::numeric(20,6) as intercept,
                     REGR_R2("${yColumn}", "${xColumn}")::numeric(10,6) as r_squared,
@@ -500,23 +517,30 @@ export function createStatsRegressionTool(adapter) {
                 FROM ${schemaPrefix}"${table}"
                 ${whereClause}
             `;
-            const result = await adapter.executeQuery(sql, ...(queryParams !== undefined && queryParams.length > 0
-                ? [queryParams]
-                : []));
-            const row = result.rows?.[0];
-            if (!row)
-                return { error: "No regression data found" };
-            const response = {
-                table: `${schema ?? "public"}.${table}`,
-                xColumn,
-                yColumn,
-                regression: mapRegression(row),
-            };
-            // Add note for self-regression
-            if (xColumn === yColumn) {
-                response["note"] = "Self-regression always returns slope=1, r²=1";
+                const result = await adapter.executeQuery(sql, ...(queryParams !== undefined && queryParams.length > 0
+                    ? [queryParams]
+                    : []));
+                const row = result.rows?.[0];
+                if (!row)
+                    return { error: "No regression data found" };
+                const response = {
+                    table: `${schema ?? "public"}.${table}`,
+                    xColumn,
+                    yColumn,
+                    regression: mapRegression(row),
+                };
+                // Add note for self-regression
+                if (xColumn === yColumn) {
+                    response["note"] = "Self-regression always returns slope=1, r²=1";
+                }
+                return response;
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    error: formatPostgresError(error, { tool: "pg_stats_regression" }),
+                };
             }
-            return response;
         },
     };
 }