mssql-mcp 2.3.1 → 2.3.2

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.2";
 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.2";
 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/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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mssql-mcp",
-  "version": "2.3.1",
+  "version": "2.3.2",
   "description": "MCP Server for MS SQL Server integration with Claude Desktop, Cursor, Windsurf and VS Code",
   "main": "dist/src/index.js",
   "type": "module",