mssql-mcp 2.3.1 → 2.3.3

package/README.md

@@ -1,4 +1,4 @@
-# MS SQL Server MCP Server v2.3.1
+# MS SQL Server MCP Server v2.3.2
 
 🚀 **Model Context Protocol (MCP) server** for Microsoft SQL Server - compatible with Claude Desktop, Cursor, Windsurf and VS Code.
 

package/dist/src/constants.d.ts

@@ -1,5 +1,5 @@
 export declare const SERVER_NAME = "mssql-mcp-server";
-export declare const SERVER_VERSION = "2.3.1";
+export declare const SERVER_VERSION = "2.3.3";
 export declare const DEFAULT_PORT = 1433;
 export declare const DEFAULT_ENCRYPT = true;
 export declare const DEFAULT_TRUST_SERVER_CERTIFICATE = false;

package/dist/src/constants.js

@@ -1,5 +1,5 @@
 export const SERVER_NAME = "mssql-mcp-server";
-export const SERVER_VERSION = "2.3.1";
+export const SERVER_VERSION = "2.3.3";
 export const DEFAULT_PORT = 1433;
 export const DEFAULT_ENCRYPT = true;
 export const DEFAULT_TRUST_SERVER_CERTIFICATE = false;

package/dist/src/db/connection.js

@@ -19,6 +19,7 @@ export async function connectPool(config) {
             encrypt: config.encrypt,
             trustServerCertificate: config.trustServerCertificate,
             enableArithAbort: true,
+            useUTC: false,
         },
         connectionTimeout: config.connectionTimeout,
         requestTimeout: config.requestTimeout,

package/dist/src/tools/databases.js

@@ -1,10 +1,9 @@
 import { z } from "zod";
 import { requirePool } from "../db/connection.js";
-import { toActionableError, toolError, toolSuccess } from "../utils/errors.js";
+import { toActionableError, toolError, toolSuccess, toolSuccessMarkdown } from "../utils/errors.js";
 import { formatJson } from "../utils/format.js";
 import { formatMarkdownTable } from "../utils/markdown.js";
 import { buildPaginationMeta, clampLimit } from "../utils/pagination.js";
-import { PaginationSchema, DatabaseInfoSchema } from "../schemas/outputs.js";
 export function registerDatabasesTools(server) {
     server.registerTool("mssql_list_databases", {
         title: "List Databases",
@@ -20,7 +19,6 @@ export function registerDatabasesTools(server) {
                 .describe("Output format: 'json' for structured data, 'markdown' for human-readable table"),
         },
         annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
-        outputSchema: { databases: z.array(DatabaseInfoSchema), pagination: PaginationSchema },
     }, async ({ limit: rawLimit, offset, response_format }) => {
         try {
             const pool = requirePool();
@@ -40,7 +38,7 @@ export function registerDatabasesTools(server) {
                 const rows = page;
                 let text = formatMarkdownTable(rows, "Databases");
                 text += `\n\n*Showing ${page.length} of ${allRows.length} databases*`;
-                return toolSuccess(text, structured);
+                return toolSuccessMarkdown(text);
             }
             return toolSuccess(formatJson(structured), structured);
         }

package/dist/src/tools/procedure.js

@@ -1,15 +1,9 @@
 import { z } from "zod";
 import { requirePool } from "../db/connection.js";
 import { validateIdentifier, bracketIdentifier } from "../db/validators.js";
-import { toActionableError, toolError, toolSuccess } from "../utils/errors.js";
+import { toActionableError, toolError, toolSuccess, toolSuccessMarkdown } from "../utils/errors.js";
 import { formatJson } from "../utils/format.js";
 import { formatMarkdownMultiRecordsets } from "../utils/markdown.js";
-const ProcedureOutputSchema = {
-    recordsets: z.array(z.array(z.record(z.unknown()))),
-    rows_affected: z.array(z.number()),
-    output: z.record(z.unknown()),
-    return_value: z.unknown(),
-};
 export function registerProcedureTools(server) {
     server.registerTool("mssql_execute_stored_procedure", {
         title: "Execute Stored Procedure",
@@ -31,7 +25,6 @@ export function registerProcedureTools(server) {
                 .describe("Output format: 'json' for structured data, 'markdown' for human-readable tables"),
         },
         annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: true },
-        outputSchema: ProcedureOutputSchema,
     }, async ({ procedureName, schemaName, parameters, response_format }) => {
         try {
             const pool = requirePool();
@@ -52,7 +45,7 @@ export function registerProcedureTools(server) {
                 return_value: result.returnValue,
             };
             if (response_format === "markdown") {
-                return toolSuccess(formatMarkdownMultiRecordsets(result.recordsets, qualifiedName), structured);
+                return toolSuccessMarkdown(formatMarkdownMultiRecordsets(result.recordsets, qualifiedName));
             }
             return toolSuccess(formatJson(structured), structured);
         }
@@ -95,7 +88,7 @@ export function registerProcedureTools(server) {
                 returnValue: result.returnValue,
             };
             if (response_format === "markdown") {
-                return toolSuccess(formatMarkdownMultiRecordsets(result.recordsets));
+                return toolSuccessMarkdown(formatMarkdownMultiRecordsets(result.recordsets));
             }
             return toolSuccess(formatJson(structured), structured);
         }

package/dist/src/tools/query.js

@@ -1,17 +1,8 @@
 import { z } from "zod";
 import { requirePool } from "../db/connection.js";
-import { toActionableError, toolError, toolSuccess } from "../utils/errors.js";
+import { toActionableError, toolError, toolSuccess, toolSuccessMarkdown } from "../utils/errors.js";
 import { formatJson, truncatePayload } from "../utils/format.js";
 import { formatMarkdownTable } from "../utils/markdown.js";
-const QueryOutputSchema = {
-    recordset: z.array(z.record(z.unknown())),
-    rows_affected: z.array(z.number()),
-    output: z.record(z.unknown()),
-    execution_time_ms: z.number(),
-    parameters_used: z.number(),
-    truncated: z.boolean(),
-    truncation_message: z.string().optional(),
-};
 async function runSqlQueryCore(query, parameters, response_format, logLabel) {
     try {
         const pool = requirePool();
@@ -41,7 +32,7 @@ async function runSqlQueryCore(query, parameters, response_format, logLabel) {
             if (truncated)
                 text += `\n\n> ⚠️ ${truncation_message}`;
             text += `\n\n*Rows affected: ${(result.rowsAffected ?? []).join(", ")} · ${elapsed}ms*`;
-            return toolSuccess(text, structured);
+            return toolSuccessMarkdown(text);
         }
         return toolSuccess(formatJson(structured), structured);
     }
@@ -72,7 +63,6 @@ export function registerQueryTools(server) {
                 .describe("Output format: 'json' for structured data, 'markdown' for human-readable table"),
         },
         annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: true },
-        outputSchema: QueryOutputSchema,
     }, ({ query, parameters, response_format }) => runSqlQueryCore(query, parameters, response_format, "mssql_run_sql_query"));
     // Backward-compatible alias
     server.registerTool("mssql_execute_query", {

package/dist/src/tools/schema.js

@@ -2,11 +2,10 @@ import { z } from "zod";
 import sql from "mssql";
 import { requirePool } from "../db/connection.js";
 import { buildSchemaObjectsQuery } from "../db/query-builders.js";
-import { toActionableError, toolError, toolSuccess } from "../utils/errors.js";
+import { toActionableError, toolError, toolSuccess, toolSuccessMarkdown } from "../utils/errors.js";
 import { formatJson } from "../utils/format.js";
 import { formatMarkdownTable } from "../utils/markdown.js";
 import { buildPaginationMeta, clampLimit } from "../utils/pagination.js";
-import { PaginationSchema, SchemaObjectSchema } from "../schemas/outputs.js";
 export function registerSchemaTools(server) {
     server.registerTool("mssql_list_schema_objects", {
         title: "List Schema Objects",
@@ -32,7 +31,6 @@ export function registerSchemaTools(server) {
                 .describe("Output format: 'json' for structured data, 'markdown' for human-readable table"),
         },
         annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
-        outputSchema: { objects: z.array(SchemaObjectSchema), pagination: PaginationSchema },
     }, async ({ objectType, schemaName, limit: rawLimit, offset, response_format }) => {
         try {
             const pool = requirePool();
@@ -51,7 +49,7 @@ export function registerSchemaTools(server) {
                 const rows = page;
                 let text = formatMarkdownTable(rows, `Schema Objects (${objectType})`);
                 text += `\n\n*Showing ${page.length} of ${allRows.length} · offset ${offset}*`;
-                return toolSuccess(text, structured);
+                return toolSuccessMarkdown(text);
             }
             return toolSuccess(formatJson(structured), structured);
         }
@@ -85,7 +83,7 @@ export function registerSchemaTools(server) {
             const result = await request.query(query);
             const rows = result.recordset ?? [];
             if (response_format === "markdown") {
-                return toolSuccess(formatMarkdownTable(rows));
+                return toolSuccessMarkdown(formatMarkdownTable(rows));
             }
             return toolSuccess(formatJson(rows));
         }

package/dist/src/tools/table.js

@@ -3,11 +3,10 @@ import sql from "mssql";
 import { requirePool } from "../db/connection.js";
 import { validateIdentifier, validateOrderBy, SAFE_IDENTIFIER_RE } from "../db/validators.js";
 import { buildSelectQuery, buildSelectWithWhereQuery } from "../db/query-builders.js";
-import { toActionableError, toolError, toolSuccess } from "../utils/errors.js";
+import { toActionableError, toolError, toolSuccess, toolSuccessMarkdown } from "../utils/errors.js";
 import { formatJson, truncatePayload } from "../utils/format.js";
 import { formatMarkdownTable } from "../utils/markdown.js";
 import { buildPaginationMeta, clampLimit } from "../utils/pagination.js";
-import { PaginationSchema, ColumnInfoSchema } from "../schemas/outputs.js";
 export function registerTableTools(server) {
     server.registerTool("mssql_describe_table_columns", {
         title: "Describe Table Columns",
@@ -23,7 +22,6 @@ export function registerTableTools(server) {
                 .describe("Output format: 'json' for structured data, 'markdown' for human-readable table"),
         },
         annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
-        outputSchema: { columns: z.array(ColumnInfoSchema), table: z.string() },
     }, async ({ tableName, schemaName, response_format }) => {
         try {
             const pool = requirePool();
@@ -47,7 +45,7 @@ export function registerTableTools(server) {
             };
             if (response_format === "markdown") {
                 const rows = result.recordset;
-                return toolSuccess(formatMarkdownTable(rows, `Columns: ${schemaName}.${tableName}`), structured);
+                return toolSuccessMarkdown(formatMarkdownTable(rows, `Columns: ${schemaName}.${tableName}`));
             }
             return toolSuccess(formatJson(structured), structured);
         }
@@ -86,7 +84,7 @@ export function registerTableTools(server) {
           `);
             const rows = result.recordset ?? [];
             if (response_format === "markdown") {
-                return toolSuccess(formatMarkdownTable(rows));
+                return toolSuccessMarkdown(formatMarkdownTable(rows));
             }
             return toolSuccess(formatJson(rows));
         }
@@ -140,14 +138,6 @@ export function registerTableTools(server) {
                 .describe("Output format: 'json' for structured data, 'markdown' for human-readable table"),
         },
         annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
-        outputSchema: {
-            data: z.array(z.record(z.unknown())),
-            pagination: PaginationSchema,
-            table: z.string(),
-            execution_time_ms: z.number(),
-            truncated: z.boolean().optional(),
-            truncation_message: z.string().optional(),
-        },
     }, async ({ tableName, schemaName, columns, limit: rawLimit, offset, whereClause, orderBy, parameters, response_format }) => {
         try {
             const pool = requirePool();
@@ -185,7 +175,7 @@ export function registerTableTools(server) {
                 if (truncated)
                     text += `\n\n> ⚠️ ${truncation_message}`;
                 text += `\n\n*${rows.length} rows · offset ${offset} · ${elapsed}ms*`;
-                return toolSuccess(text, structured);
+                return toolSuccessMarkdown(text);
             }
             return toolSuccess(formatJson(structured), structured);
         }
@@ -250,7 +240,7 @@ export function registerTableTools(server) {
                 structured.truncation_message = truncation_message;
             }
             if (response_format === "markdown") {
-                return toolSuccess(formatMarkdownTable(data));
+                return toolSuccessMarkdown(formatMarkdownTable(data));
             }
             return toolSuccess(formatJson(structured), structured);
         }

package/dist/src/utils/errors.d.ts

@@ -10,6 +10,12 @@ export declare function toolError(message: string): {
     }[];
     isError: true;
 };
+export declare function toolSuccessMarkdown(text: string): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};
 export declare function toolSuccess(text: string, structuredContent?: Record<string, unknown>): {
     content: Array<{
         type: "text";

package/dist/src/utils/errors.js

@@ -1,3 +1,4 @@
+import { normalizeOutput } from "./format.js";
 export class McpToolError extends Error {
     cause;
     constructor(message, cause) {
@@ -18,12 +19,17 @@ export function toolError(message) {
         isError: true,
     };
 }
+export function toolSuccessMarkdown(text) {
+    return {
+        content: [{ type: "text", text }],
+    };
+}
 export function toolSuccess(text, structuredContent) {
     const result = {
         content: [{ type: "text", text }],
     };
     if (structuredContent !== undefined) {
-        result.structuredContent = structuredContent;
+        result.structuredContent = normalizeOutput(structuredContent);
     }
     return result;
 }

package/dist/src/utils/format.d.ts

@@ -1,4 +1,12 @@
 export declare function formatJson(data: unknown): string;
+export declare function formatDisplayValue(value: unknown, column?: {
+    type?: unknown;
+    scale?: number;
+}): string;
+export declare function normalizeOutput(value: unknown, column?: {
+    type?: unknown;
+    scale?: number;
+}): unknown;
 export declare function truncatePayload(data: unknown[], maxBytes?: number): {
     data: unknown[];
     truncated: boolean;

package/dist/src/utils/format.js

@@ -1,18 +1,127 @@
 import { MAX_TEXT_PAYLOAD_BYTES } from "../constants.js";
+function pad(value, width) {
+    return String(value).padStart(width, "0");
+}
+function getRecordsetColumns(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const columns = value.columns;
+    if (!columns || typeof columns !== "object" || Array.isArray(columns)) {
+        return undefined;
+    }
+    return columns;
+}
+function getTypeName(column) {
+    const type = column?.type;
+    if (typeof type === "function") {
+        return type.name || undefined;
+    }
+    if (type && typeof type === "object" && "name" in type) {
+        const name = type.name;
+        return typeof name === "string" ? name : undefined;
+    }
+    return undefined;
+}
+function getExtraFraction(date) {
+    const raw = typeof date.nanosecondsDelta === "number"
+        ? date.nanosecondsDelta
+        : typeof date.nanosecondDelta === "number"
+            ? date.nanosecondDelta
+            : 0;
+    if (!Number.isFinite(raw)) {
+        return 0;
+    }
+    return Math.max(0, Math.min(9999, Math.round(raw * 10_000_000)));
+}
+function buildFraction(date, milliseconds, scale) {
+    const base = `${pad(milliseconds, 3)}${pad(getExtraFraction(date), 4)}`;
+    const safeScale = scale === undefined ? undefined : Math.max(0, Math.min(7, scale));
+    if (safeScale === 0) {
+        return "";
+    }
+    if (safeScale !== undefined) {
+        return base.slice(0, safeScale);
+    }
+    return base.replace(/0+$/, "");
+}
+function formatDateParts(date, useUtcClock) {
+    return {
+        year: useUtcClock ? date.getUTCFullYear() : date.getFullYear(),
+        month: (useUtcClock ? date.getUTCMonth() : date.getMonth()) + 1,
+        day: useUtcClock ? date.getUTCDate() : date.getDate(),
+        hours: useUtcClock ? date.getUTCHours() : date.getHours(),
+        minutes: useUtcClock ? date.getUTCMinutes() : date.getMinutes(),
+        seconds: useUtcClock ? date.getUTCSeconds() : date.getSeconds(),
+        milliseconds: useUtcClock ? date.getUTCMilliseconds() : date.getMilliseconds(),
+    };
+}
+function formatDateValue(date, column) {
+    const typeName = getTypeName(column)?.toLowerCase();
+    const useUtcClock = typeName === "datetimeoffset";
+    const parts = formatDateParts(date, useUtcClock);
+    const fraction = buildFraction(date, parts.milliseconds, column?.scale);
+    const dateText = `${pad(parts.year, 4)}-${pad(parts.month, 2)}-${pad(parts.day, 2)}`;
+    const timeText = `${pad(parts.hours, 2)}:${pad(parts.minutes, 2)}:${pad(parts.seconds, 2)}`;
+    if (typeName === "date") {
+        return dateText;
+    }
+    if (typeName === "time") {
+        return fraction ? `${timeText}.${fraction}` : timeText;
+    }
+    return fraction ? `${dateText} ${timeText}.${fraction}` : `${dateText} ${timeText}`;
+}
+function isPlainObject(value) {
+    return typeof value === "object"
+        && value !== null
+        && !Array.isArray(value)
+        && !Buffer.isBuffer(value)
+        && !(value instanceof Date);
+}
+function normalizeRecordRow(row, columns) {
+    return Object.fromEntries(Object.entries(row).map(([key, value]) => [key, normalizeOutput(value, columns[key])]));
+}
 export function formatJson(data) {
-    return JSON.stringify(data, null, 2);
+    return JSON.stringify(normalizeOutput(data), null, 2);
+}
+export function formatDisplayValue(value, column) {
+    const normalized = normalizeOutput(value, column);
+    if (normalized == null) {
+        return "";
+    }
+    if (typeof normalized === "object") {
+        return JSON.stringify(normalized);
+    }
+    return String(normalized);
+}
+export function normalizeOutput(value, column) {
+    if (value instanceof Date) {
+        return formatDateValue(value, column);
+    }
+    const columns = getRecordsetColumns(value);
+    if (Array.isArray(value)) {
+        if (columns) {
+            return value.map((row) => isPlainObject(row) ? normalizeRecordRow(row, columns) : normalizeOutput(row));
+        }
+        return value.map((entry) => normalizeOutput(entry));
+    }
+    if (isPlainObject(value)) {
+        return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, normalizeOutput(entry)]));
+    }
+    return value;
 }
 export function truncatePayload(data, maxBytes = MAX_TEXT_PAYLOAD_BYTES) {
-    const full = JSON.stringify(data);
+    const normalizedData = normalizeOutput(data);
+    const full = JSON.stringify(normalizedData);
     if (Buffer.byteLength(full, "utf8") <= maxBytes) {
-        return { data, truncated: false };
+        return { data: normalizedData, truncated: false };
     }
     // Binary search for safe row count
     let lo = 0;
-    let hi = data.length;
+    let hi = normalizedData.length;
     while (lo < hi) {
         const mid = Math.floor((lo + hi + 1) / 2);
-        if (Buffer.byteLength(JSON.stringify(data.slice(0, mid)), "utf8") <= maxBytes) {
+        if (Buffer.byteLength(JSON.stringify(normalizedData.slice(0, mid)), "utf8") <= maxBytes) {
             lo = mid;
         }
         else {
@@ -20,8 +129,8 @@ export function truncatePayload(data, maxBytes = MAX_TEXT_PAYLOAD_BYTES) {
         }
     }
     return {
-        data: data.slice(0, lo),
+        data: normalizedData.slice(0, lo),
         truncated: true,
-        truncation_message: `Result truncated to ${lo} of ${data.length} rows to stay within ${maxBytes} byte limit.`,
+        truncation_message: `Result truncated to ${lo} of ${normalizedData.length} rows to stay within ${maxBytes} byte limit.`,
     };
 }

package/dist/src/utils/markdown.js

@@ -1,5 +1,6 @@
-function escapeCell(value) {
-    return String(value ?? "")
+import { formatDisplayValue } from "./format.js";
+function escapeCell(value, column) {
+    return formatDisplayValue(value, column)
         .replace(/\r?\n|\r/g, " ")
         .replace(/\|/g, "\\|");
 }
@@ -7,17 +8,18 @@ export function formatMarkdownTable(rows, title) {
     if (rows.length === 0) {
         return title ? `**${title}**\n\nNo results found.` : "No results found.";
     }
+    const columns = (rows.columns) ?? undefined;
     const headers = Object.keys(rows[0]);
     const header = `| ${headers.join(" | ")} |`;
     const sep = `| ${headers.map(() => "---").join(" | ")} |`;
     const body = rows
-        .map((row) => `| ${headers.map((h) => escapeCell(row[h])).join(" | ")} |`)
+        .map((row) => `| ${headers.map((h) => escapeCell(row[h], columns?.[h])).join(" | ")} |`)
         .join("\n");
     const table = [header, sep, body].join("\n");
     return title ? `**${title}**\n\n${table}` : table;
 }
 export function formatMarkdownList(obj, title) {
-    const lines = Object.entries(obj).map(([k, v]) => `- **${k}**: ${typeof v === "object" ? JSON.stringify(v) : String(v ?? "")}`);
+    const lines = Object.entries(obj).map(([k, v]) => `- **${k}**: ${formatDisplayValue(v)}`);
     const list = lines.join("\n");
     return title ? `**${title}**\n\n${list}` : list;
 }

package/dist/tests/unit/config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/unit/config.test.js

@@ -0,0 +1,180 @@
+import { strict as assert } from "node:assert";
+import { test } from "node:test";
+import { ConfigSchema, loadHttpConfig, loadConfigFromEnv } from "../../src/config.js";
+// --- ConfigSchema ---
+test("ConfigSchema - applies default port 1433", () => {
+    const result = ConfigSchema.parse({ server: "localhost" });
+    assert.equal(result.port, 1433);
+});
+test("ConfigSchema - applies default encrypt true", () => {
+    const result = ConfigSchema.parse({ server: "localhost" });
+    assert.equal(result.encrypt, true);
+});
+test("ConfigSchema - applies default trustServerCertificate false", () => {
+    const result = ConfigSchema.parse({ server: "localhost" });
+    assert.equal(result.trustServerCertificate, false);
+});
+test("ConfigSchema - applies default connectionTimeout 30000", () => {
+    const result = ConfigSchema.parse({ server: "localhost" });
+    assert.equal(result.connectionTimeout, 30000);
+});
+test("ConfigSchema - applies default requestTimeout 30000", () => {
+    const result = ConfigSchema.parse({ server: "localhost" });
+    assert.equal(result.requestTimeout, 30000);
+});
+test("ConfigSchema - accepts overridden port", () => {
+    const result = ConfigSchema.parse({ server: "myserver", port: 1434 });
+    assert.equal(result.port, 1434);
+});
+test("ConfigSchema - accepts encrypt false", () => {
+    const result = ConfigSchema.parse({ server: "myserver", encrypt: false });
+    assert.equal(result.encrypt, false);
+});
+test("ConfigSchema - accepts trustServerCertificate true", () => {
+    const result = ConfigSchema.parse({ server: "myserver", trustServerCertificate: true });
+    assert.equal(result.trustServerCertificate, true);
+});
+test("ConfigSchema - throws on empty server string", () => {
+    assert.throws(() => ConfigSchema.parse({ server: "" }), /Server address is required/);
+});
+test("ConfigSchema - throws on missing server", () => {
+    assert.throws(() => ConfigSchema.parse({}));
+});
+test("ConfigSchema - throws on port out of range", () => {
+    assert.throws(() => ConfigSchema.parse({ server: "localhost", port: 0 }));
+    assert.throws(() => ConfigSchema.parse({ server: "localhost", port: 65536 }));
+});
+// --- loadHttpConfig ---
+test("loadHttpConfig - returns default host 127.0.0.1 when env not set", () => {
+    const savedHost = process.env.MCP_HOST;
+    const savedPort = process.env.MCP_PORT;
+    delete process.env.MCP_HOST;
+    delete process.env.MCP_PORT;
+    try {
+        const config = loadHttpConfig();
+        assert.equal(config.host, "127.0.0.1");
+    }
+    finally {
+        if (savedHost !== undefined)
+            process.env.MCP_HOST = savedHost;
+        if (savedPort !== undefined)
+            process.env.MCP_PORT = savedPort;
+    }
+});
+test("loadHttpConfig - returns default port 3001 when env not set", () => {
+    const savedHost = process.env.MCP_HOST;
+    const savedPort = process.env.MCP_PORT;
+    delete process.env.MCP_HOST;
+    delete process.env.MCP_PORT;
+    try {
+        const config = loadHttpConfig();
+        assert.equal(config.port, 3001);
+    }
+    finally {
+        if (savedHost !== undefined)
+            process.env.MCP_HOST = savedHost;
+        if (savedPort !== undefined)
+            process.env.MCP_PORT = savedPort;
+    }
+});
+test("loadHttpConfig - reads host from MCP_HOST", () => {
+    const savedHost = process.env.MCP_HOST;
+    process.env.MCP_HOST = "0.0.0.0";
+    try {
+        const config = loadHttpConfig();
+        assert.equal(config.host, "0.0.0.0");
+    }
+    finally {
+        if (savedHost !== undefined)
+            process.env.MCP_HOST = savedHost;
+        else
+            delete process.env.MCP_HOST;
+    }
+});
+test("loadHttpConfig - reads port from MCP_PORT", () => {
+    const savedPort = process.env.MCP_PORT;
+    process.env.MCP_PORT = "8080";
+    try {
+        const config = loadHttpConfig();
+        assert.equal(config.port, 8080);
+    }
+    finally {
+        if (savedPort !== undefined)
+            process.env.MCP_PORT = savedPort;
+        else
+            delete process.env.MCP_PORT;
+    }
+});
+// --- loadConfigFromEnv ---
+test("loadConfigFromEnv - throws when DB_SERVER not set", () => {
+    const saved = process.env.DB_SERVER;
+    delete process.env.DB_SERVER;
+    try {
+        assert.throws(() => loadConfigFromEnv());
+    }
+    finally {
+        if (saved !== undefined)
+            process.env.DB_SERVER = saved;
+    }
+});
+test("loadConfigFromEnv - reads DB_SERVER and applies defaults", () => {
+    const savedServer = process.env.DB_SERVER;
+    const savedEncrypt = process.env.DB_ENCRYPT;
+    process.env.DB_SERVER = "myserver";
+    delete process.env.DB_ENCRYPT;
+    try {
+        const config = loadConfigFromEnv();
+        assert.equal(config.server, "myserver");
+        assert.equal(config.port, 1433);
+        assert.equal(config.encrypt, true);
+        assert.equal(config.trustServerCertificate, false);
+    }
+    finally {
+        if (savedServer !== undefined)
+            process.env.DB_SERVER = savedServer;
+        else
+            delete process.env.DB_SERVER;
+        if (savedEncrypt !== undefined)
+            process.env.DB_ENCRYPT = savedEncrypt;
+    }
+});
+test("loadConfigFromEnv - DB_ENCRYPT=false disables encryption", () => {
+    const savedServer = process.env.DB_SERVER;
+    const savedEncrypt = process.env.DB_ENCRYPT;
+    process.env.DB_SERVER = "myserver";
+    process.env.DB_ENCRYPT = "false";
+    try {
+        const config = loadConfigFromEnv();
+        assert.equal(config.encrypt, false);
+    }
+    finally {
+        if (savedServer !== undefined)
+            process.env.DB_SERVER = savedServer;
+        else
+            delete process.env.DB_SERVER;
+        if (savedEncrypt !== undefined)
+            process.env.DB_ENCRYPT = savedEncrypt;
+        else
+            delete process.env.DB_ENCRYPT;
+    }
+});
+test("loadConfigFromEnv - DB_TRUST_SERVER_CERTIFICATE=true enables trust", () => {
+    const savedServer = process.env.DB_SERVER;
+    const savedTrust = process.env.DB_TRUST_SERVER_CERTIFICATE;
+    process.env.DB_SERVER = "myserver";
+    process.env.DB_TRUST_SERVER_CERTIFICATE = "true";
+    try {
+        const config = loadConfigFromEnv();
+        assert.equal(config.trustServerCertificate, true);
+    }
+    finally {
+        if (savedServer !== undefined)
+            process.env.DB_SERVER = savedServer;
+        else
+            delete process.env.DB_SERVER;
+        if (savedTrust !== undefined)
+            process.env.DB_TRUST_SERVER_CERTIFICATE = savedTrust;
+        else
+            delete process.env.DB_TRUST_SERVER_CERTIFICATE;
+    }
+});

package/dist/tests/unit/errors.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/unit/errors.test.js

@@ -0,0 +1,52 @@
+import { strict as assert } from "node:assert";
+import { test } from "node:test";
+import { McpToolError, toActionableError, toolError } from "../../src/utils/errors.js";
+test("toolError - wraps message with error emoji", () => {
+    const result = toolError("connection failed");
+    assert.equal(result.content[0].type, "text");
+    assert.ok(result.content[0].text.includes("❌"));
+    assert.ok(result.content[0].text.includes("connection failed"));
+});
+test("toolError - sets isError flag to true", () => {
+    const result = toolError("oops");
+    assert.equal(result.isError, true);
+});
+test("toolError - content type is always 'text'", () => {
+    const result = toolError("msg");
+    assert.equal(result.content.length, 1);
+    assert.equal(result.content[0].type, "text");
+});
+test("toActionableError - extracts message from Error instance", () => {
+    const err = new Error("connection refused");
+    assert.equal(toActionableError(err), "connection refused");
+});
+test("toActionableError - converts plain string to string", () => {
+    assert.equal(toActionableError("plain string"), "plain string");
+});
+test("toActionableError - converts number to string", () => {
+    assert.equal(toActionableError(42), "42");
+});
+test("toActionableError - converts null to string", () => {
+    assert.equal(toActionableError(null), "null");
+});
+test("McpToolError - has correct name", () => {
+    const err = new McpToolError("test error");
+    assert.equal(err.name, "McpToolError");
+});
+test("McpToolError - is instanceof Error", () => {
+    const err = new McpToolError("test error");
+    assert.ok(err instanceof Error);
+});
+test("McpToolError - stores message", () => {
+    const err = new McpToolError("something failed");
+    assert.equal(err.message, "something failed");
+});
+test("McpToolError - stores cause when provided", () => {
+    const cause = new Error("original cause");
+    const err = new McpToolError("wrapper", cause);
+    assert.equal(err.cause, cause);
+});
+test("McpToolError - cause is undefined when not provided", () => {
+    const err = new McpToolError("no cause");
+    assert.equal(err.cause, undefined);
+});

package/dist/tests/unit/format.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/unit/format.test.js

@@ -0,0 +1,106 @@
+import { strict as assert } from "node:assert";
+import { test } from "node:test";
+import { formatDisplayValue, normalizeOutput } from "../../src/utils/format.js";
+// Type stubs — getTypeName() uses function.name lowercased,
+// or falls back to object.name property.
+const DateType = { name: "Date" };
+const TimeType = { name: "Time" };
+function pad(value, width) {
+    return String(value).padStart(width, "0");
+}
+function formatLocalDate(d) {
+    return `${pad(d.getFullYear(), 4)}-${pad(d.getMonth() + 1, 2)}-${pad(d.getDate(), 2)}`;
+}
+function formatLocalTime(d) {
+    return `${pad(d.getHours(), 2)}:${pad(d.getMinutes(), 2)}:${pad(d.getSeconds(), 2)}`;
+}
+function formatLocalDateTime(d) {
+    return `${formatLocalDate(d)} ${formatLocalTime(d)}`;
+}
+// --- formatDisplayValue ---
+test("formatDisplayValue - null returns empty string", () => {
+    assert.equal(formatDisplayValue(null), "");
+});
+test("formatDisplayValue - undefined returns empty string", () => {
+    assert.equal(formatDisplayValue(undefined), "");
+});
+test("formatDisplayValue - string returns itself", () => {
+    assert.equal(formatDisplayValue("hello"), "hello");
+});
+test("formatDisplayValue - number returns string representation", () => {
+    assert.equal(formatDisplayValue(42), "42");
+    assert.equal(formatDisplayValue(3.14), "3.14");
+});
+test("formatDisplayValue - boolean returns string representation", () => {
+    assert.equal(formatDisplayValue(true), "true");
+    assert.equal(formatDisplayValue(false), "false");
+});
+test("formatDisplayValue - object returns JSON string", () => {
+    assert.equal(formatDisplayValue({ a: 1 }), JSON.stringify({ a: 1 }));
+});
+// --- normalizeOutput: SQL date types ---
+test("normalizeOutput - 'date' type returns date-only string", () => {
+    const d = new Date(2026, 3, 1, 10, 51, 23, 600);
+    const result = normalizeOutput(d, { type: DateType });
+    assert.equal(result, formatLocalDate(d));
+});
+test("normalizeOutput - 'time' type with scale=0 returns time without fraction", () => {
+    const d = new Date(2026, 3, 1, 10, 51, 23, 0);
+    const result = normalizeOutput(d, { type: TimeType, scale: 0 });
+    assert.equal(result, "10:51:23");
+});
+test("normalizeOutput - 'time' type with scale=3 includes milliseconds", () => {
+    const d = new Date(2026, 3, 1, 10, 51, 23, 600);
+    const result = normalizeOutput(d, { type: TimeType, scale: 3 });
+    assert.equal(result, "10:51:23.600");
+});
+test("normalizeOutput - datetime with scale=0 returns no fraction", () => {
+    const d = new Date(2026, 3, 1, 10, 51, 23, 600);
+    const result = normalizeOutput(d, { scale: 0 });
+    assert.equal(result, `${formatLocalDate(d)} ${formatLocalTime(d)}`);
+});
+test("normalizeOutput - datetime with scale=3 returns 3-digit fraction", () => {
+    const d = new Date(2026, 3, 1, 10, 51, 23, 600);
+    const result = normalizeOutput(d, { scale: 3 });
+    assert.equal(result, `${formatLocalDateTime(d)}.600`);
+});
+test("normalizeOutput - datetime with no column metadata trims trailing zeros", () => {
+    // 600ms → base "6000000" → trimmed to "6"
+    const d = new Date(2026, 3, 1, 10, 51, 23, 600);
+    const result = normalizeOutput(d);
+    assert.ok(result.startsWith(formatLocalDate(d)));
+    assert.ok(!result.endsWith("0"), `Trailing zeros not trimmed: ${result}`);
+});
+test("normalizeOutput - datetime with zero milliseconds and no scale returns no fraction", () => {
+    // 0ms → base "0000000" → trimmed to "" → no fraction
+    const d = new Date(2026, 3, 1, 10, 51, 23, 0);
+    const result = normalizeOutput(d);
+    assert.equal(result, `${formatLocalDateTime(d)}`);
+});
+// --- normalizeOutput: primitives & structures ---
+test("normalizeOutput - passes through number", () => {
+    assert.equal(normalizeOutput(42), 42);
+});
+test("normalizeOutput - passes through string", () => {
+    assert.equal(normalizeOutput("hello"), "hello");
+});
+test("normalizeOutput - passes through null", () => {
+    assert.equal(normalizeOutput(null), null);
+});
+test("normalizeOutput - passes through boolean", () => {
+    assert.equal(normalizeOutput(true), true);
+});
+test("normalizeOutput - normalizes Date inside plain object", () => {
+    const d = new Date(2026, 3, 1, 10, 0, 0, 0);
+    const result = normalizeOutput({ created: d });
+    assert.equal(result.created, `${formatLocalDateTime(d)}`);
+});
+test("normalizeOutput - normalizes array of primitives unchanged", () => {
+    const result = normalizeOutput([1, "two", null]);
+    assert.deepEqual(result, [1, "two", null]);
+});
+test("normalizeOutput - normalizes Date values inside array", () => {
+    const d = new Date(2026, 3, 1, 10, 0, 0, 0);
+    const result = normalizeOutput([d]);
+    assert.equal(result[0], `${formatLocalDateTime(d)}`);
+});

package/dist/tests/unit/markdown.test.js

@@ -1,6 +1,16 @@
 import { strict as assert } from "node:assert";
 import { test } from "node:test";
 import { formatMarkdownTable, formatMarkdownList, formatMarkdownMultiRecordsets, } from "../../src/utils/markdown.js";
+function DateTimeOffset() { }
+function pad(value, width) {
+    return String(value).padStart(width, "0");
+}
+function formatUtcDateTime(date) {
+    return [
+        `${pad(date.getUTCFullYear(), 4)}-${pad(date.getUTCMonth() + 1, 2)}-${pad(date.getUTCDate(), 2)}`,
+        `${pad(date.getUTCHours(), 2)}:${pad(date.getUTCMinutes(), 2)}:${pad(date.getUTCSeconds(), 2)}.${pad(date.getUTCMilliseconds(), 3)}6938`,
+    ].join(" ");
+}
 test("formatMarkdownTable - renders header and rows", () => {
     const rows = [
         { name: "Users", schema: "dbo" },
@@ -48,6 +58,16 @@ test("formatMarkdownTable - CRLF in cell values are replaced with space", () =>
     const result = formatMarkdownTable(rows);
     assert.ok(result.includes("line1 line2"));
 });
+test("formatMarkdownTable - datetimeoffset values render without JS timezone string", () => {
+    const offsetTime = new Date(Date.UTC(2026, 3, 1, 10, 51, 23, 600));
+    Object.defineProperty(offsetTime, "nanosecondsDelta", { value: 0.0006938 });
+    const rows = Object.assign([{ offset_time: offsetTime }], {
+        columns: { offset_time: { type: DateTimeOffset, scale: 7 } },
+    });
+    const result = formatMarkdownTable(rows);
+    assert.ok(result.includes(formatUtcDateTime(offsetTime)));
+    assert.ok(!result.includes("GMT"));
+});
 test("formatMarkdownList - renders key-value pairs", () => {
     const result = formatMarkdownList({ status: "connected", server: "localhost" });
     assert.ok(result.includes("**status**: connected"));

package/dist/tests/unit/query-builders.test.js

@@ -61,3 +61,27 @@ test("buildSchemaObjectsQuery - without schema filter has no @schemaName", () =>
     const q = buildSchemaObjectsQuery("tables");
     assert.ok(!q.includes("@schemaName"));
 });
+test("buildSchemaObjectsQuery - procedures only", () => {
+    const q = buildSchemaObjectsQuery("procedures");
+    assert.ok(q.includes("ROUTINE_TYPE = 'PROCEDURE'"));
+    assert.ok(!q.includes("INFORMATION_SCHEMA.TABLES"));
+    assert.ok(!q.includes("INFORMATION_SCHEMA.VIEWS"));
+    assert.ok(!q.includes("ROUTINE_TYPE = 'FUNCTION'"));
+});
+test("buildSchemaObjectsQuery - functions only", () => {
+    const q = buildSchemaObjectsQuery("functions");
+    assert.ok(q.includes("ROUTINE_TYPE = 'FUNCTION'"));
+    assert.ok(!q.includes("INFORMATION_SCHEMA.TABLES"));
+    assert.ok(!q.includes("ROUTINE_TYPE = 'PROCEDURE'"));
+});
+test("buildSelectWithWhereQuery - with column projection", () => {
+    const q = buildSelectWithWhereQuery("dbo", "Orders", ["Id", "Status"], "Status = @status", null, 0, 10);
+    assert.ok(q.includes("[Id], [Status]"));
+    assert.ok(q.includes("WHERE Status = @status"));
+    assert.ok(!q.includes("SELECT *"));
+});
+test("buildSelectWithWhereQuery - with orderBy", () => {
+    const q = buildSelectWithWhereQuery("dbo", "Orders", null, "Total > @min", "Total DESC", 0, 20);
+    assert.ok(q.includes("ORDER BY Total DESC"));
+    assert.ok(q.includes("WHERE Total > @min"));
+});

package/dist/tests/unit/tool-contracts.test.js

@@ -1,7 +1,18 @@
 import { strict as assert } from "node:assert";
 import { test } from "node:test";
+import { toolSuccess, toolSuccessMarkdown } from "../../src/utils/errors.js";
 import { buildPaginationMeta, clampLimit } from "../../src/utils/pagination.js";
-import { truncatePayload } from "../../src/utils/format.js";
+import { formatJson, truncatePayload } from "../../src/utils/format.js";
+function DateTime2() { }
+function pad(value, width) {
+    return String(value).padStart(width, "0");
+}
+function formatLocalDateTime(date) {
+    return [
+        `${pad(date.getFullYear(), 4)}-${pad(date.getMonth() + 1, 2)}-${pad(date.getDate(), 2)}`,
+        `${pad(date.getHours(), 2)}:${pad(date.getMinutes(), 2)}:${pad(date.getSeconds(), 2)}.${pad(date.getMilliseconds(), 3)}6938`,
+    ].join(" ");
+}
 test("clampLimit - defaults to DEFAULT_PAGE_SIZE (20)", () => {
     assert.equal(clampLimit(undefined), 20);
 });
@@ -60,3 +71,25 @@ test("truncatePayload - empty array not truncated", () => {
     assert.equal(result.truncated, false);
     assert.equal(result.data.length, 0);
 });
+test("formatJson - recordset datetime values use SQL-like formatting", () => {
+    const serverTime = new Date(2026, 3, 1, 10, 51, 23, 600);
+    Object.defineProperty(serverTime, "nanosecondsDelta", { value: 0.0006938 });
+    const rows = Object.assign([{ server_time: serverTime }], {
+        columns: { server_time: { type: DateTime2, scale: 7 } },
+    });
+    const result = formatJson({ recordset: rows });
+    assert.ok(result.includes(formatLocalDateTime(serverTime)));
+    assert.ok(!result.includes("GMT"));
+    assert.ok(!result.includes("T10:51:23"));
+});
+test("toolSuccessMarkdown - returns text content without structuredContent", () => {
+    const result = toolSuccessMarkdown("| col |\n| --- |\n| value |");
+    assert.equal(result.content[0].type, "text");
+    assert.ok(result.content[0].text.includes("| col |"));
+    assert.equal(result.structuredContent, undefined);
+});
+test("toolSuccess - keeps structuredContent for json-style responses", () => {
+    const result = toolSuccess("{\n  \"ok\": true\n}", { ok: true });
+    assert.equal(result.content[0].type, "text");
+    assert.equal(result.structuredContent?.ok, true);
+});

package/dist/tests/unit/validators.test.js

@@ -49,3 +49,15 @@ test("validateOrderBy - invalid clauses", () => {
     assert.throws(() => validateOrderBy("Name UNION SELECT"), /Invalid ORDER BY/);
     assert.throws(() => validateOrderBy("Name--comment"), /Invalid ORDER BY/);
 });
+test("isValidIdentifier - 128-char identifier is valid (at limit)", () => {
+    const name = "a" + "x".repeat(127); // 1 + 127 = 128 chars
+    assert.ok(isValidIdentifier(name));
+});
+test("isValidIdentifier - 129-char identifier is invalid (over limit)", () => {
+    const name = "a" + "x".repeat(128); // 1 + 128 = 129 chars
+    assert.ok(!isValidIdentifier(name));
+});
+test("isValidIdentifier - single char identifier is valid", () => {
+    assert.ok(isValidIdentifier("a"));
+    assert.ok(isValidIdentifier("_"));
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mssql-mcp",
-  "version": "2.3.1",
+  "version": "2.3.3",
   "description": "MCP Server for MS SQL Server integration with Claude Desktop, Cursor, Windsurf and VS Code",
   "main": "dist/src/index.js",
   "type": "module",
@@ -31,7 +31,7 @@
     "clean": "rimraf dist",
     "prepublishOnly": "npm run clean && npm run build",
     "typecheck": "tsc --noEmit",
-    "test": "node --test dist/tests/unit/validators.test.js dist/tests/unit/query-builders.test.js dist/tests/unit/tool-contracts.test.js dist/tests/unit/markdown.test.js",
+    "test": "node --test dist/tests/unit/validators.test.js dist/tests/unit/query-builders.test.js dist/tests/unit/tool-contracts.test.js dist/tests/unit/markdown.test.js dist/tests/unit/errors.test.js dist/tests/unit/config.test.js dist/tests/unit/format.test.js",
     "ci": "npm run typecheck && npm run build && npm test"
   },
   "keywords": [
@@ -50,11 +50,11 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.28.0",
     "dotenv": "^16.3.1",
-    "mssql": "^11.0.1",
+    "mssql": "^12.5.5",
     "zod": "^3.25.0"
   },
   "devDependencies": {
-    "@types/mssql": "^9.1.7",
+    "@types/mssql": "^12.3.0",
     "@types/node": "^20.0.0",
     "cross-env": "^7.0.3",
     "rimraf": "^5.0.0",