converse-mcp-server 2.3.1 → 2.4.0

package/src/tools/index.js

@@ -50,12 +50,12 @@ export function getTools(config = null) {
       // Create a modified inputSchema without the async parameter
       const modifiedSchema = {
         ...tool.inputSchema,
-        properties: { ...tool.inputSchema.properties }
+        properties: { ...tool.inputSchema.properties },
       };
       delete modifiedSchema.properties.async;
 
       // Create a wrapper function with modified metadata
-      const wrappedTool = async function(...args) {
+      const wrappedTool = async function (...args) {
         return await tool(...args);
       };
       wrappedTool.description = tool.description;
@@ -117,7 +117,12 @@ export function getAvailableTools() {
  * @param {boolean} enableDisplay - Whether to enable metadata display
  * @returns {string} Formatted metadata string
  */
-export function formatMetadataDisplay(metadata = {}, toolName = '', executionTime = null, enableDisplay = true) {
+export function formatMetadataDisplay(
+  metadata = {},
+  toolName = '',
+  executionTime = null,
+  enableDisplay = true,
+) {
   // Return empty string if display is disabled (useful for testing)
   if (!enableDisplay) {
     return '';
@@ -126,7 +131,10 @@ export function formatMetadataDisplay(metadata = {}, toolName = '', executionTim
   const parts = [];
 
   // Use elapsed_seconds from job if available, otherwise use executionTime
-  const timeToShow = metadata.elapsed_seconds !== undefined ? metadata.elapsed_seconds : executionTime;
+  const timeToShow =
+    metadata.elapsed_seconds !== undefined
+      ? metadata.elapsed_seconds
+      : executionTime;
 
   if (timeToShow !== null) {
     // Format time appropriately based on duration
@@ -147,7 +155,9 @@ export function formatMetadataDisplay(metadata = {}, toolName = '', executionTim
   }
 
   if (metadata.successful_models !== undefined) {
-    parts.push(`✅ ${metadata.successful_models}/${metadata.total_models} models`);
+    parts.push(
+      `✅ ${metadata.successful_models}/${metadata.total_models} models`,
+    );
   }
 
   if (metadata.continuation_id) {
@@ -178,7 +188,7 @@ export function formatFailureDetails(failureDetails = []) {
     return '';
   }
 
-  const failureList = failureDetails.map(detail => `• ${detail}`).join('\n');
+  const failureList = failureDetails.map((detail) => `• ${detail}`).join('\n');
   return `\nModel failures:\n${failureList}`;
 }
 
@@ -189,20 +199,33 @@ export function formatFailureDetails(failureDetails = []) {
  * @param {object} additionalFields - Additional fields to include in response
  * @returns {object} MCP tool response
  */
-export function createToolResponse(content, isError = false, additionalFields = {}) {
+export function createToolResponse(
+  content,
+  isError = false,
+  additionalFields = {},
+) {
   // If content is already a structured response object, use it directly
-  if (typeof content === 'object' && content !== null && !Array.isArray(content)) {
+  if (
+    typeof content === 'object' &&
+    content !== null &&
+    !Array.isArray(content)
+  ) {
     // If it's a complete response object with content array, return it directly
     if (content.content && Array.isArray(content.content)) {
       return {
         ...content,
         isError: isError || content.isError || false,
-        ...additionalFields
+        ...additionalFields,
       };
     }
 
     // If it's a tool result object (has continuation, metadata, etc.) convert to MCP format
-    if (content.continuation || content.metadata || content.content || content.metadata_display) {
+    if (
+      content.continuation ||
+      content.metadata ||
+      content.content ||
+      content.metadata_display
+    ) {
       // Prepare the text content, potentially prefixing with metadata display
       let textContent = content.content || JSON.stringify(content, null, 2);
       if (content.metadata_display) {
@@ -213,11 +236,11 @@ export function createToolResponse(content, isError = false, additionalFields =
         content: [
           {
             type: 'text',
-            text: textContent
-          }
+            text: textContent,
+          },
         ],
         isError: isError || content.isError || false,
-        ...additionalFields
+        ...additionalFields,
       };
 
       // Preserve continuation and metadata at top level
@@ -240,7 +263,7 @@ export function createToolResponse(content, isError = false, additionalFields =
         },
       ],
       isError,
-      ...additionalFields
+      ...additionalFields,
     };
   }
 
@@ -253,7 +276,7 @@ export function createToolResponse(content, isError = false, additionalFields =
       },
     ],
     isError,
-    ...additionalFields
+    ...additionalFields,
   };
 }
 
@@ -271,7 +294,7 @@ export function createToolError(message, error = null) {
   response.error = {
     message: errorText,
     type: 'ToolError',
-    timestamp: new Date().toISOString()
+    timestamp: new Date().toISOString(),
   };
 
   return response;

package/src/transport/httpTransport.js

@@ -11,7 +11,10 @@ import { randomUUID } from 'node:crypto';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import { isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
 import { createLogger } from '../utils/logger.js';
-import { registerTransportSession, clearTransportSession } from '../utils/sessionManager.js';
+import {
+  registerTransportSession,
+  clearTransportSession,
+} from '../utils/sessionManager.js';
 
 const logger = createLogger('http-transport');
 
@@ -44,13 +47,14 @@ export class HTTPTransportServer {
       },
 
       // Security settings
-      enableDnsRebindingProtection: config.enableDnsRebindingProtection || false,
+      enableDnsRebindingProtection:
+        config.enableDnsRebindingProtection || false,
       allowedHosts: config.allowedHosts || ['127.0.0.1', 'localhost'],
       rateLimitEnabled: config.rateLimitEnabled || false,
       rateLimitWindow: config.rateLimitWindow || 900000,
       rateLimitMaxRequests: config.rateLimitMaxRequests || 1000,
 
-      ...config
+      ...config,
     };
 
     this.app = express();
@@ -78,10 +82,12 @@ export class HTTPTransportServer {
    */
   setupMiddleware() {
     // JSON parsing with size limit
-    this.app.use(express.json({
-      limit: this.config.maxRequestSize,
-      strict: true
-    }));
+    this.app.use(
+      express.json({
+        limit: this.config.maxRequestSize,
+        strict: true,
+      }),
+    );
 
     // Request timeout middleware
     this.app.use((req, res, next) => {
@@ -90,8 +96,8 @@ export class HTTPTransportServer {
           data: {
             method: req.method,
             path: req.path,
-            timeout: this.config.requestTimeout
-          }
+            timeout: this.config.requestTimeout,
+          },
         });
         if (!res.headersSent) {
           res.status(408).json({
@@ -118,15 +124,17 @@ export class HTTPTransportServer {
 
         // Clean old entries
         const clientRequests = rateLimitMap.get(clientId) || [];
-        const validRequests = clientRequests.filter(time => time > windowStart);
+        const validRequests = clientRequests.filter(
+          (time) => time > windowStart,
+        );
 
         if (validRequests.length >= this.config.rateLimitMaxRequests) {
           logger.warn('Rate limit exceeded', {
             data: {
               clientId,
               requests: validRequests.length,
-              limit: this.config.rateLimitMaxRequests
-            }
+              limit: this.config.rateLimitMaxRequests,
+            },
           });
           res.status(429).json({
             jsonrpc: '2.0',
@@ -147,8 +155,8 @@ export class HTTPTransportServer {
       logger.debug('Rate limiting enabled', {
         data: {
           window: this.config.rateLimitWindow,
-          maxRequests: this.config.rateLimitMaxRequests
-        }
+          maxRequests: this.config.rateLimitMaxRequests,
+        },
       });
     }
 
@@ -156,7 +164,7 @@ export class HTTPTransportServer {
     if (this.config.enableCors) {
       this.app.use(cors(this.config.corsOptions));
       logger.debug('CORS enabled for HTTP transport', {
-        data: { corsOptions: this.config.corsOptions }
+        data: { corsOptions: this.config.corsOptions },
       });
     }
 
@@ -166,8 +174,8 @@ export class HTTPTransportServer {
         data: {
           method: req.method,
           path: req.path,
-          sessionId: req.headers['mcp-session-id']
-        }
+          sessionId: req.headers['mcp-session-id'],
+        },
       });
       next();
     });
@@ -199,7 +207,7 @@ export class HTTPTransportServer {
         transport: 'http',
         server: this.mcpServer ? 'connected' : 'disconnected',
         sessions: this.transports.size,
-        timestamp: new Date().toISOString()
+        timestamp: new Date().toISOString(),
       });
     });
 
@@ -212,9 +220,9 @@ export class HTTPTransportServer {
         endpoints: {
           mcp: '/mcp',
           health: '/health',
-          info: '/info'
+          info: '/info',
         },
-        sessions: this.transports.size
+        sessions: this.transports.size,
       });
     });
   }
@@ -238,14 +246,15 @@ export class HTTPTransportServer {
           logger.warn('Maximum concurrent sessions reached', {
             data: {
               currentSessions: this.transports.size,
-              maxSessions: this.config.maxConcurrentSessions
-            }
+              maxSessions: this.config.maxConcurrentSessions,
+            },
           });
           res.status(503).json({
             jsonrpc: '2.0',
             error: {
               code: -32000,
-              message: 'Maximum concurrent sessions reached. Please try again later.',
+              message:
+                'Maximum concurrent sessions reached. Please try again later.',
             },
             id: null,
           });
@@ -257,9 +266,12 @@ export class HTTPTransportServer {
         logger.info('Created new MCP transport', {});
       } else {
         // Invalid request
-        logger.warn('Invalid MCP request - no session ID or not initialize request', {
-          data: { sessionId, hasInitialize: isInitializeRequest(req.body) }
-        });
+        logger.warn(
+          'Invalid MCP request - no session ID or not initialize request',
+          {
+            data: { sessionId, hasInitialize: isInitializeRequest(req.body) },
+          },
+        );
         res.status(400).json({
           jsonrpc: '2.0',
           error: {
@@ -273,7 +285,6 @@ export class HTTPTransportServer {
 
       // Handle the request through the transport
       await transport.handleRequest(req, res, req.body);
-
     } catch (error) {
       logger.error('Error handling MCP request', { error });
       if (!res.headersSent) {
@@ -296,7 +307,9 @@ export class HTTPTransportServer {
     const sessionId = req.headers['mcp-session-id'];
 
     if (!sessionId || !this.transports.has(sessionId)) {
-      logger.warn('SSE request with invalid session ID', { data: { sessionId } });
+      logger.warn('SSE request with invalid session ID', {
+        data: { sessionId },
+      });
       res.status(400).send('Invalid or missing session ID');
       return;
     }
@@ -307,7 +320,10 @@ export class HTTPTransportServer {
       await transport.handleRequest(req, res);
       logger.debug('SSE connection established', { data: { sessionId } });
     } catch (error) {
-      logger.error('Error handling SSE request', { error, data: { sessionId } });
+      logger.error('Error handling SSE request', {
+        error,
+        data: { sessionId },
+      });
       if (!res.headersSent) {
         res.status(500).send('Internal server error');
       }
@@ -321,7 +337,9 @@ export class HTTPTransportServer {
     const sessionId = req.headers['mcp-session-id'];
 
     if (!sessionId || !this.transports.has(sessionId)) {
-      logger.warn('Session termination with invalid session ID', { data: { sessionId } });
+      logger.warn('Session termination with invalid session ID', {
+        data: { sessionId },
+      });
       res.status(400).send('Invalid or missing session ID');
       return;
     }
@@ -364,7 +382,7 @@ export class HTTPTransportServer {
         this.cleanupSession(transport.sessionId);
         clearTransportSession(transport);
         logger.debug('Transport session closed', {
-          data: { sessionId: transport.sessionId }
+          data: { sessionId: transport.sessionId },
         });
       }
     };
@@ -431,7 +449,7 @@ export class HTTPTransportServer {
 
     this.cleanupInterval = setInterval(() => {
       logger.debug('Running session cleanup', {
-        data: { activeSessions: this.transports.size }
+        data: { activeSessions: this.transports.size },
       });
 
       // The timeout mechanism handles cleanup automatically,
@@ -439,7 +457,10 @@ export class HTTPTransportServer {
     }, this.config.sessionCleanupInterval);
 
     // Unref the interval so it doesn't keep the process alive
-    if (this.cleanupInterval && typeof this.cleanupInterval.unref === 'function') {
+    if (
+      this.cleanupInterval &&
+      typeof this.cleanupInterval.unref === 'function'
+    ) {
       this.cleanupInterval.unref();
     }
   }
@@ -453,28 +474,34 @@ export class HTTPTransportServer {
     }
 
     return new Promise((resolve, reject) => {
-      this.server = this.app.listen(this.config.port, this.config.host, (err) => {
-        if (err) {
-          logger.error('Failed to start HTTP transport server', { error: err });
-          reject(err);
-          return;
-        }
+      this.server = this.app.listen(
+        this.config.port,
+        this.config.host,
+        (err) => {
+          if (err) {
+            logger.error('Failed to start HTTP transport server', {
+              error: err,
+            });
+            reject(err);
+            return;
+          }
 
-        this.isStarted = true;
-        this.startSessionCleanup();
+          this.isStarted = true;
+          this.startSessionCleanup();
 
-        const address = this.server.address();
-        logger.info('HTTP transport server started', {
-          data: {
-            host: address.address,
-            port: address.port,
-            endpoint: `http://${this.config.host}:${address.port}/mcp`,
-            sessionTimeout: this.config.sessionTimeout,
-            maxSessions: this.config.maxConcurrentSessions
-          }
-        });
-        resolve(address);
-      });
+          const address = this.server.address();
+          logger.info('HTTP transport server started', {
+            data: {
+              host: address.address,
+              port: address.port,
+              endpoint: `http://${this.config.host}:${address.port}/mcp`,
+              sessionTimeout: this.config.sessionTimeout,
+              maxSessions: this.config.maxConcurrentSessions,
+            },
+          });
+          resolve(address);
+        },
+      );
     });
   }
 
@@ -538,8 +565,8 @@ export class HTTPTransportServer {
         maxRequestSize: this.config.maxRequestSize,
         corsEnabled: this.config.enableCors,
         rateLimitEnabled: this.config.rateLimitEnabled,
-        dnsRebindingProtection: this.config.enableDnsRebindingProtection
-      }
+        dnsRebindingProtection: this.config.enableDnsRebindingProtection,
+      },
     };
   }
 }

package/src/utils/contextProcessor.js

@@ -33,7 +33,12 @@ export class ContextProcessorError extends Error {
  * Supported image extensions (everything else is treated as text)
  */
 const SUPPORTED_IMAGE_EXTENSIONS = [
-  '.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp'
+  '.jpg',
+  '.jpeg',
+  '.png',
+  '.gif',
+  '.webp',
+  '.bmp',
 ];
 
 /**
@@ -48,19 +53,24 @@ async function validateFilePath(filePath, options = {}) {
   if (!filePath || typeof filePath !== 'string') {
     throw new ContextProcessorError(
       'File path must be a non-empty string',
-      'INVALID_PATH'
+      'INVALID_PATH',
     );
   }
 
   // Convert to absolute path
   // For relative paths, resolve from the client's working directory if provided,
   // otherwise use process.cwd()
-  const absolutePath = isAbsolute(filePath) ? filePath : resolve(options.clientCwd || process.cwd(), filePath);
+  const absolutePath = isAbsolute(filePath)
+    ? filePath
+    : resolve(options.clientCwd || process.cwd(), filePath);
 
   // Security check is now optional and disabled by default
   if (options.enforceSecurityCheck) {
-    const allowedDirs = options.allowedDirectories || [process.cwd(), PROJECT_ROOT];
-    const isAllowed = allowedDirs.some(dir => {
+    const allowedDirs = options.allowedDirectories || [
+      process.cwd(),
+      PROJECT_ROOT,
+    ];
+    const isAllowed = allowedDirs.some((dir) => {
       const resolvedDir = resolve(dir);
       return absolutePath.startsWith(resolvedDir);
     });
@@ -69,7 +79,7 @@ async function validateFilePath(filePath, options = {}) {
       throw new ContextProcessorError(
         'File access denied: path outside allowed directories',
         'SECURITY_VIOLATION',
-        { path: absolutePath, allowedDirs }
+        { path: absolutePath, allowedDirs },
       );
     }
   }
@@ -81,7 +91,7 @@ async function validateFilePath(filePath, options = {}) {
     throw new ContextProcessorError(
       `File not accessible: ${error.message}`,
       'FILE_ACCESS_ERROR',
-      { path: absolutePath }
+      { path: absolutePath },
     );
   }
 
@@ -106,7 +116,7 @@ export async function processFileContent(filePath, options = {}) {
       if (!dataUrlMatch) {
         throw new ContextProcessorError(
           'Invalid data URL format',
-          'INVALID_DATA_URL'
+          'INVALID_DATA_URL',
         );
       }
 
@@ -123,7 +133,7 @@ export async function processFileContent(filePath, options = {}) {
         error: null,
         lastModified: new Date(),
         encoding: 'base64',
-        mimeType
+        mimeType,
       };
     }
 
@@ -135,11 +145,9 @@ export async function processFileContent(filePath, options = {}) {
 
     // Check if it's actually a file (not a directory)
     if (!fileStats.isFile()) {
-      throw new ContextProcessorError(
-        'Path is not a file',
-        'NOT_A_FILE',
-        { path: validatedPath }
-      );
+      throw new ContextProcessorError('Path is not a file', 'NOT_A_FILE', {
+        path: validatedPath,
+      });
     }
 
     const result = {
@@ -171,7 +179,6 @@ export async function processFileContent(filePath, options = {}) {
       result.content = buffer.toString('base64');
       result.mimeType = getMimeType(extension);
       result.encoding = 'base64';
-
     } else {
       // Read everything else as text
       result.type = 'text';
@@ -189,13 +196,15 @@ export async function processFileContent(filePath, options = {}) {
     }
 
     return result;
-
   } catch (error) {
     return {
       path: filePath,
       originalPath: filePath,
       type: 'error',
-      error: error instanceof ContextProcessorError ? error.message : `Unexpected error: ${error.message}`,
+      error:
+        error instanceof ContextProcessorError
+          ? error.message
+          : `Unexpected error: ${error.message}`,
       errorCode: error.code || 'UNKNOWN_ERROR',
       content: null,
       lastModified: null,
@@ -213,13 +222,13 @@ export async function processMultipleFiles(filePaths, options = {}) {
   if (!Array.isArray(filePaths)) {
     throw new ContextProcessorError(
       'filePaths must be an array',
-      'INVALID_INPUT'
+      'INVALID_INPUT',
     );
   }
 
   // Process files in parallel but isolate errors
   const results = await Promise.allSettled(
-    filePaths.map(path => processFileContent(path, options))
+    filePaths.map((path) => processFileContent(path, options)),
   );
 
   // Convert Promise.allSettled results to consistent format
@@ -260,7 +269,7 @@ export async function processWebSearchContext(query, options = {}) {
     // - DuckDuckGo API
     // - Custom search engines
     placeholder: true,
-    message: 'Web search integration placeholder - not yet implemented'
+    message: 'Web search integration placeholder - not yet implemented',
   };
 }
 
@@ -292,20 +301,25 @@ export async function processUnifiedContext(contextRequest, options = {}) {
     if (contextRequest.images && Array.isArray(contextRequest.images)) {
       result.images = await processMultipleFiles(contextRequest.images, {
         ...options,
-        imageProcessingMode: true // Placeholder for future image-specific processing
+        imageProcessingMode: true, // Placeholder for future image-specific processing
       });
     }
 
     // Process web search if provided
-    if (contextRequest.webSearch && typeof contextRequest.webSearch === 'string') {
-      result.webSearch = await processWebSearchContext(contextRequest.webSearch, options);
+    if (
+      contextRequest.webSearch &&
+      typeof contextRequest.webSearch === 'string'
+    ) {
+      result.webSearch = await processWebSearchContext(
+        contextRequest.webSearch,
+        options,
+      );
     }
-
   } catch (error) {
     result.errors.push({
       type: 'unified_processing_error',
       message: error.message,
-      code: error.code || 'UNKNOWN_ERROR'
+      code: error.code || 'UNKNOWN_ERROR',
     });
   }
 
@@ -323,9 +337,11 @@ export function createFileContext(processedFiles, options = {}) {
     return null;
   }
 
-  const textFiles = processedFiles.filter(f => f.type === 'text' && !f.error);
-  const imageFiles = processedFiles.filter(f => f.type === 'image' && !f.error);
-  const errors = processedFiles.filter(f => f.error);
+  const textFiles = processedFiles.filter((f) => f.type === 'text' && !f.error);
+  const imageFiles = processedFiles.filter(
+    (f) => f.type === 'image' && !f.error,
+  );
+  const errors = processedFiles.filter((f) => f.error);
 
   const includeErrors = options.includeErrors !== false; // Default to true
 
@@ -377,11 +393,13 @@ export function createFileContext(processedFiles, options = {}) {
         data: image.content,
       },
       // Add metadata for debugging
-      metadata: options.includeMetadata ? {
-        path: image.originalPath || image.path,
-        size: image.size,
-        lastModified: image.lastModified
-      } : undefined
+      metadata: options.includeMetadata
+        ? {
+          path: image.originalPath || image.path,
+          size: image.size,
+          lastModified: image.lastModified,
+        }
+        : undefined,
     });
   }
 
@@ -428,7 +446,7 @@ export async function validateFilePaths(filePaths, options = {}) {
   if (!Array.isArray(filePaths)) {
     throw new ContextProcessorError(
       'filePaths must be an array',
-      'INVALID_INPUT'
+      'INVALID_INPUT',
     );
   }
 
@@ -444,13 +462,13 @@ export async function validateFilePaths(filePaths, options = {}) {
       results.valid.push({
         originalPath: path,
         validatedPath,
-        isValid: true
+        isValid: true,
       });
     } catch (error) {
       const errorInfo = {
         path,
         error: error.message,
-        code: error.code
+        code: error.code,
       };
 
       if (error.code === 'SECURITY_VIOLATION') {
@@ -463,4 +481,3 @@ export async function validateFilePaths(filePaths, options = {}) {
 
   return results;
 }
-