@daniel.stefan/metalink 1.3.2 → 1.3.3

package/packages/core/dist/server/http.js

@@ -1,34 +1,35 @@
 /**
  * HTTP Server - Express-based API for MetaLink
  */
-import express from 'express';
-import rateLimit from 'express-rate-limit';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import fs from 'fs';
-import { randomUUID, createHmac } from 'crypto';
-import { ServerManager } from './manager.js';
+import express from "express";
+import rateLimit from "express-rate-limit";
+import path from "path";
+import { fileURLToPath } from "url";
+import fs from "fs";
+import { randomUUID, createHmac } from "crypto";
+import { ServerManager } from "./manager.js";
 import { version } from "../index.js";
-import { calculateTotalTokens } from './token-calculator.js';
-import { globalMetrics, MetricsPersistence, MetricsAggregator } from '../metrics/index.js';
-import { logger, generateRequestId, getOrCreateRequestId } from '../logging/index.js';
-import { getPromptsList, getPrompt } from './prompts.js';
-import { getResourcesList, getResourceTemplatesList, readResource } from './resources.js';
+import { calculateTotalTokens } from "./token-calculator.js";
+import { globalMetrics, MetricsPersistence, MetricsAggregator, } from "../metrics/index.js";
+import { logger, generateRequestId, getOrCreateRequestId, } from "../logging/index.js";
+import { getPromptsList, getPrompt } from "./prompts.js";
+import { getResourcesList, getResourceTemplatesList, readResource, } from "./resources.js";
+import { formatDescribeToolResponse, } from "../utils/toon-formatter.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 // MCP Protocol Version - MUST be set in all HTTP responses per spec 2025-06-18
-const MCP_PROTOCOL_VERSION = '2025-06-18';
+const MCP_PROTOCOL_VERSION = "2025-06-18";
 // Custom error class for invalid parameters (JSON-RPC error code -32602)
 class InvalidParamsError extends Error {
     constructor(message) {
         super(message);
-        this.name = 'InvalidParamsError';
+        this.name = "InvalidParamsError";
     }
 }
 // Custom error class for method not found (JSON-RPC error code -32601)
 class MethodNotFoundError extends Error {
     constructor(method) {
         super(`Method not found: ${method}`);
-        this.name = 'MethodNotFoundError';
+        this.name = "MethodNotFoundError";
     }
 }
 // Custom error class for session not initialized (triggers HTTP 404 for MCP spec compliance)
@@ -37,7 +38,7 @@ class MethodNotFoundError extends Error {
 class SessionNotInitializedError extends Error {
     constructor(method) {
         super(`Session must be initialized before calling ${method}. Call initialize first.`);
-        this.name = 'SessionNotInitializedError';
+        this.name = "SessionNotInitializedError";
     }
 }
 export class HttpServer {
@@ -91,12 +92,12 @@ export class HttpServer {
         // Phase 2: Set config loader for tool safety classification
         this.serverManager.setConfigLoader(this.configLoader);
         // Phase 4 - v1.4.0: Initialize metrics persistence and aggregation
-        const metricsDir = process.env.METALINK_METRICS_DIR || '~/.config/metalink';
+        const metricsDir = process.env.METALINK_METRICS_DIR || "~/.config/metalink";
         this.metricsPersistence = new MetricsPersistence(metricsDir);
         this.metricsAggregator = new MetricsAggregator();
         // Session persistence path (v1.1.24+)
-        const configDir = (process.env.METALINK_CONFIG_DIR || '~/.config/metalink').replace(/^~/, process.env.HOME || '~');
-        this.sessionPersistPath = path.join(configDir, 'sessions.json');
+        const configDir = (process.env.METALINK_CONFIG_DIR || "~/.config/metalink").replace(/^~/, process.env.HOME || "~");
+        this.sessionPersistPath = path.join(configDir, "sessions.json");
         // Load persisted metrics on startup
         this.loadPersistedMetrics();
         // Load persisted sessions on startup (v1.1.24+)
@@ -119,14 +120,14 @@ export class HttpServer {
      * Pagination support - Encode cursor data to opaque base64 string
      */
     encodeCursor(data) {
-        return Buffer.from(JSON.stringify(data)).toString('base64');
+        return Buffer.from(JSON.stringify(data)).toString("base64");
     }
     /**
      * Pagination support - Decode cursor from base64 string
      */
     decodeCursor(cursor) {
         try {
-            const decoded = Buffer.from(cursor, 'base64').toString('utf-8');
+            const decoded = Buffer.from(cursor, "base64").toString("utf-8");
             return JSON.parse(decoded);
         }
         catch {
@@ -142,7 +143,7 @@ export class HttpServer {
             return value;
         }
         // Truncate and add indicator
-        const truncated = json.substring(0, maxChars - 20) + '... [truncated]';
+        const truncated = json.substring(0, maxChars - 20) + "... [truncated]";
         try {
             return JSON.parse(truncated);
         }
@@ -151,6 +152,16 @@ export class HttpServer {
             return truncated;
         }
     }
+    /**
+     * Detect if current client is likely an LLM based on request headers
+     * Used for auto-detection of TOON format
+     */
+    isLLMClient() {
+        // This is a heuristic based on common LLM client patterns
+        // In practice, you'd track this per-session or per-request
+        // For now, we default to false and let explicit config override
+        return false;
+    }
     /**
      * Pagination support - Apply pagination to tool result
      *
@@ -177,15 +188,15 @@ export class HttpServer {
                 // More results available - create cursor
                 const nextCursor = this.encodeCursor({
                     offset: endOffset,
-                    type: 'array'
+                    type: "array",
                 });
                 return {
                     result: result.slice(startOffset, endOffset),
                     _pagination: {
                         nextCursor,
                         totalAvailable,
-                        truncated: true
-                    }
+                        truncated: true,
+                    },
                 };
             }
             else if (startOffset > 0) {
@@ -194,8 +205,8 @@ export class HttpServer {
                     result: result.slice(startOffset),
                     _pagination: {
                         totalAvailable,
-                        truncated: false
-                    }
+                        truncated: false,
+                    },
                 };
             }
         }
@@ -205,23 +216,23 @@ export class HttpServer {
             // Generate cursor for continuation
             const nextCursor = this.encodeCursor({
                 offset: maxChars,
-                type: 'chars'
+                type: "chars",
             });
             return {
                 result: this.truncateToChars(result, maxChars),
                 _pagination: {
                     nextCursor,
                     totalAvailable: json.length,
-                    truncated: true
-                }
+                    truncated: true,
+                },
             };
         }
         // No pagination needed
         return {
             result,
             _pagination: {
-                truncated: false
-            }
+                truncated: false,
+            },
         };
     }
     /**
@@ -230,19 +241,19 @@ export class HttpServer {
     setupMiddleware() {
         // Request ID middleware - generate or extract correlation ID
         this.app.use((req, _res, next) => {
-            const requestId = getOrCreateRequestId(req.headers['x-request-id']);
+            const requestId = getOrCreateRequestId(req.headers["x-request-id"]);
             req.requestId = requestId;
             next();
         });
         // Debug middleware - structured logging for all requests
         this.app.use((req, _res, next) => {
             const requestId = req.requestId;
-            logger.debug('Incoming request', {
+            logger.debug("Incoming request", {
                 requestId,
                 method: req.method,
                 path: req.path,
                 url: req.url,
-                userAgent: req.headers['user-agent'],
+                userAgent: req.headers["user-agent"],
             });
             next();
         });
@@ -251,14 +262,14 @@ export class HttpServer {
             const startTime = Date.now();
             const requestId = req.requestId;
             globalMetrics.recordApiRequest();
-            res.on('finish', () => {
+            res.on("finish", () => {
                 const latency = Date.now() - startTime;
                 globalMetrics.recordApiResponse(latency);
                 if (res.statusCode >= 400) {
                     globalMetrics.recordApiError();
                 }
                 // Log response with correlation ID
-                logger.info('Request completed', {
+                logger.info("Request completed", {
                     requestId,
                     method: req.method,
                     path: req.path,
@@ -271,7 +282,7 @@ export class HttpServer {
         // Origin header validation to prevent DNS rebinding attacks
         this.app.use((req, res, next) => {
             // Only validate POST requests (where state changes can occur)
-            if (req.method === 'POST') {
+            if (req.method === "POST") {
                 const origin = req.headers.origin;
                 const requestId = req.requestId;
                 // Allow requests with no Origin header (non-browser clients, Electron apps)
@@ -284,38 +295,38 @@ export class HttpServer {
                     const originUrl = new URL(origin);
                     const hostname = originUrl.hostname;
                     // Allow localhost, 127.0.0.1, and IPv6 loopback
-                    const allowedHosts = ['localhost', '127.0.0.1', '[::1]', '::1'];
+                    const allowedHosts = ["localhost", "127.0.0.1", "[::1]", "::1"];
                     if (!allowedHosts.includes(hostname)) {
-                        logger.warn('Rejected request from unauthorized origin', {
+                        logger.warn("Rejected request from unauthorized origin", {
                             requestId,
                             origin,
                             hostname,
-                            security: 'dns_rebinding_protection',
+                            security: "dns_rebinding_protection",
                         });
                         res.status(403).json({
-                            jsonrpc: '2.0',
+                            jsonrpc: "2.0",
                             error: {
                                 code: -32600,
-                                message: 'Invalid Request: Origin not allowed'
-                            }
+                                message: "Invalid Request: Origin not allowed",
+                            },
                         });
                         return;
                     }
                 }
                 catch (err) {
                     // Invalid origin URL
-                    logger.warn('Rejected request with malformed origin', {
+                    logger.warn("Rejected request with malformed origin", {
                         requestId,
                         origin,
-                        error: err instanceof Error ? err.message : 'Unknown error',
-                        security: 'dns_rebinding_protection',
+                        error: err instanceof Error ? err.message : "Unknown error",
+                        security: "dns_rebinding_protection",
                     });
                     res.status(403).json({
-                        jsonrpc: '2.0',
+                        jsonrpc: "2.0",
                         error: {
                             code: -32600,
-                            message: 'Invalid Request: Malformed origin'
-                        }
+                            message: "Invalid Request: Malformed origin",
+                        },
                     });
                     return;
                 }
@@ -323,23 +334,26 @@ export class HttpServer {
             next();
         });
         // Raw body parser for MCP endpoints (must come before JSON parser)
-        this.app.use('/mcp', express.raw({ type: 'application/json' }));
-        this.app.use('/mcp/rpc', express.raw({ type: 'application/json' }));
-        this.app.use('/rpc', express.raw({ type: 'application/json' }));
-        this.app.use('/rpc/rpc', express.raw({ type: 'application/json' }));
+        this.app.use("/mcp", express.raw({ type: "application/json" }));
+        this.app.use("/mcp/rpc", express.raw({ type: "application/json" }));
+        this.app.use("/rpc", express.raw({ type: "application/json" }));
+        this.app.use("/rpc/rpc", express.raw({ type: "application/json" }));
         // JSON body parser for other endpoints
         this.app.use(express.json());
         // Rate limiting
         const daemonConfig = this.config.daemon;
-        if (daemonConfig && daemonConfig.rateLimit && daemonConfig.rateLimit.enabled) {
+        if (daemonConfig &&
+            daemonConfig.rateLimit &&
+            daemonConfig.rateLimit.enabled) {
             const limiter = rateLimit({
                 windowMs: daemonConfig.rateLimit.windowMs || 60000,
                 max: daemonConfig.rateLimit.max || 500,
                 keyGenerator: (req) => {
-                    if (daemonConfig.rateLimit && daemonConfig.rateLimit.keyGenerator === 'user') {
-                        return req.userId || req.ip || '';
+                    if (daemonConfig.rateLimit &&
+                        daemonConfig.rateLimit.keyGenerator === "user") {
+                        return req.userId || req.ip || "";
                     }
-                    return req.ip || '';
+                    return req.ip || "";
                 },
             });
             this.app.use(limiter);
@@ -351,7 +365,7 @@ export class HttpServer {
         // Request logging
         this.app.use((req, res, next) => {
             const start = Date.now();
-            res.on('finish', () => {
+            res.on("finish", () => {
                 const duration = Date.now() - start;
                 console.log(`[${req.method}] ${req.path} ${res.statusCode} ${duration}ms`);
             });
@@ -364,29 +378,30 @@ export class HttpServer {
     authMiddleware(req, res, next) {
         const authHeader = req.headers.authorization;
         if (!authHeader) {
-            res.status(401).json({ error: 'Missing Authorization header' });
+            res.status(401).json({ error: "Missing Authorization header" });
             return;
         }
-        const [scheme] = authHeader.split(' ');
-        if (scheme !== 'Bearer') {
-            res.status(401).json({ error: 'Invalid Authorization scheme' });
+        const [scheme] = authHeader.split(" ");
+        if (scheme !== "Bearer") {
+            res.status(401).json({ error: "Invalid Authorization scheme" });
             return;
         }
         const token = authHeader.substring(7);
         const secret = this.config?.daemon?.auth?.secret;
         if (!secret) {
-            console.warn('[Auth] No auth secret configured, rejecting request');
-            res.status(500).json({ error: 'Auth not configured' });
+            console.warn("[Auth] No auth secret configured, rejecting request");
+            res.status(500).json({ error: "Auth not configured" });
             return;
         }
-        const expectedToken = createHmac('sha256', secret)
-            .update('metalink-auth-token').digest('hex');
+        const expectedToken = createHmac("sha256", secret)
+            .update("metalink-auth-token")
+            .digest("hex");
         if (token !== expectedToken) {
-            res.status(401).json({ error: 'Invalid authentication token' });
+            res.status(401).json({ error: "Invalid authentication token" });
             return;
         }
         req.authenticated = true;
-        req.userId = 'authenticated-user';
+        req.userId = "authenticated-user";
         next();
     }
     /**
@@ -395,41 +410,41 @@ export class HttpServer {
     setupRoutes() {
         const api = express.Router();
         // Server endpoints
-        api.get('/servers', this.listServers.bind(this));
-        api.get('/servers/available/list', this.listAvailableServers.bind(this));
-        api.post('/servers/:name/start', this.startServer.bind(this));
-        api.post('/servers/:name/stop', this.stopServer.bind(this));
-        api.post('/servers/:name/restart', this.restartServer.bind(this));
-        api.post('/servers/:name/enable', this.enableServer.bind(this));
-        api.post('/servers/:name/disable', this.disableServer.bind(this));
-        api.get('/servers/:name/status', this.getServerStatus.bind(this));
-        api.get('/servers/:name/info', this.getServerInfo.bind(this));
-        api.post('/servers/:name/refresh-tools', this.refreshServerTools.bind(this)); // v1.4.2: Force refresh tools
+        api.get("/servers", this.listServers.bind(this));
+        api.get("/servers/available/list", this.listAvailableServers.bind(this));
+        api.post("/servers/:name/start", this.startServer.bind(this));
+        api.post("/servers/:name/stop", this.stopServer.bind(this));
+        api.post("/servers/:name/restart", this.restartServer.bind(this));
+        api.post("/servers/:name/enable", this.enableServer.bind(this));
+        api.post("/servers/:name/disable", this.disableServer.bind(this));
+        api.get("/servers/:name/status", this.getServerStatus.bind(this));
+        api.get("/servers/:name/info", this.getServerInfo.bind(this));
+        api.post("/servers/:name/refresh-tools", this.refreshServerTools.bind(this)); // v1.4.2: Force refresh tools
         // Tool endpoints
-        api.get('/servers/:name/tools', this.getServerTools.bind(this));
-        api.post('/servers/:name/tools/:toolName/execute', this.executeTool.bind(this));
+        api.get("/servers/:name/tools", this.getServerTools.bind(this));
+        api.post("/servers/:name/tools/:toolName/execute", this.executeTool.bind(this));
         // Configuration endpoints
-        api.get('/config', this.getConfig.bind(this));
-        api.put('/config', this.updateConfig.bind(this));
+        api.get("/config", this.getConfig.bind(this));
+        api.put("/config", this.updateConfig.bind(this));
         // Registry management endpoints
-        api.post('/registry/servers', this.addServer.bind(this));
-        api.delete('/registry/servers/:name', this.removeServer.bind(this));
-        api.post('/registry/validate', this.validateServer.bind(this));
+        api.post("/registry/servers", this.addServer.bind(this));
+        api.delete("/registry/servers/:name", this.removeServer.bind(this));
+        api.post("/registry/validate", this.validateServer.bind(this));
         // Health endpoints
-        api.get('/health', this.healthCheck.bind(this));
+        api.get("/health", this.healthCheck.bind(this));
         // Version endpoint
-        api.get('/version', this.getVersion.bind(this));
+        api.get("/version", this.getVersion.bind(this));
         // Metrics endpoints (Phase 4 - v1.4.0)
-        api.get('/metrics', this.getMetrics.bind(this));
-        api.get('/metrics/prometheus', this.getPrometheusMetrics.bind(this));
-        api.get('/metrics/api', this.getApiMetrics.bind(this));
-        api.get('/metrics/servers/:name', this.getServerMetrics.bind(this));
-        api.get('/metrics/hourly', this.getHourlyMetrics.bind(this));
-        api.get('/metrics/daily', this.getDailyMetrics.bind(this));
-        api.get('/metrics/weekly', this.getWeeklyMetrics.bind(this));
-        api.get('/metrics/errors', this.getErrorAnalytics.bind(this));
-        api.get('/metrics/errors/:toolName', this.getToolErrorMetrics.bind(this));
-        api.get('/metrics/tools', this.getToolMetrics.bind(this)); // Test 187: Tool-specific granular metrics
+        api.get("/metrics", this.getMetrics.bind(this));
+        api.get("/metrics/prometheus", this.getPrometheusMetrics.bind(this));
+        api.get("/metrics/api", this.getApiMetrics.bind(this));
+        api.get("/metrics/servers/:name", this.getServerMetrics.bind(this));
+        api.get("/metrics/hourly", this.getHourlyMetrics.bind(this));
+        api.get("/metrics/daily", this.getDailyMetrics.bind(this));
+        api.get("/metrics/weekly", this.getWeeklyMetrics.bind(this));
+        api.get("/metrics/errors", this.getErrorAnalytics.bind(this));
+        api.get("/metrics/errors/:toolName", this.getToolErrorMetrics.bind(this));
+        api.get("/metrics/tools", this.getToolMetrics.bind(this)); // Test 187: Tool-specific granular metrics
         // Safety endpoints (Phase 1 - v1.2.0)
         api.get("/safety", this.getSafetyRules.bind(this));
         api.get("/safety/check/:server/:tool", this.checkToolSafety.bind(this));
@@ -440,77 +455,77 @@ export class HttpServer {
         api.delete("/safety/rules/:rule", this.removeRule.bind(this));
         api.post("/safety/reset", this.resetSafetyRules.bind(this));
         api.post("/safety/import", this.importSafetyRules.bind(this));
-        this.app.use('/api/v1', api);
+        this.app.use("/api/v1", api);
         // Also register /api/metrics endpoint (without /v1 prefix) for backward compatibility with tests
-        this.app.get('/api/metrics', this.getMetrics.bind(this));
+        this.app.get("/api/metrics", this.getMetrics.bind(this));
         // MCP endpoint (JSON-RPC over HTTP) - Primary endpoint per MCP 2025-06-18 spec
         // GET /mcp for streaming/SSE connections (Claude Code HTTP transport)
-        this.app.get('/mcp', this.handleMcpRequest.bind(this));
+        this.app.get("/mcp", this.handleMcpRequest.bind(this));
         // POST endpoints for standard JSON-RPC
-        this.app.post('/mcp', this.handleMcpRequest.bind(this));
+        this.app.post("/mcp", this.handleMcpRequest.bind(this));
         // DELETE /mcp for session cleanup (per MCP spec)
-        this.app.delete('/mcp', this.handleMcpRequest.bind(this));
+        this.app.delete("/mcp", this.handleMcpRequest.bind(this));
         // Legacy SSE endpoints for backward compatibility (2025-03-26 and earlier)
-        this.app.get('/sse', this.handleMcpRequest.bind(this)); // Legacy SSE endpoint
-        this.app.post('/messages', this.handleMcpRequest.bind(this)); // Legacy JSON-RPC endpoint
+        this.app.get("/sse", this.handleMcpRequest.bind(this)); // Legacy SSE endpoint
+        this.app.post("/messages", this.handleMcpRequest.bind(this)); // Legacy JSON-RPC endpoint
         // Alternative MCP endpoint paths for compatibility with various clients
         // Grok HTTP transport expects /mcp/rpc path
-        this.app.post('/mcp/rpc', this.handleMcpRequest.bind(this));
+        this.app.post("/mcp/rpc", this.handleMcpRequest.bind(this));
         // Root-level /rpc for clients that don't use /mcp prefix (e.g., Grok CLI)
-        this.app.post('/rpc', this.handleMcpRequest.bind(this));
+        this.app.post("/rpc", this.handleMcpRequest.bind(this));
         // Grok appends /rpc to URL, creating /rpc/rpc when given http://.../rpc
-        this.app.post('/rpc/rpc', this.handleMcpRequest.bind(this));
+        this.app.post("/rpc/rpc", this.handleMcpRequest.bind(this));
         // Prometheus metrics endpoint (standard /metrics path for scraping)
-        this.app.get('/metrics', this.getPrometheusMetrics.bind(this));
+        this.app.get("/metrics", this.getPrometheusMetrics.bind(this));
         // Serve dashboard static files (if available)
-        const dashboardPath = path.join(__dirname, '../../../dashboard/dist');
+        const dashboardPath = path.join(__dirname, "../../../dashboard/dist");
         const dashboardExists = fs.existsSync(dashboardPath);
-        const indexPath = path.join(dashboardPath, 'index.html');
+        const indexPath = path.join(dashboardPath, "index.html");
         const indexExists = dashboardExists && fs.existsSync(indexPath);
-        console.log('[HTTP] dashboardPath:', dashboardPath);
-        console.log('[HTTP] dashboard exists:', dashboardExists);
-        console.log('[HTTP] index.html exists:', indexExists);
+        console.log("[HTTP] dashboardPath:", dashboardPath);
+        console.log("[HTTP] dashboard exists:", dashboardExists);
+        console.log("[HTTP] index.html exists:", indexExists);
         // Serve dashboard - explicit root route
         if (indexExists) {
-            console.log('[HTTP] Registering GET / route for dashboard');
-            this.app.get('/', (_req, res) => {
-                console.log('[HTTP] Serving root path from:', indexPath);
+            console.log("[HTTP] Registering GET / route for dashboard");
+            this.app.get("/", (_req, res) => {
+                console.log("[HTTP] Serving root path from:", indexPath);
                 res.sendFile(indexPath);
             });
-            console.log('[HTTP] GET / route registered successfully');
+            console.log("[HTTP] GET / route registered successfully");
         }
         else {
-            console.log('[HTTP] Skipping GET / - index.html not found');
+            console.log("[HTTP] Skipping GET / - index.html not found");
         }
         if (dashboardExists) {
-            console.log('[HTTP] Registering static file middleware for:', dashboardPath);
+            console.log("[HTTP] Registering static file middleware for:", dashboardPath);
             // Serve static assets from dashboard
             this.app.use(express.static(dashboardPath, {
-                etag: false
+                etag: false,
             }));
-            console.log('[HTTP] Static middleware registered');
+            console.log("[HTTP] Static middleware registered");
         }
         // SPA fallback - serve index.html for client-side routing (only if dashboard exists)
         if (indexExists) {
-            console.log('[HTTP] Registering fallback route (*)');
-            this.app.get('*', (_req, res) => {
-                console.log('[HTTP] Fallback route hit for:', _req.path);
+            console.log("[HTTP] Registering fallback route (*)");
+            this.app.get("*", (_req, res) => {
+                console.log("[HTTP] Fallback route hit for:", _req.path);
                 res.sendFile(indexPath);
             });
-            console.log('[HTTP] Fallback route registered');
+            console.log("[HTTP] Fallback route registered");
         }
         else {
-            console.log('[HTTP] Skipping fallback route - dashboard not available');
+            console.log("[HTTP] Skipping fallback route - dashboard not available");
         }
         // SECURITY: Error handler with sanitization to prevent credential leakage
         // OWASP Reference: A3:2017-Sensitive Data Exposure
         this.app.use((err, _req, res, _next) => {
             // Log full error internally for debugging (not exposed to client)
-            console.error('API Error:', err);
+            console.error("API Error:", err);
             // SECURITY: Sanitize error message before sending to client
             const sanitizedMessage = this.sanitizeErrorMessage(err.message);
             res.status(500).json({
-                error: 'Internal Server Error',
+                error: "Internal Server Error",
                 message: sanitizedMessage,
             });
         });
@@ -528,7 +543,7 @@ export class HttpServer {
      */
     sanitizeErrorMessage(message) {
         if (!message)
-            return 'An error occurred';
+            return "An error occurred";
         // Patterns that indicate sensitive data that should be masked
         const sensitivePatterns = [
             // API keys and tokens (various formats)
@@ -556,11 +571,11 @@ export class HttpServer {
         ];
         let sanitized = message;
         for (const pattern of sensitivePatterns) {
-            sanitized = sanitized.replace(pattern, '[REDACTED]');
+            sanitized = sanitized.replace(pattern, "[REDACTED]");
         }
         // Additional safety: truncate very long messages that might contain dumps
         if (sanitized.length > 500) {
-            sanitized = sanitized.substring(0, 500) + '... [truncated]';
+            sanitized = sanitized.substring(0, 500) + "... [truncated]";
         }
         return sanitized;
     }
@@ -568,52 +583,52 @@ export class HttpServer {
      * Setup Server-Sent Events
      */
     setupSSE() {
-        this.app.get('/api/v1/events', (req, res) => {
+        this.app.get("/api/v1/events", (req, res) => {
             // Check authentication
             if (this.config.daemon?.auth?.enabled && !req.authenticated) {
-                res.status(401).json({ error: 'Unauthorized' });
+                res.status(401).json({ error: "Unauthorized" });
                 return;
             }
-            res.setHeader('Content-Type', 'text/event-stream');
-            res.setHeader('Cache-Control', 'no-cache');
-            res.setHeader('Connection', 'keep-alive');
+            res.setHeader("Content-Type", "text/event-stream");
+            res.setHeader("Cache-Control", "no-cache");
+            res.setHeader("Connection", "keep-alive");
             // Send initial connection message
             res.write('data: {"type":"connected"}\n\n');
             this.eventClients.add(res);
             // Clean up on disconnect
-            req.on('close', () => {
+            req.on("close", () => {
                 this.eventClients.delete(res);
             });
         });
         // Broadcast events from server manager
-        this.serverManager.on('server:started', (data) => {
+        this.serverManager.on("server:started", (data) => {
             this.broadcastEvent({
-                type: 'server:started',
+                type: "server:started",
                 data,
             });
         });
-        this.serverManager.on('server:stopped', (data) => {
+        this.serverManager.on("server:stopped", (data) => {
             this.broadcastEvent({
-                type: 'server:stopped',
+                type: "server:stopped",
                 data,
             });
         });
-        this.serverManager.on('server:error', (data) => {
+        this.serverManager.on("server:error", (data) => {
             this.broadcastEvent({
-                type: 'server:error',
+                type: "server:error",
                 data,
             });
         });
-        this.serverManager.on('health:check', (data) => {
+        this.serverManager.on("health:check", (data) => {
             this.broadcastEvent({
-                type: 'health:check',
+                type: "health:check",
                 data,
             });
         });
         // Listen for server removal events (from removeServer method)
-        this.serverManager.on('server:removed', (data) => {
+        this.serverManager.on("server:removed", (data) => {
             this.broadcastEvent({
-                type: 'server:removed',
+                type: "server:removed",
                 data,
             });
         });
@@ -635,12 +650,13 @@ export class HttpServer {
         try {
             const servers = this.configLoader.getServers();
             const serverInfos = servers.map((config) => {
-                const isStdio = config.transport === 'stdio' || config.transport === undefined;
+                const isStdio = config.transport === "stdio" || config.transport === undefined;
                 const tools = this.serverManager.getServerTools(config.name);
                 const baseInfo = {
                     name: config.name,
                     env: config.env || {},
-                    status: (this.serverManager.getServerStatus(config.name)?.status || 'stopped'),
+                    status: (this.serverManager.getServerStatus(config.name)?.status ||
+                        "stopped"),
                     process: this.serverManager.getServerStatus(config.name),
                     toolCount: tools.length || 0,
                     tokenEstimate: calculateTotalTokens(tools),
@@ -661,7 +677,7 @@ export class HttpServer {
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to list servers',
+                error: error instanceof Error ? error.message : "Failed to list servers",
             });
         }
     }
@@ -672,15 +688,16 @@ export class HttpServer {
         try {
             const allServers = this.configLoader.getAllServers();
             const exposedServers = this.configLoader.getServers();
-            const exposedNames = new Set(exposedServers.map(s => s.name));
+            const exposedNames = new Set(exposedServers.map((s) => s.name));
             const serverInfos = allServers.map((config) => {
-                const isStdio = config.transport === 'stdio' || config.transport === undefined;
+                const isStdio = config.transport === "stdio" || config.transport === undefined;
                 const tools = this.serverManager.getServerTools(config.name);
                 const baseInfo = {
                     name: config.name,
-                    type: isStdio ? 'stdio' : 'http',
+                    type: isStdio ? "stdio" : "http",
                     env: config.env || {},
-                    status: (this.serverManager.getServerStatus(config.name)?.status || 'stopped'),
+                    status: (this.serverManager.getServerStatus(config.name)?.status ||
+                        "stopped"),
                     process: this.serverManager.getServerStatus(config.name),
                     enabled: exposedNames.has(config.name),
                     toolCount: tools.length || 0,
@@ -691,7 +708,7 @@ export class HttpServer {
                         ...baseInfo,
                         command: config.command,
                         args: config.args || [],
-                        fullCommand: `${config.command} ${(config.args || []).join(' ')}`.trim(),
+                        fullCommand: `${config.command} ${(config.args || []).join(" ")}`.trim(),
                     }
                     : {
                         ...baseInfo,
@@ -703,7 +720,9 @@ export class HttpServer {
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to list available servers',
+                error: error instanceof Error
+                    ? error.message
+                    : "Failed to list available servers",
             });
         }
     }
@@ -720,18 +739,18 @@ export class HttpServer {
             }
             // Get current EXPOSE_SERVERS list
             const currentExposed = process.env.EXPOSE_SERVERS
-                ? process.env.EXPOSE_SERVERS.split(',').map(s => s.trim())
-                : (this.config.base_servers || []);
+                ? process.env.EXPOSE_SERVERS.split(",").map((s) => s.trim())
+                : this.config.base_servers || [];
             // Add server if not already exposed
             if (!currentExposed.includes(name)) {
                 currentExposed.push(name);
-                process.env.EXPOSE_SERVERS = currentExposed.join(',');
+                process.env.EXPOSE_SERVERS = currentExposed.join(",");
             }
             res.json({ success: true, message: `Server ${name} enabled` });
         }
         catch (error) {
             res.status(400).json({
-                error: error instanceof Error ? error.message : 'Failed to enable server',
+                error: error instanceof Error ? error.message : "Failed to enable server",
             });
         }
     }
@@ -743,19 +762,19 @@ export class HttpServer {
             const { name } = req.params;
             // Get current EXPOSE_SERVERS list
             const currentExposed = process.env.EXPOSE_SERVERS
-                ? process.env.EXPOSE_SERVERS.split(',').map(s => s.trim())
-                : (this.config.base_servers || []);
+                ? process.env.EXPOSE_SERVERS.split(",").map((s) => s.trim())
+                : this.config.base_servers || [];
             // Remove server if exposed
             const index = currentExposed.indexOf(name);
             if (index >= 0) {
                 currentExposed.splice(index, 1);
-                process.env.EXPOSE_SERVERS = currentExposed.join(',');
+                process.env.EXPOSE_SERVERS = currentExposed.join(",");
             }
             res.json({ success: true, message: `Server ${name} disabled` });
         }
         catch (error) {
             res.status(400).json({
-                error: error instanceof Error ? error.message : 'Failed to disable server',
+                error: error instanceof Error ? error.message : "Failed to disable server",
             });
         }
     }
@@ -767,7 +786,9 @@ export class HttpServer {
             const { name } = req.params;
             const config = this.configLoader.getServer(name);
             if (!config) {
-                res.status(404).json({ error: `Server ${name} not found in configuration` });
+                res
+                    .status(404)
+                    .json({ error: `Server ${name} not found in configuration` });
                 return;
             }
             const process = await this.serverManager.startServer(config);
@@ -778,7 +799,7 @@ export class HttpServer {
         }
         catch (error) {
             res.status(400).json({
-                error: error instanceof Error ? error.message : 'Failed to start server',
+                error: error instanceof Error ? error.message : "Failed to start server",
             });
         }
     }
@@ -796,7 +817,7 @@ export class HttpServer {
         }
         catch (error) {
             res.status(400).json({
-                error: error instanceof Error ? error.message : 'Failed to stop server',
+                error: error instanceof Error ? error.message : "Failed to stop server",
             });
         }
     }
@@ -808,7 +829,9 @@ export class HttpServer {
             const { name } = req.params;
             const config = this.configLoader.getServer(name);
             if (!config) {
-                res.status(404).json({ error: `Server ${name} not found in configuration` });
+                res
+                    .status(404)
+                    .json({ error: `Server ${name} not found in configuration` });
                 return;
             }
             const process = await this.serverManager.restartServer(config);
@@ -819,7 +842,7 @@ export class HttpServer {
         }
         catch (error) {
             res.status(400).json({
-                error: error instanceof Error ? error.message : 'Failed to restart server',
+                error: error instanceof Error ? error.message : "Failed to restart server",
             });
         }
     }
@@ -832,7 +855,9 @@ export class HttpServer {
             const { name } = req.params;
             const config = this.configLoader.getServer(name);
             if (!config) {
-                res.status(404).json({ error: `Server ${name} not found in configuration` });
+                res
+                    .status(404)
+                    .json({ error: `Server ${name} not found in configuration` });
                 return;
             }
             console.log(`[HTTP] Force refreshing tools for ${name}...`);
@@ -841,12 +866,14 @@ export class HttpServer {
                 success: true,
                 serverName: name,
                 toolCount: tools.length,
-                tools: tools.map(t => t.name),
+                tools: tools.map((t) => t.name),
             });
         }
         catch (error) {
             res.status(400).json({
-                error: error instanceof Error ? error.message : 'Failed to refresh server tools',
+                error: error instanceof Error
+                    ? error.message
+                    : "Failed to refresh server tools",
             });
         }
     }
@@ -870,11 +897,11 @@ export class HttpServer {
                     server: name,
                     status: {
                         pid: 0,
-                        status: 'stopped',
+                        status: "stopped",
                         uptime: 0,
                         lastHealthCheck: 0,
-                        errorCount: 0
-                    }
+                        errorCount: 0,
+                    },
                 });
                 return;
             }
@@ -882,7 +909,9 @@ export class HttpServer {
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to get server status',
+                error: error instanceof Error
+                    ? error.message
+                    : "Failed to get server status",
             });
         }
     }
@@ -893,7 +922,7 @@ export class HttpServer {
     async getServerInfo(req, res) {
         try {
             const { name } = req.params;
-            const forceDiscovery = req.query.forceDiscovery === 'true';
+            const forceDiscovery = req.query.forceDiscovery === "true";
             // Get server configuration from registry
             const serverConfig = this.configLoader.getServer(name);
             if (!serverConfig) {
@@ -923,16 +952,17 @@ export class HttpServer {
             const exposedServers = this.configLoader.getServers();
             const enabled = exposedServers.some((s) => s.name === name);
             // Build response - different fields for stdio vs HTTP servers
-            const isStdio = serverConfig.transport === 'stdio' || serverConfig.transport === undefined;
+            const isStdio = serverConfig.transport === "stdio" ||
+                serverConfig.transport === undefined;
             const baseResponse = {
                 name: serverConfig.name,
-                status: runtimeStatus?.status || 'stopped',
+                status: runtimeStatus?.status || "stopped",
                 enabled,
                 pid: runtimeStatus?.pid,
                 uptime: runtimeStatus?.uptime,
                 lastHealthCheck: runtimeStatus?.lastHealthCheck,
                 errorCount: runtimeStatus?.errorCount,
-                tools: tools.map(t => t.name),
+                tools: tools.map((t) => t.name),
                 toolCount: tools.length,
             };
             const response = isStdio
@@ -953,7 +983,7 @@ export class HttpServer {
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to get server info',
+                error: error instanceof Error ? error.message : "Failed to get server info",
             });
         }
     }
@@ -964,7 +994,7 @@ export class HttpServer {
         try {
             const { name } = req.params;
             const status = this.serverManager.getServerStatus(name);
-            if (!status || status.status !== 'running') {
+            if (!status || status.status !== "running") {
                 res.status(400).json({ error: `Server ${name} is not running` });
                 return;
             }
@@ -974,7 +1004,7 @@ export class HttpServer {
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to get server tools',
+                error: error instanceof Error ? error.message : "Failed to get server tools",
             });
         }
     }
@@ -986,7 +1016,7 @@ export class HttpServer {
             const { name, toolName } = req.params;
             const { arguments: args } = req.body;
             const status = this.serverManager.getServerStatus(name);
-            if (!status || status.status !== 'running') {
+            if (!status || status.status !== "running") {
                 res.status(400).json({ error: `Server ${name} is not running` });
                 return;
             }
@@ -1001,7 +1031,7 @@ export class HttpServer {
         catch (error) {
             const response = {
                 success: false,
-                error: error instanceof Error ? error.message : 'Failed to execute tool',
+                error: error instanceof Error ? error.message : "Failed to execute tool",
             };
             res.status(500).json(response);
         }
@@ -1016,7 +1046,9 @@ export class HttpServer {
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to get configuration',
+                error: error instanceof Error
+                    ? error.message
+                    : "Failed to get configuration",
             });
         }
     }
@@ -1027,8 +1059,10 @@ export class HttpServer {
         try {
             // Extract config updates from request body
             const updates = req.body;
-            if (!updates || typeof updates !== 'object') {
-                res.status(400).json({ error: 'Invalid configuration: expected object' });
+            if (!updates || typeof updates !== "object") {
+                res
+                    .status(400)
+                    .json({ error: "Invalid configuration: expected object" });
                 return;
             }
             // Handle specific config sections that can be updated
@@ -1037,11 +1071,13 @@ export class HttpServer {
             }
             // Reload configuration to pick up any file-based changes
             await this.configLoader.reload();
-            res.json({ success: true, message: 'Configuration updated' });
+            res.json({ success: true, message: "Configuration updated" });
         }
         catch (error) {
             res.status(400).json({
-                error: error instanceof Error ? error.message : 'Failed to update configuration',
+                error: error instanceof Error
+                    ? error.message
+                    : "Failed to update configuration",
             });
         }
     }
@@ -1065,23 +1101,23 @@ export class HttpServer {
                     if (isActive) {
                         const tools = this.serverManager.getServerTools(serverName);
                         baseServerChecks[serverName] = {
-                            status: 'healthy',
-                            tools_count: tools.length
+                            status: "healthy",
+                            tools_count: tools.length,
                         };
                         healthyCount++;
                     }
                     else {
                         baseServerChecks[serverName] = {
-                            status: 'unhealthy',
-                            error: 'Server not running'
+                            status: "unhealthy",
+                            error: "Server not running",
                         };
                         degradedCount++;
                     }
                 }
                 catch (error) {
                     baseServerChecks[serverName] = {
-                        status: 'unhealthy',
-                        error: error instanceof Error ? error.message : 'Unknown error'
+                        status: "unhealthy",
+                        error: error instanceof Error ? error.message : "Unknown error",
                     };
                     degradedCount++;
                 }
@@ -1091,17 +1127,17 @@ export class HttpServer {
             let httpStatusCode;
             if (degradedCount === 0) {
                 // All base servers are healthy
-                overallStatus = 'healthy';
+                overallStatus = "healthy";
                 httpStatusCode = 200;
             }
             else if (healthyCount > 0) {
                 // Some base servers are down but not all
-                overallStatus = 'degraded';
+                overallStatus = "degraded";
                 httpStatusCode = 200; // Still operational
             }
             else {
                 // All base servers are down or critical failure
-                overallStatus = 'unhealthy';
+                overallStatus = "unhealthy";
                 httpStatusCode = 503; // Service Unavailable
             }
             const health = {
@@ -1110,25 +1146,25 @@ export class HttpServer {
                 uptime_seconds: uptimeSeconds,
                 checks: {
                     daemon: {
-                        status: 'healthy'
+                        status: "healthy",
                     },
-                    base_servers: baseServerChecks
-                }
+                    base_servers: baseServerChecks,
+                },
             };
             res.status(httpStatusCode).json(health);
         }
         catch (error) {
             // Critical daemon error
             res.status(503).json({
-                status: 'unhealthy',
+                status: "unhealthy",
                 version,
                 uptime_seconds: Math.floor((Date.now() - this.startTime) / 1000),
                 checks: {
                     daemon: {
-                        status: 'unhealthy',
-                        error: error instanceof Error ? error.message : 'Health check failed'
-                    }
-                }
+                        status: "unhealthy",
+                        error: error instanceof Error ? error.message : "Health check failed",
+                    },
+                },
             });
         }
     }
@@ -1141,7 +1177,7 @@ export class HttpServer {
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to get version',
+                error: error instanceof Error ? error.message : "Failed to get version",
             });
         }
     }
@@ -1161,7 +1197,7 @@ export class HttpServer {
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to get metrics',
+                error: error instanceof Error ? error.message : "Failed to get metrics",
             });
         }
     }
@@ -1170,11 +1206,13 @@ export class HttpServer {
      */
     async getPrometheusMetrics(_req, res) {
         try {
-            res.set('Content-Type', 'text/plain');
+            res.set("Content-Type", "text/plain");
             res.send(globalMetrics.exportPrometheus());
         }
         catch (error) {
-            res.status(500).send(`# Error exporting metrics: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            res
+                .status(500)
+                .send(`# Error exporting metrics: ${error instanceof Error ? error.message : "Unknown error"}`);
         }
     }
     /**
@@ -1186,7 +1224,7 @@ export class HttpServer {
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to get API metrics',
+                error: error instanceof Error ? error.message : "Failed to get API metrics",
             });
         }
     }
@@ -1198,14 +1236,18 @@ export class HttpServer {
             const { name } = req.params;
             const serverMetrics = globalMetrics.getServerMetrics(name);
             if (!serverMetrics) {
-                res.status(404).json({ error: `Server '${name}' not found or no metrics available` });
+                res.status(404).json({
+                    error: `Server '${name}' not found or no metrics available`,
+                });
                 return;
             }
             res.json(serverMetrics);
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to get server metrics',
+                error: error instanceof Error
+                    ? error.message
+                    : "Failed to get server metrics",
             });
         }
     }
@@ -1214,18 +1256,20 @@ export class HttpServer {
      */
     async getHourlyMetrics(req, res) {
         try {
-            const hours = parseInt(req.query.hours || '24');
+            const hours = parseInt(req.query.hours || "24");
             const allMetrics = globalMetrics.getMetrics();
             const hourlyData = this.metricsAggregator.aggregateHourly(allMetrics, hours);
             res.json({
-                period: 'hourly',
+                period: "hourly",
                 hours,
                 data: hourlyData,
             });
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to get hourly metrics',
+                error: error instanceof Error
+                    ? error.message
+                    : "Failed to get hourly metrics",
             });
         }
     }
@@ -1234,18 +1278,20 @@ export class HttpServer {
      */
     async getDailyMetrics(req, res) {
         try {
-            const days = parseInt(req.query.days || '7');
+            const days = parseInt(req.query.days || "7");
             const allMetrics = globalMetrics.getMetrics();
             const dailyData = this.metricsAggregator.aggregateDaily(allMetrics, days);
             res.json({
-                period: 'daily',
+                period: "daily",
                 days,
                 data: dailyData,
             });
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to get daily metrics',
+                error: error instanceof Error
+                    ? error.message
+                    : "Failed to get daily metrics",
             });
         }
     }
@@ -1254,18 +1300,20 @@ export class HttpServer {
      */
     async getWeeklyMetrics(req, res) {
         try {
-            const weeks = parseInt(req.query.weeks || '4');
+            const weeks = parseInt(req.query.weeks || "4");
             const allMetrics = globalMetrics.getMetrics();
             const weeklyData = this.metricsAggregator.aggregateWeekly(allMetrics, weeks);
             res.json({
-                period: 'weekly',
+                period: "weekly",
                 weeks,
                 data: weeklyData,
             });
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to get weekly metrics',
+                error: error instanceof Error
+                    ? error.message
+                    : "Failed to get weekly metrics",
             });
         }
     }
@@ -1279,7 +1327,9 @@ export class HttpServer {
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to get error analytics',
+                error: error instanceof Error
+                    ? error.message
+                    : "Failed to get error analytics",
             });
         }
     }
@@ -1294,7 +1344,7 @@ export class HttpServer {
             const metrics = globalMetrics.getToolErrorMetrics(toolName, serverName);
             if (!metrics) {
                 res.status(404).json({
-                    error: `No metrics found for tool '${toolName}'${serverName ? ` on server '${serverName}'` : ''}`
+                    error: `No metrics found for tool '${toolName}'${serverName ? ` on server '${serverName}'` : ""}`,
                 });
                 return;
             }
@@ -1302,7 +1352,9 @@ export class HttpServer {
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to get tool error metrics',
+                error: error instanceof Error
+                    ? error.message
+                    : "Failed to get tool error metrics",
             });
         }
     }
@@ -1316,12 +1368,16 @@ export class HttpServer {
     async getToolMetrics(req, res) {
         try {
             const { serverName } = req.query;
-            const slow = req.query.slow ? parseInt(req.query.slow, 10) : undefined;
-            const errorsThreshold = req.query.errors ? parseFloat(req.query.errors) : undefined;
+            const slow = req.query.slow
+                ? parseInt(req.query.slow, 10)
+                : undefined;
+            const errorsThreshold = req.query.errors
+                ? parseFloat(req.query.errors)
+                : undefined;
             let metrics = globalMetrics.getAllToolMetrics();
             // Filter by server if requested
             if (serverName) {
-                metrics = metrics.filter(m => m.serverName === serverName);
+                metrics = metrics.filter((m) => m.serverName === serverName);
             }
             // Return slowest tools if requested
             if (slow !== undefined) {
@@ -1338,7 +1394,7 @@ export class HttpServer {
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to get tool metrics',
+                error: error instanceof Error ? error.message : "Failed to get tool metrics",
             });
         }
     }
@@ -1350,15 +1406,15 @@ export class HttpServer {
             const data = await this.metricsPersistence.load();
             if (data) {
                 globalMetrics.restoreMetrics(data);
-                console.log('[MetricsPersistence] Successfully restored metrics from disk');
+                console.log("[MetricsPersistence] Successfully restored metrics from disk");
             }
             else {
-                console.log('[MetricsPersistence] No persisted metrics found, starting fresh');
+                console.log("[MetricsPersistence] No persisted metrics found, starting fresh");
             }
         }
         catch (error) {
-            console.error('[MetricsPersistence] Failed to load metrics:', error);
-            console.log('[MetricsPersistence] Starting with fresh metrics');
+            console.error("[MetricsPersistence] Failed to load metrics:", error);
+            console.log("[MetricsPersistence] Starting with fresh metrics");
         }
     }
     /**
@@ -1369,12 +1425,12 @@ export class HttpServer {
             timestamp: Date.now(),
             metrics: globalMetrics.getMetrics(),
             serverMetrics: globalMetrics.getAllServerMetrics(),
-            toolMetrics: Array.from(globalMetrics['toolMetrics'].values()), // Access private field for persistence
+            toolMetrics: Array.from(globalMetrics["toolMetrics"].values()), // Access private field for persistence
             apiMetrics: globalMetrics.getApiMetrics(),
         });
         // Save every 60 seconds
         this.metricsPersistence.startPeriodicWrites(getMetricsData, 60000);
-        console.log('[MetricsPersistence] Started periodic writes (60s interval)');
+        console.log("[MetricsPersistence] Started periodic writes (60s interval)");
     }
     // ===  Session Management (Streamable HTTP - MCP 2025-03-26) ===
     /**
@@ -1390,7 +1446,7 @@ export class HttpServer {
         events.push({
             id: eventId,
             timestamp: Date.now(),
-            data: eventData
+            data: eventData,
         });
         // Keep only last N events to avoid memory bloat
         if (events.length > this.MAX_EVENTS_PER_SESSION) {
@@ -1406,7 +1462,7 @@ export class HttpServer {
         if (!lastEventId)
             return events;
         // Return all events after lastEventId
-        return events.filter(e => e.id > lastEventId);
+        return events.filter((e) => e.id > lastEventId);
     }
     createSession(clientInfo) {
         const sessionId = randomUUID();
@@ -1417,10 +1473,10 @@ export class HttpServer {
             clientInfo,
             initialized: false,
             lastEventId: 0,
-            protocolVersion: '2025-06-18'
+            protocolVersion: "2025-06-18",
         });
-        const clientName = clientInfo?.name || 'unknown';
-        const clientVersion = clientInfo?.version || 'unknown';
+        const clientName = clientInfo?.name || "unknown";
+        const clientVersion = clientInfo?.version || "unknown";
         console.log(`[MCP] Session created: ${sessionId} | Client: ${clientName}/${clientVersion}`);
         // Persist sessions to disk (v1.1.24+)
         this.persistSessions();
@@ -1497,16 +1553,16 @@ export class HttpServer {
             const data = {
                 version: this.SESSION_PERSIST_VERSION,
                 persistedAt: Date.now(),
-                sessions: sessionsObj
+                sessions: sessionsObj,
             };
             // Atomic write: write to temp file, then rename
             const tempPath = `${this.sessionPersistPath}.tmp`;
-            fs.writeFileSync(tempPath, JSON.stringify(data, null, 2), 'utf8');
+            fs.writeFileSync(tempPath, JSON.stringify(data, null, 2), "utf8");
             fs.renameSync(tempPath, this.sessionPersistPath);
             console.log(`[SessionPersistence] Saved ${this.sessions.size} sessions to disk`);
         }
         catch (error) {
-            console.error('[SessionPersistence] Failed to persist sessions:', error);
+            console.error("[SessionPersistence] Failed to persist sessions:", error);
             // Non-fatal: sessions still work in memory
         }
     }
@@ -1517,10 +1573,10 @@ export class HttpServer {
     loadSessions() {
         try {
             if (!fs.existsSync(this.sessionPersistPath)) {
-                console.log('[SessionPersistence] No persisted sessions found, starting fresh');
+                console.log("[SessionPersistence] No persisted sessions found, starting fresh");
                 return;
             }
-            const content = fs.readFileSync(this.sessionPersistPath, 'utf8');
+            const content = fs.readFileSync(this.sessionPersistPath, "utf8");
             const data = JSON.parse(content);
             // Version check for future migrations
             if (data.version !== this.SESSION_PERSIST_VERSION) {
@@ -1548,12 +1604,12 @@ export class HttpServer {
         }
         catch (error) {
             const errCode = error.code;
-            if (errCode === 'ENOENT') {
-                console.log('[SessionPersistence] No persisted sessions found, starting fresh');
+            if (errCode === "ENOENT") {
+                console.log("[SessionPersistence] No persisted sessions found, starting fresh");
             }
             else {
-                console.error('[SessionPersistence] Failed to load sessions:', error);
-                console.log('[SessionPersistence] Starting with fresh sessions');
+                console.error("[SessionPersistence] Failed to load sessions:", error);
+                console.log("[SessionPersistence] Starting with fresh sessions");
             }
         }
     }
@@ -1563,26 +1619,37 @@ export class HttpServer {
      */
     async handleStreamableRequest(request, req) {
         const { method, params, id } = request;
-        const sessionId = req?.headers['mcp-session-id'];
+        const sessionId = req?.headers["mcp-session-id"];
         // Validate JSON-RPC 2.0 structure
-        if (!request.jsonrpc || request.jsonrpc !== '2.0') {
-            return [{
-                    jsonrpc: '2.0',
+        if (!request.jsonrpc || request.jsonrpc !== "2.0") {
+            return [
+                {
+                    jsonrpc: "2.0",
                     id,
-                    error: { code: -32600, message: 'Invalid Request: jsonrpc field must be "2.0"' }
-                }, sessionId];
+                    error: {
+                        code: -32600,
+                        message: 'Invalid Request: jsonrpc field must be "2.0"',
+                    },
+                },
+                sessionId,
+            ];
         }
         try {
             let result;
             let session;
             let responseSessionId;
             // Handle session-aware methods
-            if (method === 'initialize') {
+            if (method === "initialize") {
                 const initParams = params;
                 // Protocol version negotiation per spec 2025-11-25
                 const requestedVersion = initParams.protocolVersion;
-                const supportedVersions = ['2025-11-25', '2025-06-18', '2025-03-26', '2024-11-05']; // List in order of preference
-                let negotiatedVersion = '2025-11-25'; // Default to latest
+                const supportedVersions = [
+                    "2025-11-25",
+                    "2025-06-18",
+                    "2025-03-26",
+                    "2024-11-05",
+                ]; // List in order of preference
+                let negotiatedVersion = "2025-11-25"; // Default to latest
                 if (requestedVersion) {
                     if (supportedVersions.includes(requestedVersion)) {
                         // Client requested supported version
@@ -1593,8 +1660,9 @@ export class HttpServer {
                         // Client requested unsupported version - offer fallback chain
                         console.log(`[MCP] Unsupported protocol version requested: ${requestedVersion}. Offering fallback to ${negotiatedVersion}`);
                         // Return error with supported versions for client to retry with fallback
-                        return [{
-                                jsonrpc: '2.0',
+                        return [
+                            {
+                                jsonrpc: "2.0",
                                 id,
                                 error: {
                                     code: -32602,
@@ -1602,10 +1670,12 @@ export class HttpServer {
                                     data: {
                                         requested: requestedVersion,
                                         supported: supportedVersions,
-                                        recommended: negotiatedVersion
-                                    }
-                                }
-                            }, undefined];
+                                        recommended: negotiatedVersion,
+                                    },
+                                },
+                            },
+                            undefined,
+                        ];
                     }
                 }
                 // Create or retrieve session
@@ -1623,7 +1693,7 @@ export class HttpServer {
                         clientInfo: initParams.clientInfo,
                         initialized: false,
                         lastEventId: 0,
-                        protocolVersion: '2025-06-18'
+                        protocolVersion: "2025-06-18",
                     });
                     newSessionId = sessionId;
                 }
@@ -1634,7 +1704,7 @@ export class HttpServer {
                 session = this.getSession(newSessionId);
                 session.initialized = true;
                 session.protocolVersion = negotiatedVersion;
-                session.userAgent = req?.headers?.['user-agent'] || 'unknown';
+                session.userAgent = req?.headers?.["user-agent"] || "unknown";
                 session.lastEventId = 0;
                 responseSessionId = newSessionId;
                 // Store client capabilities for per-client feature adaptation
@@ -1643,12 +1713,14 @@ export class HttpServer {
                 }
                 // Extract callback URL from request headers for bidirectional communication (MCP callback protocol)
                 if (req) {
-                    const callbackUrl = req.headers['x-callback-url'];
-                    const callbackPort = req.headers['x-callback-port'];
+                    const callbackUrl = req.headers["x-callback-url"];
+                    const callbackPort = req.headers["x-callback-port"];
                     if (callbackUrl || callbackPort) {
                         const url = callbackUrl || `http://127.0.0.1:${callbackPort}/mcp`;
                         session.callbackUrl = url;
-                        session.callbackPort = callbackPort ? parseInt(callbackPort, 10) : undefined;
+                        session.callbackPort = callbackPort
+                            ? parseInt(callbackPort, 10)
+                            : undefined;
                         console.log(`[MCP] Callback registered: ${url}`);
                     }
                 }
@@ -1658,20 +1730,23 @@ export class HttpServer {
                     capabilities: {
                         tools: { listChanged: true },
                         prompts: { listChanged: false },
-                        resources: { listChanged: false }
+                        resources: { listChanged: false },
                     },
                     serverInfo: {
-                        name: 'metalink',
-                        version
-                    }
+                        name: "metalink",
+                        version,
+                    },
                 };
-                return [{
-                        jsonrpc: '2.0',
+                return [
+                    {
+                        jsonrpc: "2.0",
                         id,
-                        result
-                    }, responseSessionId];
+                        result,
+                    },
+                    responseSessionId,
+                ];
             }
-            else if (method === 'notifications/initialized') {
+            else if (method === "notifications/initialized") {
                 return [null, sessionId]; // No response for notifications
             }
             else {
@@ -1685,99 +1760,114 @@ export class HttpServer {
                         // Per MCP spec, should return HTTP 404, but we can't from this function.
                         // Caller handles HTTP 404 at line ~2067. This is defensive programming only.
                         console.error(`[MCP] Session validation fallback triggered for: ${sessionId.substring(0, 8)}...`);
-                        return [{
-                                jsonrpc: '2.0',
+                        return [
+                            {
+                                jsonrpc: "2.0",
                                 id,
-                                error: { code: -32603, message: 'Invalid or expired session' }
-                            }, sessionId];
+                                error: { code: -32603, message: "Invalid or expired session" },
+                            },
+                            sessionId,
+                        ];
                     }
                 }
                 // Handle other MCP methods
-                if (method === 'ping') {
+                if (method === "ping") {
                     // MCP spec: ping method for keepalive/health checks
                     result = {};
                 }
-                else if (method === 'roots/list') {
+                else if (method === "roots/list") {
                     result = { roots: [] };
                 }
-                else if (method === 'prompts/list') {
+                else if (method === "prompts/list") {
                     result = { prompts: getPromptsList() };
                 }
-                else if (method === 'resources/list') {
+                else if (method === "resources/list") {
                     result = { resources: getResourcesList() };
                 }
-                else if (method === 'resources/templates/list') {
+                else if (method === "resources/templates/list") {
                     result = { resourceTemplates: getResourceTemplatesList() };
                 }
-                else if (method === 'prompts/get') {
+                else if (method === "prompts/get") {
                     const promptParams = params;
                     if (!promptParams.name) {
-                        throw new InvalidParamsError('Missing required parameter: name');
+                        throw new InvalidParamsError("Missing required parameter: name");
                     }
                     try {
                         result = getPrompt(promptParams.name, promptParams.arguments || {});
                     }
                     catch (err) {
-                        throw new InvalidParamsError(err instanceof Error ? err.message : 'Unknown prompt error');
+                        throw new InvalidParamsError(err instanceof Error ? err.message : "Unknown prompt error");
                     }
                 }
-                else if (method === 'resources/read') {
+                else if (method === "resources/read") {
                     const resourceParams = params;
                     if (!resourceParams.uri) {
-                        throw new InvalidParamsError('Missing required parameter: uri');
+                        throw new InvalidParamsError("Missing required parameter: uri");
                     }
                     try {
                         result = await readResource(resourceParams.uri, this.serverManager, this.configLoader);
                     }
                     catch (err) {
-                        throw new InvalidParamsError(err instanceof Error ? err.message : 'Unknown resource error');
+                        throw new InvalidParamsError(err instanceof Error ? err.message : "Unknown resource error");
                     }
                 }
-                else if (method === 'tools/list') {
+                else if (method === "tools/list") {
                     // Auto-reinitialize session if not initialized (transparent to client)
                     // This handles stale sessions from server restarts without client needing to retry
                     if (!session?.initialized) {
-                        const newSessionId = this.createSession({ name: 'auto-reinit', version: '1.0' });
+                        const newSessionId = this.createSession({
+                            name: "auto-reinit",
+                            version: "1.0",
+                        });
                         const newSession = this.getSession(newSessionId);
                         newSession.initialized = true;
-                        newSession.protocolVersion = '2025-06-18';
+                        newSession.protocolVersion = "2025-06-18";
                         responseSessionId = newSessionId;
                         console.log(`[MCP] Auto-reinitialized session for tools/list: ${newSessionId}`);
                     }
                     result = await this.mcpListTools();
                 }
-                else if (method === 'tools/call') {
+                else if (method === "tools/call") {
                     // Auto-reinitialize session if not initialized (transparent to client)
                     // This handles stale sessions from server restarts without client needing to retry
                     let effectiveSessionId = sessionId;
                     if (!session?.initialized) {
-                        const newSessionId = this.createSession({ name: 'auto-reinit', version: '1.0' });
+                        const newSessionId = this.createSession({
+                            name: "auto-reinit",
+                            version: "1.0",
+                        });
                         const newSession = this.getSession(newSessionId);
                         newSession.initialized = true;
-                        newSession.protocolVersion = '2025-06-18';
+                        newSession.protocolVersion = "2025-06-18";
                         responseSessionId = newSessionId;
                         effectiveSessionId = newSessionId;
                         console.log(`[MCP] Auto-reinitialized session for tools/call: ${newSessionId}`);
                     }
                     const callParams = params;
                     if (!callParams.name) {
-                        throw new InvalidParamsError('Missing required parameter: name');
+                        throw new InvalidParamsError("Missing required parameter: name");
                     }
                     result = await this.mcpCallTool(callParams.name, callParams.arguments, effectiveSessionId);
                 }
                 else {
-                    return [{
-                            jsonrpc: '2.0',
+                    return [
+                        {
+                            jsonrpc: "2.0",
                             id,
-                            error: { code: -32601, message: `Unknown method: ${method}` }
-                        }, sessionId];
+                            error: { code: -32601, message: `Unknown method: ${method}` },
+                        },
+                        sessionId,
+                    ];
                 }
             }
-            return [{
-                    jsonrpc: '2.0',
+            return [
+                {
+                    jsonrpc: "2.0",
                     id,
-                    result
-                }, responseSessionId];
+                    result,
+                },
+                responseSessionId,
+            ];
         }
         catch (error) {
             // SessionNotInitializedError must bubble up to trigger HTTP 404
@@ -1787,14 +1877,17 @@ export class HttpServer {
             }
             // Check if this is an invalid parameters error (JSON-RPC -32602)
             const isInvalidParams = error instanceof InvalidParamsError;
-            return [{
-                    jsonrpc: '2.0',
+            return [
+                {
+                    jsonrpc: "2.0",
                     id,
                     error: {
                         code: isInvalidParams ? -32602 : -32603,
-                        message: error instanceof Error ? error.message : 'Internal error'
-                    }
-                }, sessionId];
+                        message: error instanceof Error ? error.message : "Internal error",
+                    },
+                },
+                sessionId,
+            ];
         }
     }
     /**
@@ -1802,8 +1895,8 @@ export class HttpServer {
      */
     async handleMcpRequest(req, res) {
         const requestStartTime = Date.now();
-        const userAgent = req.headers['user-agent'] || 'unknown';
-        const sessionId = req.headers['mcp-session-id'];
+        const userAgent = req.headers["user-agent"] || "unknown";
+        const sessionId = req.headers["mcp-session-id"];
         const requestId = req.requestId || generateRequestId();
         // Create child logger with request context
         const reqLogger = logger.child({
@@ -1813,56 +1906,62 @@ export class HttpServer {
             userAgent,
         });
         // Log incoming MCP request
-        reqLogger.info('MCP request received', {
+        reqLogger.info("MCP request received", {
             path: req.path,
-            protocol: req.headers['mcp-protocol-version'],
+            protocol: req.headers["mcp-protocol-version"],
         });
         try {
             // Handle GET requests per MCP spec 2025-06-18 - SSE streaming for server-sent events
-            if (req.method === 'GET') {
-                const sessionId = req.headers['mcp-session-id'];
+            if (req.method === "GET") {
+                const sessionId = req.headers["mcp-session-id"];
                 // If no session ID, handle health check with JSON response
                 if (!sessionId) {
                     const responseTime = Date.now() - requestStartTime;
-                    reqLogger.info('Health check request', {
+                    reqLogger.info("Health check request", {
                         accept: req.headers.accept,
-                        protocolVersion: req.headers['mcp-protocol-version'],
+                        protocolVersion: req.headers["mcp-protocol-version"],
                     });
                     // Health check - always return JSON regardless of Accept header
-                    res.setHeader('Content-Type', 'application/json');
-                    res.setHeader('MCP-Protocol-Version', MCP_PROTOCOL_VERSION);
-                    res.setHeader('X-Request-Id', requestId);
-                    res.status(200).json({ status: 'ready', protocol: MCP_PROTOCOL_VERSION });
-                    reqLogger.info('Health check response sent', {
+                    res.setHeader("Content-Type", "application/json");
+                    res.setHeader("MCP-Protocol-Version", MCP_PROTOCOL_VERSION);
+                    res.setHeader("X-Request-Id", requestId);
+                    res
+                        .status(200)
+                        .json({ status: "ready", protocol: MCP_PROTOCOL_VERSION });
+                    reqLogger.info("Health check response sent", {
                         status: 200,
                         duration_ms: responseTime,
                     });
                     return;
                 }
                 // Session-based requests - set up SSE streaming with Last-Event-ID resumption support
-                res.setHeader('Content-Type', 'text/event-stream');
-                res.setHeader('Cache-Control', 'no-cache');
-                res.setHeader('Connection', 'keep-alive');
-                res.setHeader('X-Accel-Buffering', 'no');
-                res.setHeader('MCP-Protocol-Version', MCP_PROTOCOL_VERSION);
+                res.setHeader("Content-Type", "text/event-stream");
+                res.setHeader("Cache-Control", "no-cache");
+                res.setHeader("Connection", "keep-alive");
+                res.setHeader("X-Accel-Buffering", "no");
+                res.setHeader("MCP-Protocol-Version", MCP_PROTOCOL_VERSION);
                 const session = this.getSession(sessionId);
                 if (!session?.initialized) {
-                    res.status(404).json({ error: 'Session not found or not initialized' });
+                    res
+                        .status(404)
+                        .json({ error: "Session not found or not initialized" });
                     return;
                 }
-                res.setHeader('Mcp-Session-Id', sessionId);
+                res.setHeader("Mcp-Session-Id", sessionId);
                 // Check for Last-Event-ID header (per MCP 2025-06-18 spec for resumption)
-                const lastEventIdHeader = req.headers['last-event-id'];
-                const lastEventId = lastEventIdHeader ? parseInt(String(lastEventIdHeader), 10) : undefined;
+                const lastEventIdHeader = req.headers["last-event-id"];
+                const lastEventId = lastEventIdHeader
+                    ? parseInt(String(lastEventIdHeader), 10)
+                    : undefined;
                 if (lastEventId !== undefined) {
-                    reqLogger.info('SSE stream resumption requested', {
+                    reqLogger.info("SSE stream resumption requested", {
                         lastEventId,
-                        transport: 'sse',
+                        transport: "sse",
                     });
                 }
                 else {
-                    reqLogger.info('New SSE stream connection', {
-                        transport: 'sse',
+                    reqLogger.info("New SSE stream connection", {
+                        transport: "sse",
                     });
                 }
                 // Track SSE connection for server-sent messages
@@ -1871,9 +1970,9 @@ export class HttpServer {
                 if (lastEventId !== undefined) {
                     const bufferedEvents = this.getEventsForResumption(sessionId, lastEventId);
                     if (bufferedEvents.length > 0) {
-                        reqLogger.debug('Sending buffered events for resumption', {
+                        reqLogger.debug("Sending buffered events for resumption", {
                             eventCount: bufferedEvents.length,
-                            transport: 'sse',
+                            transport: "sse",
                         });
                         for (const event of bufferedEvents) {
                             res.write(`id: ${event.id}\ndata: ${JSON.stringify(event.data)}\n\n`);
@@ -1883,8 +1982,10 @@ export class HttpServer {
                 else {
                     // Send initial endpoint event ONLY on new connection (not on resumption)
                     // Resuming connections should only receive buffered events, not duplicate endpoint events
-                    const endpointEventId = this.trackSseEvent(sessionId, { type: 'endpoint' });
-                    res.write(`id: ${endpointEventId}\ndata: ${JSON.stringify({ type: 'endpoint' })}\n\n`);
+                    const endpointEventId = this.trackSseEvent(sessionId, {
+                        type: "endpoint",
+                    });
+                    res.write(`id: ${endpointEventId}\ndata: ${JSON.stringify({ type: "endpoint" })}\n\n`);
                     // Update session's last event ID
                     if (session) {
                         session.lastEventId = endpointEventId;
@@ -1895,22 +1996,22 @@ export class HttpServer {
                 // This is critical for clients like mcp-remote that rely on async iterators
                 const keepaliveInterval = setInterval(() => {
                     try {
-                        res.write(':keepalive\n\n');
+                        res.write(":keepalive\n\n");
                     }
                     catch (error) {
-                        reqLogger.debug('SSE keepalive write failed', {
-                            error: error instanceof Error ? error.message : 'Unknown error',
-                            transport: 'sse',
+                        reqLogger.debug("SSE keepalive write failed", {
+                            error: error instanceof Error ? error.message : "Unknown error",
+                            transport: "sse",
                         });
                         clearInterval(keepaliveInterval);
                     }
                 }, 15000); // Send keepalive every 15 seconds
                 // Clean up on disconnect
-                req.on('close', () => {
+                req.on("close", () => {
                     clearInterval(keepaliveInterval);
                     this.sseConnections.delete(sessionId);
-                    reqLogger.info('SSE connection closed', {
-                        transport: 'sse',
+                    reqLogger.info("SSE connection closed", {
+                        transport: "sse",
                     });
                 });
                 // Keep connection open for server-sent events
@@ -1922,33 +2023,33 @@ export class HttpServer {
             // Only use SSE if:
             // 1. Client explicitly requests ONLY SSE ("text/event-stream")
             // 2. OR client doesn't offer JSON as an option
-            const acceptHeader = req.headers.accept || 'application/json';
-            const hasJSON = acceptHeader.includes('application/json');
-            const hasSSE = acceptHeader.includes('text/event-stream');
+            const acceptHeader = req.headers.accept || "application/json";
+            const hasJSON = acceptHeader.includes("application/json");
+            const hasSSE = acceptHeader.includes("text/event-stream");
             // Use SSE only if SSE is available AND JSON is NOT preferred
             const useSSE = hasSSE && !hasJSON;
             // Debug: Log all headers to understand mcp-remote communication
-            console.log('[MCP] POST request headers:', {
-                'x-callback-url': req.headers['x-callback-url'],
-                'x-callback-port': req.headers['x-callback-port'],
-                'mcp-session-id': req.headers['mcp-session-id'],
-                'user-agent': req.headers['user-agent'],
-                'content-type': req.headers['content-type'],
-                'accept': req.headers['accept']
+            console.log("[MCP] POST request headers:", {
+                "x-callback-url": req.headers["x-callback-url"],
+                "x-callback-port": req.headers["x-callback-port"],
+                "mcp-session-id": req.headers["mcp-session-id"],
+                "user-agent": req.headers["user-agent"],
+                "content-type": req.headers["content-type"],
+                accept: req.headers["accept"],
             });
             console.log(`[MCP] SSE mode: ${useSSE} (based on Accept header: "${acceptHeader}")`);
             // Parse raw body with robust error handling
-            let text = '';
+            let text = "";
             try {
                 if (!req.body) {
                     // Empty body - valid for some requests
-                    text = '';
+                    text = "";
                 }
-                else if (typeof req.body === 'string') {
+                else if (typeof req.body === "string") {
                     text = req.body;
                 }
                 else if (Buffer.isBuffer(req.body)) {
-                    text = req.body.toString('utf-8');
+                    text = req.body.toString("utf-8");
                 }
                 else {
                     // Unknown body type - try to convert
@@ -1956,20 +2057,20 @@ export class HttpServer {
                 }
             }
             catch (parseError) {
-                console.error('[MCP] Body parsing error:', parseError);
+                console.error("[MCP] Body parsing error:", parseError);
                 res.status(400).json({
-                    jsonrpc: '2.0',
+                    jsonrpc: "2.0",
                     error: {
                         code: -32700,
-                        message: 'Invalid request body'
+                        message: "Invalid request body",
                     },
-                    id: null
+                    id: null,
                 });
                 return;
             }
             if (!text || text.trim().length === 0) {
-                res.setHeader('Content-Type', 'application/json');
-                res.send('');
+                res.setHeader("Content-Type", "application/json");
+                res.send("");
                 return;
             }
             // Parse JSON-RPC requests (support both batch arrays and newline-delimited)
@@ -1993,7 +2094,7 @@ export class HttpServer {
             }
             catch (parseError) {
                 // Fallback to newline-delimited format
-                const lines = text.split('\n').filter((line) => line.trim());
+                const lines = text.split("\n").filter((line) => line.trim());
                 console.log(`[MCP Request] Newline-delimited format with ${lines.length} lines`);
                 for (const line of lines) {
                     try {
@@ -2001,9 +2102,9 @@ export class HttpServer {
                     }
                     catch (lineError) {
                         responses.push({
-                            jsonrpc: '2.0',
-                            error: { code: -32700, message: 'Parse error' },
-                            id: null
+                            jsonrpc: "2.0",
+                            error: { code: -32700, message: "Parse error" },
+                            id: null,
                         });
                     }
                 }
@@ -2013,15 +2114,16 @@ export class HttpServer {
                 console.log(`[MCP Request] Processing ${requests.length} request(s)`);
                 requests.forEach((req, idx) => {
                     const truncatedParams = JSON.stringify(req.params || {}).substring(0, 200);
-                    console.log(`[MCP Request] ${idx + 1}: method="${req.method}" id="${req.id}" params=${truncatedParams}${JSON.stringify(req.params || {}).length > 200 ? '...' : ''}`);
+                    console.log(`[MCP Request] ${idx + 1}: method="${req.method}" id="${req.id}" params=${truncatedParams}${JSON.stringify(req.params || {}).length > 200 ? "..." : ""}`);
                 });
             }
             for (const request of requests) {
                 try {
                     // Detect protocol version and route appropriately
-                    if (request.method === 'initialize') {
-                        const protocolVersion = request.params?.protocolVersion;
-                        if (protocolVersion === '2024-11-05') {
+                    if (request.method === "initialize") {
+                        const protocolVersion = request.params
+                            ?.protocolVersion;
+                        if (protocolVersion === "2024-11-05") {
                             // Legacy protocol path
                             const response = await this.handleJsonRpcRequest(request);
                             if (response)
@@ -2039,19 +2141,22 @@ export class HttpServer {
                     }
                     else {
                         // For non-initialize requests, detect by session presence in header
-                        const headerSessionId = req.headers['mcp-session-id'];
+                        const headerSessionId = req.headers["mcp-session-id"];
                         if (headerSessionId) {
                             // Session ID provided - check if it exists
                             if (!this.getSession(headerSessionId)) {
                                 // Session doesn't exist - auto-create and initialize (transparent recovery)
                                 // This handles stale sessions from server restarts without client needing to reinitialize
-                                const newSessionId = this.createSession({ name: 'auto-reinit', version: '1.0' });
+                                const newSessionId = this.createSession({
+                                    name: "auto-reinit",
+                                    version: "1.0",
+                                });
                                 const newSession = this.getSession(newSessionId);
                                 newSession.initialized = true;
-                                newSession.protocolVersion = '2025-06-18';
+                                newSession.protocolVersion = "2025-06-18";
                                 console.log(`[MCP] Auto-reinitialized stale session ${headerSessionId.substring(0, 8)}... → ${newSessionId.substring(0, 8)}...`);
                                 // Update header for downstream processing (hacky but works)
-                                req.headers['mcp-session-id'] = newSessionId;
+                                req.headers["mcp-session-id"] = newSessionId;
                             }
                             // Has valid session (original or auto-created) → use Streamable HTTP
                             const [response, sId] = await this.handleStreamableRequest(request, req);
@@ -2071,9 +2176,9 @@ export class HttpServer {
                 }
                 catch (parseError) {
                     responses.push({
-                        jsonrpc: '2.0',
-                        error: { code: -32700, message: 'Parse error' },
-                        id: null
+                        jsonrpc: "2.0",
+                        error: { code: -32700, message: "Parse error" },
+                        id: null,
                     });
                 }
             }
@@ -2088,17 +2193,19 @@ export class HttpServer {
             // Callback port is independent - it's for fallback/bidirectional, not transport selection
             const shouldUseSSE = useSSE;
             // Check if session has callback URL registered
-            const session = lastSessionId ? this.getSession(lastSessionId) : undefined;
+            const session = lastSessionId
+                ? this.getSession(lastSessionId)
+                : undefined;
             const hasCallback = session?.callbackUrl !== undefined;
             const responseTime = Date.now() - requestStartTime;
             if (shouldUseSSE) {
                 // Server-Sent Events format
                 console.log(`[MCP] Sending ${responses.length} response(s) in SSE format`);
-                res.setHeader('Content-Type', 'text/event-stream');
-                res.setHeader('Cache-Control', 'no-cache');
-                res.setHeader('Connection', 'keep-alive');
-                res.setHeader('X-Accel-Buffering', 'no');
-                res.setHeader('MCP-Protocol-Version', MCP_PROTOCOL_VERSION);
+                res.setHeader("Content-Type", "text/event-stream");
+                res.setHeader("Cache-Control", "no-cache");
+                res.setHeader("Connection", "keep-alive");
+                res.setHeader("X-Accel-Buffering", "no");
+                res.setHeader("MCP-Protocol-Version", MCP_PROTOCOL_VERSION);
                 for (const response of responses) {
                     const dataStr = `data: ${JSON.stringify(response)}\n\n`;
                     console.log(`[MCP] Writing SSE data: ${dataStr.substring(0, 100)}...`);
@@ -2110,22 +2217,22 @@ export class HttpServer {
                 console.log(`[MCP Response] ${new Date().toISOString()} | SSE | Responses: ${responses.length} | Time: ${responseTime}ms | User-Agent: ${userAgent}`);
                 responses.forEach((resp, idx) => {
                     const truncated = JSON.stringify(resp).substring(0, 300);
-                    console.log(`[MCP Response] SSE ${idx + 1}: ${truncated}${JSON.stringify(resp).length > 300 ? '...' : ''}`);
+                    console.log(`[MCP Response] SSE ${idx + 1}: ${truncated}${JSON.stringify(resp).length > 300 ? "..." : ""}`);
                 });
             }
             else {
                 // Standard JSON (array for batch, newline-delimited for multiple single requests)
-                reqLogger.debug('Sending JSON response', {
+                reqLogger.debug("Sending JSON response", {
                     responseCount: responses.length,
                     batch: isBatchRequest,
-                    transport: 'json',
+                    transport: "json",
                 });
-                res.setHeader('Content-Type', 'application/json');
-                res.setHeader('MCP-Protocol-Version', MCP_PROTOCOL_VERSION);
-                res.setHeader('X-Request-Id', requestId);
+                res.setHeader("Content-Type", "application/json");
+                res.setHeader("MCP-Protocol-Version", MCP_PROTOCOL_VERSION);
+                res.setHeader("X-Request-Id", requestId);
                 // Set Mcp-Session-Id header if session exists
                 if (lastSessionId) {
-                    res.setHeader('Mcp-Session-Id', lastSessionId);
+                    res.setHeader("Mcp-Session-Id", lastSessionId);
                 }
                 let responseText;
                 if (isBatchRequest) {
@@ -2134,14 +2241,14 @@ export class HttpServer {
                 }
                 else {
                     // Newline-delimited format (backward compatibility)
-                    responseText = responses.map(r => JSON.stringify(r)).join('\n');
+                    responseText = responses.map((r) => JSON.stringify(r)).join("\n");
                 }
                 res.write(responseText);
                 res.end();
-                reqLogger.info('MCP response sent', {
+                reqLogger.info("MCP response sent", {
                     responseCount: responses.length,
                     duration_ms: responseTime,
-                    transport: 'json',
+                    transport: "json",
                     batch: isBatchRequest,
                 });
             }
@@ -2151,23 +2258,25 @@ export class HttpServer {
             // SessionNotInitializedError returns HTTP 404 per MCP spec
             // This triggers client auto-reinitialize handlers
             if (error instanceof SessionNotInitializedError) {
-                reqLogger.info('Session not initialized - returning HTTP 404 for client auto-reinitialize', {
+                reqLogger.info("Session not initialized - returning HTTP 404 for client auto-reinitialize", {
                     error: error.message,
                     duration_ms: responseTime,
                 });
-                res.setHeader('MCP-Protocol-Version', MCP_PROTOCOL_VERSION);
-                res.setHeader('X-Request-Id', requestId);
+                res.setHeader("MCP-Protocol-Version", MCP_PROTOCOL_VERSION);
+                res.setHeader("X-Request-Id", requestId);
                 res.status(404).json({ error: error.message });
                 return;
             }
-            reqLogger.error('MCP request failed', {
-                error: error instanceof Error ? error.message : 'Internal error',
+            reqLogger.error("MCP request failed", {
+                error: error instanceof Error ? error.message : "Internal error",
                 stack: error instanceof Error ? error.stack : undefined,
                 duration_ms: responseTime,
             });
-            res.setHeader('MCP-Protocol-Version', MCP_PROTOCOL_VERSION);
-            res.setHeader('X-Request-Id', requestId);
-            res.status(500).json({ error: error instanceof Error ? error.message : 'Internal error' });
+            res.setHeader("MCP-Protocol-Version", MCP_PROTOCOL_VERSION);
+            res.setHeader("X-Request-Id", requestId);
+            res.status(500).json({
+                error: error instanceof Error ? error.message : "Internal error",
+            });
         }
     }
     /**
@@ -2176,80 +2285,83 @@ export class HttpServer {
     async handleJsonRpcRequest(request) {
         const { method, params, id } = request;
         // Validate JSON-RPC 2.0 structure
-        if (!request.jsonrpc || request.jsonrpc !== '2.0') {
+        if (!request.jsonrpc || request.jsonrpc !== "2.0") {
             return {
-                jsonrpc: '2.0',
+                jsonrpc: "2.0",
                 id,
-                error: { code: -32600, message: 'Invalid Request: jsonrpc field must be "2.0"' }
+                error: {
+                    code: -32600,
+                    message: 'Invalid Request: jsonrpc field must be "2.0"',
+                },
             };
         }
         try {
             let result;
             // Handle MCP methods
-            if (method === 'notifications/initialized') {
+            if (method === "notifications/initialized") {
                 return null; // No response for notifications
             }
-            if (method === 'initialize') {
+            if (method === "initialize") {
                 result = {
-                    protocolVersion: '2024-11-05',
+                    protocolVersion: "2024-11-05",
                     capabilities: {
                         tools: { listChanged: true },
                         prompts: { listChanged: false },
                         resources: { listChanged: false },
                     },
                     serverInfo: {
-                        name: 'metalink',
+                        name: "metalink",
                         version,
                     },
                 };
             }
-            else if (method === 'ping') {
+            else if (method === "ping") {
                 // MCP spec: ping method for keepalive/health checks
                 result = {};
             }
-            else if (method === 'roots/list') {
+            else if (method === "roots/list") {
                 result = { roots: [] };
             }
-            else if (method === 'prompts/list') {
+            else if (method === "prompts/list") {
                 result = { prompts: getPromptsList() };
             }
-            else if (method === 'resources/list') {
+            else if (method === "resources/list") {
                 result = { resources: getResourcesList() };
             }
-            else if (method === 'resources/templates/list') {
+            else if (method === "resources/templates/list") {
                 result = { resourceTemplates: getResourceTemplatesList() };
             }
-            else if (method === 'prompts/get') {
+            else if (method === "prompts/get") {
                 const promptParams = params;
                 if (!promptParams.name) {
-                    throw new InvalidParamsError('Missing required parameter: name');
+                    throw new InvalidParamsError("Missing required parameter: name");
                 }
                 try {
                     result = getPrompt(promptParams.name, promptParams.arguments || {});
                 }
                 catch (err) {
-                    throw new InvalidParamsError(err instanceof Error ? err.message : 'Unknown prompt error');
+                    throw new InvalidParamsError(err instanceof Error ? err.message : "Unknown prompt error");
                 }
             }
-            else if (method === 'resources/read') {
+            else if (method === "resources/read") {
                 const resourceParams = params;
                 if (!resourceParams.uri) {
-                    throw new InvalidParamsError('Missing required parameter: uri');
+                    throw new InvalidParamsError("Missing required parameter: uri");
                 }
                 try {
                     result = await readResource(resourceParams.uri, this.serverManager, this.configLoader);
                 }
                 catch (err) {
-                    throw new InvalidParamsError(err instanceof Error ? err.message : 'Unknown resource error');
+                    throw new InvalidParamsError(err instanceof Error ? err.message : "Unknown resource error");
                 }
             }
-            else if (method === 'tools/list') {
+            else if (method === "tools/list") {
                 result = await this.mcpListTools();
             }
-            else if (method === 'tools/call') {
+            else if (method === "tools/call") {
                 const callParams = params;
                 if (!callParams.name) {
-                    throw new InvalidParamsError('Missing required parameter: name');
+                    throw new InvalidParamsError("Missing required parameter: name");
                 }
                 result = await this.mcpCallTool(callParams.name, callParams.arguments);
             }
@@ -2257,7 +2369,7 @@ export class HttpServer {
                 throw new MethodNotFoundError(method);
             }
             return {
-                jsonrpc: '2.0',
+                jsonrpc: "2.0",
                 id,
                 result,
             };
@@ -2276,11 +2388,11 @@ export class HttpServer {
                 errorCode = -32602; // Invalid params
             }
             return {
-                jsonrpc: '2.0',
+                jsonrpc: "2.0",
                 id,
                 error: {
                     code: errorCode,
-                    message: error instanceof Error ? error.message : 'Internal error',
+                    message: error instanceof Error ? error.message : "Internal error",
                 },
             };
         }
@@ -2334,124 +2446,130 @@ export class HttpServer {
          * Legacy mode: Set dynamicToolExposure=true to expose all base server tools
          */
         tools.push({
-            name: 'search_tools',
+            name: "search_tools",
             description: 'Search tools by keyword across all available servers, or list all tools from a specific server. Can also search by server name to find all tools from matching servers. When exactly 1 tool matches, automatically includes full schema (inputSchema, requiredParams, example) to save a describe_tool call. Each result includes annotations.safety ("safe" or "risky") - use execute_tool for safe, execute_tool_confirm for risky.',
             inputSchema: {
-                type: 'object',
+                type: "object",
                 properties: {
                     query: {
-                        type: 'string',
-                        description: 'Optional keyword to search for in server names, tool names, and descriptions. If query matches a server name, returns all tools from that server.',
+                        type: "string",
+                        description: "Optional keyword to search for in server names, tool names, and descriptions. If query matches a server name, returns all tools from that server.",
                     },
                     server_name: {
-                        type: 'string',
-                        description: 'Optional server name to filter results. If provided, only returns tools from this specific server.',
+                        type: "string",
+                        description: "Optional server name to filter results. If provided, only returns tools from this specific server.",
                     },
                 },
                 required: [],
             },
         }, {
-            name: 'describe_tool',
-            description: 'Get detailed schema for a specific tool including validation hints. Returns inputSchema, requiredParams, and optional validation warnings/suggestions when schema is incomplete or incorrect.',
+            name: "describe_tool",
+            description: "Get detailed schema for a specific tool including validation hints. Returns inputSchema, requiredParams, and optional validation warnings/suggestions when schema is incomplete or incorrect.",
             inputSchema: {
-                type: 'object',
+                type: "object",
                 properties: {
                     server_name: {
-                        type: 'string',
+                        type: "string",
                         description: 'Server name (e.g., "memory", "jira-basic-auth")',
                     },
                     tool_name: {
-                        type: 'string',
+                        type: "string",
                         description: 'Tool name (e.g., "create_entities", "search_issues")',
                     },
                 },
-                required: ['server_name', 'tool_name'],
+                required: ["server_name", "tool_name"],
             },
         }, {
-            name: 'execute_tool',
+            name: "execute_tool",
             description: this.getExecuteToolDescription(),
             inputSchema: {
-                type: 'object',
+                type: "object",
                 properties: {
                     server_name: {
-                        type: 'string',
+                        type: "string",
                         description: 'Server name (e.g., "jira-basic-auth", "memory")',
-                        example: 'jira-basic-auth'
+                        example: "jira-basic-auth",
                     },
                     tool_name: {
-                        type: 'string',
+                        type: "string",
                         description: 'Tool name (e.g., "confluence_search", "create_entities")',
-                        example: 'confluence_search'
+                        example: "confluence_search",
                     },
                     arguments: {
-                        type: 'object',
-                        description: 'Tool-specific parameters. Call describe_tool(server_name, tool_name) first to discover required parameters, then nest those parameters here.',
+                        type: "object",
+                        description: "Tool-specific parameters. Call describe_tool(server_name, tool_name) first to discover required parameters, then nest those parameters here.",
                         example: {
-                            cql: 'type=page ORDER BY created DESC',
-                            limit: 10
+                            cql: "type=page ORDER BY created DESC",
+                            limit: 10,
                         },
-                        additionalProperties: true
+                        additionalProperties: true,
                     },
                     max_results: {
-                        type: 'number',
-                        description: 'Optional: Limit array results to N items (for pagination)',
-                        example: 50
+                        type: "number",
+                        description: "Optional: Limit array results to N items (for pagination)",
+                        example: 50,
                     },
                     max_result_chars: {
-                        type: 'number',
-                        description: 'Optional: Limit total response size to N characters (default: 50000)',
-                        example: 10000
+                        type: "number",
+                        description: "Optional: Limit total response size to N characters (default: 50000)",
+                        example: 10000,
                     },
                     cursor: {
-                        type: 'string',
-                        description: 'Optional: Opaque cursor from previous response to continue pagination'
-                    }
+                        type: "string",
+                        description: "Optional: Opaque cursor from previous response to continue pagination",
+                    },
                 },
-                required: ['server_name', 'tool_name', 'arguments'],
-                additionalProperties: false
-            }
+                required: ["server_name", "tool_name", "arguments"],
+                additionalProperties: false,
+            },
         }, {
-            name: 'execute_tool_confirm',
+            name: "execute_tool_confirm",
             description: 'Execute risky tool (requires user confirmation). IMPORTANT: Check annotations.safety in search_tools results - only use this for "risky" tools, use execute_tool for "safe" tools. Safety annotation is authoritative. Required for external services without explicit safe rules.',
             inputSchema: {
-                type: 'object',
+                type: "object",
                 properties: {
                     server_name: {
-                        type: 'string',
+                        type: "string",
                         description: 'Server name (e.g., "jira-basic-auth", "memory")',
-                        example: 'memory'
+                        example: "memory",
                     },
                     tool_name: {
-                        type: 'string',
+                        type: "string",
                         description: 'Tool name (e.g., "create_issue", "delete_entities")',
-                        example: 'create_entities'
+                        example: "create_entities",
                     },
                     arguments: {
-                        type: 'object',
-                        description: 'Tool arguments object. REQUIRED. All tool-specific parameters MUST be nested inside this object, not at the top level.',
+                        type: "object",
+                        description: "Tool arguments object. REQUIRED. All tool-specific parameters MUST be nested inside this object, not at the top level.",
                         example: {
-                            entities: [{ name: 'test', entityType: 'concept', observations: ['example data'] }]
+                            entities: [
+                                {
+                                    name: "test",
+                                    entityType: "concept",
+                                    observations: ["example data"],
+                                },
+                            ],
                         },
-                        additionalProperties: true
+                        additionalProperties: true,
                     },
                     max_results: {
-                        type: 'number',
-                        description: 'Optional: Limit array results to N items (for pagination)',
-                        example: 50
+                        type: "number",
+                        description: "Optional: Limit array results to N items (for pagination)",
+                        example: 50,
                     },
                     max_result_chars: {
-                        type: 'number',
-                        description: 'Optional: Limit total response size to N characters (default: 50000)',
-                        example: 10000
+                        type: "number",
+                        description: "Optional: Limit total response size to N characters (default: 50000)",
+                        example: 10000,
                     },
                     cursor: {
-                        type: 'string',
-                        description: 'Optional: Opaque cursor from previous response to continue pagination'
-                    }
+                        type: "string",
+                        description: "Optional: Opaque cursor from previous response to continue pagination",
+                    },
                 },
-                required: ['server_name', 'tool_name', 'arguments'],
-                additionalProperties: false
-            }
+                required: ["server_name", "tool_name", "arguments"],
+                additionalProperties: false,
+            },
         });
         // OPTIONAL: Base server tools - controlled by config options (v1.3.57+)
         // Three modes:
@@ -2471,7 +2589,10 @@ export class HttpServer {
                         tools.push({
                             name: `${serverName}-${tool.name}`,
                             description: tool.description || `Tool from ${serverName} server`,
-                            inputSchema: tool.inputSchema || { type: 'object', properties: {} },
+                            inputSchema: tool.inputSchema || {
+                                type: "object",
+                                properties: {},
+                            },
                         });
                     }
                 }
@@ -2500,7 +2621,7 @@ export class HttpServer {
     async mcpCallTool(name, args, sessionId) {
         // Track metrics for tool call (Phase 4 - v1.4.0)
         const startTime = Date.now();
-        globalMetrics.incrementCounter(`tool_calls_${name}`, 'calls');
+        globalMetrics.incrementCounter(`tool_calls_${name}`, "calls");
         // SECURITY: Extract server name for rate limiting
         // For meta-tools (execute_tool, search_tools), extract from args
         // For direct calls (server-tool), extract from name
@@ -2508,7 +2629,7 @@ export class HttpServer {
         // Record tool call for error rate tracking
         globalMetrics.recordToolCall(name, serverName || undefined);
         // Log tool call with structured context
-        logger.info('Tool call initiated', {
+        logger.info("Tool call initiated", {
             tool: name,
             server: serverName || undefined,
             sessionId,
@@ -2519,21 +2640,21 @@ export class HttpServer {
         }
         // SECURITY: Discovery endpoint rate limiting (P1)
         // search_tools and describe_tool have separate rate limits per session
-        if (name === 'search_tools' || name === 'describe_tool') {
-            const rateLimitKey = sessionId || 'anonymous';
+        if (name === "search_tools" || name === "describe_tool") {
+            const rateLimitKey = sessionId || "anonymous";
             this.checkDiscoveryRateLimit(rateLimitKey);
         }
         try {
             const result = await this.executeToolCall(name, args);
             // Record successful execution metrics
             const latency = Date.now() - startTime;
-            globalMetrics.setGauge(`tool_latency_${name}`, latency, 'ms');
+            globalMetrics.setGauge(`tool_latency_${name}`, latency, "ms");
             // Record granular tool-specific metrics (Test 187)
             if (serverName) {
-                globalMetrics.recordToolExecution(serverName, name.replace(`${serverName}-`, ''), latency);
+                globalMetrics.recordToolExecution(serverName, name.replace(`${serverName}-`, ""), latency);
             }
             // Log successful tool execution
-            logger.info('Tool call completed', {
+            logger.info("Tool call completed", {
                 tool: name,
                 server: serverName || undefined,
                 duration_ms: latency,
@@ -2542,16 +2663,16 @@ export class HttpServer {
         }
         catch (error) {
             // Record error metrics with detailed tracking
-            globalMetrics.incrementCounter(`tool_errors_${name}`, 'errors');
+            globalMetrics.incrementCounter(`tool_errors_${name}`, "errors");
             globalMetrics.recordToolError(error, name, serverName || undefined);
             // Record granular tool-specific error (Test 187)
             if (serverName) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
-                globalMetrics.recordToolFailure(serverName, name.replace(`${serverName}-`, ''), errorMessage);
+                globalMetrics.recordToolFailure(serverName, name.replace(`${serverName}-`, ""), errorMessage);
             }
             // Log tool execution error
             const latency = Date.now() - startTime;
-            logger.error('Tool call failed', {
+            logger.error("Tool call failed", {
                 tool: name,
                 server: serverName || undefined,
                 error: error instanceof Error ? error.message : String(error),
@@ -2569,18 +2690,22 @@ export class HttpServer {
      */
     extractServerNameForRateLimit(name, args) {
         // Meta-tools with explicit server_name argument
-        if (name === 'execute_tool' || name === 'execute_tool_confirm' ||
-            name === 'describe_tool' || name === 'list_tools') {
+        if (name === "execute_tool" ||
+            name === "execute_tool_confirm" ||
+            name === "describe_tool" ||
+            name === "list_tools") {
             const callArgs = args;
             return callArgs?.server_name || null;
         }
         // Discovery tools - no server-specific rate limiting
-        if (name === 'search_tools' || name === 'list_available_servers' || name === 'list_servers') {
+        if (name === "search_tools" ||
+            name === "list_available_servers" ||
+            name === "list_servers") {
             return null;
         }
         // Direct tool calls: "server-toolName" format
-        if (name.includes('-')) {
-            const parts = name.split('-');
+        if (name.includes("-")) {
+            const parts = name.split("-");
             return parts[0];
         }
         return null;
@@ -2611,7 +2736,7 @@ export class HttpServer {
             const waitTime = Math.ceil((limiter.resetTime - now) / 1000);
             console.warn(`[SECURITY] Rate limit exceeded for server '${serverName}': ` +
                 `${limiter.count} calls in window, max ${this.TOOL_RATE_LIMIT_MAX_CALLS}`);
-            globalMetrics.incrementCounter(`rate_limit_exceeded_${serverName}`, 'rate_limits');
+            globalMetrics.incrementCounter(`rate_limit_exceeded_${serverName}`, "rate_limits");
             throw new Error(`Rate limit exceeded for server '${serverName}'. ` +
                 `Maximum ${this.TOOL_RATE_LIMIT_MAX_CALLS} tool calls per minute. ` +
                 `Please wait ${waitTime} seconds before retrying.`);
@@ -2643,7 +2768,7 @@ export class HttpServer {
             const waitTime = Math.ceil((limiter.resetTime - now) / 1000);
             console.warn(`[SECURITY] Discovery rate limit exceeded for session '${sessionId}': ` +
                 `${limiter.count} calls in window, max ${this.DISCOVERY_RATE_LIMIT_MAX_CALLS}`);
-            globalMetrics.incrementCounter('discovery_rate_limit_exceeded', 'rate_limits');
+            globalMetrics.incrementCounter("discovery_rate_limit_exceeded", "rate_limits");
             throw new Error(`Discovery rate limit exceeded. ` +
                 `Maximum ${this.DISCOVERY_RATE_LIMIT_MAX_CALLS} discovery calls per minute. ` +
                 `Please wait ${waitTime} seconds before retrying.`);
@@ -2656,68 +2781,73 @@ export class HttpServer {
     async executeToolCall(name, args) {
         const callArgs = args;
         switch (name) {
-            case 'list_available_servers': {
+            case "list_available_servers": {
                 const allServers = this.configLoader.getAllServers();
                 const enabledServers = this.configLoader.getServers();
-                const enabledNames = new Set(enabledServers.map(s => s.name));
+                const enabledNames = new Set(enabledServers.map((s) => s.name));
                 return {
                     content: [
                         {
-                            type: 'text',
+                            type: "text",
                             text: JSON.stringify({
-                                servers: allServers.map(s => {
-                                    const isStdio = s.transport === 'stdio' || s.transport === undefined;
+                                servers: allServers.map((s) => {
+                                    const isStdio = s.transport === "stdio" || s.transport === undefined;
                                     return {
                                         name: s.name,
-                                        ...(isStdio ? { command: s.command } : { url: s.url }),
+                                        ...(isStdio
+                                            ? { command: s.command }
+                                            : { url: s.url }),
                                         enabled: enabledNames.has(s.name),
                                     };
                                 }),
-                            }, null, 2)
-                        }
-                    ]
+                            }, null, 2),
+                        },
+                    ],
                 };
             }
-            case 'list_servers': {
+            case "list_servers": {
                 const servers = this.configLoader.getServers();
                 return {
                     content: [
                         {
-                            type: 'text',
+                            type: "text",
                             text: JSON.stringify({
-                                servers: servers.map(s => {
-                                    const isStdio = s.transport === 'stdio' || s.transport === undefined;
+                                servers: servers.map((s) => {
+                                    const isStdio = s.transport === "stdio" || s.transport === undefined;
                                     return {
                                         name: s.name,
-                                        ...(isStdio ? { command: s.command } : { url: s.url }),
-                                        status: this.serverManager.getServerStatus(s.name)?.status || 'stopped',
+                                        ...(isStdio
+                                            ? { command: s.command }
+                                            : { url: s.url }),
+                                        status: this.serverManager.getServerStatus(s.name)?.status ||
+                                            "stopped",
                                         toolCount: this.serverManager.getServerTools(s.name).length || 0,
                                     };
                                 }),
-                            }, null, 2)
-                        }
-                    ]
+                            }, null, 2),
+                        },
+                    ],
                 };
             }
-            case 'list_tools': {
+            case "list_tools": {
                 const serverName = callArgs?.server_name;
                 if (!serverName)
-                    throw new InvalidParamsError('server_name required');
+                    throw new InvalidParamsError("server_name required");
                 // Get tools from server manager
                 const tools = this.serverManager.getServerTools(serverName);
                 return {
                     content: [
                         {
-                            type: 'text',
+                            type: "text",
                             text: JSON.stringify({
                                 server: serverName,
                                 tools: tools || [],
-                            }, null, 2)
-                        }
-                    ]
+                            }, null, 2),
+                        },
+                    ],
                 };
             }
-            case 'execute_tool': {
+            case "execute_tool": {
                 const args = callArgs;
                 // DEBUG: Log raw incoming args to diagnose Raycast/Grok issues
                 console.log(`[DEBUG execute_tool] RAW INCOMING ARGS: ${JSON.stringify(args)}`);
@@ -2732,7 +2862,7 @@ export class HttpServer {
                 const toolArgs = fixedArgs.arguments || {};
                 // SAFETY CHECK: Verify this tool is classified as 'safe' (with argument inspection)
                 const safetyResult = this.serverManager.classifyToolSafety(serverName, toolName, toolArgs);
-                if (safetyResult.safety === 'risky') {
+                if (safetyResult.safety === "risky") {
                     throw new InvalidParamsError(`Tool ${serverName}:${toolName} is classified as RISKY and requires user confirmation.\n` +
                         `Use 'execute_tool_confirm' instead for this tool.\n` +
                         `Classification reason: ${safetyResult.reason}`);
@@ -2746,7 +2876,7 @@ export class HttpServer {
                 const missingArgs = this.serverManager.detectMissingArguments(fixedArgs, toolSchema);
                 if (missingArgs) {
                     const inputSchema = toolSchema.inputSchema;
-                    const requiredParams = inputSchema?.required?.join(', ') || 'unknown';
+                    const requiredParams = inputSchema?.required?.join(", ") || "unknown";
                     const errorMsg = `❌ Missing required parameters for ${serverName}:${toolName}\n` +
                         `\n` +
                         `Required: ${requiredParams}\n` +
@@ -2762,7 +2892,7 @@ export class HttpServer {
                 const inputSchema2 = toolSchema.inputSchema;
                 const requiredParams2 = inputSchema2?.required || [];
                 // Check if required params are missing from arguments
-                const missingRequiredParams = requiredParams2.filter(param => !(param in args2));
+                const missingRequiredParams = requiredParams2.filter((param) => !(param in args2));
                 if (missingRequiredParams.length > 0) {
                     // Generate example values for each required param
                     const exampleArgs = {};
@@ -2772,9 +2902,9 @@ export class HttpServer {
                             exampleArgs[param] = propSchema.example;
                         else if (propSchema?.default)
                             exampleArgs[param] = propSchema.default;
-                        else if (propSchema?.type === 'string')
+                        else if (propSchema?.type === "string")
                             exampleArgs[param] = `<${param}>`;
-                        else if (propSchema?.type === 'number')
+                        else if (propSchema?.type === "number")
                             exampleArgs[param] = 10;
                         else
                             exampleArgs[param] = `<${param}>`;
@@ -2782,7 +2912,7 @@ export class HttpServer {
                     const errorMsg = `❌ Missing required parameters for ${serverName}:${toolName}\n` +
                         `\n` +
                         `You provided: ${JSON.stringify(args2)}\n` +
-                        `Missing: ${missingRequiredParams.join(', ')}\n` +
+                        `Missing: ${missingRequiredParams.join(", ")}\n` +
                         `\n` +
                         `✅ CORRECT FORMAT:\n` +
                         `  {"server_name": "${serverName}", "tool_name": "${toolName}", "arguments": ${JSON.stringify(exampleArgs)}}\n` +
@@ -2803,24 +2933,28 @@ export class HttpServer {
                     const paginationParams = {
                         max_results: fixedArgs.max_results,
                         max_result_chars: fixedArgs.max_result_chars,
-                        cursor: fixedArgs.cursor
+                        cursor: fixedArgs.cursor,
                     };
                     // Only paginate if at least one pagination param is provided
-                    if (paginationParams.max_results || paginationParams.max_result_chars || paginationParams.cursor) {
+                    if (paginationParams.max_results ||
+                        paginationParams.max_result_chars ||
+                        paginationParams.cursor) {
                         const paginated = this.paginateResult(result, paginationParams);
                         // Return result with pagination metadata merged in
-                        if (typeof result === 'object' && result !== null && !Array.isArray(result)) {
+                        if (typeof result === "object" &&
+                            result !== null &&
+                            !Array.isArray(result)) {
                             return {
                                 ...result,
                                 result: paginated.result,
-                                _pagination: paginated._pagination
+                                _pagination: paginated._pagination,
                             };
                         }
                         else {
                             // If result is not an object (e.g., primitive or array), wrap it
                             return {
                                 result: paginated.result,
-                                _pagination: paginated._pagination
+                                _pagination: paginated._pagination,
                             };
                         }
                     }
@@ -2832,14 +2966,16 @@ export class HttpServer {
                     const inputSchema = toolSchema.inputSchema;
                     // Check if error is parameter-related
                     const errorStr = (toolError instanceof Error ? toolError.message : String(toolError)).toLowerCase();
-                    const isParamError = errorStr.includes('null') || errorStr.includes('undefined') ||
-                        errorStr.includes('required') || errorStr.includes('missing');
+                    const isParamError = errorStr.includes("null") ||
+                        errorStr.includes("undefined") ||
+                        errorStr.includes("required") ||
+                        errorStr.includes("missing");
                     if (isParamError && inputSchema) {
                         const requiredParams = inputSchema.required || [];
                         const availableParams = Object.keys(inputSchema.properties || {});
-                        const optionalParams = availableParams.filter(p => !requiredParams.includes(p));
-                        const requiredList = requiredParams.length > 0 ? requiredParams.join(', ') : 'none';
-                        const optionalList = optionalParams.length > 0 ? optionalParams.join(', ') : 'none';
+                        const optionalParams = availableParams.filter((p) => !requiredParams.includes(p));
+                        const requiredList = requiredParams.length > 0 ? requiredParams.join(", ") : "none";
+                        const optionalList = optionalParams.length > 0 ? optionalParams.join(", ") : "none";
                         const hint = `\n\n💡 Hint: This tool expects:\n` +
                             `  Required: ${requiredList}\n` +
                             `  Optional: ${optionalList}\n` +
@@ -2849,7 +2985,7 @@ export class HttpServer {
                     throw new Error(errorMsg);
                 }
             }
-            case 'execute_tool_confirm': {
+            case "execute_tool_confirm": {
                 const args = callArgs;
                 // Phase 2a: Detect and fix Raycast format issues
                 const fixedArgs = this.serverManager.detectAndFixRaycastFormat(args);
@@ -2872,7 +3008,7 @@ export class HttpServer {
                 const missingArgs = this.serverManager.detectMissingArguments(fixedArgs, toolSchema);
                 if (missingArgs) {
                     const inputSchema = toolSchema.inputSchema;
-                    const requiredParams = inputSchema?.required?.join(', ') || 'unknown';
+                    const requiredParams = inputSchema?.required?.join(", ") || "unknown";
                     const errorMsg = `❌ Missing required parameters for ${serverName}:${toolName}\n` +
                         `\n` +
                         `Required: ${requiredParams}\n` +
@@ -2898,24 +3034,28 @@ export class HttpServer {
                     const paginationParams = {
                         max_results: fixedArgs.max_results,
                         max_result_chars: fixedArgs.max_result_chars,
-                        cursor: fixedArgs.cursor
+                        cursor: fixedArgs.cursor,
                     };
                     // Only paginate if at least one pagination param is provided
-                    if (paginationParams.max_results || paginationParams.max_result_chars || paginationParams.cursor) {
+                    if (paginationParams.max_results ||
+                        paginationParams.max_result_chars ||
+                        paginationParams.cursor) {
                         const paginated = this.paginateResult(result, paginationParams);
                         // Return result with pagination metadata merged in
-                        if (typeof result === 'object' && result !== null && !Array.isArray(result)) {
+                        if (typeof result === "object" &&
+                            result !== null &&
+                            !Array.isArray(result)) {
                             return {
                                 ...result,
                                 result: paginated.result,
-                                _pagination: paginated._pagination
+                                _pagination: paginated._pagination,
                             };
                         }
                         else {
                             // If result is not an object (e.g., primitive or array), wrap it
                             return {
                                 result: paginated.result,
-                                _pagination: paginated._pagination
+                                _pagination: paginated._pagination,
                             };
                         }
                     }
@@ -2927,14 +3067,16 @@ export class HttpServer {
                     const inputSchema = toolSchema.inputSchema;
                     // Check if error is parameter-related
                     const errorStr = (toolError instanceof Error ? toolError.message : String(toolError)).toLowerCase();
-                    const isParamError = errorStr.includes('null') || errorStr.includes('undefined') ||
-                        errorStr.includes('required') || errorStr.includes('missing');
+                    const isParamError = errorStr.includes("null") ||
+                        errorStr.includes("undefined") ||
+                        errorStr.includes("required") ||
+                        errorStr.includes("missing");
                     if (isParamError && inputSchema) {
                         const requiredParams = inputSchema.required || [];
                         const availableParams = Object.keys(inputSchema.properties || {});
-                        const optionalParams = availableParams.filter(p => !requiredParams.includes(p));
-                        const requiredList = requiredParams.length > 0 ? requiredParams.join(', ') : 'none';
-                        const optionalList = optionalParams.length > 0 ? optionalParams.join(', ') : 'none';
+                        const optionalParams = availableParams.filter((p) => !requiredParams.includes(p));
+                        const requiredList = requiredParams.length > 0 ? requiredParams.join(", ") : "none";
+                        const optionalList = optionalParams.length > 0 ? optionalParams.join(", ") : "none";
                         const hint = `\n\n💡 Hint: This tool expects:\n` +
                             `  Required: ${requiredList}\n` +
                             `  Optional: ${optionalList}\n` +
@@ -2947,18 +3089,18 @@ export class HttpServer {
             // ===== 4-TOOL SPEAKEASY APPROACH (v1.3.52) =====
             // Discovery tools: search_tools, describe_tool
             // Execution tools: execute_tool, execute_tool_confirm
-            case 'search_tools': {
+            case "search_tools": {
                 // FIX v1.3.52: Search ALL servers using CACHED schemas (no auto-start)
                 // UPDATE v1.3.56: Support optional server_name filter and server name matching
                 // - query (optional): Search term for server names, tool names, and descriptions
                 // - server_name (optional): Filter to specific server
                 // - At least one parameter required
                 try {
-                    const query = callArgs?.query || '';
-                    const serverNameFilter = callArgs?.server_name || '';
+                    const query = callArgs?.query || "";
+                    const serverNameFilter = callArgs?.server_name || "";
                     // Validate: at least one parameter provided
                     if (!query && !serverNameFilter) {
-                        throw new InvalidParamsError('At least one parameter required: query or server_name');
+                        throw new InvalidParamsError("At least one parameter required: query or server_name");
                     }
                     const results = [];
                     // Get all servers or filter to specific server
@@ -2971,12 +3113,16 @@ export class HttpServer {
                         throw new InvalidParamsError(`Server '${serverNameFilter}' not found in registry`);
                     }
                     // Multi-keyword matching: split query into individual words
-                    const keywords = query.toLowerCase().split(/\s+/).filter(k => k.length > 0);
+                    const keywords = query
+                        .toLowerCase()
+                        .split(/\s+/)
+                        .filter((k) => k.length > 0);
                     // Step 1: Check if any keyword matches a server name
                     let serverKeyword;
                     if (keywords.length > 0 && !serverNameFilter) {
                         for (const keyword of keywords) {
-                            const matchedServer = allServers.find((s) => s.name.toLowerCase().includes(keyword) || keyword.includes(s.name.toLowerCase()));
+                            const matchedServer = allServers.find((s) => s.name.toLowerCase().includes(keyword) ||
+                                keyword.includes(s.name.toLowerCase()));
                             if (matchedServer) {
                                 serverKeyword = keyword;
                                 serversToSearch = [matchedServer];
@@ -2986,47 +3132,47 @@ export class HttpServer {
                     }
                     // Step 2: Get remaining keywords (exclude server name keyword)
                     const searchKeywords = serverKeyword
-                        ? keywords.filter(k => k !== serverKeyword)
+                        ? keywords.filter((k) => k !== serverKeyword)
                         : keywords;
                     for (const serverConfig of serversToSearch) {
                         const serverName = serverConfig.name.toLowerCase();
                         const tools = this.serverManager.getServerTools(serverConfig.name);
                         for (const tool of tools) {
                             const toolName = tool.name.toLowerCase();
-                            const toolDesc = (tool.description || '').toLowerCase();
+                            const toolDesc = (tool.description || "").toLowerCase();
                             // Determine match type
-                            let matchType = 'all';
+                            let matchType = "all";
                             let shouldInclude = false;
                             if (keywords.length === 0) {
                                 // No query, just listing all tools from filtered server
-                                matchType = 'all';
+                                matchType = "all";
                                 shouldInclude = true;
                             }
                             else if (serverKeyword && searchKeywords.length === 0) {
                                 // Only server name in query - return ALL tools from this server
-                                matchType = 'server';
+                                matchType = "server";
                                 shouldInclude = true;
                             }
                             else if (searchKeywords.length > 0) {
                                 // Multi-keyword matching: check if ANY keyword matches tool name or description
-                                const nameMatches = searchKeywords.some(keyword => toolName.includes(keyword));
-                                const descMatches = searchKeywords.some(keyword => toolDesc.includes(keyword));
+                                const nameMatches = searchKeywords.some((keyword) => toolName.includes(keyword));
+                                const descMatches = searchKeywords.some((keyword) => toolDesc.includes(keyword));
                                 if (nameMatches && descMatches) {
-                                    matchType = 'all';
+                                    matchType = "all";
                                     shouldInclude = true;
                                 }
                                 else if (nameMatches) {
-                                    matchType = 'name';
+                                    matchType = "name";
                                     shouldInclude = true;
                                 }
                                 else if (descMatches) {
-                                    matchType = 'description';
+                                    matchType = "description";
                                     shouldInclude = true;
                                 }
                                 else if (serverKeyword) {
                                     // Server matched but no tool/description keywords matched
                                     // Still include if we're filtering by server (be permissive)
-                                    matchType = 'server';
+                                    matchType = "server";
                                     shouldInclude = true;
                                 }
                             }
@@ -3037,7 +3183,7 @@ export class HttpServer {
                                 const requiredArray = inputSchema?.required;
                                 const allParams = properties ? Object.keys(properties) : [];
                                 const requiredParams = requiredArray || [];
-                                const optionalParams = allParams.filter(p => !requiredParams.includes(p));
+                                const optionalParams = allParams.filter((p) => !requiredParams.includes(p));
                                 // Generate example arguments from inputSchema
                                 const exampleArgs = {};
                                 if (properties) {
@@ -3050,34 +3196,38 @@ export class HttpServer {
                                         else if (prop.default !== undefined) {
                                             exampleArgs[key] = prop.default;
                                         }
-                                        else if (prop.type === 'string') {
+                                        else if (prop.type === "string") {
                                             // Generate meaningful examples for common param names
-                                            if (key === 'query')
-                                                exampleArgs[key] = 'search term';
-                                            else if (key === 'cql')
-                                                exampleArgs[key] = 'type=page ORDER BY created DESC';
-                                            else if (key === 'jql')
-                                                exampleArgs[key] = 'project = PROJ ORDER BY created DESC';
-                                            else if (key === 'timezone')
-                                                exampleArgs[key] = 'UTC';
-                                            else if (key === 'url')
-                                                exampleArgs[key] = 'https://example.com';
+                                            if (key === "query")
+                                                exampleArgs[key] = "search term";
+                                            else if (key === "cql")
+                                                exampleArgs[key] = "type=page ORDER BY created DESC";
+                                            else if (key === "jql")
+                                                exampleArgs[key] =
+                                                    "project = PROJ ORDER BY created DESC";
+                                            else if (key === "timezone")
+                                                exampleArgs[key] = "UTC";
+                                            else if (key === "url")
+                                                exampleArgs[key] = "https://example.com";
                                             else
                                                 exampleArgs[key] = `<${key}>`;
                                         }
-                                        else if (prop.type === 'number' || prop.type === 'integer') {
-                                            if (key === 'limit' || key === 'max_results' || key === 'maxResults')
+                                        else if (prop.type === "number" ||
+                                            prop.type === "integer") {
+                                            if (key === "limit" ||
+                                                key === "max_results" ||
+                                                key === "maxResults")
                                                 exampleArgs[key] = 10;
                                             else
                                                 exampleArgs[key] = 1;
                                         }
-                                        else if (prop.type === 'boolean') {
+                                        else if (prop.type === "boolean") {
                                             exampleArgs[key] = true;
                                         }
-                                        else if (prop.type === 'array') {
+                                        else if (prop.type === "array") {
                                             exampleArgs[key] = [];
                                         }
-                                        else if (prop.type === 'object') {
+                                        else if (prop.type === "object") {
                                             exampleArgs[key] = {};
                                         }
                                     }
@@ -3094,7 +3244,7 @@ export class HttpServer {
                                     safetyAnnotation = {
                                         safety: classification.safety,
                                         safetyReason: classification.reason,
-                                        requiresConfirmation: classification.safety === 'risky',
+                                        requiresConfirmation: classification.safety === "risky",
                                     };
                                 }
                                 // v1.3.x: Check for argument inspection rules
@@ -3103,15 +3253,15 @@ export class HttpServer {
                                 const fullToolName = `${serverConfig.name}:${tool.name}`;
                                 const argInspectionRule = argInspectionRules.find((rule) => rule.tool === fullToolName);
                                 let toolNote = "Use describe_tool to get full schema before execution";
-                                if (argInspectionRule && safetyAnnotation.safety === 'risky') {
+                                if (argInspectionRule && safetyAnnotation.safety === "risky") {
                                     // Add argument inspection hint for risky tools with auto-approval patterns
                                     safetyAnnotation.argumentInspection = {
                                         enabled: true,
                                         field: argInspectionRule.argumentField,
                                         safePatterns: argInspectionRule.safeCommandPatterns || [],
-                                        note: `Auto-approved when ${argInspectionRule.argumentField} matches safe patterns (e.g., ${(argInspectionRule.safeCommandPatterns || []).slice(0, 3).join(', ')})`
+                                        note: `Auto-approved when ${argInspectionRule.argumentField} matches safe patterns (e.g., ${(argInspectionRule.safeCommandPatterns || []).slice(0, 3).join(", ")})`,
                                     };
-                                    toolNote = `Risky by default, but AUTO-APPROVED for read-only operations. Check ${argInspectionRule.argumentField} - patterns like ${(argInspectionRule.safeCommandPatterns || []).slice(0, 3).join(', ')} are safe.`;
+                                    toolNote = `Risky by default, but AUTO-APPROVED for read-only operations. Check ${argInspectionRule.argumentField} - patterns like ${(argInspectionRule.safeCommandPatterns || []).slice(0, 3).join(", ")} are safe.`;
                                 }
                                 results.push({
                                     server: serverConfig.name,
@@ -3122,14 +3272,16 @@ export class HttpServer {
                                     matchType,
                                     // v1.3.x: Top-level safety fields for easier access
                                     safety: safetyAnnotation.safety,
-                                    execute_with: safetyAnnotation.safety === 'safe' ? 'execute_tool' : 'execute_tool_confirm',
+                                    execute_with: safetyAnnotation.safety === "safe"
+                                        ? "execute_tool"
+                                        : "execute_tool_confirm",
                                     annotations: safetyAnnotation,
                                     _schema: {
                                         inputSchema,
                                         requiredParams,
                                         optionalParams,
-                                        exampleArgs
-                                    }
+                                        exampleArgs,
+                                    },
                                 });
                             }
                         }
@@ -3147,12 +3299,16 @@ export class HttpServer {
                             result.example = {
                                 server_name: result.server,
                                 tool_name: result.tool,
-                                arguments: schema.exampleArgs
+                                arguments: schema.exampleArgs,
                             };
                             // Anthropic Advanced Tool Use: Include tool use examples if available
                             // https://www.anthropic.com/engineering/advanced-tool-use
-                            const tool = this.serverManager.getServerTools(result.server).find(t => t.name === result.tool);
-                            if (tool?.inputExamples && Array.isArray(tool.inputExamples) && tool.inputExamples.length > 0) {
+                            const tool = this.serverManager
+                                .getServerTools(result.server)
+                                .find((t) => t.name === result.tool);
+                            if (tool?.inputExamples &&
+                                Array.isArray(tool.inputExamples) &&
+                                tool.inputExamples.length > 0) {
                                 result.inputExamples = tool.inputExamples;
                             }
                             // Remove the note since we're providing full schema
@@ -3164,7 +3320,7 @@ export class HttpServer {
                     else {
                         // Include inputSchema in all results for Raycast compatibility
                         // v1.1.67: Always include inputSchema even when not auto-describing
-                        results.forEach(r => {
+                        results.forEach((r) => {
                             if (r._schema) {
                                 r.inputSchema = r._schema.inputSchema;
                                 r.requiredParams = r._schema.requiredParams;
@@ -3176,30 +3332,30 @@ export class HttpServer {
                     return {
                         content: [
                             {
-                                type: 'text',
+                                type: "text",
                                 text: JSON.stringify({
                                     query: query || undefined,
                                     server_name: serverNameFilter || undefined,
                                     count: results.length,
                                     autoDescribed,
-                                    tools: results.slice(0, 50)
-                                }, null, 2)
-                            }
-                        ]
+                                    tools: results.slice(0, 50),
+                                }, null, 2),
+                            },
+                        ],
                     };
                 }
                 catch (error) {
                     throw new Error(`Failed to search tools: ${error instanceof Error ? error.message : String(error)}`);
                 }
             }
-            case 'describe_tool': {
+            case "describe_tool": {
                 try {
                     const serverName = callArgs?.server_name;
                     const toolName = callArgs?.tool_name;
                     // RAYCAST DEBUG: Log what client is requesting
                     console.log(`[describe_tool] REQUEST: server="${serverName}" tool="${toolName}"`);
                     if (!serverName || !toolName) {
-                        throw new InvalidParamsError('server_name and tool_name are required');
+                        throw new InvalidParamsError("server_name and tool_name are required");
                     }
                     // Get server config
                     const allServers = this.configLoader.getAllServers();
@@ -3209,15 +3365,15 @@ export class HttpServer {
                     }
                     // Discover tools from the server
                     const toolSchemas = await this.serverManager.discoverToolSchemas(serverName, serverConfig);
-                    const toolSchema = toolSchemas.find(t => t.name === toolName);
+                    const toolSchema = toolSchemas.find((t) => t.name === toolName);
                     if (!toolSchema) {
-                        const availableTools = toolSchemas.map(t => t.name).join(', ');
+                        const availableTools = toolSchemas.map((t) => t.name).join(", ");
                         throw new Error(`Tool '${toolName}' not found in server '${serverName}'.\n` +
                             `Available tools: ${availableTools}\n` +
                             `Use search_tools with a keyword to find tools across all servers.`);
                     }
                     // v1.4.0: Validate schema and collect hints
-                    const { SchemaValidator } = await import('./schema-validator.js');
+                    const { SchemaValidator } = await import("./schema-validator.js");
                     const validator = new SchemaValidator();
                     const validationResult = validator.validateToolSchema(toolSchema);
                     // Generate example arguments from inputSchema
@@ -3235,44 +3391,46 @@ export class HttpServer {
                             else if (prop.default !== undefined) {
                                 exampleArgs[key] = prop.default;
                             }
-                            else if (prop.type === 'string') {
-                                exampleArgs[key] = prop.description ? `<${key}>` : 'example';
+                            else if (prop.type === "string") {
+                                exampleArgs[key] = prop.description ? `<${key}>` : "example";
                             }
-                            else if (prop.type === 'number') {
+                            else if (prop.type === "number") {
                                 exampleArgs[key] = 10;
                             }
-                            else if (prop.type === 'boolean') {
+                            else if (prop.type === "boolean") {
                                 exampleArgs[key] = true;
                             }
-                            else if (prop.type === 'array') {
+                            else if (prop.type === "array") {
                                 exampleArgs[key] = [];
                             }
-                            else if (prop.type === 'object') {
+                            else if (prop.type === "object") {
                                 exampleArgs[key] = {};
                             }
                         }
                     }
                     // Calculate optional params (all params not in required array)
                     const allParams = properties ? Object.keys(properties) : [];
-                    const optionalParams = allParams.filter(p => !(requiredArray || []).includes(p));
+                    const optionalParams = allParams.filter((p) => !(requiredArray || []).includes(p));
                     // Build tool object matching search_tools auto-describe format for Raycast compatibility
                     const toolObj = {
                         server: serverName,
                         tool: toolName,
                         name: `${serverName}-${toolName}`,
-                        description: toolSchema.description || '',
+                        description: toolSchema.description || "",
                         inputSchema: toolSchema.inputSchema || {},
                         requiredParams: requiredArray || [],
                         optionalParams: optionalParams,
                         example: {
                             server_name: serverName,
                             tool_name: toolName,
-                            arguments: exampleArgs
-                        }
+                            arguments: exampleArgs,
+                        },
                     };
                     // Anthropic Advanced Tool Use: Include tool use examples if available
                     // https://www.anthropic.com/engineering/advanced-tool-use
-                    if (toolSchema.inputExamples && Array.isArray(toolSchema.inputExamples) && toolSchema.inputExamples.length > 0) {
+                    if (toolSchema.inputExamples &&
+                        Array.isArray(toolSchema.inputExamples) &&
+                        toolSchema.inputExamples.length > 0) {
                         toolObj.inputExamples = toolSchema.inputExamples;
                     }
                     // Phase 2: Include safety annotations if available
@@ -3284,17 +3442,38 @@ export class HttpServer {
                         server: serverName,
                         tools: [toolObj],
                         count: 1,
-                        detailLevel: 'full' // Always full for describe_tool
+                        detailLevel: "full", // Always full for describe_tool
                     };
                     // RAYCAST DEBUG: Log what schema is returned
                     console.log(`[describe_tool] RESPONSE: ${serverName}:${toolName} - requiredParams=${JSON.stringify(requiredArray || [])} - hasInputSchema=${!!toolSchema.inputSchema}`);
+                    // Check if TOON format is enabled
+                    const toonConfig = this.configLoader.getConfig()?.toon;
+                    const useToon = toonConfig?.enabled &&
+                        (toonConfig?.format === "toon" ||
+                            (toonConfig?.format === "auto" && this.isLLMClient()));
+                    let responseText;
+                    if (useToon) {
+                        // Format as TOON (Token-Optimized Object Notation)
+                        const toonOptions = {
+                            includeDescriptions: toonConfig?.includeDescriptions ?? true,
+                            includeTypes: toonConfig?.includeTypes ?? true,
+                            includeExamples: toonConfig?.includeExamples ?? true,
+                            maxDescriptionLength: toonConfig?.maxDescriptionLength ?? 100,
+                        };
+                        responseText = formatDescribeToolResponse(serverName, toolSchema, toonOptions);
+                        console.log(`[describe_tool] Using TOON format (~${toonConfig?.format === "toon" ? "50%" : "auto-detected"} token savings)`);
+                    }
+                    else {
+                        // Default JSON format
+                        responseText = JSON.stringify(responseObj, null, 2);
+                    }
                     return {
                         content: [
                             {
-                                type: 'text',
-                                text: JSON.stringify(responseObj, null, 2)
-                            }
-                        ]
+                                type: "text",
+                                text: responseText,
+                            },
+                        ],
                     };
                 }
                 catch (error) {
@@ -3530,8 +3709,8 @@ export class HttpServer {
             default: {
                 // Handle base server tools in format "server-toolName"
                 // Support hyphenated server names like "duckduckgo-mcp"
-                if (name.includes('-')) {
-                    const lastHyphenIndex = name.lastIndexOf('-');
+                if (name.includes("-")) {
+                    const lastHyphenIndex = name.lastIndexOf("-");
                     if (lastHyphenIndex === -1) {
                         throw new InvalidParamsError(`Invalid tool name format: ${name}`);
                     }
@@ -3569,30 +3748,32 @@ export class HttpServer {
                         const args2 = args || {};
                         console.log(`[MetaLink] direct tool call: ${name} with args ${JSON.stringify(args2)}`);
                         // Phase 3: Special handling for memory-search_nodes - use fallback directly
-                        if (serverName === 'memory' && toolName === 'search_nodes') {
+                        if (serverName === "memory" && toolName === "search_nodes") {
                             console.log(`[MetaLink] Intercepting memory-search_nodes - using read_graph with client-side filtering`);
                             try {
-                                const graphResult = await this.serverManager.callTool('memory', 'read_graph', {});
-                                const query = (args2.query || '').toLowerCase();
+                                const graphResult = await this.serverManager.callTool("memory", "read_graph", {});
+                                const query = (args2.query || "").toLowerCase();
                                 // Parse the nested response
-                                if (graphResult && typeof graphResult === 'object') {
+                                if (graphResult && typeof graphResult === "object") {
                                     const resultObj = graphResult;
                                     if (resultObj.content && Array.isArray(resultObj.content)) {
                                         const textContent = resultObj.content[0]?.text;
                                         if (textContent) {
                                             const graphData = JSON.parse(textContent);
                                             // Filter entities by query
-                                            const filteredEntities = graphData.entities?.filter((e) => query === '' ||
+                                            const filteredEntities = graphData.entities?.filter((e) => query === "" ||
                                                 e.name.toLowerCase().includes(query) ||
                                                 e.observations?.some((obs) => obs.toLowerCase().includes(query))) || [];
                                             return {
-                                                content: [{
-                                                        type: 'text',
+                                                content: [
+                                                    {
+                                                        type: "text",
                                                         text: JSON.stringify({
                                                             entities: filteredEntities,
-                                                            relations: graphData.relations || []
-                                                        }, null, 2)
-                                                    }]
+                                                            relations: graphData.relations || [],
+                                                        }, null, 2),
+                                                    },
+                                                ],
                                             };
                                         }
                                     }
@@ -3612,17 +3793,25 @@ export class HttpServer {
                             // Enhanced error with inputSchema for debugging
                             const errorMsg = `Tool execution failed for ${name}: ${toolError instanceof Error ? toolError.message : String(toolError)}`;
                             // Check if error is parameter-related
-                            const errorStr = (toolError instanceof Error ? toolError.message : String(toolError)).toLowerCase();
-                            const isParamError = errorStr.includes('null') || errorStr.includes('undefined') ||
-                                errorStr.includes('required') || errorStr.includes('missing');
+                            const errorStr = (toolError instanceof Error
+                                ? toolError.message
+                                : String(toolError)).toLowerCase();
+                            const isParamError = errorStr.includes("null") ||
+                                errorStr.includes("undefined") ||
+                                errorStr.includes("required") ||
+                                errorStr.includes("missing");
                             if (isParamError && toolSchema) {
                                 const inputSchema = toolSchema.inputSchema;
                                 if (inputSchema) {
                                     const requiredParams = inputSchema.required || [];
                                     const availableParams = Object.keys(inputSchema.properties || {});
-                                    const optionalParams = availableParams.filter(p => !requiredParams.includes(p));
-                                    const requiredList = requiredParams.length > 0 ? requiredParams.join(', ') : 'none';
-                                    const optionalList = optionalParams.length > 0 ? optionalParams.join(', ') : 'none';
+                                    const optionalParams = availableParams.filter((p) => !requiredParams.includes(p));
+                                    const requiredList = requiredParams.length > 0
+                                        ? requiredParams.join(", ")
+                                        : "none";
+                                    const optionalList = optionalParams.length > 0
+                                        ? optionalParams.join(", ")
+                                        : "none";
                                     const hint = `\n\n💡 Hint: This tool expects:\n` +
                                         `  Required: ${requiredList}\n` +
                                         `  Optional: ${optionalList}\n` +
@@ -3656,7 +3845,7 @@ export class HttpServer {
                 await this.serverManager.ensureServerStarted(server.name, server);
                 const tools = this.serverManager.getServerTools(server.name);
                 discoveredToolCount = tools.length;
-                console.log(`[AddServer] Discovered ${discoveredToolCount} tools for '${server.name}': ${tools.map(t => t.name).join(', ')}`);
+                console.log(`[AddServer] Discovered ${discoveredToolCount} tools for '${server.name}': ${tools.map((t) => t.name).join(", ")}`);
             }
             catch (discoveryError) {
                 console.warn(`[AddServer] Tool discovery failed for '${server.name}' (non-fatal):`, discoveryError);
@@ -3664,7 +3853,7 @@ export class HttpServer {
             }
             // Broadcast server:added event
             this.broadcastEvent({
-                type: 'server:added',
+                type: "server:added",
                 data: {
                     server,
                     timestamp: Date.now(),
@@ -3678,7 +3867,7 @@ export class HttpServer {
             });
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : 'Failed to add server';
+            const message = error instanceof Error ? error.message : "Failed to add server";
             res.status(400).json({
                 error: message,
             });
@@ -3700,9 +3889,9 @@ export class HttpServer {
             }
             // Check if server is running and require force if so
             const status = this.serverManager.getServerStatus(name);
-            if (status?.status === 'running') {
+            if (status?.status === "running") {
                 // Check for force flag in query params
-                const force = req.query.force === 'true';
+                const force = req.query.force === "true";
                 if (!force) {
                     res.status(409).json({
                         error: `Server '${name}' is currently running. Use ?force=true to remove it anyway.`,
@@ -3722,7 +3911,7 @@ export class HttpServer {
             await this.configLoader.removeServerFromRegistry(name, { timeout: 5000 });
             // Broadcast server:removed event
             this.broadcastEvent({
-                type: 'server:removed',
+                type: "server:removed",
                 data: {
                     name,
                     timestamp: Date.now(),
@@ -3734,7 +3923,7 @@ export class HttpServer {
             });
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : 'Failed to remove server';
+            const message = error instanceof Error ? error.message : "Failed to remove server";
             res.status(400).json({
                 error: message,
             });
@@ -3745,7 +3934,7 @@ export class HttpServer {
      */
     async validateServer(req, res) {
         try {
-            const { RegistryManager } = await import('../config/registry.js');
+            const { RegistryManager } = await import("../config/registry.js");
             const registry = new RegistryManager();
             // Validate configuration
             const validation = await registry.validateServer(req.body, {
@@ -3754,7 +3943,7 @@ export class HttpServer {
             if (validation.valid) {
                 res.json({
                     valid: true,
-                    message: 'Server configuration is valid',
+                    message: "Server configuration is valid",
                 });
             }
             else {
@@ -3765,7 +3954,7 @@ export class HttpServer {
             }
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : 'Validation error';
+            const message = error instanceof Error ? error.message : "Validation error";
             res.status(400).json({
                 error: message,
             });
@@ -3786,7 +3975,7 @@ export class HttpServer {
                 // NOTE: Intentionally NOT resolving - keeps event loop alive for background mode
             });
             // Handle server errors
-            this.server.on('error', (err) => {
+            this.server.on("error", (err) => {
                 reject(err);
             });
         });
@@ -3808,14 +3997,15 @@ export class HttpServer {
     }
     notifyToolsListChanged() {
         const now = Date.now();
-        if (now - this.lastToolsListNotification < this.TOOLS_LIST_NOTIFICATION_THROTTLE_MS) {
-            console.log('[MCP] Throttling tools/list_changed notification');
+        if (now - this.lastToolsListNotification <
+            this.TOOLS_LIST_NOTIFICATION_THROTTLE_MS) {
+            console.log("[MCP] Throttling tools/list_changed notification");
             return;
         }
         this.lastToolsListNotification = now;
         const notification = {
-            jsonrpc: '2.0',
-            method: 'notifications/tools/list_changed'
+            jsonrpc: "2.0",
+            method: "notifications/tools/list_changed",
         };
         let sentCount = 0;
         for (const [sessionId, conn] of this.sseConnections) {
@@ -3846,14 +4036,14 @@ export class HttpServer {
             console.log(`[CALLBACK] Posting response to ${session.callbackUrl}`);
             // POST response to callback URL
             const callbackResponse = await fetch(session.callbackUrl, {
-                method: 'POST',
+                method: "POST",
                 headers: {
-                    'Content-Type': 'application/json',
-                    'Mcp-Session-Id': session.id,
-                    'MCP-Protocol-Version': MCP_PROTOCOL_VERSION
+                    "Content-Type": "application/json",
+                    "Mcp-Session-Id": session.id,
+                    "MCP-Protocol-Version": MCP_PROTOCOL_VERSION,
                 },
                 body: JSON.stringify(response),
-                signal: AbortSignal.timeout(10000) // 10 second timeout
+                signal: AbortSignal.timeout(10000), // 10 second timeout
             });
             if (!callbackResponse.ok) {
                 console.warn(`[CALLBACK] Warning: callback returned ${callbackResponse.status}`);
@@ -3873,7 +4063,7 @@ export class HttpServer {
      */
     async getSafetyRules(req, res) {
         try {
-            const includePatterns = req.query.include_patterns === 'true';
+            const includePatterns = req.query.include_patterns === "true";
             const rules = this.configLoader.getToolSafetyRules();
             const response = {
                 safeToolOverrides: rules.safeToolOverrides || [],
@@ -3889,7 +4079,7 @@ export class HttpServer {
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to get safety rules',
+                error: error instanceof Error ? error.message : "Failed to get safety rules",
             });
         }
     }
@@ -3901,7 +4091,7 @@ export class HttpServer {
             const { server, tool } = req.params;
             if (!server || !tool) {
                 res.status(400).json({
-                    error: 'Missing required parameters: server and tool',
+                    error: "Missing required parameters: server and tool",
                 });
                 return;
             }
@@ -3912,12 +4102,14 @@ export class HttpServer {
                 fullName: `${server}:${tool}`,
                 safety: result.safety,
                 reason: result.reason,
-                requiresConfirmation: result.safety === 'risky',
+                requiresConfirmation: result.safety === "risky",
             });
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to check tool safety',
+                error: error instanceof Error
+                    ? error.message
+                    : "Failed to check tool safety",
             });
         }
     }
@@ -3927,9 +4119,9 @@ export class HttpServer {
     async addSafeToolOverride(req, res) {
         try {
             const { tool, reason } = req.body;
-            if (!tool || typeof tool !== 'string') {
+            if (!tool || typeof tool !== "string") {
                 res.status(400).json({
-                    error: 'Missing or invalid required parameter: tool (string)',
+                    error: "Missing or invalid required parameter: tool (string)",
                 });
                 return;
             }
@@ -3937,7 +4129,7 @@ export class HttpServer {
             const toolPattern = /^[a-zA-Z0-9_-]+:[a-zA-Z0-9_*-]+$/;
             if (!toolPattern.test(tool)) {
                 res.status(400).json({
-                    error: 'Invalid tool format. Expected: server:tool or server:*',
+                    error: "Invalid tool format. Expected: server:tool or server:*",
                 });
                 return;
             }
@@ -3951,7 +4143,9 @@ export class HttpServer {
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to add safe tool override',
+                error: error instanceof Error
+                    ? error.message
+                    : "Failed to add safe tool override",
             });
         }
     }
@@ -3961,9 +4155,9 @@ export class HttpServer {
     async addRiskyToolOverride(req, res) {
         try {
             const { tool, reason } = req.body;
-            if (!tool || typeof tool !== 'string') {
+            if (!tool || typeof tool !== "string") {
                 res.status(400).json({
-                    error: 'Missing or invalid required parameter: tool (string)',
+                    error: "Missing or invalid required parameter: tool (string)",
                 });
                 return;
             }
@@ -3971,7 +4165,7 @@ export class HttpServer {
             const toolPattern = /^[a-zA-Z0-9_-]+:[a-zA-Z0-9_*-]+$/;
             if (!toolPattern.test(tool)) {
                 res.status(400).json({
-                    error: 'Invalid tool format. Expected: server:tool or server:*',
+                    error: "Invalid tool format. Expected: server:tool or server:*",
                 });
                 return;
             }
@@ -3985,7 +4179,9 @@ export class HttpServer {
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to add risky tool override',
+                error: error instanceof Error
+                    ? error.message
+                    : "Failed to add risky tool override",
             });
         }
     }
@@ -3995,9 +4191,9 @@ export class HttpServer {
     async addSafePattern(req, res) {
         try {
             const { pattern, reason } = req.body;
-            if (!pattern || typeof pattern !== 'string') {
+            if (!pattern || typeof pattern !== "string") {
                 res.status(400).json({
-                    error: 'Missing or invalid required parameter: pattern (string)',
+                    error: "Missing or invalid required parameter: pattern (string)",
                 });
                 return;
             }
@@ -4021,7 +4217,7 @@ export class HttpServer {
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to add safe pattern',
+                error: error instanceof Error ? error.message : "Failed to add safe pattern",
             });
         }
     }
@@ -4031,9 +4227,9 @@ export class HttpServer {
     async addRiskyPattern(req, res) {
         try {
             const { pattern, reason } = req.body;
-            if (!pattern || typeof pattern !== 'string') {
+            if (!pattern || typeof pattern !== "string") {
                 res.status(400).json({
-                    error: 'Missing or invalid required parameter: pattern (string)',
+                    error: "Missing or invalid required parameter: pattern (string)",
                 });
                 return;
             }
@@ -4057,7 +4253,9 @@ export class HttpServer {
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to add risky pattern',
+                error: error instanceof Error
+                    ? error.message
+                    : "Failed to add risky pattern",
             });
         }
     }
@@ -4069,7 +4267,7 @@ export class HttpServer {
             const { rule } = req.params;
             if (!rule) {
                 res.status(400).json({
-                    error: 'Missing required parameter: rule',
+                    error: "Missing required parameter: rule",
                 });
                 return;
             }
@@ -4078,26 +4276,26 @@ export class HttpServer {
             // Auto-detect rule type
             const rules = this.configLoader.getToolSafetyRules();
             let removed = false;
-            let type = '';
+            let type = "";
             if (rules.safeToolOverrides?.includes(decodedRule)) {
                 await this.configLoader.removeSafeToolOverride(decodedRule);
                 removed = true;
-                type = 'safe_tool_override';
+                type = "safe_tool_override";
             }
             else if (rules.riskyToolOverrides?.includes(decodedRule)) {
                 await this.configLoader.removeRiskyToolOverride(decodedRule);
                 removed = true;
-                type = 'risky_tool_override';
+                type = "risky_tool_override";
             }
             else if (rules.safePatterns?.includes(decodedRule)) {
                 await this.configLoader.removeSafePattern(decodedRule);
                 removed = true;
-                type = 'safe_pattern';
+                type = "safe_pattern";
             }
             else if (rules.riskyPatterns?.includes(decodedRule)) {
                 await this.configLoader.removeRiskyPattern(decodedRule);
                 removed = true;
-                type = 'risky_pattern';
+                type = "risky_pattern";
             }
             if (!removed) {
                 res.status(404).json({
@@ -4114,7 +4312,7 @@ export class HttpServer {
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to remove rule',
+                error: error instanceof Error ? error.message : "Failed to remove rule",
             });
         }
     }
@@ -4126,19 +4324,21 @@ export class HttpServer {
             const { force } = req.body;
             if (!force) {
                 res.status(400).json({
-                    error: 'Reset requires explicit confirmation. Set force: true',
+                    error: "Reset requires explicit confirmation. Set force: true",
                 });
                 return;
             }
             await this.configLoader.resetToDefaults();
             res.json({
                 success: true,
-                message: 'Reset all safety rules to defaults',
+                message: "Reset all safety rules to defaults",
             });
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to reset safety rules',
+                error: error instanceof Error
+                    ? error.message
+                    : "Failed to reset safety rules",
             });
         }
     }
@@ -4148,30 +4348,52 @@ export class HttpServer {
     async importSafetyRules(req, res) {
         try {
             const { rules, merge = true } = req.body; // Default to merge mode
-            if (!rules || typeof rules !== 'object') {
+            if (!rules || typeof rules !== "object") {
                 res.status(400).json({
-                    error: 'Missing or invalid required parameter: rules (object)',
+                    error: "Missing or invalid required parameter: rules (object)",
                 });
                 return;
             }
             // Get current rules to preserve argumentInspectionRules
             const currentRules = this.configLoader.getToolSafetyRules();
             // Extract arrays from the rules object
-            const safeToolOverrides = Array.isArray(rules.safeToolOverrides) ? rules.safeToolOverrides : [];
-            const riskyToolOverrides = Array.isArray(rules.riskyToolOverrides) ? rules.riskyToolOverrides : [];
-            const safePatterns = Array.isArray(rules.safePatterns) ? rules.safePatterns : [];
-            const riskyPatterns = Array.isArray(rules.riskyPatterns) ? rules.riskyPatterns : [];
+            const safeToolOverrides = Array.isArray(rules.safeToolOverrides)
+                ? rules.safeToolOverrides
+                : [];
+            const riskyToolOverrides = Array.isArray(rules.riskyToolOverrides)
+                ? rules.riskyToolOverrides
+                : [];
+            const safePatterns = Array.isArray(rules.safePatterns)
+                ? rules.safePatterns
+                : [];
+            const riskyPatterns = Array.isArray(rules.riskyPatterns)
+                ? rules.riskyPatterns
+                : [];
             // Preserve argumentInspectionRules unless explicitly provided in import
             const argumentInspectionRules = Array.isArray(rules.argumentInspectionRules)
                 ? rules.argumentInspectionRules
-                : (currentRules.argumentInspectionRules || []);
+                : currentRules.argumentInspectionRules || [];
             if (merge) {
                 // Merge mode: Add new rules to existing ones (default)
                 // Merge tool overrides (avoid duplicates)
-                const mergedSafeTools = [...new Set([...(currentRules.safeToolOverrides || []), ...safeToolOverrides])];
-                const mergedRiskyTools = [...new Set([...(currentRules.riskyToolOverrides || []), ...riskyToolOverrides])];
-                const mergedSafePatterns = [...new Set([...(currentRules.safePatterns || []), ...safePatterns])];
-                const mergedRiskyPatterns = [...new Set([...(currentRules.riskyPatterns || []), ...riskyPatterns])];
+                const mergedSafeTools = [
+                    ...new Set([
+                        ...(currentRules.safeToolOverrides || []),
+                        ...safeToolOverrides,
+                    ]),
+                ];
+                const mergedRiskyTools = [
+                    ...new Set([
+                        ...(currentRules.riskyToolOverrides || []),
+                        ...riskyToolOverrides,
+                    ]),
+                ];
+                const mergedSafePatterns = [
+                    ...new Set([...(currentRules.safePatterns || []), ...safePatterns]),
+                ];
+                const mergedRiskyPatterns = [
+                    ...new Set([...(currentRules.riskyPatterns || []), ...riskyPatterns]),
+                ];
                 await this.configLoader.setToolSafetyRules({
                     safeToolOverrides: mergedSafeTools,
                     riskyToolOverrides: mergedRiskyTools,
@@ -4181,7 +4403,7 @@ export class HttpServer {
                 });
                 res.json({
                     success: true,
-                    message: 'Safety rules imported and merged successfully',
+                    message: "Safety rules imported and merged successfully",
                     imported: {
                         safeTools: mergedSafeTools.length,
                         riskyTools: mergedRiskyTools.length,
@@ -4201,7 +4423,7 @@ export class HttpServer {
                 });
                 res.json({
                     success: true,
-                    message: 'Safety rules imported successfully (replace mode)',
+                    message: "Safety rules imported successfully (replace mode)",
                     imported: {
                         safeTools: safeToolOverrides.length,
                         riskyTools: riskyToolOverrides.length,
@@ -4213,7 +4435,9 @@ export class HttpServer {
         }
         catch (error) {
             res.status(500).json({
-                error: error instanceof Error ? error.message : 'Failed to import safety rules',
+                error: error instanceof Error
+                    ? error.message
+                    : "Failed to import safety rules",
             });
         }
     }
@@ -4228,10 +4452,10 @@ export class HttpServer {
                 apiMetrics: globalMetrics.getApiMetrics(),
             };
             await this.metricsPersistence.save(finalMetrics);
-            console.log('[MetricsPersistence] Saved final metrics on shutdown');
+            console.log("[MetricsPersistence] Saved final metrics on shutdown");
         }
         catch (error) {
-            console.error('[MetricsPersistence] Failed to save metrics on shutdown:', error);
+            console.error("[MetricsPersistence] Failed to save metrics on shutdown:", error);
         }
         await this.serverManager.cleanup();
         for (const client of this.eventClients) {