converse-mcp-server 2.29.2 → 3.0.1

package/src/utils/formatStatus.js

@@ -10,6 +10,16 @@ import { SummarizationService } from '../services/summarizationService.js';
 import { debugLog, debugError } from './console.js';
 import { JOB_STATUS } from '../async/asyncJobStore.js';
 
+/**
+ * Normalize a job's mode, mapping the pre-v3 `conversation` tool name to the
+ * `roundtable` mode so durable pre-v3 snapshots render with the right branch.
+ * @param {string} mode
+ * @returns {string}
+ */
+function normalizeMode(mode) {
+  return mode === 'conversation' ? 'roundtable' : mode;
+}
+
 /**
  * Format job list as human-readable text with titles and summaries
  * @param {object} jobsList - Jobs list object with summary
@@ -57,23 +67,26 @@ export async function formatJobListHumanReadable(jobsList, dependencies = {}) {
         completed_with_errors: '⚠️',
       }[job.status] || '❓';
 
+    const mode = normalizeMode(job.mode || job.tool);
     const provider =
-      job.provider || (job.tool === 'consensus' ? 'multiple' : 'unknown');
+      job.provider || (mode === 'chat' ? 'unknown' : 'multiple');
 
     // Format start time as readable date/time
     const startTime = job.created_at
       ? new Date(job.created_at).toLocaleString()
       : 'unknown';
 
-    // Format: emoji STATUS | TOOL | id | sequence | started | time | [progress for consensus only] | provider
+    // Format: emoji STATUS | MODE | id | sequence | started | time | [progress] | provider
     const sequenceStr = '1/1';
 
     // Build base status line
-    let statusLine = `${statusEmoji} ${job.status.toUpperCase()} | ${job.tool.toUpperCase()} | ${job.continuation_id} | ${sequenceStr} | ${startTime} | ${timeStr}`;
+    let statusLine = `${statusEmoji} ${job.status.toUpperCase()} | ${mode.toUpperCase()} | ${job.continuation_id} | ${sequenceStr} | ${startTime} | ${timeStr}`;
 
-    // Add consensus progress if applicable
-    if (job.tool === 'consensus' && job.consensus_progress) {
-      statusLine += ` | ${job.consensus_progress}`;
+    // Add per-mode progress if applicable
+    const progressText =
+      job.consensus_progress || job.roundtable_progress || job.chat_progress;
+    if (progressText) {
+      statusLine += ` | ${progressText}`;
     }
 
     statusLine += ` | ${provider}`;
@@ -144,16 +157,18 @@ export async function formatHumanReadableStatus(
   // Add sequence info if provided
   const sequenceStr = options.sequence ? ` | ${options.sequence}` : '';
 
+  const mode = normalizeMode(jobStatus.mode || jobStatus.tool);
+
   // Build complete status line with all info
-  let statusLine = `${statusEmoji} ${jobStatus.status.toUpperCase()} | ${jobStatus.tool.toUpperCase()} | ${jobStatus.continuation_id}${sequenceStr} | Started: ${startTime} | ${timeStr} elapsed`;
+  let statusLine = `${statusEmoji} ${jobStatus.status.toUpperCase()} | ${mode.toUpperCase()} | ${jobStatus.continuation_id}${sequenceStr} | Started: ${startTime} | ${timeStr} elapsed`;
 
   // Add title if available
   if (jobStatus.title) {
     statusLine += ` | "${jobStatus.title}"`;
   }
 
-  // Add progress for consensus tool only (show x/y format)
-  if (jobStatus.tool === 'consensus') {
+  // Add per-mode progress + models list
+  if (mode === 'consensus') {
     if (jobStatus.consensus_progress) {
       statusLine += ` | ${jobStatus.consensus_progress}`;
     } else if (jobStatus.providers) {
@@ -166,24 +181,28 @@ export async function formatHumanReadableStatus(
       const total = providerEntries.length;
       statusLine += ` | ${completed}/${total} responded`;
     }
-    // Add models list for consensus
     if (jobStatus.models_list) {
       statusLine += ` | ${jobStatus.models_list}`;
     }
-  } else if (jobStatus.tool === 'conversation') {
-    // Add turn progress and models list for conversation (x/y turns)
-    if (jobStatus.conversation_progress) {
-      statusLine += ` | ${jobStatus.conversation_progress} turns`;
+  } else if (mode === 'roundtable') {
+    // Add turn progress and models list (x/y turns)
+    if (jobStatus.roundtable_progress) {
+      statusLine += ` | ${jobStatus.roundtable_progress} turns`;
     }
     if (jobStatus.models_list) {
       statusLine += ` | ${jobStatus.models_list}`;
     }
-  } else if (jobStatus.tool === 'chat') {
-    // Add provider/model for chat
+  } else {
+    // chat mode
+    if (jobStatus.chat_progress) {
+      statusLine += ` | ${jobStatus.chat_progress}`;
+    }
     if (jobStatus.provider && jobStatus.model) {
       statusLine += ` | ${jobStatus.provider}/${jobStatus.model}`;
     } else if (jobStatus.provider) {
       statusLine += ` | ${jobStatus.provider}`;
+    } else if (jobStatus.models_list) {
+      statusLine += ` | ${jobStatus.models_list}`;
     }
   }
 
@@ -332,10 +351,16 @@ export function formatJobStatus(job, options = {}) {
   const elapsedMs = now - startTime;
   const elapsedSeconds = elapsedMs / 1000;
 
+  // `mode` is the unified chat tool's execution mode; `tool` is kept as a
+  // fallback so any durable pre-v3 job snapshot on disk still renders. The old
+  // `conversation` tool maps to `roundtable`.
+  const mode = normalizeMode(job.mode || job.tool);
+
   const formatted = {
     continuation_id: job.jobId,
     status: job.status,
     tool: job.tool,
+    mode,
     created_at: job.createdAt,
     updated_at: job.updatedAt,
     progress: job.overall?.progress || 0,
@@ -346,7 +371,9 @@ export function formatJobStatus(job, options = {}) {
     model: job.model || null,
     models_list: job.models_list || null,
     consensus_progress: job.consensus_progress || null,
-    conversation_progress: job.conversation_progress || null,
+    // `conversation_progress` is the pre-v3 key for what is now roundtable.
+    roundtable_progress: job.roundtable_progress || job.conversation_progress || null,
+    chat_progress: job.chat_progress || null,
     // Include new metadata fields if present
     accumulated_content: job.accumulated_content || null,
     title: job.title || null,
@@ -354,8 +381,8 @@ export function formatJobStatus(job, options = {}) {
     reasoning_summary: job.reasoning_summary || null,
   };
 
-  // For consensus, gather provider previews
-  if (job.tool === 'consensus') {
+  // For the parallel modes (chat, consensus), gather per-provider previews.
+  if (mode === 'consensus' || mode === 'chat') {
     const providerPreviews = {};
     for (let i = 0; i < 10; i++) {
       // Check up to 10 providers

package/src/utils/modelRouting.js

@@ -7,6 +7,26 @@
  * importing from another tool module (which would risk circular dependencies).
  */
 
+/**
+ * Provider auto-selection priority order. Subscription-based CLI/SDK providers
+ * (codex, gemini-cli, claude, copilot) come before API-key providers so "auto"
+ * routing prefers them. Shared by every mode's model-resolution path.
+ * @type {string[]}
+ */
+export const PROVIDER_PRIORITY = [
+  'codex',
+  'gemini-cli',
+  'claude',
+  'copilot',
+  'openai',
+  'google',
+  'xai',
+  'anthropic',
+  'mistral',
+  'deepseek',
+  'openrouter',
+];
+
 /**
  * Get default model for a provider
  * @param {string} providerName - Provider name
@@ -19,17 +39,149 @@ export function getDefaultModelForProvider(providerName) {
     claude: 'claude',
     copilot: 'copilot',
     openai: 'gpt-5.6',
-    xai: 'grok-4-0709',
+    xai: 'grok-4.5',
     google: 'gemini-pro',
     anthropic: 'claude-sonnet-4-20250514',
-    mistral: 'magistral-medium-2506',
-    deepseek: 'deepseek-reasoner',
-    openrouter: 'qwen/qwen3-coder',
+    mistral: 'mistral-medium-3-5',
+    deepseek: 'deepseek-v4-pro',
+    openrouter: 'z-ai/glm-5.2',
   };
 
   return defaults[providerName] || 'gpt-5.6';
 }
 
+/**
+ * Curated friendly-alias → { provider, canonicalModel } table. Single source of
+ * truth for routing the bare friendly aliases of the API-key providers (xAI,
+ * Mistral, DeepSeek) to their canonical current-generation model IDs, so the
+ * routing-parity checks are enumerable and capability-gating gets a deterministic
+ * canonical ID regardless of provider-level alias quirks. Copilot's aliases stay
+ * inside copilot.js because they are reached only via the `copilot:` namespace
+ * (bare `gpt-*`/`claude-*`/`gemini-*` keyword-route to their native API providers).
+ * OpenRouter models are reached by full slug or the `openrouter:` namespace, not
+ * by friendly aliases. Keys are lowercase.
+ * @type {Object<string, {provider: string, canonicalModel: string}>}
+ */
+export const CURATED_MODEL_ALIASES = {
+  // xAI
+  grok: { provider: 'xai', canonicalModel: 'grok-4.5' },
+  'grok-4.5': { provider: 'xai', canonicalModel: 'grok-4.5' },
+  'grok-4.5-latest': { provider: 'xai', canonicalModel: 'grok-4.5' },
+  'grok-build-latest': { provider: 'xai', canonicalModel: 'grok-4.5' },
+  // Mistral
+  mistral: { provider: 'mistral', canonicalModel: 'mistral-medium-3-5' },
+  'mistral-medium': { provider: 'mistral', canonicalModel: 'mistral-medium-3-5' },
+  'mistral-medium-3-5': { provider: 'mistral', canonicalModel: 'mistral-medium-3-5' },
+  'mistral-small': { provider: 'mistral', canonicalModel: 'mistral-small-2603' },
+  'mistral-small-2603': { provider: 'mistral', canonicalModel: 'mistral-small-2603' },
+  'mistral-large': { provider: 'mistral', canonicalModel: 'mistral-large-2512' },
+  'mistral-large-2512': { provider: 'mistral', canonicalModel: 'mistral-large-2512' },
+  // DeepSeek (native — OpenRouter DeepSeek models use their full slug instead)
+  deepseek: { provider: 'deepseek', canonicalModel: 'deepseek-v4-pro' },
+  'deepseek-pro': { provider: 'deepseek', canonicalModel: 'deepseek-v4-pro' },
+  'deepseek-v4-pro': { provider: 'deepseek', canonicalModel: 'deepseek-v4-pro' },
+  'deepseek-flash': { provider: 'deepseek', canonicalModel: 'deepseek-v4-flash' },
+  'deepseek-v4-flash': { provider: 'deepseek', canonicalModel: 'deepseek-v4-flash' },
+};
+
+/**
+ * Parse OpenRouter model decorations off a slug. `:online` is consumed into a
+ * `webSearch` flag (the provider attaches the web plugin from the flag) and is
+ * never carried on the request/lookup ID; other suffixes such as `:free` are
+ * preserved on the request model but stripped from the bare lookup base.
+ * @param {string} slug - Slug with the `openrouter:` namespace already removed
+ * @returns {{ base: string, modelForRequest: string, webSearch: boolean }}
+ */
+function parseOpenRouterDecorations(slug) {
+  const segments = String(slug).split(':');
+  const base = segments[0];
+  const decorations = segments.slice(1);
+  const webSearch = decorations.includes('online');
+  const kept = decorations.filter((d) => d !== 'online');
+  const modelForRequest = kept.length ? `${base}:${kept.join(':')}` : base;
+  return { base, modelForRequest, webSearch };
+}
+
+/**
+ * Classify a model spec into { providerName, canonicalModel, options } by the
+ * design resolution order: explicit namespace prefix, curated friendly alias,
+ * full OpenRouter slug / `openrouter:` prefix (no env gate), then keyword/
+ * passthrough. `options` carries flags derived from decorations (e.g.
+ * `web_search` from an OpenRouter `:online`). Unknown explicit IDs pass through
+ * unchanged (never silently substituted).
+ * @param {string} spec - Model specification
+ * @param {object} providers - Provider instances
+ * @returns {{ providerName: string, canonicalModel: string, options: object }}
+ */
+function classifyModelSpec(spec, providers) {
+  const raw = String(spec);
+  const lower = raw.toLowerCase();
+  const options = {};
+
+  if (lower === 'auto') {
+    const providerName = mapModelToProvider('auto', providers);
+    return {
+      providerName,
+      canonicalModel: getDefaultModelForProvider(providerName),
+      options,
+    };
+  }
+
+  // Explicit OpenRouter namespace: route without OPENROUTER_DYNAMIC_MODELS and
+  // parse `:online`/`:free` decorations before any lookup.
+  if (lower.startsWith('openrouter:')) {
+    const { modelForRequest, webSearch } = parseOpenRouterDecorations(
+      raw.slice('openrouter:'.length),
+    );
+    if (webSearch) options.web_search = true;
+    return { providerName: 'openrouter', canonicalModel: modelForRequest, options };
+  }
+
+  // Other explicit namespaces pass the spec through unchanged; the target
+  // provider strips its own prefix (preserves current copilot/claude/gemini-cli
+  // behavior).
+  if (
+    lower.startsWith('copilot:') ||
+    lower.startsWith('claude:') ||
+    lower.startsWith('gemini:')
+  ) {
+    return {
+      providerName: mapModelToProvider(raw, providers),
+      canonicalModel: raw,
+      options,
+    };
+  }
+
+  // Curated friendly alias → provider + canonical ID.
+  const curated = CURATED_MODEL_ALIASES[lower];
+  if (curated) {
+    return {
+      providerName: curated.provider,
+      canonicalModel: curated.canonicalModel,
+      options,
+    };
+  }
+
+  // Full provider/model slug: a native provider that statically owns the bare
+  // model wins; otherwise it is an OpenRouter slug (decorations parsed).
+  if (raw.includes('/')) {
+    const { base, modelForRequest, webSearch } = parseOpenRouterDecorations(raw);
+    const providerName = mapModelToProvider(base, providers);
+    if (providerName === 'openrouter' && webSearch) {
+      options.web_search = true;
+    }
+    return { providerName, canonicalModel: modelForRequest, options };
+  }
+
+  // Keyword routing / unknown-ID passthrough (unchanged model string).
+  const providerName = mapModelToProvider(raw, providers);
+  return {
+    providerName,
+    canonicalModel: resolveAutoModel(raw, providerName),
+    options,
+  };
+}
+
 /**
  * Resolve "auto" model to default model for the provider
  * @param {string} model - Model name (may be "auto")
@@ -87,6 +239,49 @@ export function providerSupportsImages(providerInstance, providerName) {
   }
 }
 
+/**
+ * Return the available provider names in PROVIDER_PRIORITY order, optionally
+ * skipping text-only providers when the request has images and capping the
+ * count. Shared by every mode's "auto" expansion path.
+ * @param {object} providers - Provider instances
+ * @param {object} config - Configuration
+ * @param {object} [options]
+ * @param {boolean} [options.hasImages=false] - Skip text-only providers when true
+ * @param {number} [options.limit=Infinity] - Max number of providers to return
+ * @returns {string[]} Ordered available provider names
+ */
+export function getAvailableProviders(providers, config, { hasImages = false, limit = Infinity } = {}) {
+  const names = [];
+  for (const name of PROVIDER_PRIORITY) {
+    if (names.length >= limit) break;
+    const provider = providers[name];
+    if (!provider || !provider.isAvailable(config)) continue;
+    if (hasImages && !providerSupportsImages(provider, name)) continue;
+    names.push(name);
+  }
+  return names;
+}
+
+/**
+ * Resolve a single model spec into routing facts: its provider name, the
+ * provider instance, the concrete model, and an availability status. Callers
+ * own their error wording and structural handling by switching on `status`
+ * ('ok' | 'not_found' | 'unavailable').
+ * @param {string} spec - Model specification
+ * @param {object} providers - Provider instances
+ * @param {object} config - Configuration
+ * @returns {{ providerName: string, provider: object, resolvedModel: string, status: string, options: object }}
+ */
+export function resolveModelSpec(spec, providers, config) {
+  const { providerName, canonicalModel, options } = classifyModelSpec(
+    spec,
+    providers,
+  );
+  const provider = providers[providerName];
+  const status = !provider ? 'not_found' : !provider.isAvailable(config) ? 'unavailable' : 'ok';
+  return { providerName, provider, resolvedModel: canonicalModel, status, options };
+}
+
 /**
  * Map model name to provider name
  * @param {string} model - Model name
@@ -160,6 +355,14 @@ export function mapModelToProvider(model, providers) {
     return 'copilot';
   }
 
+  // Check openrouter: prefix (e.g., openrouter:z-ai/glm-5.2). Routes to
+  // OpenRouter without the OPENROUTER_DYNAMIC_MODELS gate. Must be before the
+  // slash-format check so the namespaced slug is not probed against native
+  // providers.
+  if (modelLower.startsWith('openrouter:')) {
+    return 'openrouter';
+  }
+
   // Check OpenRouter-specific patterns first
   if (
     modelLower === 'openrouter auto' ||

package/src/providers/openrouter-endpoints-client.js

@@ -1,220 +0,0 @@
-/**
- * OpenRouter Endpoints API Client
- *
- * Handles fetching model capabilities from OpenRouter's endpoints API.
- * Provides caching and error handling for dynamic model discovery.
- */
-
-import { debugLog, debugError } from '../utils/console.js';
-
-/**
- * Parse an OpenRouter model ID into author and slug components
- * @param {string} modelId - Model ID in format "author/slug"
- * @returns {{author: string, slug: string} | null} Parsed components or null if invalid
- */
-function parseModelId(modelId) {
-  if (!modelId || typeof modelId !== 'string') {
-    return null;
-  }
-
-  const parts = modelId.split('/');
-  if (parts.length !== 2) {
-    return null;
-  }
-
-  const [author, slug] = parts;
-  if (!author || !slug) {
-    return null;
-  }
-
-  return { author, slug };
-}
-
-/**
- * Convert endpoint data to model configuration format
- * @param {Object} endpointData - Raw endpoint data from API
- * @returns {Object} Model configuration object
- */
-function convertEndpointToModelConfig(endpointData) {
-  const data = endpointData.data;
-  const modelId = data.id;
-
-  // Find the best endpoint (prefer primary providers)
-  const preferredProviders = ['Anthropic', 'OpenAI', 'Google', 'XAI'];
-  let selectedEndpoint = data.endpoints[0]; // Default to first
-
-  for (const endpoint of data.endpoints) {
-    if (preferredProviders.includes(endpoint.provider_name)) {
-      selectedEndpoint = endpoint;
-      break;
-    }
-  }
-
-  // Extract supported parameters
-  const supportedParams = selectedEndpoint.supported_parameters || [];
-
-  return {
-    modelName: modelId,
-    friendlyName: data.name || `${modelId} (via OpenRouter)`,
-    description: data.description || `Dynamic model: ${modelId}`,
-    contextWindow: selectedEndpoint.context_length || 8192,
-    maxOutputTokens: selectedEndpoint.max_completion_tokens || 4096,
-    supportsStreaming: true, // Most models support streaming
-    supportsImages:
-      data.architecture?.input_modalities?.includes('image') || false,
-    supportsTemperature: supportedParams.includes('temperature'),
-    supportsWebSearch: false, // Not in API response, conservative default
-    supportsThinking: supportedParams.includes('reasoning'),
-    supportsTools: supportedParams.includes('tools'),
-    timeout: 300000, // 5 minutes default
-    isDynamic: true,
-    // Store additional metadata
-    metadata: {
-      architecture: data.architecture,
-      endpoints: data.endpoints,
-      pricing: selectedEndpoint.pricing,
-      selectedProvider: selectedEndpoint.provider_name,
-      maxPromptTokens: selectedEndpoint.max_prompt_tokens,
-    },
-  };
-}
-
-/**
- * Fetch model endpoints from OpenRouter API
- * @param {string} modelId - Model ID in format "author/slug"
- * @returns {Promise<Object|null>} Model configuration or null if not found
- */
-export async function fetchModelEndpoints(modelId) {
-  const parsed = parseModelId(modelId);
-  if (!parsed) {
-    debugLog(`[OpenRouter Endpoints] Invalid model ID format: ${modelId}`);
-    return null;
-  }
-
-  const { author, slug } = parsed;
-  const url = `https://openrouter.ai/api/v1/models/${author}/${slug}/endpoints`;
-
-  try {
-    debugLog(`[OpenRouter Endpoints] Fetching endpoints for ${modelId}`);
-
-    const response = await globalThis.fetch(url, {
-      method: 'GET',
-      headers: {
-        Accept: 'application/json',
-      },
-    });
-
-    if (response.status === 404) {
-      debugLog(`[OpenRouter Endpoints] Model not found: ${modelId}`);
-      return null;
-    }
-
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-    }
-
-    const data = await response.json();
-
-    // Validate response structure
-    if (!data?.data?.id || !data?.data?.endpoints?.length) {
-      debugLog(
-        `[OpenRouter Endpoints] Invalid response structure for ${modelId}`,
-      );
-      return null;
-    }
-
-    const modelConfig = convertEndpointToModelConfig(data);
-    debugLog(
-      `[OpenRouter Endpoints] Successfully fetched config for ${modelId}`,
-    );
-
-    return modelConfig;
-  } catch (error) {
-    debugError(`[OpenRouter Endpoints] Error fetching ${modelId}:`, error);
-    return null;
-  }
-}
-
-/**
- * Create a simple in-memory cache for model endpoints
- */
-export function createEndpointsCache() {
-  const cache = new Map();
-  const DEFAULT_TTL = 24 * 60 * 60 * 1000; // 24 hours
-  const FAILED_TTL = 5 * 60 * 1000; // 5 minutes for failed requests
-
-  return {
-    /**
-     * Get a cached value
-     * @param {string} key - Cache key
-     * @returns {{found: boolean, value: any}} Cache result
-     */
-    get(key) {
-      const entry = cache.get(key);
-      if (!entry) {
-        return { found: false, value: null };
-      }
-
-      if (Date.now() > entry.expiry) {
-        cache.delete(key);
-        return { found: false, value: null };
-      }
-
-      return { found: true, value: entry.value };
-    },
-
-    /**
-     * Set a cached value
-     * @param {string} key - Cache key
-     * @param {Object|null} value - Value to cache
-     * @param {boolean} isFailure - Whether this is a failed request
-     */
-    set(key, value, isFailure = false) {
-      const ttl = isFailure ? FAILED_TTL : DEFAULT_TTL;
-      cache.set(key, {
-        value,
-        expiry: Date.now() + ttl,
-      });
-    },
-
-    /**
-     * Clear the entire cache
-     */
-    clear() {
-      cache.clear();
-    },
-
-    /**
-     * Get cache size
-     * @returns {number} Number of cached entries
-     */
-    size() {
-      return cache.size;
-    },
-  };
-}
-
-// Create a singleton cache instance
-export const endpointsCache = createEndpointsCache();
-
-/**
- * Fetch model endpoints with caching
- * @param {string} modelId - Model ID in format "author/slug"
- * @returns {Promise<Object|null>} Model configuration or null if not found
- */
-export async function fetchModelEndpointsWithCache(modelId) {
-  // Check cache first
-  const cached = endpointsCache.get(modelId);
-  if (cached.found) {
-    debugLog(`[OpenRouter Endpoints] Using cached config for ${modelId}`);
-    return cached.value;
-  }
-
-  // Fetch from API
-  const config = await fetchModelEndpoints(modelId);
-
-  // Cache the result (including null for not found)
-  endpointsCache.set(modelId, config, config === null);
-
-  return config;
-}