neoagent 3.2.1-beta.1 → 3.2.1-beta.3

package/server/services/ai/model_discovery.js

@@ -0,0 +1,227 @@
+'use strict';
+
+const crypto = require('crypto');
+
+const REFRESH_INTERVAL_MS = 5 * 60 * 1000;
+const PERMANENT_ERROR_BACKOFF_MS = 30 * 60 * 1000;
+const DISCOVERY_TIMEOUT_MS = 10_000;
+const OLLAMA_REFRESH_INTERVAL_MS = 30_000;
+
+const providerModelCache = new Map();
+const providerRefreshes = new Map();
+const ollamaModelCache = new Map();
+const ollamaRefreshes = new Map();
+const openrouterPricingCache = new Map();
+
+function inferModelPurpose(id) {
+  const value = id.toLowerCase();
+  if (/flash|nano|lite|tiny|haiku|scout|mini(?!max)|small/.test(value)) return 'fast';
+  if (/r1|qwq|o[0-9]|reasoning|thinking/.test(value)) return 'planning';
+  if (/code|coder|starcoder|devstral|codex|codegemma/.test(value)) return 'coding';
+  return 'general';
+}
+
+const PROVIDER_LABELS = Object.freeze({
+  openai: (model) => `${model.id} (OpenAI)`,
+  anthropic: (model) => `${model.name || model.id} (Anthropic)`,
+  google: (model) => `${model.name || model.id} (Google)`,
+  nvidia: (model) => `${model.id} (NVIDIA NIM)`,
+  grok: (model) => `${model.id} (xAI)`,
+  'grok-oauth': (model) => `${model.id} (xAI OAuth)`,
+  openrouter: (model) => `${model.name || model.id} (OpenRouter)`,
+});
+
+function cacheKeyForProvider(providerId, apiKey, baseUrl) {
+  return crypto
+    .createHash('sha256')
+    .update(String(providerId || ''))
+    .update('\0')
+    .update(String(apiKey || ''))
+    .update('\0')
+    .update(String(baseUrl || ''))
+    .digest('hex');
+}
+
+function abortError(signal, fallback = 'Model discovery aborted.') {
+  if (signal?.reason instanceof Error) return signal.reason;
+  const error = new Error(String(signal?.reason || fallback));
+  error.name = 'AbortError';
+  error.code = 'ABORT_ERR';
+  return error;
+}
+
+function waitForSharedResult(promise, signal) {
+  if (!signal) return promise;
+  if (signal.aborted) return Promise.reject(abortError(signal));
+
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(abortError(signal));
+    signal.addEventListener('abort', onAbort, { once: true });
+    promise.then(resolve, reject).finally(() => {
+      signal.removeEventListener('abort', onAbort);
+    });
+  });
+}
+
+async function runDiscovery(factory, timeoutMs = DISCOVERY_TIMEOUT_MS) {
+  const controller = new AbortController();
+  let timer = null;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      const error = new Error(`Model discovery timed out after ${timeoutMs}ms.`);
+      error.code = 'MODEL_DISCOVERY_TIMEOUT';
+      controller.abort(error);
+      reject(error);
+    }, timeoutMs);
+  });
+
+  try {
+    return await Promise.race([
+      Promise.resolve().then(() => factory(controller.signal)),
+      timeout,
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function normalizeRawModels(rawModels, providerId, fallbackIds = []) {
+  const source = Array.isArray(rawModels) && rawModels.length > 0
+    ? rawModels
+    : fallbackIds;
+  const labelModel = PROVIDER_LABELS[providerId] || ((model) => model.name || model.id);
+  const normalized = [];
+  const seen = new Set();
+
+  for (const raw of source) {
+    const model = typeof raw === 'string' ? { id: raw, name: raw } : raw;
+    const id = String(model?.id || '').trim();
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    normalized.push({
+      id,
+      label: labelModel({ ...model, id }),
+      provider: providerId,
+      purpose: inferModelPurpose(id),
+    });
+  }
+  return normalized;
+}
+
+function updateOpenRouterPricing(rawModels) {
+  if (!Array.isArray(rawModels)) return;
+  for (const model of rawModels) {
+    if (!model || typeof model !== 'object' || model.pricing?.prompt == null) continue;
+    const inputPerM = Number.parseFloat(model.pricing.prompt) * 1_000_000;
+    if (!Number.isFinite(inputPerM) || inputPerM < 0) continue;
+    openrouterPricingCache.set(model.id, inputPerM);
+    if (!model.id.includes('/')) continue;
+    const bareId = model.id.slice(model.id.indexOf('/') + 1);
+    if (!openrouterPricingCache.has(bareId)) {
+      openrouterPricingCache.set(bareId, inputPerM);
+    }
+  }
+}
+
+function isPermanentDiscoveryError(error) {
+  return /401|403|unauthorized|forbidden|credits|spending/i.test(String(error?.message || ''));
+}
+
+async function loadProviderModels({ providerId, factory, apiKey, baseUrl, existing }) {
+  let provider = null;
+  try {
+    const config = {};
+    if (factory.apiKey) config.apiKey = apiKey;
+    if (factory.baseUrl) config.baseUrl = baseUrl;
+    provider = new factory.Provider(config);
+    const rawModels = await runDiscovery((signal) => provider.listModels(signal));
+    if (providerId === 'openrouter') updateOpenRouterPricing(rawModels);
+    const models = normalizeRawModels(rawModels, providerId, provider.models);
+    const entry = { models, expiresAt: Date.now() + REFRESH_INTERVAL_MS };
+    return entry;
+  } catch (error) {
+    console.warn(`[Models] Failed to refresh ${providerId} models:`, error.message);
+    const models = existing?.models?.length
+      ? existing.models
+      : normalizeRawModels([], providerId, provider?.models || []);
+    const retryAfterMs = isPermanentDiscoveryError(error)
+      ? PERMANENT_ERROR_BACKOFF_MS
+      : REFRESH_INTERVAL_MS;
+    return { models, expiresAt: Date.now() + retryAfterMs };
+  }
+}
+
+async function refreshProviderModelList({ providerId, factory, apiKey, baseUrl, signal }) {
+  const cacheKey = cacheKeyForProvider(providerId, apiKey, baseUrl);
+  const existing = providerModelCache.get(cacheKey);
+  if (existing && existing.expiresAt > Date.now()) return existing.models;
+
+  let refresh = providerRefreshes.get(cacheKey);
+  if (!refresh) {
+    refresh = loadProviderModels({ providerId, factory, apiKey, baseUrl, existing })
+      .then((entry) => {
+        providerModelCache.set(cacheKey, entry);
+        return entry.models;
+      })
+      .finally(() => providerRefreshes.delete(cacheKey));
+    providerRefreshes.set(cacheKey, refresh);
+  }
+  return waitForSharedResult(refresh, signal);
+}
+
+async function loadOllamaModels({ baseUrl, Provider, existing }) {
+  try {
+    const provider = new Provider({ baseUrl });
+    const rawModels = await runDiscovery((signal) => provider.listModels(signal));
+    const models = normalizeRawModels(rawModels, 'ollama').map((model) => ({
+      ...model,
+      label: `${model.id} (Ollama / Local)`,
+      purpose: 'general',
+    }));
+    return { models, expiresAt: Date.now() + OLLAMA_REFRESH_INTERVAL_MS };
+  } catch (error) {
+    console.warn('[Models] Failed to refresh Ollama models:', error.message);
+    return {
+      models: existing?.models || [],
+      expiresAt: Date.now() + OLLAMA_REFRESH_INTERVAL_MS,
+    };
+  }
+}
+
+async function refreshOllamaModels({ baseUrl, Provider, signal }) {
+  const cacheKey = String(baseUrl || '');
+  const existing = ollamaModelCache.get(cacheKey);
+  if (existing && existing.expiresAt > Date.now()) return existing.models;
+
+  let refresh = ollamaRefreshes.get(cacheKey);
+  if (!refresh) {
+    refresh = loadOllamaModels({ baseUrl, Provider, existing })
+      .then((entry) => {
+        ollamaModelCache.set(cacheKey, entry);
+        return entry.models;
+      })
+      .finally(() => ollamaRefreshes.delete(cacheKey));
+    ollamaRefreshes.set(cacheKey, refresh);
+  }
+  return waitForSharedResult(refresh, signal);
+}
+
+function getInputCostPerM(modelId) {
+  return openrouterPricingCache.get(modelId);
+}
+
+function classifyPriceTier(modelId) {
+  const costPerM = getInputCostPerM(modelId);
+  if (costPerM === undefined) return null;
+  if (costPerM === 0) return 'free';
+  if (costPerM < 0.5) return 'cheap';
+  if (costPerM < 5) return 'medium';
+  return 'expensive';
+}
+
+module.exports = {
+  classifyPriceTier,
+  getInputCostPerM,
+  refreshOllamaModels,
+  refreshProviderModelList,
+};

package/server/services/ai/model_identity.js

@@ -0,0 +1,71 @@
+'use strict';
+
+const MODEL_SELECTION_SEPARATOR = '::';
+
+function createModelSelectionId(provider, modelId) {
+  return `${String(provider).trim().toLowerCase()}${MODEL_SELECTION_SEPARATOR}${String(modelId).trim()}`;
+}
+
+function getRawModelId(model) {
+  return String(model?.modelId || model?.id || '').trim();
+}
+
+function toSelectableModel(model) {
+  const provider = String(model?.provider || '').trim().toLowerCase();
+  const modelId = getRawModelId(model);
+  return {
+    ...model,
+    id: createModelSelectionId(provider, modelId),
+    modelId,
+    provider,
+  };
+}
+
+function resolveModelSelection(models, value, options = {}) {
+  const requested = String(value || '').trim();
+  if (!requested) return null;
+
+  const exact = models.find((model) => model.id === requested);
+  if (exact) return exact;
+
+  const legacyMatches = models.filter((model) => getRawModelId(model) === requested);
+  if (legacyMatches.length <= 1) return legacyMatches[0] || null;
+
+  const preferredProvider = String(options.preferredProvider || '').trim().toLowerCase();
+  if (preferredProvider) {
+    const preferred = legacyMatches.find((model) => model.provider === preferredProvider);
+    if (preferred) return preferred;
+  }
+
+  // Preserve the catalog's stable ordering for legacy, unscoped settings. New
+  // selections always use the provider-scoped id and are therefore unambiguous.
+  return legacyMatches[0];
+}
+
+function normalizeModelSelections(models, values) {
+  if (!Array.isArray(values)) return [];
+  const normalized = [];
+  const seen = new Set();
+  for (const value of values) {
+    const model = resolveModelSelection(models, value);
+    if (!model || seen.has(model.id)) continue;
+    seen.add(model.id);
+    normalized.push(model.id);
+  }
+  return normalized;
+}
+
+function modelMatchesConfiguredId(model, configuredIds) {
+  if (!configuredIds) return false;
+  return configuredIds.has(model.id) || configuredIds.has(getRawModelId(model));
+}
+
+module.exports = {
+  MODEL_SELECTION_SEPARATOR,
+  createModelSelectionId,
+  getRawModelId,
+  modelMatchesConfiguredId,
+  normalizeModelSelections,
+  resolveModelSelection,
+  toSelectableModel,
+};

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;
@@ -350,7 +265,11 @@ async function getProviderHealthCatalog(userId, agentId = null) {
         let availabilityReason = provider.availabilityReason;
 
         if (provider.id === 'ollama' && provider.enabled) {
-            const probe = await probeOllama(provider.baseUrl || AI_PROVIDER_DEFINITIONS.ollama.defaultBaseUrl);
+            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,