@bytebase/dbhub 0.24.0 → 1.1.0

package/dist/index.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import {
   BUILTIN_TOOL_EXECUTE_SQL,
+  BUILTIN_TOOL_EXPLAIN_SQL,
+  BUILTIN_TOOL_HEALTH_CHECK,
   BUILTIN_TOOL_SEARCH_OBJECTS,
   ConnectorManager,
   classifyConnectionError,
@@ -15,11 +17,14 @@ import {
   resolveSourceConfigs,
   resolveTomlConfigPath,
   resolveTransport
-} from "./chunk-MQR6VX5F.js";
+} from "./chunk-GSSLHJB6.js";
 import {
   allowedKeywords,
-  isReadOnlySQL
-} from "./chunk-JO7YQPBQ.js";
+  getFirstKeyword,
+  hasEscapeHatchFunction,
+  isReadOnlySQL,
+  sqlServerDynamicSqlPattern
+} from "./chunk-EPOKWSFC.js";
 import {
   loadConnectors
 } from "./chunk-WVVMH6FJ.js";
@@ -31,13 +36,14 @@ import {
   getDatabaseTypeFromDSN,
   getDefaultPortForType,
   parseConnectionInfoFromDSN,
-  splitSQLStatements
+  splitSQLStatements,
+  stripCommentsAndStrings
 } from "./chunk-JEZZN2YZ.js";
 
 // src/server.ts
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { McpServer, createMcpHandler } from "@modelcontextprotocol/server";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import { toNodeHandler } from "@modelcontextprotocol/node";
 import express from "express";
 import http from "http";
 import path from "path";
@@ -98,6 +104,53 @@ function createToolSuccessResponse(data, meta = {}) {
   };
 }
 
+// src/utils/sql-access-policy.ts
+var CLASS_SEVERITY = {
+  read: 0,
+  dml: 1,
+  ddl: 2,
+  admin: 3,
+  unknown: 4
+};
+var ddlPattern = /\b(?:create|alter|drop|truncate|rename)\b/i;
+var dmlPattern = /\b(?:insert|update|delete|merge|replace\s+(?:(?:low_priority|delayed)\s+)?into)\b/i;
+var grantRevokePattern = /\b(?:grant|revoke)\b/i;
+function isAdminStatement(stripped, connectorType) {
+  if (grantRevokePattern.test(stripped)) return true;
+  if (hasEscapeHatchFunction(stripped, connectorType)) return true;
+  return connectorType === "sqlserver" && sqlServerDynamicSqlPattern.test(stripped);
+}
+function policyFromReadonly(readonly) {
+  const write = readonly === true ? "deny" : "allow";
+  return { read: "allow", dml: write, ddl: write, admin: write, unknown: write };
+}
+function isReadOnlyPolicy(policy) {
+  return policy.dml === "deny" && policy.ddl === "deny" && policy.admin === "deny" && policy.unknown === "deny";
+}
+function classifyStatement(sql, connectorType) {
+  if (isReadOnlySQL(sql, connectorType)) {
+    return "read";
+  }
+  const stripped = stripCommentsAndStrings(sql, connectorType);
+  if (isAdminStatement(stripped, connectorType)) return "admin";
+  if (ddlPattern.test(stripped)) return "ddl";
+  if (dmlPattern.test(stripped)) return "dml";
+  return "unknown";
+}
+function classifySQL(sql, connectorType) {
+  let strictest = "read";
+  for (const statement of splitSQLStatements(sql, connectorType)) {
+    const cls = classifyStatement(statement, connectorType);
+    if (CLASS_SEVERITY[cls] > CLASS_SEVERITY[strictest]) {
+      strictest = cls;
+    }
+  }
+  return strictest;
+}
+function sqlVerdict(policy, sql, connectorType) {
+  return policy[classifySQL(sql, connectorType)];
+}
+
 // src/requests/store.ts
 var RequestStore = class {
   constructor() {
@@ -149,18 +202,30 @@ var RequestStore = class {
 var requestStore = new RequestStore();
 
 // src/utils/client-identifier.ts
-function getClientIdentifier(extra) {
-  const userAgent = extra?.requestInfo?.headers?.["user-agent"];
+function getClientIdentifier(ctx) {
+  const userAgent = ctx?.http?.req?.headers.get("user-agent");
   if (userAgent) {
     return userAgent;
   }
   return "stdio";
 }
 
+// src/utils/normalize-id.ts
+function normalizeSourceId(id) {
+  return id.replace(/[^a-zA-Z0-9]/g, "_");
+}
+
 // src/utils/tool-handler-helpers.ts
 function getEffectiveSourceId(sourceId) {
   return sourceId || "default";
 }
+function resolveTrackedToolName(sourceId, baseName) {
+  const isSingleSource = ConnectorManager.getAvailableSourceIds().length === 1;
+  if (isSingleSource) {
+    return baseName;
+  }
+  return `${baseName}_${normalizeSourceId(getEffectiveSourceId(sourceId))}`;
+}
 function createReadonlyViolationMessage(toolName, sourceId, connectorType) {
   return `Tool '${toolName}' cannot execute in readonly mode for source '${sourceId}'. Only read-only SQL operations are allowed: ${allowedKeywords[connectorType]?.join(", ") || "none"}`;
 }
@@ -196,10 +261,7 @@ function tryClassifyConnectionError(error, rawSourceId, displaySourceId) {
 var executeSqlSchema = {
   sql: z.string().describe("SQL to execute (multiple statements separated by ;)")
 };
-function areAllStatementsReadOnly(sql, connectorType) {
-  const statements = splitSQLStatements(sql, connectorType);
-  return statements.every((statement) => isReadOnlySQL(statement, connectorType));
-}
+var executeSqlInputSchema = z.object(executeSqlSchema);
 function createExecuteSqlToolHandler(sourceId) {
   return async (args, extra) => {
     const { sql } = args;
@@ -214,14 +276,14 @@ function createExecuteSqlToolHandler(sourceId) {
       const actualSourceId = connector.getId();
       const registry = getToolRegistry();
       const toolConfig = registry.getBuiltinToolConfig(BUILTIN_TOOL_EXECUTE_SQL, actualSourceId);
-      const isReadonly = toolConfig?.readonly === true;
-      if (isReadonly && !areAllStatementsReadOnly(sql, connector.id)) {
+      const policy = policyFromReadonly(toolConfig?.readonly);
+      if (sqlVerdict(policy, sql, connector.id) === "deny") {
         errorMessage = `Read-only mode is enabled. Only the following SQL operations are allowed: ${allowedKeywords[connector.id]?.join(", ") || "none"}`;
         success = false;
         return createToolErrorResponse(errorMessage, "READONLY_VIOLATION");
       }
       const executeOptions = {
-        readonly: toolConfig?.readonly,
+        readonly: isReadOnlyPolicy(policy),
         maxRows: toolConfig?.max_rows
       };
       result = await connector.executeSQL(sql, executeOptions);
@@ -264,6 +326,7 @@ var searchDatabaseObjectsSchema = {
   detail_level: z2.enum(["names", "summary", "full"]).default("names").describe("Detail: names (minimal), summary (metadata), full (all)"),
   limit: z2.number().int().positive().max(1e3).default(100).describe("Max results")
 };
+var searchDatabaseObjectsInputSchema = z2.object(searchDatabaseObjectsSchema);
 function likePatternToRegex(pattern) {
   const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/%/g, ".*").replace(/_/g, ".");
   return new RegExp(`^${escaped}$`, "i");
@@ -738,15 +801,151 @@ function createSearchDatabaseObjectsToolHandler(sourceId) {
   };
 }
 
-// src/utils/tool-metadata.ts
+// src/tools/explain-sql.ts
 import { z as z3 } from "zod";
+var explainSqlSchema = {
+  sql: z3.string().describe("Single SQL statement to explain (no trailing semicolon-separated statements)")
+};
+var explainSqlInputSchema = z3.object(explainSqlSchema);
+function buildExplainStatement(connectorType, sql) {
+  if (connectorType === "sqlite") {
+    return `EXPLAIN QUERY PLAN ${sql}`;
+  }
+  return `EXPLAIN ${sql}`;
+}
+function validateExplainInput(sql, connectorType) {
+  const statements = splitSQLStatements(sql, connectorType);
+  if (statements.length !== 1) {
+    return "explain_sql only supports a single SQL statement";
+  }
+  const firstWord = getFirstKeyword(statements[0], connectorType);
+  if (firstWord === "explain") {
+    return "explain_sql input must not itself start with EXPLAIN";
+  }
+  if (firstWord === "analyze") {
+    return "explain_sql does not support ANALYZE (it must never execute the statement)";
+  }
+  const cleaned = stripCommentsAndStrings(statements[0], connectorType).trim();
+  const leadingOptions = cleaned.match(/^\(([\s\S]*?)\)/)?.[1];
+  if (leadingOptions && /\banalyze\b/i.test(leadingOptions)) {
+    return "explain_sql does not support ANALYZE (it must never execute the statement)";
+  }
+  return null;
+}
+function createExplainSqlToolHandler(sourceId) {
+  return async (args, extra) => {
+    const { sql } = args;
+    const startTime = Date.now();
+    const effectiveSourceId = getEffectiveSourceId(sourceId);
+    let success = true;
+    let errorMessage;
+    let result;
+    try {
+      await ConnectorManager.ensureConnected(sourceId);
+      const connector = ConnectorManager.getCurrentConnector(sourceId);
+      const validationError = validateExplainInput(sql, connector.id);
+      if (validationError) {
+        success = false;
+        errorMessage = validationError;
+        return createToolErrorResponse(errorMessage, "INVALID_INPUT");
+      }
+      const explainStatement = buildExplainStatement(connector.id, sql);
+      result = await connector.executeSQL(explainStatement, { readonly: true });
+      const responseData = {
+        rows: result.rows,
+        count: result.rowCount,
+        source_id: effectiveSourceId,
+        ...result.messages && result.messages.length > 0 ? { messages: result.messages } : {}
+      };
+      return createToolSuccessResponse(responseData);
+    } catch (error) {
+      success = false;
+      errorMessage = error.message;
+      const classified = tryClassifyConnectionError(error, sourceId, effectiveSourceId);
+      if (classified) return classified;
+      return createToolErrorResponse(errorMessage, "EXECUTION_ERROR");
+    } finally {
+      trackToolRequest(
+        {
+          sourceId: effectiveSourceId,
+          toolName: resolveTrackedToolName(sourceId, "explain_sql"),
+          sql
+        },
+        startTime,
+        extra,
+        success,
+        errorMessage
+      );
+    }
+  };
+}
 
-// src/utils/normalize-id.ts
-function normalizeSourceId(id) {
-  return id.replace(/[^a-zA-Z0-9]/g, "_");
+// src/tools/health-check.ts
+import { z as z4 } from "zod";
+var healthCheckSchema = {};
+var healthCheckInputSchema = z4.object(healthCheckSchema);
+function createHealthCheckToolHandler(sourceId) {
+  return async (_args, extra) => {
+    const startTime = Date.now();
+    const effectiveSourceId = getEffectiveSourceId(sourceId);
+    let success = true;
+    let errorMessage;
+    try {
+      await ConnectorManager.ensureConnected(sourceId);
+      const connector = ConnectorManager.getCurrentConnector(sourceId);
+      if (!connector.getHealthCheck) {
+        success = false;
+        errorMessage = `health_check is not supported for '${connector.id}' sources yet`;
+        return createToolErrorResponse(errorMessage, "UNSUPPORTED");
+      }
+      const health = await connector.getHealthCheck();
+      return createToolSuccessResponse({
+        source_id: effectiveSourceId,
+        ...health.connections ? {
+          connections: {
+            total: health.connections.total,
+            active: health.connections.active,
+            idle: health.connections.idle,
+            idle_in_transaction: health.connections.idleInTransaction,
+            ...health.connections.idleInTransactionAborted !== void 0 ? { idle_in_transaction_aborted: health.connections.idleInTransactionAborted } : {},
+            max_connections: health.connections.maxConnections,
+            longest_idle_in_transaction_seconds: health.connections.longestIdleInTransactionSeconds,
+            longest_active_query_seconds: health.connections.longestActiveQuerySeconds
+          }
+        } : {},
+        ...health.bufferCache ? {
+          buffer_cache: {
+            hit_ratio_pct: health.bufferCache.hitRatioPct,
+            blocks_hit: health.bufferCache.blocksHit,
+            blocks_read: health.bufferCache.blocksRead
+          }
+        } : {},
+        ...health.notes && health.notes.length > 0 ? { notes: health.notes } : {}
+      });
+    } catch (error) {
+      success = false;
+      errorMessage = error.message;
+      const classified = tryClassifyConnectionError(error, sourceId, effectiveSourceId);
+      if (classified) return classified;
+      return createToolErrorResponse(errorMessage, "EXECUTION_ERROR");
+    } finally {
+      trackToolRequest(
+        {
+          sourceId: effectiveSourceId,
+          toolName: effectiveSourceId === "default" ? "health_check" : `health_check_${effectiveSourceId}`,
+          sql: ""
+        },
+        startTime,
+        extra,
+        success,
+        errorMessage
+      );
+    }
+  };
 }
 
 // src/utils/tool-metadata.ts
+import { z as z5 } from "zod";
 function buildSourceDescriptionPrefix(description) {
   const trimmed = description?.trim() ?? "";
   if (!trimmed) return "";
@@ -756,17 +955,17 @@ function zodToParameters(schema) {
   const parameters = [];
   for (const [key, zodType] of Object.entries(schema)) {
     const description = zodType.description || "";
-    const required = !(zodType instanceof z3.ZodOptional);
+    const required = !(zodType instanceof z5.ZodOptional);
     let type = "string";
-    if (zodType instanceof z3.ZodString) {
+    if (zodType instanceof z5.ZodString) {
       type = "string";
-    } else if (zodType instanceof z3.ZodNumber) {
+    } else if (zodType instanceof z5.ZodNumber) {
       type = "number";
-    } else if (zodType instanceof z3.ZodBoolean) {
+    } else if (zodType instanceof z5.ZodBoolean) {
       type = "boolean";
-    } else if (zodType instanceof z3.ZodArray) {
+    } else if (zodType instanceof z5.ZodArray) {
       type = "array";
-    } else if (zodType instanceof z3.ZodObject) {
+    } else if (zodType instanceof z5.ZodObject) {
       type = "object";
     }
     parameters.push({
@@ -778,24 +977,32 @@ function zodToParameters(schema) {
   }
   return parameters;
 }
-function getExecuteSqlMetadata(sourceId) {
+function resolveBuiltinToolNaming(sourceId, baseName, titleLabel) {
   const sourceIds = ConnectorManager.getAvailableSourceIds();
   const sourceConfig = ConnectorManager.getSourceConfig(sourceId);
   const dbType = sourceConfig.type;
   const isSingleSource = sourceIds.length === 1;
+  const name = isSingleSource ? baseName : `${baseName}_${normalizeSourceId(sourceId)}`;
+  const title = isSingleSource ? `${titleLabel} (${dbType})` : `${titleLabel} on ${sourceId} (${dbType})`;
+  const userDescPrefix = buildSourceDescriptionPrefix(sourceConfig.description);
+  return { dbType, isSingleSource, name, title, userDescPrefix };
+}
+function getExecuteSqlMetadata(sourceId) {
+  const { dbType, isSingleSource, name, title, userDescPrefix } = resolveBuiltinToolNaming(
+    sourceId,
+    "execute_sql",
+    "Execute SQL"
+  );
   const registry = getToolRegistry();
   const toolConfig = registry.getBuiltinToolConfig(BUILTIN_TOOL_EXECUTE_SQL, sourceId);
   const executeOptions = {
     readonly: toolConfig?.readonly,
     maxRows: toolConfig?.max_rows
   };
-  const toolName = isSingleSource ? "execute_sql" : `execute_sql_${normalizeSourceId(sourceId)}`;
-  const title = isSingleSource ? `Execute SQL (${dbType})` : `Execute SQL on ${sourceId} (${dbType})`;
-  const userDescPrefix = buildSourceDescriptionPrefix(sourceConfig.description);
   const readonlyNote = executeOptions.readonly ? " [READ-ONLY MODE]" : "";
   const maxRowsNote = executeOptions.maxRows ? ` (limited to ${executeOptions.maxRows} rows)` : "";
   const description = isSingleSource ? `${userDescPrefix}Execute SQL queries on the ${dbType} database${readonlyNote}${maxRowsNote}` : `${userDescPrefix}Execute SQL queries on the '${sourceId}' ${dbType} database${readonlyNote}${maxRowsNote}`;
-  const isReadonly = executeOptions.readonly === true;
+  const isReadonly = isReadOnlyPolicy(policyFromReadonly(executeOptions.readonly));
   const annotations = {
     title,
     readOnlyHint: isReadonly,
@@ -808,25 +1015,62 @@ function getExecuteSqlMetadata(sourceId) {
     openWorldHint: false
   };
   return {
-    name: toolName,
+    name,
     description,
     schema: executeSqlSchema,
     annotations
   };
 }
 function getSearchObjectsMetadata(sourceId) {
-  const sourceIds = ConnectorManager.getAvailableSourceIds();
-  const sourceConfig = ConnectorManager.getSourceConfig(sourceId);
-  const dbType = sourceConfig.type;
-  const isSingleSource = sourceIds.length === 1;
-  const toolName = isSingleSource ? "search_objects" : `search_objects_${normalizeSourceId(sourceId)}`;
-  const title = isSingleSource ? `Search Database Objects (${dbType})` : `Search Database Objects on ${sourceId} (${dbType})`;
-  const userDescPrefix = buildSourceDescriptionPrefix(sourceConfig.description);
+  const { dbType, isSingleSource, name, title, userDescPrefix } = resolveBuiltinToolNaming(
+    sourceId,
+    "search_objects",
+    "Search Database Objects"
+  );
   const description = isSingleSource ? `${userDescPrefix}Search and list database objects on the ${dbType} database` : `${userDescPrefix}Search and list database objects on the '${sourceId}' ${dbType} database`;
+  return { name, description, title };
+}
+function getExplainSqlMetadata(sourceId) {
+  const { dbType, isSingleSource, name, title, userDescPrefix } = resolveBuiltinToolNaming(
+    sourceId,
+    "explain_sql",
+    "Explain Query Plan"
+  );
+  const description = isSingleSource ? `${userDescPrefix}Show the execution plan for a SQL statement on the ${dbType} database without running it. Always read-only and safe, independent of the source's read/write mode.` : `${userDescPrefix}Show the execution plan for a SQL statement on the '${sourceId}' ${dbType} database without running it. Always read-only and safe, independent of the source's read/write mode.`;
+  const annotations = {
+    title,
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  };
+  return {
+    name,
+    description,
+    schema: explainSqlSchema,
+    annotations
+  };
+}
+function getHealthCheckMetadata(sourceId) {
+  const { dbType, isSingleSource, name, title, userDescPrefix } = resolveBuiltinToolNaming(
+    sourceId,
+    "health_check",
+    "Health Check"
+  );
+  const description = isSingleSource ? `${userDescPrefix}Report operational health metrics (connection pool state, buffer cache hit ratio) for the ${dbType} database. Read-only, independent of the source's read/write mode.` : `${userDescPrefix}Report operational health metrics (connection pool state, buffer cache hit ratio) for the '${sourceId}' ${dbType} database. Read-only, independent of the source's read/write mode.`;
+  const annotations = {
+    title,
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: false,
+    // Metrics change from call to call, unlike explain_sql's plan output
+    openWorldHint: false
+  };
   return {
-    name: toolName,
+    name,
     description,
-    title
+    schema: healthCheckSchema,
+    annotations
   };
 }
 function customParamsToToolParams(params) {
@@ -900,6 +1144,16 @@ function buildSearchObjectsTool(sourceId) {
     // search_objects is always readonly
   };
 }
+function buildExplainSqlTool(sourceId) {
+  const explainMetadata = getExplainSqlMetadata(sourceId);
+  return {
+    name: explainMetadata.name,
+    description: explainMetadata.description,
+    parameters: zodToParameters(explainMetadata.schema),
+    readonly: true
+    // explain_sql is always readonly
+  };
+}
 function buildCustomTool(toolConfig) {
   return {
     name: toolConfig.name,
@@ -918,6 +1172,8 @@ function getToolsForSource(sourceId) {
       return buildExecuteSqlTool(sourceId, toolConfig);
     } else if (toolConfig.name === "search_objects") {
       return buildSearchObjectsTool(sourceId);
+    } else if (toolConfig.name === "explain_sql") {
+      return buildExplainSqlTool(sourceId);
     } else {
       return buildCustomTool(toolConfig);
     }
@@ -925,7 +1181,7 @@ function getToolsForSource(sourceId) {
 }
 
 // src/tools/custom-tool-handler.ts
-import { z as z4 } from "zod";
+import { z as z6 } from "zod";
 function buildZodSchemaFromParameters(parameters) {
   if (!parameters || parameters.length === 0) {
     return {};
@@ -935,26 +1191,26 @@ function buildZodSchemaFromParameters(parameters) {
     let fieldSchema;
     switch (param.type) {
       case "string":
-        fieldSchema = z4.string().describe(param.description);
+        fieldSchema = z6.string().describe(param.description);
         break;
       case "integer":
-        fieldSchema = z4.number().int().describe(param.description);
+        fieldSchema = z6.number().int().describe(param.description);
         break;
       case "float":
-        fieldSchema = z4.number().describe(param.description);
+        fieldSchema = z6.number().describe(param.description);
         break;
       case "boolean":
-        fieldSchema = z4.boolean().describe(param.description);
+        fieldSchema = z6.boolean().describe(param.description);
         break;
       case "array":
-        fieldSchema = z4.array(z4.unknown()).describe(param.description);
+        fieldSchema = z6.array(z6.unknown()).describe(param.description);
         break;
       default:
         throw new Error(`Unsupported parameter type: ${param.type}`);
     }
     if (param.allowed_values && param.allowed_values.length > 0) {
       if (param.type === "string") {
-        fieldSchema = z4.enum(param.allowed_values).describe(param.description);
+        fieldSchema = z6.enum(param.allowed_values).describe(param.description);
       } else {
         fieldSchema = fieldSchema.refine(
           (val) => param.allowed_values.includes(val),
@@ -971,9 +1227,17 @@ function buildZodSchemaFromParameters(parameters) {
   }
   return schemaShape;
 }
+var customToolInputSchemas = /* @__PURE__ */ new WeakMap();
+function getCustomToolInputSchema(toolConfig) {
+  let schema = customToolInputSchemas.get(toolConfig);
+  if (!schema) {
+    schema = z6.object(buildZodSchemaFromParameters(toolConfig.parameters));
+    customToolInputSchemas.set(toolConfig, schema);
+  }
+  return schema;
+}
 function createCustomToolHandler(toolConfig) {
-  const zodSchemaShape = buildZodSchemaFromParameters(toolConfig.parameters);
-  const zodSchema = z4.object(zodSchemaShape);
+  const zodSchema = getCustomToolInputSchema(toolConfig);
   return async (args, extra) => {
     const startTime = Date.now();
     let success = true;
@@ -983,12 +1247,12 @@ function createCustomToolHandler(toolConfig) {
       const validatedArgs = zodSchema.parse(args);
       await ConnectorManager.ensureConnected(toolConfig.source);
       const connector = ConnectorManager.getCurrentConnector(toolConfig.source);
+      const policy = policyFromReadonly(toolConfig.readonly);
       const executeOptions = {
-        readonly: toolConfig.readonly,
+        readonly: isReadOnlyPolicy(policy),
         maxRows: toolConfig.max_rows
       };
-      const isReadonly = executeOptions.readonly === true;
-      if (isReadonly && !isReadOnlySQL(toolConfig.statement, connector.id)) {
+      if (sqlVerdict(policy, toolConfig.statement, connector.id) === "deny") {
         errorMessage = createReadonlyViolationMessage(toolConfig.name, toolConfig.source, connector.id);
         success = false;
         return createToolErrorResponse(errorMessage, "READONLY_VIOLATION");
@@ -1013,7 +1277,7 @@ function createCustomToolHandler(toolConfig) {
       errorMessage = error.message;
       const classified = tryClassifyConnectionError(error, toolConfig.source, toolConfig.source);
       if (classified) return classified;
-      if (error instanceof z4.ZodError) {
+      if (error instanceof z6.ZodError) {
         const issues = error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
         errorMessage = `Parameter validation failed: ${issues}`;
       } else {
@@ -1053,6 +1317,10 @@ function registerTools(server) {
         registerExecuteSqlTool(server, sourceId);
       } else if (toolConfig.name === BUILTIN_TOOL_SEARCH_OBJECTS) {
         registerSearchObjectsTool(server, sourceId);
+      } else if (toolConfig.name === BUILTIN_TOOL_EXPLAIN_SQL) {
+        registerExplainSqlTool(server, sourceId);
+      } else if (toolConfig.name === BUILTIN_TOOL_HEALTH_CHECK) {
+        registerHealthCheckTool(server, sourceId);
       } else {
         registerCustomTool(server, sourceId, toolConfig);
       }
@@ -1065,7 +1333,7 @@ function registerExecuteSqlTool(server, sourceId) {
     metadata.name,
     {
       description: metadata.description,
-      inputSchema: metadata.schema,
+      inputSchema: executeSqlInputSchema,
       annotations: metadata.annotations
     },
     createExecuteSqlToolHandler(sourceId)
@@ -1077,7 +1345,7 @@ function registerSearchObjectsTool(server, sourceId) {
     metadata.name,
     {
       description: metadata.description,
-      inputSchema: searchDatabaseObjectsSchema,
+      inputSchema: searchDatabaseObjectsInputSchema,
       annotations: {
         title: metadata.title,
         readOnlyHint: true,
@@ -1089,16 +1357,39 @@ function registerSearchObjectsTool(server, sourceId) {
     createSearchDatabaseObjectsToolHandler(sourceId)
   );
 }
+function registerExplainSqlTool(server, sourceId) {
+  const metadata = getExplainSqlMetadata(sourceId);
+  server.registerTool(
+    metadata.name,
+    {
+      description: metadata.description,
+      inputSchema: explainSqlInputSchema,
+      annotations: metadata.annotations
+    },
+    createExplainSqlToolHandler(sourceId)
+  );
+}
+function registerHealthCheckTool(server, sourceId) {
+  const metadata = getHealthCheckMetadata(sourceId);
+  server.registerTool(
+    metadata.name,
+    {
+      description: metadata.description,
+      inputSchema: healthCheckInputSchema,
+      annotations: metadata.annotations
+    },
+    createHealthCheckToolHandler(sourceId)
+  );
+}
 function registerCustomTool(server, sourceId, toolConfig) {
   const sourceConfig = ConnectorManager.getSourceConfig(sourceId);
   const dbType = sourceConfig.type;
-  const isReadOnly = isReadOnlySQL(toolConfig.statement, dbType);
-  const zodSchema = buildZodSchemaFromParameters(toolConfig.parameters);
+  const isReadOnly = classifySQL(toolConfig.statement, dbType) === "read";
   server.registerTool(
     toolConfig.name,
     {
       description: toolConfig.description,
-      inputSchema: zodSchema,
+      inputSchema: getCustomToolInputSchema(toolConfig),
       annotations: {
         title: `${toolConfig.name} (${dbType})`,
         readOnlyHint: isReadOnly,
@@ -1538,6 +1829,8 @@ var packageJsonPath = path.join(__dirname, "..", "package.json");
 var packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
 var SERVER_NAME = "DBHub MCP Server";
 var SERVER_VERSION = packageJson.version;
+var TOOLS_LIST_CACHE_TTL_MS = 3e5;
+var logMcpError = (scope) => (error) => console.error(`MCP ${scope} error:`, error);
 function generateBanner(version, modes = []) {
   const modeText = modes.length > 0 ? ` [${modes.join(" | ")}]` : "";
   return `
@@ -1583,7 +1876,7 @@ See documentation for more details on configuring database connections.
     const sources = sourceConfigsData.sources;
     console.error(`Configuration source: ${sourceConfigsData.source}`);
     await connectorManager.connectWithSources(sources);
-    const { initializeToolRegistry: initializeToolRegistry2 } = await import("./registry-ZU6ZFNQ2.js");
+    const { initializeToolRegistry: initializeToolRegistry2 } = await import("./registry-JYRRNC3E.js");
     initializeToolRegistry2({
       sources: sourceConfigsData.sources,
       tools: sourceConfigsData.tools
@@ -1594,10 +1887,18 @@ See documentation for more details on configuring database connections.
       initialTools: sourceConfigsData.tools
     });
     const createServer = () => {
-      const server = new McpServer({
-        name: SERVER_NAME,
-        version: SERVER_VERSION
-      });
+      const server = new McpServer(
+        {
+          name: SERVER_NAME,
+          version: SERVER_VERSION
+        },
+        {
+          // `private` keeps caching client-side (no shared/proxy caches).
+          cacheHints: {
+            "tools/list": { ttlMs: TOOLS_LIST_CACHE_TTL_MS, cacheScope: "private" }
+          }
+        }
+      );
       registerTools(server);
       return server;
     };
@@ -1639,7 +1940,7 @@ See documentation for more details on configuring database connections.
         }
         res.header("Access-Control-Allow-Origin", origin || "http://localhost");
         res.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-        res.header("Access-Control-Allow-Headers", "Content-Type, Mcp-Session-Id");
+        res.header("Access-Control-Allow-Headers", "Content-Type, Mcp-Session-Id, MCP-Protocol-Version, Mcp-Method, Mcp-Name");
         res.header("Access-Control-Allow-Credentials", "true");
         if (req.method === "OPTIONS") {
           return res.sendStatus(200);
@@ -1654,29 +1955,10 @@ See documentation for more details on configuring database connections.
       app.get("/api/sources", listSources);
       app.get("/api/sources/:sourceId", getSource);
       app.get("/api/requests", listRequests);
-      app.get("/mcp", (req, res) => {
-        res.status(405).json({
-          error: "Method Not Allowed",
-          message: "SSE streaming is not supported in stateless mode. Use POST requests with JSON responses."
-        });
-      });
-      app.post("/mcp", async (req, res) => {
-        try {
-          const transport = new StreamableHTTPServerTransport({
-            sessionIdGenerator: void 0,
-            // Disable session management for stateless mode
-            enableJsonResponse: true
-            // Use JSON responses (SSE not supported in stateless mode)
-          });
-          const server = createServer();
-          await server.connect(transport);
-          await transport.handleRequest(req, res, req.body);
-        } catch (error) {
-          console.error("Error handling request:", error);
-          if (!res.headersSent) {
-            res.status(500).json({ error: "Internal server error" });
-          }
-        }
+      const mcpHandler = createMcpHandler(createServer, { onerror: logMcpError("handler") });
+      const mcpNodeHandler = toNodeHandler(mcpHandler, { onerror: logMcpError("adapter") });
+      app.all("/mcp", (req, res) => {
+        void mcpNodeHandler(req, res, req.body);
       });
       if (process.env.NODE_ENV !== "development") {
         app.get("*", (req, res) => {
@@ -1712,16 +1994,14 @@ See documentation for more details on configuring database connections.
         console.error(`MCP server endpoint at http://${userHost}:${boundPort}/mcp`);
       });
     } else {
-      const server = createServer();
-      const transport = new StdioServerTransport();
-      await server.connect(transport);
+      const stdioHandle = serveStdio(createServer, { onerror: logMcpError("stdio") });
       console.error("MCP server running on stdio");
       let isShuttingDown = false;
       const shutdown = async () => {
         if (isShuttingDown) return;
         isShuttingDown = true;
         console.error("Shutting down...");
-        await transport.close();
+        await stdioHandle.close();
         await connectorManager.disconnect();
         process.exit(0);
       };
@@ -1737,11 +2017,11 @@ See documentation for more details on configuring database connections.
 
 // src/index.ts
 var connectorModules = [
-  { load: () => import("./postgres-ZQFXCBYA.js"), name: "PostgreSQL", driver: "pg" },
-  { load: () => import("./sqlserver-LHWZ7WOP.js"), name: "SQL Server", driver: "mssql" },
-  { load: () => import("./sqlite-JH5CNV5E.js"), name: "SQLite", driver: "node:sqlite" },
-  { load: () => import("./mysql-MHIZK2UY.js"), name: "MySQL", driver: "mysql2" },
-  { load: () => import("./mariadb-VZMU7LYA.js"), name: "MariaDB", driver: "mariadb" }
+  { load: () => import("./postgres-5ZOFYV6X.js"), name: "PostgreSQL", driver: "pg" },
+  { load: () => import("./sqlserver-PSAZRH7G.js"), name: "SQL Server", driver: "mssql" },
+  { load: () => import("./sqlite-5M7SDAQZ.js"), name: "SQLite", driver: "node:sqlite" },
+  { load: () => import("./mysql-265M3KBD.js"), name: "MySQL", driver: "mysql2" },
+  { load: () => import("./mariadb-DUDFBY5W.js"), name: "MariaDB", driver: "mariadb" }
 ];
 loadConnectors(connectorModules).then(() => main()).catch((error) => {
   console.error("Fatal error:", error);