converse-mcp-server 1.11.1 → 1.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "converse-mcp-server",
-  "version": "1.11.1",
+  "version": "1.12.0",
   "description": "Converse MCP Server - Converse with other LLMs with chat and consensus tools",
   "type": "module",
   "main": "src/index.js",

package/src/continuationStore.js

@@ -6,7 +6,7 @@
  * Provides a consistent interface (get/set/delete) for state management.
  */
 
-import { randomUUID } from 'crypto';
+import { nanoid } from 'nanoid';
 import { debugLog, debugError } from './utils/console.js';
 
 /**
@@ -302,11 +302,12 @@ export function setContinuationStore(store) {
 }
 
 /**
- * Generate a new UUID-based continuation ID
- * @returns {string} Unique continuation ID
+ * Generate a new short continuation ID
+ * @returns {string} Unique continuation ID (format: conv_XXXXXXXXXX)
  */
 export function generateContinuationId() {
-  return `conv_${randomUUID()}`;
+  // Generate a 10-character nanoid for short but unique IDs
+  return `conv_${nanoid(10)}`;
 }
 
 /**
@@ -319,9 +320,14 @@ export function isValidContinuationId(continuationId) {
     return false;
   }
 
-  // Check for conv_ prefix and UUID format
+  // Check for conv_ prefix and nanoid format (10 characters, URL-safe)
+  // nanoid uses URL-safe alphabet: A-Za-z0-9_-
+  const nanoidPattern = /^conv_[A-Za-z0-9_-]{10}$/;
+  
+  // Also accept legacy UUID format for backward compatibility
   const uuidPattern = /^conv_[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-  return uuidPattern.test(continuationId);
+  
+  return nanoidPattern.test(continuationId) || uuidPattern.test(continuationId);
 }
 
 /**

package/src/tools/chat.js

@@ -5,7 +5,7 @@
  * Handles context processing, provider calls, and state management.
  */
 
-import { createToolResponse, createToolError } from './index.js';
+import { createToolResponse, createToolError, formatMetadataDisplay } from './index.js';
 import { processUnifiedContext, createFileContext } from '../utils/contextProcessor.js';
 import { generateContinuationId, addMessageToHistory } from '../continuationStore.js';
 import { debugLog, debugError } from '../utils/console.js';
@@ -69,7 +69,7 @@ export async function chatTool(args, dependencies) {
 
     // Validate file paths before processing
     if (files.length > 0 || images.length > 0) {
-      const validation = await validateAllPaths({ files, images });
+      const validation = await validateAllPaths({ files, images }, { clientCwd: config.server?.client_cwd });
       if (!validation.valid) {
         logger.error('File validation failed', { errors: validation.errors });
         return validation.errorResponse;
@@ -189,12 +189,14 @@ export async function chatTool(args, dependencies) {
 
     // Call provider
     let response;
+    const startTime = Date.now();
     try {
       response = await selectedProvider.invoke(messages, providerOptions);
     } catch (error) {
       logger.error('Provider error', { error, data: { provider: providerName } });
       return createToolError(`Provider error: ${error.message}`);
     }
+    const executionTime = (Date.now() - startTime) / 1000; // Convert to seconds
 
     // Validate response
     if (!response || !response.content) {
@@ -224,9 +226,25 @@ export async function chatTool(args, dependencies) {
       // Continue even if save fails
     }
 
-    // Create response with continuation
+    // Prepare metadata for display
+    const displayMetadata = {
+      continuation_id: continuationId,
+      provider: providerName,
+      model: resolvedModel,
+      execution_time: executionTime,
+      message_count: updatedMessages.filter(msg => msg.role !== 'system').length,
+      ...response.metadata
+    };
+
+    // Format metadata display (disable in test environment)
+    const enableMetadataDisplay = config.environment?.nodeEnv !== 'test';
+    const metadataDisplay = formatMetadataDisplay(displayMetadata, 'chat', executionTime, enableMetadataDisplay);
+    
+    // Create response with continuation and metadata display
+    const responseContent = metadataDisplay ? `${metadataDisplay}\n\n${response.content}` : response.content;
+    
     const result = {
-      content: response.content,
+      content: responseContent,
       continuation: {
         id: continuationId,
         provider: providerName,

package/src/tools/consensus.js

@@ -5,7 +5,7 @@
  * Calls all available providers simultaneously and aggregates responses.
  */
 
-import { createToolResponse, createToolError } from './index.js';
+import { createToolResponse, createToolError, formatMetadataDisplay, formatFailureDetails } from './index.js';
 import { processUnifiedContext, createFileContext } from '../utils/contextProcessor.js';
 import { generateContinuationId, addMessageToHistory } from '../continuationStore.js';
 import { debugLog, debugError } from '../utils/console.js';
@@ -77,7 +77,7 @@ export async function consensusTool(args, dependencies) {
       const validation = await validateAllPaths({
         files,
         images
-      });
+      }, { clientCwd: config.server?.client_cwd });
       if (!validation.valid) {
         logger.error('File validation failed', { errors: validation.errors });
         return validation.errorResponse;
@@ -234,6 +234,7 @@ export async function consensusTool(args, dependencies) {
 
     // Phase 1: Initial parallel provider calls
     logger.debug('Calling providers in parallel', { data: { providerCount: providerCalls.length } });
+    const consensusStartTime = Date.now();
     const initialResults = await Promise.allSettled(
       providerCalls.map(async (call) => {
         try {
@@ -388,6 +389,54 @@ Please provide your refined response:`;
       // Continue even if save fails
     }
 
+    const consensusExecutionTime = (Date.now() - consensusStartTime) / 1000; // Convert to seconds
+    
+    // Calculate final success count and collect failure details
+    let finalSuccessCount;
+    let failureDetails = [];
+    
+    if (enable_cross_feedback && refinedPhase) {
+      // When cross-feedback is enabled, count only models that succeeded in both phases
+      finalSuccessCount = refinedPhase.filter(r => r.status === 'success').length;
+      
+      // Collect detailed failure information
+      refinedPhase.forEach(result => {
+        if (result.status === 'partial') {
+          failureDetails.push(`${result.model} (refinement failed)`);
+        }
+      });
+      
+      // Add models that failed in initial phase
+      initialPhase.failed.forEach(failure => {
+        failureDetails.push(`${failure.model} (initial failed)`);
+      });
+    } else {
+      // When cross-feedback is disabled, count initial successes
+      finalSuccessCount = initialPhase.successful.length;
+      
+      // Collect initial failure information
+      initialPhase.failed.forEach(failure => {
+        failureDetails.push(`${failure.model} (${failure.error})`);
+      });
+    }
+    
+    // Prepare metadata for display
+    const displayMetadata = {
+      continuation_id: continuationId,
+      successful_models: finalSuccessCount,
+      total_models: models.length,
+      execution_time: consensusExecutionTime,
+      cross_feedback: enable_cross_feedback,
+      refined_responses: refinedPhase ? refinedPhase.filter(r => r.status === 'success').length : 0,
+      initial_successes: initialPhase.successful.length,
+      partial_successes: refinedPhase ? refinedPhase.filter(r => r.status === 'partial').length : 0,
+      failure_details: failureDetails
+    };
+
+    // Format metadata display (disable in test environment)
+    const enableMetadataDisplay = config.environment?.nodeEnv !== 'test';
+    const metadataDisplay = formatMetadataDisplay(displayMetadata, 'consensus', consensusExecutionTime, enableMetadataDisplay);
+    
     // Build result object keeping backward compatibility but removing rawResponse
     const result = {
       status: 'consensus_complete',
@@ -408,7 +457,8 @@ Please provide your refined response:`;
         enable_cross_feedback,
         temperature,
         models_requested: models
-      }
+      },
+      metadata_display: metadataDisplay
     };
 
     // Apply token limiting to the final response
@@ -416,13 +466,22 @@ Please provide your refined response:`;
     const resultStr = JSON.stringify(result, null, 2);
     const limitedResult = applyTokenLimit(resultStr, tokenLimit);
 
+    // Add failure details to the response content if there are failures and display is enabled
+    let finalContent = limitedResult.content;
+    if (enableMetadataDisplay && failureDetails.length > 0) {
+      const failureInfo = formatFailureDetails(failureDetails);
+      finalContent = limitedResult.content + failureInfo;
+    }
+
     // Return with continuation at top level for test compatibility
+    // For consensus, we'll add metadata display to a separate field to maintain JSON structure
     return createToolResponse({
-      content: limitedResult.content,
+      content: finalContent,
       continuation: {
         id: continuationId,
         messageCount: messages.length + 1
-      }
+      },
+      metadata_display: metadataDisplay
     });
 
   } catch (error) {

package/src/tools/index.js

@@ -66,6 +66,73 @@ export function getAvailableTools() {
   return Object.keys(tools);
 }
 
+/**
+ * Format metadata for display in tool responses
+ * @param {object} metadata - Metadata to format
+ * @param {string} toolName - Name of the tool
+ * @param {number} executionTime - Execution time in seconds
+ * @param {boolean} enableDisplay - Whether to enable metadata display
+ * @returns {string} Formatted metadata string
+ */
+export function formatMetadataDisplay(metadata = {}, toolName = '', executionTime = null, enableDisplay = true) {
+  // Return empty string if display is disabled (useful for testing)
+  if (!enableDisplay) {
+    return '';
+  }
+  
+  const parts = [];
+  
+  if (executionTime !== null) {
+    // Format time appropriately based on duration
+    let timeDisplay;
+    if (executionTime >= 60) {
+      // Show minutes and seconds for long requests
+      const minutes = Math.floor(executionTime / 60);
+      const seconds = Math.round(executionTime % 60);
+      timeDisplay = `${minutes}m${seconds}s`;
+    } else if (executionTime >= 1) {
+      // Show seconds with 1 decimal place for requests over 1 second
+      timeDisplay = `${executionTime.toFixed(1)}s`;
+    } else {
+      // Show seconds with 2 decimal places for sub-second requests
+      timeDisplay = `${executionTime.toFixed(2)}s`;
+    }
+    parts.push(`⏱️ ${timeDisplay}`);
+  }
+  
+  if (metadata.successful_models !== undefined) {
+    parts.push(`✅ ${metadata.successful_models}/${metadata.total_models} models`);
+  }
+  
+  if (metadata.continuation_id) {
+    parts.push(`🔗 ${metadata.continuation_id}`);
+  }
+  
+  if (metadata.provider) {
+    parts.push(`🤖 ${metadata.provider}`);
+  }
+  
+  if (metadata.model) {
+    parts.push(`📱 ${metadata.model}`);
+  }
+  
+  return parts.length > 0 ? `[${parts.join(' | ')}]` : '';
+}
+
+/**
+ * Format failure details for display in tool responses
+ * @param {array} failureDetails - Array of failure detail strings
+ * @returns {string} Formatted failure details string
+ */
+export function formatFailureDetails(failureDetails = []) {
+  if (!failureDetails || failureDetails.length === 0) {
+    return '';
+  }
+  
+  const failureList = failureDetails.map(detail => `• ${detail}`).join('\n');
+  return `\nModel failures:\n${failureList}`;
+}
+
 /**
  * Create MCP-compatible tool response
  * @param {string|object} content - Response content (string) or full response object
@@ -86,12 +153,18 @@ export function createToolResponse(content, isError = false, additionalFields =
     }
 
     // If it's a tool result object (has continuation, metadata, etc.) convert to MCP format
-    if (content.continuation || content.metadata || content.content) {
+    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) {
+        textContent = `${content.metadata_display}\n\n${textContent}`;
+      }
+      
       const mcpResponse = {
         content: [
           {
             type: 'text',
-            text: content.content || JSON.stringify(content, null, 2)
+            text: textContent
           }
         ],
         isError: isError || content.isError || false,

package/src/utils/fileValidator.js

@@ -13,9 +13,10 @@ import { createToolError } from '../tools/index.js';
  * Validate that all provided file paths exist
  * @param {string[]} filePaths - Array of file paths to validate
  * @param {string} fileType - Type of files being validated (e.g., 'file', 'image')
+ * @param {object} options - Validation options including clientCwd
  * @returns {Promise<{valid: boolean, missingPaths: string[], error?: object}>}
  */
-export async function validateFilePaths(filePaths, fileType = 'file') {
+export async function validateFilePaths(filePaths, fileType = 'file', options = {}) {
   if (!Array.isArray(filePaths) || filePaths.length === 0) {
     return { valid: true, missingPaths: [] };
   }
@@ -34,9 +35,10 @@ export async function validateFilePaths(filePaths, fileType = 'file') {
     }
 
     // Convert to absolute path if needed
+    // Use clientCwd if provided (for auto-detected client working directory), otherwise fall back to process.cwd()
     const absolutePath = isAbsolute(filePath)
       ? filePath
-      : resolve(process.cwd(), filePath);
+      : resolve(options.clientCwd || process.cwd(), filePath);
 
     try {
       // Check if file exists and is readable
@@ -62,14 +64,15 @@ export async function validateFilePaths(filePaths, fileType = 'file') {
 /**
  * Validate both files and images together
  * @param {object} paths - Object containing files and images arrays
+ * @param {object} options - Validation options including clientCwd
  * @returns {Promise<{valid: boolean, errors: string[], errorResponse?: object}>}
  */
-export async function validateAllPaths({ files = [], images = [] }) {
+export async function validateAllPaths({ files = [], images = [] }, options = {}) {
   const errors = [];
 
   // Validate regular files
   if (files.length > 0) {
-    const fileValidation = await validateFilePaths(files, 'file');
+    const fileValidation = await validateFilePaths(files, 'file', options);
     if (!fileValidation.valid) {
       errors.push(`Files not found: ${fileValidation.missingPaths.join(', ')}`);
     }
@@ -77,7 +80,7 @@ export async function validateAllPaths({ files = [], images = [] }) {
 
   // Validate image files
   if (images.length > 0) {
-    const imageValidation = await validateFilePaths(images, 'image');
+    const imageValidation = await validateFilePaths(images, 'image', options);
     if (!imageValidation.valid) {
       errors.push(`Images not found: ${imageValidation.missingPaths.join(', ')}`);
     }