converse-mcp-server 1.0.2 → 1.1.0

package/README.md

@@ -54,7 +54,7 @@ GOOGLE_API_KEY=your_google_api_key_here
 XAI_API_KEY=xai-your_xai_key_here
 
 # Optional: Server configuration
-PORT=3000
+PORT=3157
 LOG_LEVEL=info
 MAX_MCP_OUTPUT_TOKENS=200000
 
@@ -172,14 +172,14 @@ LOG_LEVEL=debug npm run dev
 
 ```bash
 # Server management
-npm start              # Start server (auto-kills existing server on port 3000)
+npm start              # Start server (auto-kills existing server on port 3157)
 npm run start:clean    # Start server without killing existing processes
 npm run start:port     # Start server on port 3001 (avoids port conflicts)
 npm run dev            # Development with hot reload (auto-kills existing server)
 npm run dev:clean      # Development without killing existing processes
 npm run dev:port       # Development on port 3001 (avoids port conflicts)
 npm run dev:quiet      # Development with minimal logging
-npm run kill-server    # Kill any server running on port 3000
+npm run kill-server    # Kill any server running on port 3157
 
 # Testing
 npm test               # Run all tests
@@ -198,15 +198,15 @@ npm run validate       # Full validation (lint + test)
 npm run build          # Build for production
 npm run debug          # Start with debugger
 npm run check-deps     # Check for outdated dependencies
-npm run kill-server    # Kill any server running on port 3000
+npm run kill-server    # Kill any server running on port 3157
 ```
 
 ### 💡 Development Notes
 
-**Port Management**: The server runs on port 3000 by default for HTTP transport. If you encounter "EADDRINUSE" errors:
+**Port Management**: The server runs on port 3157 by default for HTTP transport. If you encounter "EADDRINUSE" errors:
 
-1. **Automatic cleanup**: `npm start` and `npm run dev` will automatically attempt to kill existing processes on port 3000
-2. **Manual cleanup**: Run `npm run kill-server` to manually free up port 3000  
+1. **Automatic cleanup**: `npm start` and `npm run dev` will automatically attempt to kill existing processes on port 3157
+2. **Manual cleanup**: Run `npm run kill-server` to manually free up port 3157  
 3. **Clean start**: Use `:clean` variants (`npm run start:clean`, `npm run dev:clean`) to skip auto-cleanup
 4. **Persistent issues**: If port conflicts persist, manually kill Node.js processes or restart your terminal
 
@@ -223,7 +223,7 @@ npm start -- --transport=stdio
 ```
 
 **Transport Modes**: 
-- **HTTP Transport** (default): `http://localhost:3000/mcp` - Better for development and debugging
+- **HTTP Transport** (default): `http://localhost:3157/mcp` - Better for development and debugging
 - **Stdio Transport**: Use `--transport=stdio` or set `MCP_TRANSPORT=stdio` for traditional stdio communication
 
 ### Testing with Real APIs
@@ -263,7 +263,7 @@ node final-integration-test.js
 ```
 
 **Expected Results:**
-- Server starts without errors on port 3000
+- Server starts without errors on port 3157
 - All unit tests pass
 - Real API tests connect successfully (if keys configured)
 - Integration tests achieve >70% success rate
@@ -363,7 +363,7 @@ converse/
 
 | Variable | Description | Default | Example |
 |----------|-------------|---------|---------|
-| `PORT` | Server port | `3000` | `3000` |
+| `PORT` | Server port | `3157` | `3157` |
 | `LOG_LEVEL` | Logging level | `info` | `debug`, `info`, `error` |
 | `MAX_MCP_OUTPUT_TOKENS` | Token response limit | `25000` | `200000` |
 | `GOOGLE_LOCATION` | Google API region | `us-central1` | `us-central1` |

package/docs/API.md

@@ -12,7 +12,7 @@ The Converse MCP Server provides two main tools through the Model Context Protoc
 The server supports two transport modes:
 
 ### HTTP Transport (Default)
-- **Endpoint**: `http://localhost:3000/mcp` 
+- **Endpoint**: `http://localhost:3157/mcp` 
 - **Protocol**: HTTP streaming with JSON-RPC 2.0
 - **Usage**: Best for development, debugging, and web integrations
 - **Features**: Health endpoints, CORS support, session management

package/docs/ARCHITECTURE.md

@@ -65,10 +65,10 @@ const server = new Server(
   { capabilities: { tools: {} } }
 );
 
-// HTTP transport on port 3000 (default)
+// HTTP transport on port 3157 (default)
 const httpTransport = new StreamableHTTPServerTransport({
   host: 'localhost',
-  port: 3000
+  port: 3157
 });
 ```
 
@@ -288,7 +288,7 @@ export const config = {
   
   // Server settings
   server: {
-    port: parseInt(process.env.PORT) || 3000,
+    port: parseInt(process.env.PORT) || 3157,
     logLevel: process.env.LOG_LEVEL || 'info',
     maxOutputTokens: parseInt(process.env.MAX_MCP_OUTPUT_TOKENS) || 25000
   },

package/package.json

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

package/src/config.js

@@ -36,7 +36,7 @@ const logger = createLogger('config');
 const CONFIG_SCHEMA = {
   // Server configuration
   server: {
-    PORT: { type: 'number', default: 3000, description: 'Server port' },
+    PORT: { type: 'number', default: 3157, description: 'Server port' },
     HOST: { type: 'string', default: 'localhost', description: 'Server host' },
     NODE_ENV: { type: 'string', default: 'development', description: 'Environment mode' },
     LOG_LEVEL: { type: 'string', default: 'info', description: 'Logging level' },
@@ -47,7 +47,7 @@ const CONFIG_SCHEMA = {
     MCP_TRANSPORT: { type: 'string', default: 'http', description: 'MCP transport type (http or stdio)' },
     
     // HTTP server settings
-    HTTP_PORT: { type: 'number', default: 3000, description: 'HTTP server port' },
+    HTTP_PORT: { type: 'number', default: 3157, description: 'HTTP server port' },
     HTTP_HOST: { type: 'string', default: 'localhost', description: 'HTTP server host' },
     HTTP_REQUEST_TIMEOUT: { type: 'number', default: 300000, description: 'HTTP request timeout in milliseconds (5 minutes)' },
     HTTP_MAX_REQUEST_SIZE: { type: 'string', default: '10mb', description: 'Maximum HTTP request body size' },
@@ -219,16 +219,8 @@ export async function loadConfig() {
       }
     }
 
-    // Load provider configuration
-    for (const [key, schema] of Object.entries(CONFIG_SCHEMA.providers)) {
-      try {
-        const value = validateEnvVar(key, process.env[key], schema);
-        const configKey = key.toLowerCase().replace(/_/g, '');
-        config.providers[configKey] = value;
-      } catch (error) {
-        errors.push(error.message);
-      }
-    }
+    // Initialize providers object (no provider-specific config currently)
+    config.providers = {};
 
     // Load MCP configuration
     for (const [key, schema] of Object.entries(CONFIG_SCHEMA.mcp)) {
@@ -303,7 +295,7 @@ export function getHttpTransportConfig(config) {
 
   return {
     // Server settings
-    port: transport.port || 3000,
+    port: transport.port || 3157,
     host: transport.host || 'localhost',
     requestTimeout: transport.requesttimeout || 300000,
     maxRequestSize: transport.maxrequestsize || '10mb',

package/src/index.js

@@ -34,7 +34,7 @@ Options:
 
 Environment Variables:
   MCP_TRANSPORT        Transport type (http or stdio)
-  PORT                 HTTP server port (default: 3000)
+  PORT                 HTTP server port (default: 3157)
   HOST                 HTTP server host (default: localhost)
 
 Examples:
@@ -91,6 +91,20 @@ async function main() {
     process.exit(0);
   }
 
+  // Determine transport type first to configure logging appropriately
+  const transportType = getTransportType();
+  
+  // Set environment variable early for stdio transport to suppress console output
+  if (transportType === 'stdio') {
+    process.env.MCP_TRANSPORT = 'stdio';
+    // Reconfigure logger with updated environment
+    const { configureLogger } = await import('./utils/logger.js');
+    configureLogger({
+      level: process.env.LOG_LEVEL || 'info',
+      isDevelopment: process.env.NODE_ENV === 'development'
+    });
+  }
+
   const serverTimer = startTimer('server-startup', 'server');
   
   try {
@@ -102,9 +116,7 @@ async function main() {
 
     // Get MCP client configuration
     const mcpConfig = getMcpClientConfig(config);
-
-    // Determine transport type
-    const transportType = getTransportType();
+    
     logger.info('Using transport type', { data: { transport: transportType } });
 
     logger.debug('Creating MCP server instance', { 

package/src/providers/google.js

@@ -19,9 +19,10 @@ const SUPPORTED_MODELS = {
     supportsImages: true,
     supportsTemperature: true,
     supportsThinking: true,
+    supportsWebSearch: true,
     maxThinkingTokens: 24576,
     timeout: 300000,
-    description: 'Gemini 2.0 Flash (1M context) - Latest fast model with experimental thinking, supports audio/video input',
+    description: 'Gemini 2.0 Flash (1M context) - Latest fast model with experimental thinking, supports audio/video input and grounding',
     aliases: ['flash-2.0', 'flash2']
   },
   'gemini-2.0-flash-lite': {
@@ -33,9 +34,10 @@ const SUPPORTED_MODELS = {
     supportsImages: false,
     supportsTemperature: true,
     supportsThinking: false,
+    supportsWebSearch: true,
     maxThinkingTokens: 0,
     timeout: 300000,
-    description: 'Gemini 2.0 Flash Lite (1M context) - Lightweight fast model, text-only',
+    description: 'Gemini 2.0 Flash Lite (1M context) - Lightweight fast model, text-only with grounding',
     aliases: ['flashlite', 'flash-lite']
   },
   'gemini-2.5-flash': {
@@ -47,9 +49,10 @@ const SUPPORTED_MODELS = {
     supportsImages: true,
     supportsTemperature: true,
     supportsThinking: true,
+    supportsWebSearch: true,
     maxThinkingTokens: 24576,
     timeout: 300000,
-    description: 'Ultra-fast (1M context) - Quick analysis, simple queries, rapid iterations',
+    description: 'Ultra-fast (1M context) - Quick analysis, simple queries, rapid iterations with grounding',
     aliases: ['flash', 'flash2.5', 'gemini-flash', 'gemini-flash-2.5']
   },
   'gemini-2.5-pro': {
@@ -58,6 +61,7 @@ const SUPPORTED_MODELS = {
     contextWindow: 1048576, // 1M tokens
     maxOutputTokens: 65536,
     supportsStreaming: true,
+    supportsWebSearch: true,
     supportsImages: true,
     supportsTemperature: true,
     supportsThinking: true,
@@ -160,18 +164,63 @@ function convertMessagesToGemini(messages) {
       // Google Gemini handles system prompts differently - they are typically prepended to the first user message
       systemPrompt = content;
     } else if (role === 'user') {
-      // Combine system prompt with user message if present
-      const userContent = systemPrompt ? `${systemPrompt}\n\n${content}` : content;
+      const parts = [];
+      
+      // Handle complex content structure (array with text and images)
+      if (Array.isArray(content)) {
+        let textContent = '';
+        
+        for (const item of content) {
+          if (item.type === 'text') {
+            textContent += item.text;
+          } else if (item.type === 'image' && item.source) {
+            // Convert Anthropic/Claude format to Google Gemini format
+            parts.push({
+              inlineData: {
+                mimeType: item.source.media_type,
+                data: item.source.data
+              }
+            });
+            debugLog(`[Google] Converting image: ${item.source.media_type}, data length: ${item.source.data.length}`);
+          }
+        }
+        
+        // Combine system prompt with text content if present
+        const finalTextContent = systemPrompt ? `${systemPrompt}\n\n${textContent}` : textContent;
+        if (finalTextContent) {
+          parts.unshift({ text: finalTextContent });
+        }
+      } else {
+        // Simple string content
+        const userContent = systemPrompt ? `${systemPrompt}\n\n${content}` : content;
+        parts.push({ text: userContent });
+      }
+      
       contents.push({
         role: 'user',
-        parts: [{ text: userContent }]
+        parts: parts
       });
       systemPrompt = null; // Only use system prompt once
     } else if (role === 'assistant') {
-      contents.push({
-        role: 'model', // Google uses 'model' instead of 'assistant'
-        parts: [{ text: content }]
-      });
+      // Handle assistant messages
+      if (Array.isArray(content)) {
+        const parts = [];
+        for (const item of content) {
+          if (item.type === 'text') {
+            parts.push({ text: item.text });
+          }
+          // Assistant messages typically don't have images, but handle if needed
+        }
+        contents.push({
+          role: 'model', // Google uses 'model' instead of 'assistant'
+          parts: parts
+        });
+      } else {
+        contents.push({
+          role: 'model',
+          parts: [{ text: content }]
+        });
+      }
     }
   }
 
@@ -181,12 +230,12 @@ function convertMessagesToGemini(messages) {
 /**
  * Calculate thinking budget for models that support it
  */
-function calculateThinkingBudget(modelConfig, reasoningEffort) {
+function calculateThinkingBudget(modelConfig, reasoning_effort) {
   if (!modelConfig.supportsThinking || !modelConfig.maxThinkingTokens) {
     return 0;
   }
 
-  const budget = THINKING_BUDGETS[reasoningEffort] || THINKING_BUDGETS.medium;
+  const budget = THINKING_BUDGETS[reasoning_effort] || THINKING_BUDGETS.medium;
   return Math.floor(modelConfig.maxThinkingTokens * budget);
 }
 
@@ -281,7 +330,8 @@ export const googleProvider = {
       temperature = 0.7,
       maxTokens = null,
       stream: _unused_stream = false, // Acknowledged but not used yet
-      reasoningEffort = 'medium',
+      reasoning_effort = 'medium',
+      use_websearch = false,
       config,
       ...otherOptions
     } = options;
@@ -321,15 +371,20 @@ export const googleProvider = {
     }
 
     // Add thinking configuration for models that support it
-    if (modelConfig.supportsThinking && reasoningEffort) {
-      const thinkingBudget = calculateThinkingBudget(modelConfig, reasoningEffort);
+    if (modelConfig.supportsThinking && reasoning_effort) {
+      const thinkingBudget = calculateThinkingBudget(modelConfig, reasoning_effort);
       if (thinkingBudget > 0) {
         generationConfig.thinkingConfig = { thinkingBudget };
       }
     }
 
+    // Add web search grounding if requested and model supports it
+    if (use_websearch && modelConfig.supportsWebSearch) {
+      generationConfig.tools = [{ googleSearch: {} }];
+    }
+
     try {
-      debugLog(`[Google] Calling ${resolvedModel} with ${messages.length} messages`);
+      debugLog(`[Google] Calling ${resolvedModel} with ${messages.length} messages${use_websearch && modelConfig.supportsWebSearch ? ' (with grounding)' : ''}`);
 
       const startTime = Date.now();
 
@@ -371,8 +426,10 @@ export const googleProvider = {
           usage,
           response_time_ms: responseTime,
           finish_reason: finishReason,
-          reasoning_effort: modelConfig.supportsThinking ? reasoningEffort : null,
-          provider: 'google'
+          reasoning_effort: modelConfig.supportsThinking ? reasoning_effort : null,
+          provider: 'google',
+          web_search_used: use_websearch && modelConfig.supportsWebSearch,
+          grounding_metadata: response.groundingMetadata || null
         }
       };
 

package/src/providers/openai.js

@@ -18,6 +18,8 @@ const SUPPORTED_MODELS = {
     supportsStreaming: true,
     supportsImages: true,
     supportsTemperature: false,
+    supportsWebSearch: true,
+    supportsResponsesAPI: true,
     timeout: 300000, // 5 minutes
     description: 'Strong reasoning (200K context) - Logical problems, code generation, systematic analysis'
   },
@@ -29,6 +31,8 @@ const SUPPORTED_MODELS = {
     supportsStreaming: true,
     supportsImages: true,
     supportsTemperature: false,
+    supportsWebSearch: false, // o3-mini does not support web search
+    supportsResponsesAPI: true,
     timeout: 300000,
     description: 'Fast O3 variant (200K context) - Balanced performance/speed, moderate complexity',
     aliases: ['o3mini', 'o3 mini']
@@ -41,6 +45,8 @@ const SUPPORTED_MODELS = {
     supportsStreaming: true,
     supportsImages: true,
     supportsTemperature: false,
+    supportsWebSearch: true,
+    supportsResponsesAPI: true,
     timeout: 1800000, // 30 minutes
     description: 'Professional-grade reasoning (200K context) - EXTREMELY EXPENSIVE: Only for the most complex problems',
     aliases: ['o3-pro', 'o3pro', 'o3 pro']
@@ -52,7 +58,9 @@ const SUPPORTED_MODELS = {
     maxOutputTokens: 100000,
     supportsStreaming: true,
     supportsImages: true,
-    supportsTemperature: true,
+    supportsTemperature: false,
+    supportsWebSearch: true,
+    supportsResponsesAPI: true,
     timeout: 180000, // 3 minutes
     description: 'Latest reasoning model (200K context) - Optimized for shorter contexts, rapid reasoning',
     aliases: ['o4mini', 'o4', 'o4 mini']
@@ -65,6 +73,8 @@ const SUPPORTED_MODELS = {
     supportsStreaming: true,
     supportsImages: true,
     supportsTemperature: true,
+    supportsWebSearch: true,
+    supportsResponsesAPI: true,
     timeout: 300000,
     description: 'GPT-4.1 (1M context) - Advanced reasoning model with large context window',
     aliases: ['gpt4.1', 'gpt-4.1', 'gpt 4.1']
@@ -77,6 +87,8 @@ const SUPPORTED_MODELS = {
     supportsStreaming: true,
     supportsImages: true,
     supportsTemperature: true,
+    supportsWebSearch: true,
+    supportsResponsesAPI: true,
     timeout: 180000,
     description: 'GPT-4o (128K context) - Multimodal flagship model with vision capabilities',
     aliases: ['gpt4o', 'gpt 4o', '4o']
@@ -89,6 +101,8 @@ const SUPPORTED_MODELS = {
     supportsStreaming: true,
     supportsImages: true,
     supportsTemperature: true,
+    supportsWebSearch: true,
+    supportsResponsesAPI: true,
     timeout: 120000,
     description: 'GPT-4o-mini (128K context) - Fast and efficient multimodal model',
     aliases: ['gpt4o-mini', 'gpt 4o mini', '4o mini', '4o-mini']
@@ -148,9 +162,9 @@ function validateApiKey(apiKey) {
 }
 
 /**
- * Convert messages to OpenAI format
+ * Convert messages to OpenAI format, handling both Responses API and Chat Completions API
  */
-function convertMessages(messages) {
+function convertMessages(messages, useResponsesAPI = false) {
   if (!Array.isArray(messages)) {
     throw new OpenAIProviderError('Messages must be an array', 'INVALID_MESSAGES');
   }
@@ -170,6 +184,60 @@ function convertMessages(messages) {
       throw new OpenAIProviderError(`Message content is required at index ${index}`, 'MISSING_CONTENT');
     }
 
+    // Handle complex content structure (array with text and images)
+    if (Array.isArray(content)) {
+      debugLog(`[OpenAI] Processing complex content array with ${content.length} items for ${useResponsesAPI ? 'Responses API' : 'Chat Completions API'}`);
+      if (useResponsesAPI) {
+        // Convert to Responses API format
+        const convertedContent = [];
+        
+        for (const item of content) {
+          if (item.type === 'text') {
+            convertedContent.push({
+              type: 'input_text',
+              text: item.text
+            });
+          } else if (item.type === 'image' && item.source) {
+            // Convert Anthropic/Claude format to OpenAI Responses API format
+            const imageUrl = `data:${item.source.media_type};base64,${item.source.data}`;
+            debugLog(`[OpenAI] Converting image for Responses API: ${item.source.media_type}, data length: ${item.source.data.length}`);
+            convertedContent.push({
+              type: 'input_image',
+              image_url: imageUrl
+            });
+          }
+        }
+        
+        return { role, content: convertedContent };
+      } else {
+        // Convert to Chat Completions API format
+        const convertedContent = [];
+        
+        for (const item of content) {
+          if (item.type === 'text') {
+            convertedContent.push({
+              type: 'text',
+              text: item.text
+            });
+          } else if (item.type === 'image' && item.source) {
+            // Convert Anthropic/Claude format to OpenAI Chat Completions format
+            const imageUrl = `data:${item.source.media_type};base64,${item.source.data}`;
+            debugLog(`[OpenAI] Converting image for Chat Completions API: ${item.source.media_type}, data length: ${item.source.data.length}`);
+            convertedContent.push({
+              type: 'image_url',
+              image_url: {
+                url: imageUrl,
+                detail: 'auto'
+              }
+            });
+          }
+        }
+        
+        return { role, content: convertedContent };
+      }
+    }
+
+    // Simple string content
     return { role, content };
   });
 }
@@ -190,7 +258,8 @@ export const openaiProvider = {
       temperature = 0.7,
       maxTokens = null,
       stream = false,
-      reasoningEffort = 'medium',
+      reasoning_effort = 'medium',
+      use_websearch = false,
       config,
       ...otherOptions
     } = options;
@@ -213,75 +282,129 @@ export const openaiProvider = {
     const resolvedModel = resolveModelName(model);
     const modelConfig = SUPPORTED_MODELS[resolvedModel] || {};
 
+    // Always use Responses API since all OpenAI models support it
+    // Only fallback to Chat Completions API if Responses API is explicitly not supported
+    const shouldUseResponsesAPI = modelConfig.supportsResponsesAPI !== false;
+
     // Convert and validate messages
-    const openaiMessages = convertMessages(messages);
-
-    // Build request payload (exclude reasoning_effort from otherOptions)
-    const { reasoning_effort: _unused, ...cleanOptions } = otherOptions;
-    const requestPayload = {
-      model: resolvedModel,
-      messages: openaiMessages,
-      stream,
-      ...cleanOptions
-    };
-
-    // Add temperature if model supports it
-    if (modelConfig.supportsTemperature !== false && temperature !== undefined) {
-      requestPayload.temperature = Math.max(0, Math.min(2, temperature));
+    const openaiMessages = convertMessages(messages, shouldUseResponsesAPI);
+
+    // Build request payload based on API type
+    let requestPayload;
+    
+    if (shouldUseResponsesAPI) {
+      // Build Responses API payload
+      requestPayload = {
+        model: resolvedModel,
+        input: openaiMessages,
+        stream,
+        ...otherOptions
+      };
+      
+      // Add web search tools only if requested and model supports it
+      if (use_websearch && modelConfig.supportsWebSearch) {
+        requestPayload.tools = [{ type: 'web_search' }];
+      }
+      
+      // Add temperature if model supports it
+      if (modelConfig.supportsTemperature !== false && temperature !== undefined) {
+        requestPayload.temperature = Math.max(0, Math.min(2, temperature));
+      }
+      
+      // Add reasoning effort for thinking models (o3 series only)
+      if (resolvedModel.startsWith('o3') && reasoning_effort) {
+        requestPayload.reasoning = { effort: reasoning_effort };
+      }
+    } else {
+      // Build Chat Completions API payload
+      const { reasoning_effort: _unused, ...cleanOptions } = otherOptions;
+      requestPayload = {
+        model: resolvedModel,
+        messages: openaiMessages,
+        stream,
+        ...cleanOptions
+      };
+      
+      // Add temperature if model supports it
+      if (modelConfig.supportsTemperature !== false && temperature !== undefined) {
+        requestPayload.temperature = Math.max(0, Math.min(2, temperature));
+      }
+      
+      // Add reasoning effort for thinking models (o3 series only)
+      if (resolvedModel.startsWith('o3') && reasoning_effort) {
+        requestPayload.reasoning_effort = reasoning_effort;
+      }
     }
-
-    // Add max tokens if specified
+    
+    // Add max tokens if specified (both APIs)
     if (maxTokens) {
-      requestPayload.max_tokens = Math.min(maxTokens, modelConfig.maxOutputTokens || 100000);
-    }
-
-    // Add reasoning effort for thinking models (o3 series only)
-    if (resolvedModel.startsWith('o3') && reasoningEffort) {
-      requestPayload.reasoning_effort = reasoningEffort;
+      if (shouldUseResponsesAPI) {
+        requestPayload.max_output_tokens = Math.min(maxTokens, modelConfig.maxOutputTokens || 100000);
+      } else {
+        requestPayload.max_tokens = Math.min(maxTokens, modelConfig.maxOutputTokens || 100000);
+      }
     }
-    // Note: GPT-4o and other models don't support reasoning_effort parameter
-    // Only O3 series models support this parameter
 
     try {
-      debugLog(`[OpenAI] Calling ${resolvedModel} with ${openaiMessages.length} messages`);
+      const apiType = shouldUseResponsesAPI ? 'Responses API' : 'Chat Completions API';
+      debugLog(`[OpenAI] Calling ${resolvedModel} via ${apiType} with ${openaiMessages.length} messages${use_websearch && modelConfig.supportsWebSearch ? ' (with web search)' : ''}`);
 
       const startTime = Date.now();
 
-      // Make the API call
-      const response = await openai.chat.completions.create(requestPayload);
+      // Make the API call based on API type
+      let response;
+      if (shouldUseResponsesAPI) {
+        response = await openai.responses.create(requestPayload);
+      } else {
+        response = await openai.chat.completions.create(requestPayload);
+      }
 
       const responseTime = Date.now() - startTime;
       debugLog(`[OpenAI] Response received in ${responseTime}ms`);
 
-      // Extract response data
-      const choice = response.choices[0];
-      if (!choice) {
-        throw new OpenAIProviderError('No response choice received from OpenAI', 'NO_RESPONSE_CHOICE');
-      }
-
-      const content = choice.message?.content;
-      if (!content) {
-        throw new OpenAIProviderError('No content in response from OpenAI', 'NO_RESPONSE_CONTENT');
+      // Extract response data based on API type
+      let content, stopReason, usage;
+      
+      if (shouldUseResponsesAPI) {
+        // Handle Responses API response format
+        if (!response.output_text) {
+          throw new OpenAIProviderError('No output_text in Responses API response', 'NO_RESPONSE_CONTENT');
+        }
+        content = response.output_text;
+        stopReason = response.status || 'stop';
+        usage = response.usage || {};
+      } else {
+        // Handle Chat Completions API response format
+        const choice = response.choices[0];
+        if (!choice) {
+          throw new OpenAIProviderError('No response choice received from OpenAI', 'NO_RESPONSE_CHOICE');
+        }
+        
+        content = choice.message?.content;
+        if (!content) {
+          throw new OpenAIProviderError('No content in response from OpenAI', 'NO_RESPONSE_CONTENT');
+        }
+        stopReason = choice.finish_reason || 'stop';
+        usage = response.usage || {};
       }
 
-      // Extract usage information
-      const usage = response.usage || {};
-
       // Return unified response format
       return {
         content,
-        stop_reason: choice.finish_reason || 'stop',
+        stop_reason: stopReason,
         rawResponse: response,
         metadata: {
           model: response.model || resolvedModel,
           usage: {
-            input_tokens: usage.prompt_tokens || 0,
-            output_tokens: usage.completion_tokens || 0,
+            input_tokens: usage.prompt_tokens || usage.input_tokens || 0,
+            output_tokens: usage.completion_tokens || usage.output_tokens || 0,
             total_tokens: usage.total_tokens || 0
           },
           response_time_ms: responseTime,
-          finish_reason: choice.finish_reason,
-          provider: 'openai'
+          finish_reason: stopReason,
+          provider: 'openai',
+          api_type: apiType,
+          web_search_used: use_websearch && modelConfig.supportsWebSearch
         }
       };
 

package/src/providers/xai.js

@@ -18,8 +18,9 @@ const SUPPORTED_MODELS = {
     supportsStreaming: true,
     supportsImages: true,
     supportsTemperature: true,
+    supportsWebSearch: true,
     timeout: 300000, // 5 minutes
-    description: 'GROK-4 (256K context) - Latest advanced model from X.AI with image support',
+    description: 'GROK-4 (256K context) - Latest advanced model from X.AI with image support and live search',
     aliases: ['grok', 'grok4', 'grok-4', 'grok-4-latest', 'grok 4', 'grok 4 latest']
   },
   'grok-3': {
@@ -30,6 +31,7 @@ const SUPPORTED_MODELS = {
     supportsStreaming: true,
     supportsImages: false,
     supportsTemperature: true,
+    supportsWebSearch: false,
     timeout: 300000,
     description: 'GROK-3 (131K context) - Previous generation reasoning model from X.AI',
     aliases: ['grok3', 'grok 3']
@@ -42,6 +44,7 @@ const SUPPORTED_MODELS = {
     supportsStreaming: true,
     supportsImages: false,
     supportsTemperature: true,
+    supportsWebSearch: false,
     timeout: 300000,
     description: 'GROK-3 Fast (131K context) - Higher performance variant, faster processing but more expensive',
     aliases: ['grok3fast', 'grok3-fast', 'grok 3 fast']
@@ -123,6 +126,33 @@ function convertMessages(messages) {
       throw new XAIProviderError(`Message content is required at index ${index}`, 'MISSING_CONTENT');
     }
 
+    // Handle complex content structure (array with text and images)
+    if (Array.isArray(content)) {
+      const convertedContent = [];
+      
+      for (const item of content) {
+        if (item.type === 'text') {
+          convertedContent.push({
+            type: 'text',
+            text: item.text
+          });
+        } else if (item.type === 'image' && item.source) {
+          // Convert Anthropic/Claude format to OpenAI format for XAI
+          convertedContent.push({
+            type: 'image_url',
+            image_url: {
+              url: `data:${item.source.media_type};base64,${item.source.data}`,
+              detail: 'auto'
+            }
+          });
+          debugLog(`[XAI] Converting image: ${item.source.media_type}, data length: ${item.source.data.length}`);
+        }
+      }
+      
+      return { role, content: convertedContent };
+    }
+
+    // Simple string content
     return { role, content };
   });
 }
@@ -143,7 +173,8 @@ export const xaiProvider = {
       temperature = 0.7,
       maxTokens = null,
       stream = false,
-      reasoningEffort = 'medium',
+      reasoning_effort = 'medium',
+      use_websearch = false,
       config,
       ...otherOptions
     } = options;
@@ -174,7 +205,7 @@ export const xaiProvider = {
     const xaiMessages = convertMessages(messages);
 
     // Filter out unsupported parameters for XAI/Grok models
-    const { reasoning_effort, reasoningEffort: reasoningEffortAlias, ...supportedOptions } = otherOptions;
+    const { reasoning_effort: _unused_reasoning_effort, ...supportedOptions } = otherOptions;
     
     // Build request payload
     const requestPayload = {
@@ -194,11 +225,18 @@ export const xaiProvider = {
       requestPayload.max_tokens = Math.min(maxTokens, modelConfig.maxOutputTokens || 256000);
     }
 
+    // Add web search parameters if requested and model supports it
+    if (use_websearch && modelConfig.supportsWebSearch) {
+      requestPayload.search_parameters = {
+        mode: 'auto' // Let the model decide when to use web search
+      };
+    }
+
     // Note: XAI/Grok models don't currently support reasoning_effort parameter
     // We silently ignore it for API consistency (no need to log warnings in tests)
 
     try {
-      debugLog(`[XAI] Calling ${resolvedModel} with ${xaiMessages.length} messages`);
+      debugLog(`[XAI] Calling ${resolvedModel} with ${xaiMessages.length} messages${use_websearch && modelConfig.supportsWebSearch ? ' (with live search)' : ''}`);
 
       const startTime = Date.now();
 
@@ -236,7 +274,8 @@ export const xaiProvider = {
           },
           response_time_ms: responseTime,
           finish_reason: choice.finish_reason,
-          provider: 'xai'
+          provider: 'xai',
+          web_search_used: use_websearch && modelConfig.supportsWebSearch
         }
       };
 

package/src/tools/chat.js

@@ -12,6 +12,7 @@ import { debugLog, debugError } from '../utils/console.js';
 import { createLogger } from '../utils/logger.js';
 import { CHAT_PROMPT } from '../systemPrompts.js';
 import { applyTokenLimit, getTokenLimit } from '../utils/tokenLimiter.js';
+import { validateAllPaths } from '../utils/fileValidator.js';
 
 const logger = createLogger('chat');
 
@@ -65,6 +66,15 @@ export async function chatTool(args, dependencies) {
       continuationId = generateContinuationId();
     }
 
+    // Validate file paths before processing
+    if (files.length > 0 || images.length > 0) {
+      const validation = await validateAllPaths({ files, images });
+      if (!validation.valid) {
+        logger.error('File validation failed', { errors: validation.errors });
+        return validation.errorResponse;
+      }
+    }
+
     // Process context (files, images, web search)
     let contextMessage = null;
     if (files.length > 0 || images.length > 0 || use_websearch) {
@@ -77,9 +87,10 @@ export async function chatTool(args, dependencies) {
         
         const contextResult = await contextProcessor.processUnifiedContext(contextRequest);
         
-        // Create context message from files
-        if (contextResult.files.length > 0) {
-          contextMessage = createFileContext(contextResult.files, {
+        // Create context message from files and images
+        const allProcessedFiles = [...contextResult.files, ...contextResult.images];
+        if (allProcessedFiles.length > 0) {
+          contextMessage = createFileContext(allProcessedFiles, {
             includeMetadata: true,
             includeErrors: true
           });
@@ -111,16 +122,22 @@ export async function chatTool(args, dependencies) {
     // Add conversation history
     messages.push(...conversationHistory);
     
-    // Add context message if available
-    if (contextMessage) {
-      messages.push(contextMessage);
+    // Add user prompt with context
+    const userMessage = {
+      role: 'user',
+      content: prompt // default to simple string content
+    };
+    
+    // If we have context (files/images), create complex content array
+    if (contextMessage && contextMessage.content) {
+      // Create complex content array
+      userMessage.content = [
+        ...contextMessage.content, // Include all file/image parts
+        { type: 'text', text: prompt } // Add the user prompt as text
+      ];
     }
     
-    // Add user prompt
-    messages.push({
-      role: 'user',
-      content: prompt
-    });
+    messages.push(userMessage);
 
     // Select provider
     let selectedProvider;
@@ -160,6 +177,7 @@ export async function chatTool(args, dependencies) {
       model: resolvedModel,
       temperature,
       reasoning_effort,
+      use_websearch: use_websearch,
       config
     };
 

package/src/tools/consensus.js

@@ -12,6 +12,7 @@ import { debugLog, debugError } from '../utils/console.js';
 import { createLogger } from '../utils/logger.js';
 import { CONSENSUS_PROMPT } from '../systemPrompts.js';
 import { applyTokenLimit, getTokenLimit } from '../utils/tokenLimiter.js';
+import { validateAllPaths } from '../utils/fileValidator.js';
 
 const logger = createLogger('consensus');
 
@@ -44,7 +45,8 @@ export async function consensusTool(args, dependencies) {
       enable_cross_feedback = true,
       cross_feedback_prompt,
       temperature = 0.2,
-      reasoning_effort = 'medium'
+      reasoning_effort = 'medium',
+      use_websearch = false
     } = args;
 
     let conversationHistory = [];
@@ -70,6 +72,18 @@ export async function consensusTool(args, dependencies) {
       continuationId = generateContinuationId();
     }
 
+    // Validate file paths before processing
+    if (relevant_files.length > 0 || images.length > 0) {
+      const validation = await validateAllPaths({ 
+        files: relevant_files, 
+        images: images 
+      });
+      if (!validation.valid) {
+        logger.error('File validation failed', { errors: validation.errors });
+        return validation.errorResponse;
+      }
+    }
+
     // Process context (files and images)
     let contextMessage = null;
     if (relevant_files.length > 0 || images.length > 0) {
@@ -81,9 +95,10 @@ export async function consensusTool(args, dependencies) {
         
         const contextResult = await contextProcessor.processUnifiedContext(contextRequest);
         
-        // Create context message from files
-        if (contextResult.files.length > 0) {
-          contextMessage = createFileContext(contextResult.files, {
+        // Create context message from files and images
+        const allProcessedFiles = [...contextResult.files, ...contextResult.images];
+        if (allProcessedFiles.length > 0) {
+          contextMessage = createFileContext(allProcessedFiles, {
             includeMetadata: true,
             includeErrors: true
           });
@@ -107,16 +122,22 @@ export async function consensusTool(args, dependencies) {
     // Add conversation history
     messages.push(...conversationHistory);
     
-    // Add context message if available
-    if (contextMessage) {
-      messages.push(contextMessage);
+    // Add user prompt with context
+    const userMessage = {
+      role: 'user',
+      content: prompt // default to simple string content
+    };
+    
+    // If we have context (files/images), create complex content array
+    if (contextMessage && contextMessage.content) {
+      // Create complex content array
+      userMessage.content = [
+        ...contextMessage.content, // Include all file/image parts
+        { type: 'text', text: prompt } // Add the user prompt as text
+      ];
     }
     
-    // Add user prompt
-    messages.push({
-      role: 'user',
-      content: prompt
-    });
+    messages.push(userMessage);
 
     // Resolve model specifications to provider calls
     const providerCalls = [];
@@ -165,6 +186,7 @@ export async function consensusTool(args, dependencies) {
           model: resolvedModelName, // Use resolved model name for API call
           temperature,
           reasoning_effort,
+          use_websearch: use_websearch,
           config,
           ...modelSpec // Allow model-specific overrides
         }
@@ -476,6 +498,11 @@ consensusTool.inputSchema = {
       description: 'Reasoning depth for thinking models. Examples: "medium" (balanced - default), "high" (complex analysis), "max" (thorough evaluation). Default: "medium"',
       default: 'medium'
     },
+    use_websearch: {
+      type: 'boolean',
+      description: 'Enable web search for current information and best practices. Only works with models that support web search (OpenAI, XAI, Google). Example: true for recent developments, false for analysis. Default: false',
+      default: false
+    },
   },
   required: ['prompt', 'models'],
 };

package/src/transport/httpTransport.js

@@ -22,7 +22,7 @@ export class HTTPTransportServer {
   constructor(config = {}) {
     this.config = {
       // Server settings
-      port: config.port || 3000,
+      port: config.port || 3157,
       host: config.host || 'localhost',
       requestTimeout: config.requestTimeout || 300000,
       maxRequestSize: config.maxRequestSize || '10mb',

package/src/utils/fileValidator.js

@@ -0,0 +1,90 @@
+/**
+ * File Validator Utility
+ * 
+ * Validates that file paths exist before processing them.
+ * Returns early with clear error messages if any files are not found.
+ */
+
+import { access, constants } from 'fs/promises';
+import { resolve, isAbsolute } from 'path';
+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')
+ * @returns {Promise<{valid: boolean, missingPaths: string[], error?: object}>}
+ */
+export async function validateFilePaths(filePaths, fileType = 'file') {
+  if (!Array.isArray(filePaths) || filePaths.length === 0) {
+    return { valid: true, missingPaths: [] };
+  }
+
+  const missingPaths = [];
+  
+  for (const filePath of filePaths) {
+    if (!filePath || typeof filePath !== 'string') {
+      missingPaths.push(`Invalid path: ${filePath}`);
+      continue;
+    }
+
+    // Convert to absolute path if needed
+    const absolutePath = isAbsolute(filePath) 
+      ? filePath 
+      : resolve(process.cwd(), filePath);
+
+    try {
+      // Check if file exists and is readable
+      await access(absolutePath, constants.R_OK);
+    } catch (error) {
+      // Keep the original path in the error message for clarity
+      missingPaths.push(filePath);
+    }
+  }
+
+  if (missingPaths.length > 0) {
+    const errorMessage = `The following ${fileType}${missingPaths.length > 1 ? 's' : ''} could not be found: ${missingPaths.join(', ')}`;
+    return {
+      valid: false,
+      missingPaths,
+      error: createToolError(errorMessage)
+    };
+  }
+
+  return { valid: true, missingPaths: [] };
+}
+
+/**
+ * Validate both files and images together
+ * @param {object} paths - Object containing files and images arrays
+ * @returns {Promise<{valid: boolean, errors: string[], errorResponse?: object}>}
+ */
+export async function validateAllPaths({ files = [], images = [] }) {
+  const errors = [];
+  
+  // Validate regular files
+  if (files.length > 0) {
+    const fileValidation = await validateFilePaths(files, 'file');
+    if (!fileValidation.valid) {
+      errors.push(`Files not found: ${fileValidation.missingPaths.join(', ')}`);
+    }
+  }
+
+  // Validate image files
+  if (images.length > 0) {
+    const imageValidation = await validateFilePaths(images, 'image');
+    if (!imageValidation.valid) {
+      errors.push(`Images not found: ${imageValidation.missingPaths.join(', ')}`);
+    }
+  }
+
+  if (errors.length > 0) {
+    return {
+      valid: false,
+      errors,
+      errorResponse: createToolError(errors.join('. '))
+    };
+  }
+
+  return { valid: true, errors: [] };
+}