mssql-mcp 2.0.2 → 2.0.3

package/README.md

@@ -1,4 +1,4 @@
-# MS SQL Server MCP Server v2.0.2
+# MS SQL Server MCP Server v2.0.3
 
 🚀 **Smart Trust-Based Model Context Protocol (MCP) server** for Microsoft SQL Server with intelligent auto-connection and AI-friendly design.
 
@@ -96,6 +96,7 @@ All tools auto-connect using environment variables.
 - ✅ **Query Caching**: 5-minute TTL for SELECT queries
 - ✅ **Performance Monitoring**: Execution time tracking
 - ✅ **Latest MCP SDK**: v1.20.2 with 2025 protocol
+- ✅ **Clean Logging**: Minimal console output, MCP protocol compatible
 
 ## 🔍 Troubleshooting
 
@@ -108,6 +109,19 @@ All tools auto-connect using environment variables.
 - Only server operations are blocked
 - Database operations should work normally
 
+## 📋 Version History
+
+### v2.0.3 - Latest
+- ✅ Updated documentation with modern styling
+- ✅ Improved troubleshooting section
+- ✅ Enhanced feature descriptions
+
+### v2.0.2 - Performance & Compatibility
+- ✅ Simplified logging for MCP protocol compatibility
+- ✅ All console output moved to stderr
+- ✅ Clean, professional log messages
+- ✅ Version bump to 2.0.2
+
 ## 📄 License
 
 MIT License
@@ -119,4 +133,4 @@ MIT License
 
 ---
 
-**🎉 v2.0.2: Smart auto-connection with complete SQL support**
+**🎉 v2.0.3: Enhanced documentation and user experience**

package/dist/index.js

@@ -17,152 +17,24 @@ const ConfigSchema = z.object({
     connectionTimeout: z.number().int().min(1000).max(60000).optional().default(30000),
     requestTimeout: z.number().int().min(1000).max(300000).optional().default(30000),
 });
-// Enhanced error class for better error handling with MCP compliance
-class MCPServerError extends Error {
-    code;
-    details;
-    category;
-    constructor(message, code, details, category = 'SYSTEM') {
-        super(message);
-        this.code = code;
-        this.details = details;
-        this.category = category;
-        this.name = 'MCPServerError';
-    }
-    toCallToolResult() {
-        return {
-            content: [{
-                    type: "text",
-                    text: `Error: ${this.message} (Code: ${this.code})`
-                }],
-            isError: true,
-            _meta: {
-                errorCategory: this.category,
-                errorCode: this.code,
-                timestamp: new Date().toISOString(),
-                details: this.details
-            }
-        };
-    }
-}
-// Query result cache for performance optimization
-class QueryCache {
-    cache = new Map();
-    defaultTTL = 300000; // 5 minutes
-    set(key, data, ttl = this.defaultTTL) {
-        this.cache.set(key, { data, timestamp: Date.now(), ttl });
-    }
-    get(key) {
-        const item = this.cache.get(key);
-        if (!item)
-            return null;
-        if (Date.now() - item.timestamp > item.ttl) {
-            this.cache.delete(key);
-            return null;
-        }
-        return item.data;
-    }
-    clear() {
-        this.cache.clear();
-    }
-    cleanup() {
-        const now = Date.now();
-        for (const [key, item] of this.cache.entries()) {
-            if (now - item.timestamp > item.ttl) {
-                this.cache.delete(key);
-            }
-        }
-    }
-}
-// No rate limiting - trust-based approach
-class RateLimiter {
-    constructor() {
-        // Silent - no console output for MCP protocol
-    }
-    checkLimit(clientId, operation) {
-        // Always allow - user has provided credentials and is trusted
-        return true;
-    }
-}
 class MSSQLMCPServer {
     server;
     pool = null;
     config = null;
-    queryCache = new QueryCache();
-    rateLimiter = new RateLimiter();
-    clientId = `client_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
     constructor() {
         this.server = new McpServer({
             name: "mssql-mcp-server",
-            version: "2.0.2",
-            instructions: "🚀 UNRESTRICTED SQL SERVER MCP SERVER v2.0.2 - TRUST-BASED!\n\n✨ FOR AI ASSISTANTS: COMPLETE FREEDOM!\n• All SQL operations allowed (SELECT, INSERT, UPDATE, DELETE, DROP, CREATE, etc.)\n• No rate limiting - unlimited operations\n• Auto-connects automatically with environment variables\n• Just use any tool directly (execute_query, get_schema, etc.)\n\n🔧 SETUP: Set DB_SERVER, DB_DATABASE, DB_USER, DB_PASSWORD environment variables\n\n🛡️ MINIMAL SECURITY: Only blocks server-level operations (SHUTDOWN, XP_CMDSHELL)\n⚡ FEATURES: Query caching, performance monitoring, dry-run validation",
+            version: "2.0.3",
         });
         this.setupTools();
         this.setupResources();
-        // Set up periodic cache cleanup (every 5 minutes)
-        setInterval(() => {
-            this.queryCache.cleanup();
-        }, 300000);
-    }
-    // Enhanced error handling method with MCP compliance
-    handleToolError(error, toolName) {
-        if (error instanceof MCPServerError) {
-            console.error(`MCP Error [${error.code}] in ${toolName}: ${error.message}`, error.details);
-            return error.toCallToolResult();
-        }
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error(`Tool error in ${toolName}:`, errorMessage);
-        return {
-            content: [{
-                    type: "text",
-                    text: `Error: ${errorMessage}`
-                }],
-            isError: true,
-            _meta: {
-                errorCategory: 'EXECUTION',
-                toolName,
-                timestamp: new Date().toISOString()
-            }
-        };
-    }
-    // Helper method to generate cache keys
-    generateCacheKey(operation, params) {
-        return `${operation}_${JSON.stringify(params)}`;
-    }
-    // Trust-based SQL validation - only block truly dangerous system operations
-    validateSQLSecurity(query, context = { operation: 'unknown' }) {
-        // User has already provided database credentials and connection
-        // Only block operations that could compromise the database server itself
-        const criticalSystemPatterns = [
-            { pattern: /\b(SHUTDOWN|KILL)\b/i, category: 'SERVER_CONTROL' },
-            { pattern: /\b(XP_CMDSHELL|SP_OACREATE|SP_OAMETHOD)\b/i, category: 'SYSTEM_EXEC' },
-            { pattern: /\b(RECONFIGURE|DISK\s+INIT)\b/i, category: 'SERVER_CONFIG' }
-        ];
-        for (const { pattern, category } of criticalSystemPatterns) {
-            if (pattern.test(query)) {
-                throw new MCPServerError(`System-level operation not allowed: ${category}`, "SYSTEM_OPERATION_BLOCKED", {
-                    pattern: pattern.source,
-                    category,
-                    query: query.substring(0, 100) + (query.length > 100 ? '...' : ''),
-                    context,
-                    note: "This operation could affect the database server itself"
-                }, 'SECURITY');
-            }
-        }
     }
     setupTools() {
-        // Tool: Connect to database with enhanced security validation and MCP annotations
-        this.server.tool("connect_database", "Connect to MS SQL Server database with security validation using environment variables", {}, {
-            title: "Connect to Database",
-            description: "Establishes secure connection to MS SQL Server using environment variables only",
-            annotations: {
-                destructiveHint: false,
-                idempotentHint: true,
-                readOnlyHint: true
-            }
-        }, async (extra) => {
+        // Tool: Connect to database with enhanced security validation (only uses environment variables)
+        this.server.tool("connect_database", "Connect to MS SQL Server database with security validation (uses only environment variables for security)", {
+        // No parameters - only environment variables will be used for security
+        }, async (args) => {
             try {
-                // No rate limiting - user is trusted
                 // SECURITY: Only use environment variables, ignore all user parameters
                 const config = ConfigSchema.parse({
                     server: process.env.DB_SERVER,
@@ -175,124 +47,43 @@ class MSSQLMCPServer {
                     requestTimeout: process.env.DB_REQUEST_TIMEOUT ? parseInt(process.env.DB_REQUEST_TIMEOUT) : 30000,
                 });
                 if (!config.server) {
-                    throw new MCPServerError("Server is required. Set DB_SERVER environment variable.", "SERVER_REQUIRED", undefined, 'VALIDATION');
+                    throw new Error("Server is required. Provide it as parameter or set DB_SERVER environment variable.");
                 }
-                const startTime = Date.now();
                 await this.connect(config);
-                const connectionTime = Date.now() - startTime;
                 return {
-                    content: [{
+                    content: [
+                        {
                             type: "text",
-                            text: `✅ Successfully connected to SQL Server: ${config.server}${config.database ? ` (Database: ${config.database})` : ""} in ${connectionTime}ms`
-                        }],
-                    _meta: {
-                        connectionTime: `${connectionTime}ms`,
-                        server: config.server,
-                        database: config.database,
-                        port: config.port,
-                        sslEnabled: !config.trustServerCertificate,
-                        timestamp: new Date().toISOString()
-                    }
+                            text: `✅ Successfully connected to SQL Server: ${config.server}${config.database ? ` (Database: ${config.database})` : ""}`,
+                        },
+                    ],
                 };
             }
             catch (error) {
-                return this.handleToolError(error, 'connect_database');
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                console.error("❌ Database connection failed:", errorMessage);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `❌ Failed to connect: ${errorMessage}`,
+                        },
+                    ],
+                    isError: true,
+                };
             }
         });
-        // Tool: Execute SQL query with enhanced security, caching, and MCP annotations
-        this.server.tool("execute_query", "Execute SQL queries directly - auto-connects if needed. No manual connection required when environment variables are set.", {
-            query: z.string().min(1, "Query cannot be empty").describe("SQL query to execute (parameters recommended for user input)"),
-            parameters: z.record(z.any()).optional().describe("Query parameters for security (key-value pairs)"),
-            useCache: z.boolean().optional().default(true).describe("Enable result caching for SELECT queries"),
-            dryRun: z.boolean().optional().default(false).describe("Validate query without execution"),
-        }, {
-            title: "Execute SQL Query",
-            description: "Executes SQL queries with comprehensive security validation and performance optimization",
-            annotations: {
-                destructiveHint: false,
-                idempotentHint: true,
-                readOnlyHint: true
-            }
-        }, async ({ query, parameters, useCache, dryRun }, extra) => {
+        // Tool: Execute SQL query with enhanced security
+        this.server.tool("execute_query", "Execute a SQL query against the connected database with security validation", {
+            query: z.string().min(1, "Query cannot be empty").describe("SQL query to execute"),
+            parameters: z.record(z.any()).optional().describe("Query parameters (key-value pairs) - always use parameters for user input"),
+        }, async ({ query, parameters }) => {
             try {
-                // No rate limiting - user is trusted
-                // Auto-connection logic for better AI experience
                 if (!this.pool) {
-                    console.error("Auto-connecting...");
-                    try {
-                        // Try to auto-connect using environment variables
-                        const config = ConfigSchema.parse({
-                            server: process.env.DB_SERVER,
-                            database: process.env.DB_DATABASE,
-                            user: process.env.DB_USER,
-                            password: process.env.DB_PASSWORD,
-                            port: process.env.DB_PORT ? parseInt(process.env.DB_PORT) : 1433,
-                            trustServerCertificate: process.env.DB_TRUST_SERVER_CERTIFICATE === 'true',
-                            connectionTimeout: process.env.DB_CONNECTION_TIMEOUT ? parseInt(process.env.DB_CONNECTION_TIMEOUT) : 30000,
-                            requestTimeout: process.env.DB_REQUEST_TIMEOUT ? parseInt(process.env.DB_REQUEST_TIMEOUT) : 30000,
-                        });
-                        if (!config.server) {
-                            throw new MCPServerError("❌ Auto-connection failed: DB_SERVER environment variable not set. Please set database connection environment variables or use connect_database tool first.", "AUTO_CONNECTION_FAILED", {
-                                requiredEnvVars: ['DB_SERVER', 'DB_DATABASE', 'DB_USER', 'DB_PASSWORD'],
-                                suggestion: "Use connect_database tool manually or set environment variables"
-                            }, 'CONNECTION');
-                        }
-                        await this.connect(config);
-                        console.error("Auto-connected");
-                    }
-                    catch (autoConnectError) {
-                        throw new MCPServerError("❌ No database connection available and auto-connection failed. Please use connect_database tool first or check your environment variables.", "NO_CONNECTION_AUTO_FAILED", {
-                            autoConnectError: autoConnectError instanceof Error ? autoConnectError.message : String(autoConnectError),
-                            suggestion: "1. Use connect_database tool first, OR\n2. Set environment variables: DB_SERVER, DB_DATABASE, DB_USER, DB_PASSWORD"
-                        }, 'CONNECTION');
-                    }
-                }
-                // Enhanced security validation with context
-                this.validateSQLSecurity(query, { operation: 'execute_query', userProvided: true });
-                // Check cache for SELECT queries
-                const queryType = query.trim().toUpperCase().split(/\s+/)[0];
-                const isSelectQuery = queryType === 'SELECT';
-                let cacheKey = null;
-                if (isSelectQuery && useCache && !dryRun) {
-                    cacheKey = this.generateCacheKey('execute_query', { query, parameters });
-                    const cachedResult = this.queryCache.get(cacheKey);
-                    if (cachedResult) {
-                        return {
-                            content: [{
-                                    type: "text",
-                                    text: JSON.stringify({
-                                        ...cachedResult,
-                                        fromCache: true,
-                                        executionTime: "0ms (cached)",
-                                        cacheHit: true
-                                    }, null, 2)
-                                }],
-                            _meta: {
-                                cached: true,
-                                cacheKey,
-                                timestamp: new Date().toISOString()
-                            }
-                        };
-                    }
-                }
-                // Dry run validation
-                if (dryRun) {
-                    return {
-                        content: [{
-                                type: "text",
-                                text: `✅ Query validation passed:\n• Query type: ${queryType}\n• Parameters: ${parameters ? Object.keys(parameters).length : 0}\n• Estimated complexity: ${query.length > 200 ? 'High' : 'Low'}\n• Security: ✓ Passed\n• Ready for execution`
-                            }],
-                        _meta: {
-                            dryRun: true,
-                            queryType,
-                            parameterCount: parameters ? Object.keys(parameters).length : 0,
-                            validationPassed: true,
-                            timestamp: new Date().toISOString()
-                        }
-                    };
+                    throw new Error("No database connection. Please connect first using connect_database tool.");
                 }
                 const request = this.pool.request();
-                // Add parameters with type safety
+                // Add parameters if provided (recommended for security)
                 if (parameters) {
                     for (const [key, value] of Object.entries(parameters)) {
                         request.input(key, value);
@@ -301,190 +92,131 @@ class MSSQLMCPServer {
                 const startTime = Date.now();
                 const result = await request.query(query);
                 const executionTime = Date.now() - startTime;
-                const response = {
-                    recordset: result.recordset,
-                    rowsAffected: result.rowsAffected,
-                    output: result.output,
-                    executionTime: `${executionTime}ms`,
-                    parametersUsed: parameters ? Object.keys(parameters).length : 0,
-                    fromCache: false,
-                    queryType,
-                    rowCount: result.recordset.length
-                };
-                // Cache SELECT query results
-                if (isSelectQuery && useCache && cacheKey) {
-                    this.queryCache.set(cacheKey, response);
-                }
                 return {
-                    content: [{
+                    content: [
+                        {
                             type: "text",
-                            text: JSON.stringify(response, null, 2)
-                        }],
-                    _meta: {
-                        executionTime: `${executionTime}ms`,
-                        queryType,
-                        rowCount: result.recordset.length,
-                        parametersUsed: parameters ? Object.keys(parameters).length : 0,
-                        cached: false,
-                        timestamp: new Date().toISOString()
-                    }
+                            text: JSON.stringify({
+                                recordset: result.recordset,
+                                rowsAffected: result.rowsAffected,
+                                output: result.output,
+                                executionTime: `${executionTime}ms`,
+                                parametersUsed: parameters ? Object.keys(parameters).length : 0,
+                            }, null, 2),
+                        },
+                    ],
                 };
             }
             catch (error) {
-                return this.handleToolError(error, 'execute_query');
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                console.error("❌ Query execution failed:", errorMessage);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `❌ Query execution failed: ${errorMessage}`,
+                        },
+                    ],
+                    isError: true,
+                };
             }
         });
-        // Tool: Get database schema with enhanced filtering and MCP annotations
-        this.server.tool("get_schema", "Explore database schema - auto-connects if needed. No manual connection required when environment variables are set.", {
-            objectType: z.enum(["tables", "views", "procedures", "functions", "all"]).optional().default("tables").describe("Type of objects to list"),
-            schemaName: z.string().optional().describe("Filter by specific schema name"),
-            includeMetadata: z.boolean().optional().default(true).describe("Include detailed metadata"),
-        }, {
-            title: "Get Database Schema",
-            description: "Retrieves comprehensive database schema information with filtering options",
-            annotations: {
-                destructiveHint: false,
-                idempotentHint: true,
-                readOnlyHint: true
-            }
-        }, async ({ objectType, schemaName, includeMetadata }, extra) => {
+        // Tool: Get database schema
+        this.server.tool("get_schema", "Get database schema information (tables, columns, etc.)", {
+            objectType: z.enum(["tables", "views", "procedures", "functions", "all"]).optional().default("tables"),
+            schemaName: z.string().optional().describe("Specific schema name to filter"),
+        }, async ({ objectType, schemaName }) => {
             try {
-                // Auto-connection logic for seamless AI experience
                 if (!this.pool) {
-                    try {
-                        const config = ConfigSchema.parse({
-                            server: process.env.DB_SERVER,
-                            database: process.env.DB_DATABASE,
-                            user: process.env.DB_USER,
-                            password: process.env.DB_PASSWORD,
-                            port: process.env.DB_PORT ? parseInt(process.env.DB_PORT) : 1433,
-                            trustServerCertificate: process.env.DB_TRUST_SERVER_CERTIFICATE === 'true',
-                            connectionTimeout: process.env.DB_CONNECTION_TIMEOUT ? parseInt(process.env.DB_CONNECTION_TIMEOUT) : 30000,
-                            requestTimeout: process.env.DB_REQUEST_TIMEOUT ? parseInt(process.env.DB_REQUEST_TIMEOUT) : 30000,
-                        });
-                        if (config.server) {
-                            await this.connect(config);
-                        }
-                        else {
-                            throw new MCPServerError("Database connection required. Set environment variables or use connect_database tool.", "NO_CONNECTION", { requiredEnvVars: ['DB_SERVER', 'DB_DATABASE', 'DB_USER', 'DB_PASSWORD'] }, 'CONNECTION');
-                        }
-                    }
-                    catch (error) {
-                        throw new MCPServerError("Database connection required. Use connect_database tool or set environment variables.", "NO_CONNECTION_AUTO_FAILED", undefined, 'CONNECTION');
-                    }
+                    throw new Error("No database connection. Please connect first.");
                 }
                 let query = "";
-                const startTime = Date.now();
                 if (objectType === "tables" || objectType === "all") {
-                    query += includeMetadata ? `
-              SELECT
-                TABLE_SCHEMA,
-                TABLE_NAME,
-                TABLE_TYPE,
-                'table' as OBJECT_TYPE,
-                (SELECT COUNT(*) FROM INFORMATION_SCHEMA.COLUMNS c
-                 WHERE c.TABLE_NAME = t.TABLE_NAME AND c.TABLE_SCHEMA = t.TABLE_SCHEMA) as COLUMN_COUNT
-              FROM INFORMATION_SCHEMA.TABLES t
-              ${schemaName ? `WHERE TABLE_SCHEMA = @schemaName` : ""}
-            ` : `
-              SELECT
+                    query += `
+              SELECT 
                 TABLE_SCHEMA,
                 TABLE_NAME,
                 TABLE_TYPE,
                 'table' as OBJECT_TYPE
               FROM INFORMATION_SCHEMA.TABLES
-              ${schemaName ? `WHERE TABLE_SCHEMA = @schemaName` : ""}
+              ${schemaName ? `WHERE TABLE_SCHEMA = '${schemaName}'` : ""}
             `;
                 }
                 if (objectType === "views" || objectType === "all") {
                     if (query)
                         query += " UNION ALL ";
                     query += `
-              SELECT
+              SELECT 
                 TABLE_SCHEMA,
                 TABLE_NAME,
                 'VIEW' as TABLE_TYPE,
                 'view' as OBJECT_TYPE
-                ${includeMetadata ? ", (SELECT COUNT(*) FROM INFORMATION_SCHEMA.VIEW_COLUMNS v WHERE v.TABLE_NAME = TABLE_NAME AND v.TABLE_SCHEMA = TABLE_SCHEMA) as COLUMN_COUNT" : ""}
               FROM INFORMATION_SCHEMA.VIEWS
-              ${schemaName ? `WHERE TABLE_SCHEMA = @schemaName` : ""}
+              ${schemaName ? `WHERE TABLE_SCHEMA = '${schemaName}'` : ""}
             `;
                 }
                 if (objectType === "procedures" || objectType === "all") {
                     if (query)
                         query += " UNION ALL ";
                     query += `
-              SELECT
+              SELECT 
                 ROUTINE_SCHEMA as TABLE_SCHEMA,
                 ROUTINE_NAME as TABLE_NAME,
                 'PROCEDURE' as TABLE_TYPE,
                 'procedure' as OBJECT_TYPE
-                ${includeMetadata ? ", (SELECT COUNT(*) FROM INFORMATION_SCHEMA.PARAMETERS p WHERE p.SPECIFIC_NAME = ROUTINE_NAME AND p.SPECIFIC_SCHEMA = ROUTINE_SCHEMA) as PARAMETER_COUNT" : ""}
               FROM INFORMATION_SCHEMA.ROUTINES
               WHERE ROUTINE_TYPE = 'PROCEDURE'
-              ${schemaName ? `AND ROUTINE_SCHEMA = @schemaName` : ""}
+              ${schemaName ? `AND ROUTINE_SCHEMA = '${schemaName}'` : ""}
             `;
                 }
                 if (objectType === "functions" || objectType === "all") {
                     if (query)
                         query += " UNION ALL ";
                     query += `
-              SELECT
+              SELECT 
                 ROUTINE_SCHEMA as TABLE_SCHEMA,
                 ROUTINE_NAME as TABLE_NAME,
                 'FUNCTION' as TABLE_TYPE,
                 'function' as OBJECT_TYPE
-                ${includeMetadata ? ", (SELECT COUNT(*) FROM INFORMATION_SCHEMA.PARAMETERS p WHERE p.SPECIFIC_NAME = ROUTINE_NAME AND p.SPECIFIC_SCHEMA = ROUTINE_SCHEMA) as PARAMETER_COUNT" : ""}
               FROM INFORMATION_SCHEMA.ROUTINES
               WHERE ROUTINE_TYPE = 'FUNCTION'
-              ${schemaName ? `AND ROUTINE_SCHEMA = @schemaName` : ""}
+              ${schemaName ? `AND ROUTINE_SCHEMA = '${schemaName}'` : ""}
             `;
                 }
                 query += " ORDER BY TABLE_SCHEMA, TABLE_NAME";
-                const request = this.pool.request();
-                if (schemaName) {
-                    request.input('schemaName', schemaName);
-                }
-                const result = await request.query(query);
-                const executionTime = Date.now() - startTime;
+                const result = await this.pool.request().query(query);
                 return {
-                    content: [{
+                    content: [
+                        {
                             type: "text",
-                            text: JSON.stringify({
-                                objects: result.recordset,
-                                metadata: {
-                                    objectType,
-                                    schemaName: schemaName || 'all',
-                                    count: result.recordset.length,
-                                    executionTime: `${executionTime}ms`,
-                                    includeMetadata
-                                }
-                            }, null, 2)
-                        }],
-                    _meta: {
-                        objectType,
-                        count: result.recordset.length,
-                        executionTime: `${executionTime}ms`,
-                        schemaFiltered: !!schemaName,
-                        timestamp: new Date().toISOString()
-                    }
+                            text: JSON.stringify(result.recordset, null, 2),
+                        },
+                    ],
                 };
             }
             catch (error) {
-                return this.handleToolError(error, 'get_schema');
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Schema query failed: ${error instanceof Error ? error.message : String(error)}`,
+                        },
+                    ],
+                    isError: true,
+                };
             }
         });
         // Tool: Get table structure
-        this.server.tool("describe_table", "Get table structure - auto-connects if needed. No manual connection required when environment variables are set.", {
+        this.server.tool("describe_table", "Get detailed structure of a specific table", {
             tableName: z.string().describe("Name of the table"),
             schemaName: z.string().optional().default("dbo").describe("Schema name"),
         }, async ({ tableName, schemaName }) => {
             try {
                 if (!this.pool) {
-                    throw new MCPServerError("No database connection. Please connect first.", "NO_CONNECTION");
+                    throw new Error("No database connection. Please connect first.");
                 }
                 const query = `
-            SELECT
+            SELECT 
               COLUMN_NAME,
               DATA_TYPE,
               CHARACTER_MAXIMUM_LENGTH,
@@ -494,7 +226,7 @@ class MSSQLMCPServer {
               COLUMN_DEFAULT,
               ORDINAL_POSITION
             FROM INFORMATION_SCHEMA.COLUMNS
-            WHERE TABLE_NAME = @tableName
+            WHERE TABLE_NAME = @tableName 
             AND TABLE_SCHEMA = @schemaName
             ORDER BY ORDINAL_POSITION
           `;
@@ -512,7 +244,15 @@ class MSSQLMCPServer {
                 };
             }
             catch (error) {
-                return this.handleToolError(error);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Table description failed: ${error instanceof Error ? error.message : String(error)}`,
+                        },
+                    ],
+                    isError: true,
+                };
             }
         });
         // Tool: Get enhanced connection status
@@ -526,12 +266,6 @@ class MSSQLMCPServer {
                 connectionTime: isConnected ? new Date().toISOString() : null,
                 securityFeatures: {
                     sqlInjectionProtection: "Enabled",
-                    rateLimiting: "Enabled",
-                    caching: "Enabled"
-                },
-                cacheStats: {
-                    cacheSize: this.queryCache['cache'].size,
-                    clientInfo: this.clientId
                 },
                 poolInfo: this.pool ? {
                     size: this.pool.size,
@@ -556,19 +290,26 @@ class MSSQLMCPServer {
                     await this.pool.close();
                     this.pool = null;
                     this.config = null;
-                    this.queryCache.clear(); // Clear cache on disconnect
                 }
                 return {
                     content: [
                         {
                             type: "text",
-                            text: "Successfully disconnected from database and cleared cache",
+                            text: "Successfully disconnected from database",
                         },
                     ],
                 };
             }
             catch (error) {
-                return this.handleToolError(error);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Disconnect failed: ${error instanceof Error ? error.message : String(error)}`,
+                        },
+                    ],
+                    isError: true,
+                };
             }
         });
         // Tool: Get table data with enhanced security and validation
@@ -583,15 +324,15 @@ class MSSQLMCPServer {
         }, async ({ tableName, schemaName, limit, offset, whereClause, orderBy, parameters }) => {
             try {
                 if (!this.pool) {
-                    throw new MCPServerError("No database connection. Please connect first.", "NO_CONNECTION");
+                    throw new Error("No database connection. Please connect first.");
                 }
                 // Security: Validate table and schema names to prevent SQL injection
                 const tableNamePattern = /^[a-zA-Z0-9_]+$/;
                 if (!tableNamePattern.test(tableName)) {
-                    throw new MCPServerError("Invalid table name. Only letters, numbers, and underscores are allowed.", "INVALID_TABLE_NAME");
+                    throw new Error("Invalid table name. Only letters, numbers, and underscores are allowed.");
                 }
                 if (!tableNamePattern.test(schemaName)) {
-                    throw new MCPServerError("Invalid schema name. Only letters, numbers, and underscores are allowed.", "INVALID_SCHEMA_NAME");
+                    throw new Error("Invalid schema name. Only letters, numbers, and underscores are allowed.");
                 }
                 // Build query using parameterized approach
                 let query = `SELECT * FROM [${schemaName}].[${tableName}]`;
@@ -607,9 +348,10 @@ class MSSQLMCPServer {
                 }
                 if (orderBy) {
                     // Validate ORDER BY clause for basic security
+                    // Allow dotted identifiers, bracketed identifiers, commas, spaces and optional ASC/DESC per column
                     const orderByPattern = /^([\[\]a-zA-Z0-9_.]+(\s+(ASC|DESC))?)(\s*,\s*[\[\]a-zA-Z0-9_.]+(\s+(ASC|DESC))?)*$/i;
                     if (!orderByPattern.test(orderBy)) {
-                        throw new MCPServerError("Invalid ORDER BY clause. Only column names, commas, spaces, ASC, and DESC are allowed.", "INVALID_ORDER_BY");
+                        throw new Error("Invalid ORDER BY clause. Only column names, commas, spaces, ASC, and DESC are allowed.");
                     }
                     query += ` ORDER BY ${orderBy}`;
                 }
@@ -642,7 +384,17 @@ class MSSQLMCPServer {
                 };
             }
             catch (error) {
-                return this.handleToolError(error);
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                console.error("❌ Get table data failed:", errorMessage);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `❌ Get table data failed: ${errorMessage}`,
+                        },
+                    ],
+                    isError: true,
+                };
             }
         });
         // Tool: Execute stored procedure
@@ -653,7 +405,7 @@ class MSSQLMCPServer {
         }, async ({ procedureName, schemaName, parameters }) => {
             try {
                 if (!this.pool) {
-                    throw new MCPServerError("No database connection. Please connect first.", "NO_CONNECTION");
+                    throw new Error("No database connection. Please connect first.");
                 }
                 const request = this.pool.request();
                 // Add parameters if provided
@@ -678,17 +430,25 @@ class MSSQLMCPServer {
                 };
             }
             catch (error) {
-                return this.handleToolError(error);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Procedure execution failed: ${error instanceof Error ? error.message : String(error)}`,
+                        },
+                    ],
+                    isError: true,
+                };
             }
         });
         // Tool: Get database list
         this.server.tool("list_databases", "List all databases on the connected SQL Server instance", {}, async () => {
             try {
                 if (!this.pool) {
-                    throw new MCPServerError("No database connection. Please connect first.", "NO_CONNECTION");
+                    throw new Error("No database connection. Please connect first.");
                 }
                 const query = `
-            SELECT
+            SELECT 
               name,
               database_id,
               create_date,
@@ -713,30 +473,16 @@ class MSSQLMCPServer {
                 };
             }
             catch (error) {
-                return this.handleToolError(error);
-            }
-        });
-        // Tool: Clear query cache
-        this.server.tool("clear_cache", "Clear the query result cache", {}, async () => {
-            try {
-                const cacheSize = this.queryCache['cache'].size;
-                this.queryCache.clear();
                 return {
                     content: [
                         {
                             type: "text",
-                            text: JSON.stringify({
-                                message: "Query cache cleared successfully",
-                                clearedEntries: cacheSize,
-                                timestamp: new Date().toISOString()
-                            }, null, 2),
+                            text: `List databases failed: ${error instanceof Error ? error.message : String(error)}`,
                         },
                     ],
+                    isError: true,
                 };
             }
-            catch (error) {
-                return this.handleToolError(error);
-            }
         });
     }
     setupResources() {
@@ -749,14 +495,6 @@ class MSSQLMCPServer {
                     database: this.config.database,
                     port: this.config.port,
                 } : null,
-                cacheStats: {
-                    cacheSize: this.queryCache['cache'].size,
-                    lastCleanup: new Date().toISOString()
-                },
-                clientInfo: {
-                    clientId: this.clientId,
-                    rateLimitsEnabled: true
-                }
             };
             return {
                 contents: [
@@ -768,22 +506,6 @@ class MSSQLMCPServer {
                 ],
             };
         });
-        // Dynamic resource for query results cache status
-        this.server.resource("cache-status", "mssql://cache/status", async () => {
-            const status = {
-                cacheSize: this.queryCache['cache'].size,
-                rateLimiting: "DISABLED - Trust-based approach",
-                clientId: this.clientId,
-                timestamp: new Date().toISOString()
-            };
-            return {
-                contents: [{
-                        uri: "mssql://cache/status",
-                        text: JSON.stringify(status, null, 2),
-                        mimeType: "application/json"
-                    }]
-            };
-        });
     }
     async connect(config) {
         try {
@@ -871,7 +593,7 @@ class MSSQLMCPServer {
             console.error('Unhandled Rejection:', reason);
             shutdown('unhandledRejection');
         });
-        console.error("MSSQL MCP Server v2.0.2 starting...");
+        console.error("MSSQL MCP Server v2.0.3 starting...");
         await this.server.connect(transport);
         console.error("Server ready");
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mssql-mcp",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "description": "MCP Server for MS SQL Server integration with Claude Desktop, Cursor, Windsurf and VS Code",
   "main": "dist/index.js",
   "type": "module",
@@ -45,7 +45,7 @@
   "author": "BYMCS <hello@bymcs.com>",
   "license": "MIT",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.20.2",
+    "@modelcontextprotocol/sdk": "^1.17.1",
     "dotenv": "^16.3.1",
     "mssql": "^11.0.1",
     "zod": "^3.22.4"