neoagent 3.2.1-beta.1 → 3.2.1-beta.11

package/server/services/ai/models.js

@@ -1,3 +1,5 @@
+'use strict';
+
 const { AnthropicProvider } = require('./providers/anthropic');
 const { GoogleProvider } = require('./providers/google');
 const { GrokProvider } = require('./providers/grok');
@@ -14,6 +16,19 @@ const {
     getProviderConfigs,
     getProviderSecrets,
 } = require('./settings');
+const {
+    createModelSelectionId,
+    modelMatchesConfiguredId,
+    toSelectableModel,
+} = require('./model_identity');
+const {
+    classifyPriceTier,
+    getInputCostPerM,
+    refreshOllamaModels,
+    refreshProviderModelList,
+} = require('./model_discovery');
+const { fetchResponseText } = require('../network/http');
+const { createAbortError, isAbortError, throwIfAborted } = require('../../utils/abort');
 
 const STATIC_MODELS = [
     // — xAI OAuth — fallback entries shown when grok-oauth token is invalid/exhausted.
@@ -130,127 +145,27 @@ const PROVIDER_FACTORIES = Object.freeze({
     openrouter: { Provider: OpenRouterProvider, apiKey: true, baseUrl: true },
 });
 
-const dynamicModelsByBaseUrl = new Map();
-const REFRESH_INTERVAL = 30000; // 30 seconds
-
-// Unified dynamic model cache for all API-backed providers.
-// Keyed by `${providerId}:${apiKey.slice(0,8)}` to handle per-user keys.
-const providerModelCache = new Map();
-const DYNAMIC_REFRESH_INTERVAL = 5 * 60 * 1000; // 5 minutes
-
-// Populated from OpenRouter's /models response; used to price-classify models
-// from all providers.  Keyed by both the full OpenRouter ID ("openai/gpt-5-mini")
-// and the bare model ID ("gpt-5-mini") for cross-provider lookup.
-const openrouterPricingCache = new Map();
-
 // Providers whose full model list is fetched from their API at runtime.
 // grok-oauth inherits listModels() from GrokProvider and uses the same xAI endpoint.
 const DYNAMIC_PROVIDERS = ['openai', 'anthropic', 'google', 'nvidia', 'grok', 'grok-oauth', 'openrouter'];
 
-function inferModelPurpose(id) {
-    const s = id.toLowerCase();
-    if (/flash|nano|lite|tiny|haiku|scout|mini(?!max)|small/.test(s)) return 'fast';
-    if (/r1|qwq|o[0-9]|reasoning|thinking/.test(s)) return 'planning';
-    if (/code|coder|starcoder|devstral|codex|codegemma/.test(s)) return 'coding';
-    return 'general';
-}
-
-// Pricing tiers: free=$0  cheap<$0.50/1M  medium=$0.50–$5/1M  expensive>$5/1M
-// Uses live prices from openrouterPricingCache; returns null when unknown.
-function classifyPriceTier(modelId) {
-    const costPerM = openrouterPricingCache.get(modelId);
-    if (costPerM === undefined) return null;
-    if (costPerM === 0) return 'free';
-    if (costPerM < 0.5) return 'cheap';
-    if (costPerM < 5) return 'medium';
-    return 'expensive';
-}
-
-// Per-provider functions that turn a raw model object from listModels() into a display label.
-const PROVIDER_LABEL_FN = {
-    openai:    (m) => `${m.id} (OpenAI)`,
-    anthropic: (m) => `${m.name || m.id} (Anthropic)`,
-    google:    (m) => `${m.name || m.id} (Google)`,
-    nvidia:    (m) => `${m.id} (NVIDIA NIM)`,
-    grok:      (m) => `${m.id} (xAI)`,
-    openrouter:(m) => `${m.name || m.id} (OpenRouter)`,
-};
-
-async function refreshProviderModelList(providerId, apiKey, baseUrl) {
-    const cacheKey = `${providerId}:${(apiKey || '').slice(0, 8)}`;
-    const existing = providerModelCache.get(cacheKey);
-    const now = Date.now();
-
-    if (existing && now - existing.lastRefresh <= DYNAMIC_REFRESH_INTERVAL) {
-        return existing.models;
-    }
-
-    try {
-        const factory = PROVIDER_FACTORIES[providerId];
-        const config = {};
-        if (factory.apiKey) config.apiKey = apiKey;
-        if (factory.baseUrl) config.baseUrl = baseUrl;
-        const provider = new factory.Provider(config);
-
-        const raw = await provider.listModels();
-
-        // OpenRouter returns live pricing — populate the shared cache so all
-        // other providers can resolve their price tier without a lookup table.
-        if (providerId === 'openrouter') {
-            for (const m of raw) {
-                if (m.pricing?.prompt == null) continue;
-                const inputPerM = parseFloat(m.pricing.prompt) * 1_000_000;
-                openrouterPricingCache.set(m.id, inputPerM);
-                // Also index by the bare model ID (everything after the first "/")
-                // so that e.g. "gpt-5-mini" resolves from "openai/gpt-5-mini".
-                if (m.id.includes('/')) {
-                    const bareId = m.id.slice(m.id.indexOf('/') + 1);
-                    if (!openrouterPricingCache.has(bareId)) {
-                        openrouterPricingCache.set(bareId, inputPerM);
-                    }
-                }
-            }
-        }
-
-        const labelFn = PROVIDER_LABEL_FN[providerId] || ((m) => m.id);
-        const models = raw.map((m) => ({
-            id: m.id,
-            label: labelFn(m),
-            provider: providerId,
-            purpose: inferModelPurpose(m.id),
-        }));
-
-        providerModelCache.set(cacheKey, { models, lastRefresh: now });
-        return models;
-    } catch (err) {
-        console.warn(`[Models] Failed to refresh ${providerId} models:`, err.message);
-        // Always record a lastRefresh so we don't hammer the API on every request.
-        // Permanent errors (auth/billing/credits) get a longer backoff.
-        const isPermanent = /401|403|unauthorized|forbidden|credits|spending/i.test(err.message);
-        const backoff = isPermanent ? 30 * 60 * 1000 : DYNAMIC_REFRESH_INTERVAL;
-        providerModelCache.set(cacheKey, {
-            models: existing?.models || [],
-            lastRefresh: now - DYNAMIC_REFRESH_INTERVAL + backoff,
-        });
-        return existing?.models || [];
-    }
-}
-
-async function probeOllama(baseUrl, timeoutMs = 1500) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
+async function probeOllama(baseUrl, timeoutMs = 1500, signal = null) {
     try {
-        const res = await fetch(`${baseUrl}/api/tags`, {
+        const { response, text } = await fetchResponseText(`${baseUrl}/api/tags`, {
             method: 'GET',
-            signal: controller.signal
+            maxResponseBytes: 2 * 1024 * 1024,
+            serviceName: 'Ollama health check',
+            signal,
+            timeoutMs,
         });
-        if (!res.ok) {
+        if (!response.ok) {
             return {
                 healthy: false,
-                reason: `Ollama returned HTTP ${res.status}.`
+                reason: `Ollama returned HTTP ${response.status}.`
             };
         }
-        const data = await res.json().catch(() => ({}));
+        let data = {};
+        try { data = JSON.parse(text || '{}'); } catch {}
         const modelCount = Array.isArray(data?.models) ? data.models.length : 0;
         return {
             healthy: true,
@@ -259,12 +174,11 @@ async function probeOllama(baseUrl, timeoutMs = 1500) {
                 : 'Connected to Ollama, but no local models were reported.'
         };
     } catch (err) {
-        const reason = err?.name === 'AbortError'
+        if (isAbortError(err, signal)) throw createAbortError(signal);
+        const reason = err?.code === 'HTTP_TIMEOUT'
             ? `Ollama did not respond within ${timeoutMs}ms.`
             : `Could not reach Ollama at ${baseUrl}.`;
         return { healthy: false, reason };
-    } finally {
-        clearTimeout(timer);
     }
 }
 
@@ -337,11 +251,12 @@ function getProviderCatalog(userId, agentId = null) {
     });
 }
 
-async function getProviderHealthCatalog(userId, agentId = null) {
+async function getProviderHealthCatalog(userId, agentId = null, options = {}) {
     const providers = getProviderCatalog(userId, agentId);
     const enriched = [];
 
     for (const provider of providers) {
+        throwIfAborted(options.signal);
         let connected = null;
         let healthy = provider.available;
         let degraded = false;
@@ -349,8 +264,12 @@ async function getProviderHealthCatalog(userId, agentId = null) {
         let statusLabel = provider.statusLabel;
         let availabilityReason = provider.availabilityReason;
 
-        if (provider.id === 'ollama' && provider.enabled) {
-            const probe = await probeOllama(provider.baseUrl || AI_PROVIDER_DEFINITIONS.ollama.defaultBaseUrl);
+        if (provider.id === 'ollama' && provider.enabled && options.probeLocal !== false) {
+            const probe = await probeOllama(
+                provider.baseUrl || AI_PROVIDER_DEFINITIONS.ollama.defaultBaseUrl,
+                1500,
+                options.signal,
+            );
             connected = probe.healthy;
             healthy = provider.enabled && probe.healthy;
             degraded = provider.enabled && !probe.healthy;
@@ -393,21 +312,30 @@ async function getProviderHealthCatalog(userId, agentId = null) {
     return enriched;
 }
 
-async function getSupportedModels(userId, agentId = null) {
-    const providerCatalog = await getProviderHealthCatalog(userId, agentId);
+async function getSupportedModels(userId, agentId = null, options = {}) {
+    throwIfAborted(options.signal);
+    const providerCatalog = options.providerCatalog
+        || await getProviderHealthCatalog(userId, agentId, { signal: options.signal });
     const providerById = new Map(providerCatalog.map((provider) => [provider.id, provider]));
 
     const all = [...STATIC_MODELS];
-    const staticIds = new Set(STATIC_MODELS.map((model) => model.id));
+    const seenModelIds = new Set(
+        STATIC_MODELS.map((model) => createModelSelectionId(model.provider, model.id)),
+    );
 
     // Ollama: dynamic list from local server
     const ollama = providerById.get('ollama');
     if (ollama?.available) {
-        const dynamicModels = await refreshDynamicModels(ollama.baseUrl);
+        const dynamicModels = await refreshOllamaModels({
+            baseUrl: ollama.baseUrl || AI_PROVIDER_DEFINITIONS.ollama.defaultBaseUrl,
+            Provider: OllamaProvider,
+            signal: options.signal,
+        });
         for (const model of dynamicModels) {
-            if (!staticIds.has(model.id)) {
-                all.push(model);
-            }
+            const selectionId = createModelSelectionId(model.provider, model.id);
+            if (seenModelIds.has(selectionId)) continue;
+            seenModelIds.add(selectionId);
+            all.push(model);
         }
     }
 
@@ -416,16 +344,24 @@ async function getSupportedModels(userId, agentId = null) {
         .filter((id) => providerById.get(id)?.available)
         .map(async (id) => {
             const runtime = getProviderRuntimeConfig(userId, id, agentId);
-            return refreshProviderModelList(id, runtime.apiKey, runtime.baseUrl);
+            return refreshProviderModelList({
+                providerId: id,
+                factory: PROVIDER_FACTORIES[id],
+                apiKey: runtime.apiKey,
+                baseUrl: runtime.baseUrl,
+                signal: options.signal,
+            });
         });
 
     const dynamicResults = await Promise.allSettled(dynamicFetches);
+    throwIfAborted(options.signal);
     for (const result of dynamicResults) {
         if (result.status === 'fulfilled') {
             for (const model of result.value) {
-                if (!staticIds.has(model.id)) {
-                    all.push(model);
-                }
+                const selectionId = createModelSelectionId(model.provider, model.id);
+                if (seenModelIds.has(selectionId)) continue;
+                seenModelIds.add(selectionId);
+                all.push(model);
             }
         }
     }
@@ -449,6 +385,7 @@ async function getSupportedModels(userId, agentId = null) {
     }
 
     return all.map((model) => {
+        const selectableModel = toSelectableModel(model);
         const provider = providerById.get(model.provider);
         // Ollama models are always local/free; all others look up the OpenRouter
         // pricing cache (populated above by Promise.allSettled).
@@ -457,20 +394,20 @@ async function getSupportedModels(userId, agentId = null) {
             : (model.priceTier ?? classifyPriceTier(model.id));
 
         let available = provider?.available !== false;
-        if (available && globalDisabledSet?.has(model.id)) {
+        if (available && modelMatchesConfiguredId(selectableModel, globalDisabledSet)) {
             available = false;
         }
-        if (available && planAllowedModels !== null && !planAllowedModels.has(model.id)) {
+        if (available && planAllowedModels !== null && !modelMatchesConfiguredId(selectableModel, planAllowedModels)) {
             available = false;
         }
 
         const bareId = model.id.includes('/') ? model.id.slice(model.id.indexOf('/') + 1) : null;
         const inputCostPerM = model.provider === 'ollama'
             ? 0
-            : (openrouterPricingCache.get(model.id) ?? (bareId ? openrouterPricingCache.get(bareId) : undefined) ?? null);
+            : (getInputCostPerM(model.id) ?? (bareId ? getInputCostPerM(bareId) : undefined) ?? null);
 
         return {
-            ...model,
+            ...selectableModel,
             priceTier,
             inputCostPerM,
             available,
@@ -480,37 +417,6 @@ async function getSupportedModels(userId, agentId = null) {
     });
 }
 
-async function refreshDynamicModels(baseUrl) {
-    const cacheKey = baseUrl || AI_PROVIDER_DEFINITIONS.ollama.defaultBaseUrl;
-    const existing = dynamicModelsByBaseUrl.get(cacheKey);
-    const now = Date.now();
-
-    if (existing && now - existing.lastRefresh <= REFRESH_INTERVAL) {
-        return existing.models;
-    }
-
-    try {
-        const ollama = new OllamaProvider({ baseUrl: cacheKey });
-        const models = await ollama.listModels();
-        const normalized = models.map((name) => ({
-            id: name,
-            label: `${name} (Ollama / Local)`,
-            provider: 'ollama',
-            purpose: 'general',
-        }));
-
-        dynamicModelsByBaseUrl.set(cacheKey, {
-            models: normalized,
-            lastRefresh: now
-        });
-        return normalized;
-    } catch (err) {
-        console.warn('[Models] Failed to refresh Ollama models:', err.message);
-        const cached = dynamicModelsByBaseUrl.get(cacheKey);
-        return cached?.models || [];
-    }
-}
-
 function createProviderInstance(providerStr, userId = null, configOverrides = {}) {
     const factory = PROVIDER_FACTORIES[providerStr];
     if (!factory) {
@@ -537,7 +443,6 @@ function createProviderInstance(providerStr, userId = null, configOverrides = {}
 module.exports = {
     AI_PROVIDER_DEFINITIONS,
     PROVIDER_FACTORIES,
-    SUPPORTED_MODELS: STATIC_MODELS, // Backward compatibility
     createProviderInstance,
     getProviderCatalog,
     getProviderHealthCatalog,

package/server/services/ai/providerRetry.js

@@ -1,5 +1,16 @@
 'use strict';
 
+const { createAbortError } = require('../../utils/abort');
+const {
+  RETRYABLE_HTTP_STATUS: RETRYABLE_STATUS,
+  RETRYABLE_NETWORK_CODES: RETRYABLE_CODES,
+  abortableDelay,
+  computeBackoffMs,
+  getErrorCode,
+  getHttpStatus,
+  retryAfterMilliseconds,
+} = require('../../utils/retry');
+
 // Centralized transient-error retry for AI provider calls.
 //
 // A transient blip (rate limit, provider overload, brief network failure) should
@@ -14,17 +25,6 @@ const DEFAULTS = {
   maxDelayMs: 8000,
 };
 
-// HTTP statuses worth retrying: request timeout, conflict, rate limit, and the
-// 5xx family including Anthropic's 529 "overloaded" and common CDN edge codes.
-const RETRYABLE_STATUS = new Set([408, 409, 425, 429, 500, 502, 503, 504, 520, 521, 522, 524, 529]);
-
-// Low-level socket / DNS errors surfaced by Node and undici.
-const RETRYABLE_CODES = new Set([
-  'ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT', 'EPIPE', 'EAI_AGAIN', 'ENOTFOUND',
-  'ENETUNREACH', 'EHOSTUNREACH', 'EAGAIN',
-  'UND_ERR_CONNECT_TIMEOUT', 'UND_ERR_SOCKET', 'UND_ERR_HEADERS_TIMEOUT',
-]);
-
 function readNumberEnv(name, fallback, { min = 0, max = Number.MAX_SAFE_INTEGER } = {}) {
   const raw = process.env[name];
   if (raw === undefined || raw === null || String(raw).trim() === '') return fallback;
@@ -47,25 +47,10 @@ function resolveConfig(overrides = {}) {
 // SDKs disagree on where they put the HTTP status: OpenAI/Anthropic expose
 // `.status`, raw http clients use `.statusCode`, and some nest it under
 // `.response.status`. Check all of them.
-function getStatus(err) {
-  if (!err || typeof err !== 'object') return null;
-  const candidates = [err.status, err.statusCode, err.response?.status, err.cause?.status];
-  for (const value of candidates) {
-    const num = Number(value);
-    if (Number.isFinite(num) && num >= 100 && num < 600) return num;
-  }
-  return null;
-}
-
-function getErrorCode(err) {
-  if (!err || typeof err !== 'object') return null;
-  return err.code || err.errno || err.cause?.code || null;
-}
-
 function isTransientError(err) {
   if (!err) return false;
 
-  const status = getStatus(err);
+  const status = getHttpStatus(err);
   if (status !== null) return RETRYABLE_STATUS.has(status);
 
   const code = getErrorCode(err);
@@ -84,39 +69,11 @@ function isTransientError(err) {
 // own backoff. Supports both delta-seconds and `retry-after-ms` style headers.
 function retryAfterMs(err) {
   if (!err || typeof err !== 'object') return null;
-  const headers = err.headers || err.response?.headers;
-  const read = (name) => {
-    if (!headers) return undefined;
-    if (typeof headers.get === 'function') return headers.get(name);
-    return headers[name] ?? headers[name.toLowerCase()];
-  };
-
-  const ms = read('retry-after-ms');
-  if (ms !== undefined && ms !== null && String(ms).trim() !== '') {
-    const parsed = Number(ms);
-    if (Number.isFinite(parsed) && parsed >= 0) return parsed;
-  }
-
-  const after = read('retry-after');
-  if (after !== undefined && after !== null && String(after).trim() !== '') {
-    const seconds = Number(after);
-    if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1000;
-    const date = Date.parse(String(after));
-    if (Number.isFinite(date)) return Math.max(0, date - Date.now());
-  }
-
-  return null;
-}
-
-// Exponential backoff with equal-jitter: half the window is fixed, half random,
-// which spreads retries out without ever collapsing the delay to zero.
-function computeBackoffMs(attempt, baseDelayMs, maxDelayMs) {
-  const exp = Math.min(maxDelayMs, baseDelayMs * 2 ** (attempt - 1));
-  return Math.round(exp / 2 + Math.random() * (exp / 2));
+  return retryAfterMilliseconds(err.headers || err.response?.headers);
 }
 
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
+function abortError(signal) {
+  return createAbortError(signal, 'Provider retry aborted.');
 }
 
 /**
@@ -137,6 +94,7 @@ async function withProviderRetry(fn, options = {}) {
 
   let attempt = 0;
   while (true) {
+    if (options.signal?.aborted) throw abortError(options.signal);
     attempt += 1;
     try {
       return await fn(attempt);
@@ -153,7 +111,7 @@ async function withProviderRetry(fn, options = {}) {
           options.onRetry({ attempt, delayMs: waitMs, error: err });
         } catch { /* a misbehaving progress callback must not abort the retry */ }
       }
-      await delay(waitMs);
+      await abortableDelay(waitMs, options.signal);
     }
   }
 }

package/server/services/ai/provider_selector.js

@@ -0,0 +1,166 @@
+'use strict';
+
+const { getAiSettings } = require('./settings');
+const { createProviderInstance, getSupportedModels } = require('./models');
+const {
+  getRawModelId,
+  normalizeModelSelections,
+  resolveModelSelection,
+} = require('./model_identity');
+const { isModelCoolingDown } = require('./model_failure_cache');
+
+function buildSelection(model, userId, providerConfig) {
+  return {
+    provider: createProviderInstance(model.provider, userId, providerConfig),
+    model: getRawModelId(model),
+    modelSelectionId: model.id,
+    providerName: model.provider,
+  };
+}
+
+async function getProviderForUser(
+  userId,
+  _task = '',
+  isSubagent = false,
+  modelOverride = null,
+  providerConfig = {},
+) {
+  const agentId = providerConfig.agentId || null;
+  const aiSettings = getAiSettings(userId, agentId);
+  const models = await getSupportedModels(userId, agentId, {
+    signal: providerConfig.signal,
+  });
+  const selectableModels = models.filter((model) => model.available !== false);
+  const readyModels = selectableModels.filter(
+    (model) => !isModelCoolingDown(userId, agentId, model.id),
+  );
+
+  if (modelOverride && typeof modelOverride === 'string') {
+    const requested = resolveModelSelection(selectableModels, modelOverride);
+    if (!requested) {
+      throw new Error(`Requested model '${modelOverride.trim()}' is not available.`);
+    }
+    if (isModelCoolingDown(userId, agentId, requested.id) && readyModels.length > 0) {
+      const configuredFallback = resolveModelSelection(
+        readyModels,
+        aiSettings.fallback_model_id,
+      );
+      const fallback = configuredFallback
+        || readyModels.find((model) => model.provider !== requested.provider)
+        || readyModels[0];
+      providerConfig.onStatus?.({
+        phase: 'model_fallback',
+        message: `Skipping recently unavailable model ${requested.id}; using ${fallback.id}.`,
+      });
+      return buildSelection(fallback, userId, providerConfig);
+    }
+    return buildSelection(requested, userId, providerConfig);
+  }
+
+  const configuredEnabledIds = Array.isArray(aiSettings.enabled_models)
+    ? aiSettings.enabled_models.map((id) => String(id).trim()).filter(Boolean)
+    : [];
+  const enabledIds = normalizeModelSelections(selectableModels, configuredEnabledIds);
+  let availableModels = configuredEnabledIds.length > 0
+    ? readyModels.filter((model) => enabledIds.includes(model.id))
+    : readyModels;
+
+  if (
+    availableModels.length === 0
+    && configuredEnabledIds.length > 0
+    && enabledIds.length > 0
+  ) {
+    const configuredFallback = resolveModelSelection(
+      readyModels,
+      aiSettings.fallback_model_id,
+    );
+    if (configuredFallback) {
+      providerConfig.onStatus?.({
+        phase: 'model_fallback',
+        message: `Enabled models are temporarily unavailable; using ${configuredFallback.id}.`,
+      });
+      availableModels = [configuredFallback];
+    }
+  }
+
+  // If every configured model is cooling down and there is no alternative,
+  // allow one retry instead of making the installation permanently unavailable.
+  if (availableModels.length === 0 && readyModels.length === 0) {
+    availableModels = configuredEnabledIds.length > 0
+      ? selectableModels.filter((model) => enabledIds.includes(model.id))
+      : selectableModels;
+  }
+
+  if (availableModels.length === 0) {
+    const message = configuredEnabledIds.length > 0
+      ? 'None of the enabled AI models are currently available. Check model and provider settings.'
+      : 'No AI providers are currently available. Open Settings and configure at least one provider.';
+    throw new Error(message);
+  }
+
+  const fallbackModel = availableModels[0];
+  const userSelectedDefault = isSubagent
+    ? (aiSettings.default_subagent_model || 'auto')
+    : (aiSettings.default_chat_model || 'auto');
+  const smarterSelection = aiSettings.smarter_model_selector !== false
+    && aiSettings.smarter_model_selector !== 'false';
+
+  let selectedModel = fallbackModel;
+  if (userSelectedDefault !== 'auto') {
+    selectedModel = resolveModelSelection(availableModels, userSelectedDefault) || fallbackModel;
+    const configuredDefault = resolveModelSelection(selectableModels, userSelectedDefault);
+    if (
+      configuredDefault
+      && configuredDefault.id !== selectedModel.id
+      && isModelCoolingDown(userId, agentId, configuredDefault.id)
+    ) {
+      providerConfig.onStatus?.({
+        phase: 'model_fallback',
+        message: `Skipping recently unavailable model ${configuredDefault.id}; using ${selectedModel.id}.`,
+      });
+    }
+  } else {
+    const selectionHint = providerConfig.selectionHint && typeof providerConfig.selectionHint === 'object'
+      ? providerConfig.selectionHint
+      : {};
+    const preferredPurpose = String(selectionHint.purpose || '').trim().toLowerCase();
+    const highAutonomy = selectionHint.autonomyLevel === 'high'
+      || selectionHint.complexity === 'complex';
+    const requiredConfidence = String(selectionHint.requiredConfidence || '').trim().toLowerCase();
+    const costMode = String(selectionHint.costMode || aiSettings.cost_mode || 'balanced_auto')
+      .trim()
+      .toLowerCase();
+    const requestedPurpose = ['planning', 'coding', 'general', 'fast'].includes(preferredPurpose)
+      ? preferredPurpose
+      : '';
+    const priceRank = { free: 0, cheap: 1, medium: 2, expensive: 3 };
+    const chooseForPurpose = (purpose) => {
+      const candidates = availableModels.filter((model) => model.purpose === purpose);
+      if (candidates.length === 0) return null;
+      if (['economy', 'cost_saver', 'lowest_cost'].includes(costMode)) {
+        return [...candidates].sort((left, right) => (
+          (priceRank[left.priceTier] ?? 99) - (priceRank[right.priceTier] ?? 99)
+        ))[0];
+      }
+      if (['quality', 'highest_quality'].includes(costMode) || requiredConfidence === 'high') {
+        return candidates.find((model) => model.priceTier !== 'free' && model.priceTier !== 'cheap')
+          || candidates[0];
+      }
+      return candidates[0];
+    };
+
+    if (smarterSelection && requestedPurpose) {
+      selectedModel = chooseForPurpose(requestedPurpose) || fallbackModel;
+    } else if (smarterSelection && highAutonomy) {
+      selectedModel = chooseForPurpose('planning') || chooseForPurpose('general') || fallbackModel;
+    } else if (isSubagent) {
+      selectedModel = chooseForPurpose('fast') || fallbackModel;
+    } else {
+      selectedModel = chooseForPurpose('general') || fallbackModel;
+    }
+  }
+
+  return buildSelection(selectedModel, userId, providerConfig);
+}
+
+module.exports = { getProviderForUser };

package/server/services/ai/providers/anthropic.js

@@ -31,8 +31,8 @@ class AnthropicProvider extends BaseProvider {
     });
   }
 
-  async listModels() {
-    const res = await this.client.models.list({ limit: 100 });
+  async listModels(signal = null) {
+    const res = await this.client.models.list({ limit: 100 }, { signal });
     return (res.data || []).map((m) => ({ id: m.id, name: m.display_name || m.id }));
   }