neoagent 2.4.1-beta.8 → 2.4.1

package/server/services/ai/imageAnalysis.js

@@ -5,6 +5,7 @@ const path = require('path');
 
 const { getProviderForUser } = require('./engine');
 const { createProviderInstance, getProviderCatalog } = require('./models');
+const { withProviderRetry } = require('./providerRetry');
 
 function resolveImageMimeType(imagePath, overrideMimeType = null) {
   const normalized = String(overrideMimeType || '').trim().toLowerCase();
@@ -76,11 +77,14 @@ async function analyzeImageForUser({
     }
 
     try {
-      const response = await candidate.provider.analyzeImage({
-        imagePath,
-        mimeType: resolveImageMimeType(imagePath, mimeType),
-        question,
-      });
+      const response = await withProviderRetry(
+        () => candidate.provider.analyzeImage({
+          imagePath,
+          mimeType: resolveImageMimeType(imagePath, mimeType),
+          question,
+        }),
+        { label: `ImageAnalysis ${candidate.providerName}` },
+      );
       return {
         description: String(response.content || '').trim(),
         model: response.model || null,

package/server/services/ai/logFormat.js

@@ -0,0 +1,46 @@
+'use strict';
+
+// Small, dependency-free helpers for shaping values into safe log lines and
+// for tolerant JSON parsing. Shared across the AI engine and its sibling
+// modules so log formatting stays consistent and testable.
+
+function shortenRunId(runId) {
+  const value = String(runId || '').trim();
+  if (!value) return 'unknown';
+  return value.length <= 8 ? value : value.slice(0, 8);
+}
+
+function summarizeForLog(value, maxChars = 220) {
+  if (value == null) return '';
+
+  let text = '';
+  if (typeof value === 'string') {
+    text = value;
+  } else {
+    try {
+      text = JSON.stringify(value);
+    } catch {
+      text = String(value);
+    }
+  }
+
+  const normalized = text.replace(/\s+/g, ' ').trim();
+  if (normalized.length <= maxChars) return normalized;
+  return `${normalized.slice(0, maxChars)}...`;
+}
+
+function parseMaybeJson(value, fallback = null) {
+  if (!value) return fallback;
+  if (typeof value === 'object') return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+
+module.exports = {
+  shortenRunId,
+  summarizeForLog,
+  parseMaybeJson,
+};

package/server/services/ai/loopPolicy.js

@@ -46,6 +46,13 @@ function clampFinite(n, lo, hi, fallback) {
  * @returns {LoopPolicy}
  */
 function buildLoopPolicy(aiSettings = {}, triggerType = 'chat', analysisMode = 'execute', options = {}) {
+  const autonomyPolicy = options.autonomyPolicy && typeof options.autonomyPolicy === 'object'
+    ? options.autonomyPolicy
+    : {};
+  const complexity = String(autonomyPolicy.complexity || '').trim().toLowerCase();
+  const autonomyLevel = String(autonomyPolicy.autonomy_level || autonomyPolicy.autonomyLevel || '').trim().toLowerCase();
+  const parallelWork = autonomyPolicy.parallel_work === true || autonomyPolicy.parallelWork === true;
+
   // ── maxIterations ────────────────────────────────────────────────────────
   // Resolve raw value from options → aiSettings → mode/context defaults,
   // then clamp to [1, MAX_ALLOWED_ITERATIONS] and floor to integer.
@@ -58,6 +65,10 @@ function buildLoopPolicy(aiSettings = {}, triggerType = 'chat', analysisMode = '
     rawIterations = DEFAULT_WIDGET_MAX_ITERATIONS;
   } else if (analysisMode === 'plan_execute') {
     rawIterations = DEFAULT_PLAN_EXECUTE_MAX_ITERATIONS;
+  } else if (complexity === 'complex' || autonomyLevel === 'high') {
+    rawIterations = DEFAULT_PLAN_EXECUTE_MAX_ITERATIONS;
+  } else if (parallelWork || complexity === 'standard') {
+    rawIterations = Math.max(DEFAULT_MAX_ITERATIONS, 28);
   } else {
     rawIterations = DEFAULT_MAX_ITERATIONS;
   }

package/server/services/ai/messagingFallback.js

@@ -0,0 +1,228 @@
+'use strict';
+
+// Deterministic, model-free helpers for shaping outgoing messages and for
+// constructing honest fallback replies when a run fails or the model returns a
+// blank message. Kept free of engine state so the behavior is pure and unit
+// testable: every function derives its output from its arguments alone.
+
+const {
+  buildPlatformFormattingGuide,
+  normalizeOutgoingMessageForPlatform,
+} = require('../messaging/formatting_guides');
+const { summarizeForLog } = require('./logFormat');
+
+function normalizeOutgoingMessage(content, platform = null, options = {}) {
+  const normalized = normalizeOutgoingMessageForPlatform(platform, content);
+  if (options.collapseWhitespace === false) {
+    return normalized;
+  }
+  return normalized.replace(/\s+/g, ' ').trim();
+}
+
+function clampRunContext(text, maxChars) {
+  const value = normalizeOutgoingMessage(text);
+  if (!value) return '';
+  if (value.length <= maxChars) return value;
+  return `${value.slice(0, maxChars)}...`;
+}
+
+function joinSentMessages(messages = []) {
+  if (!Array.isArray(messages)) return '';
+  return messages
+    .map((message) => String(message || '').trim())
+    .filter(Boolean)
+    .join('\n\n');
+}
+
+function normalizeInterimText(content, platform = null) {
+  return normalizeOutgoingMessageForPlatform(platform, content, {
+    stripNoResponseMarker: false,
+  }).trim();
+}
+
+function buildBlankMessagingReplyPrompt(attempt, platform = null) {
+  const formattingGuide = buildPlatformFormattingGuide(platform);
+  if (attempt <= 1) {
+    return `You must send one non-empty reply for the external messaging user right now. Do not call tools. Give either: (a) the concrete outcome, or (b) a clear blocker. If tool work already happened, summarize what you actually tried and where it got blocked. Do not ask the user to repeat the original request. Do not promise future work unless that work already happened in this run or will happen automatically before this reply is sent.\n\n${formattingGuide}`;
+  }
+
+  return `Your previous reply was empty. Return one non-empty message now. Do not call tools. If needed, apologize briefly and explain the blocker in one sentence. Use the run evidence already in the conversation instead of asking the user to restate the task. Do not promise future work unless that work already happened in this run or will happen automatically before this reply is sent.\n\n${formattingGuide}`;
+}
+
+function parseToolExecutionSummary(item) {
+  if (!item?.summary) return null;
+  try {
+    const parsed = JSON.parse(item.summary);
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function toolWorkDescription(toolName) {
+  const name = String(toolName || '');
+  if (name === 'execute_command') return 'ran shell commands';
+  if (name === 'read_file' || name === 'search_files' || name === 'list_directory') return 'checked files';
+  if (name === 'web_search' || name === 'http_request') return 'looked up supporting information';
+  if (name.startsWith('browser_')) return 'checked the browser state';
+  if (name.startsWith('android_')) return 'checked the Android state';
+  if (name === 'read_health_data' || name.startsWith('recordings_')) return 'checked stored data';
+  return '';
+}
+
+function summarizeRecentWork(toolExecutions = []) {
+  const descriptions = [];
+  for (const item of toolExecutions.slice(-6)) {
+    const description = toolWorkDescription(item?.toolName);
+    if (!description || descriptions.includes(description)) continue;
+    descriptions.push(description);
+    if (descriptions.length >= 2) break;
+  }
+
+  if (descriptions.length === 0) return '';
+  if (descriptions.length === 1) return `I ${descriptions[0]}`;
+  return `I ${descriptions[0]} and ${descriptions[1]}`;
+}
+
+function hasFailureSignal(text) {
+  const normalized = normalizeOutgoingMessage(text);
+  if (!normalized) return false;
+  return /\b(error|failed|failure|traceback|exception|timed out|timeout|not found|no such file|permission denied|unable to|cannot|could not|module not found)\b/i.test(normalized);
+}
+
+function extractToolFailureMessage(item) {
+  const directError = normalizeOutgoingMessage(item?.error || '');
+  if (directError) return directError;
+
+  const summary = parseToolExecutionSummary(item);
+  if (!summary) return '';
+
+  const candidates = [
+    summary.message,
+    summary.note,
+    summary.stderr,
+    summary.stdout,
+    summary.content,
+    summary.excerpt,
+    summary.result,
+    summary.summary,
+  ];
+
+  if (summary.status === 'error') {
+    for (const candidate of candidates) {
+      const normalized = normalizeOutgoingMessage(candidate || '');
+      if (normalized) return normalized;
+    }
+    if (summary.exitCode != null) {
+      return `The last shell command exited with code ${summary.exitCode}`;
+    }
+  }
+
+  for (const candidate of candidates) {
+    const normalized = normalizeOutgoingMessage(candidate || '');
+    if (hasFailureSignal(normalized)) return normalized;
+  }
+
+  return '';
+}
+
+function buildDeterministicMessagingFallback({ failedStepCount, stepIndex, toolExecutions = [] }) {
+  const workSummary = summarizeRecentWork(toolExecutions);
+  const blocker = [...toolExecutions].reverse()
+    .map((item) => extractToolFailureMessage(item))
+    .find(Boolean);
+
+  if (workSummary && blocker) {
+    return `${workSummary}, but I got blocked: ${blocker}. I do not have a confirmed finished result yet.`;
+  }
+  if (blocker) {
+    return `I got blocked while working on this: ${blocker}. I do not have a confirmed finished result yet.`;
+  }
+  if (workSummary && stepIndex > 0) {
+    return `${workSummary}, but I do not have a confirmed finished result yet.`;
+  }
+  if (failedStepCount > 0) {
+    return 'I ran into a tool problem while working on your request, so I do not have a confirmed finished result yet.';
+  }
+  if (stepIndex > 0) {
+    return 'I completed part of the work, but I do not have a confirmed finished result yet.';
+  }
+  return 'I could not produce a reliable final reply just now.';
+}
+
+function buildMessagingFailureScenario({ err, failedStepCount, stepIndex, toolExecutions = [] }) {
+  const parts = [];
+  const runtimeError = normalizeOutgoingMessage(err?.message || '');
+  const workSummary = summarizeRecentWork(toolExecutions);
+  const blocker = [...toolExecutions].reverse()
+    .map((item) => extractToolFailureMessage(item))
+    .find(Boolean);
+
+  if (runtimeError) {
+    parts.push(`Runtime error: ${summarizeForLog(runtimeError, 260)}.`);
+  }
+  if (workSummary) {
+    parts.push(`Observed work before failure: ${workSummary}.`);
+  }
+  if (blocker) {
+    parts.push(`Most specific blocker from run evidence: ${summarizeForLog(blocker, 260)}.`);
+  }
+  if (stepIndex > 0) {
+    parts.push(`Completed steps before failure: ${stepIndex}.`);
+  }
+  if (failedStepCount > 0) {
+    parts.push(`Failed tool steps: ${failedStepCount}.`);
+  }
+
+  return parts.join(' ');
+}
+
+function buildDeterministicMessagingErrorReply({ err, failedStepCount, stepIndex, toolExecutions = [] }) {
+  const message = normalizeOutgoingMessage(err?.message || '');
+  if (/no ai providers? are currently available/i.test(message)) {
+    return 'I cannot continue right now because no AI provider is available for this account. Please check the provider settings.';
+  }
+
+  if (/(timeout|timed out)/i.test(message)) {
+    return 'I hit a timeout while processing your request and could not finish it reliably.';
+  }
+
+  const blocker = [...toolExecutions].reverse()
+    .map((item) => extractToolFailureMessage(item))
+    .find(Boolean);
+  if (blocker) {
+    return `I got blocked while checking this: ${blocker}.`;
+  }
+
+  if (message) {
+    return `I got blocked while working on this: ${message}.`;
+  }
+
+  return buildDeterministicMessagingFallback({ failedStepCount, stepIndex, toolExecutions });
+}
+
+function buildModelFailureLoopPrompt({ failedModel, nextModel, errorMessage }) {
+  return [
+    `The previous model call on "${failedModel}" failed with: ${summarizeForLog(errorMessage, 220)}.`,
+    `Continue on "${nextModel}" and recover autonomously.`,
+    'If a previous plan depended on that failed call, adjust your approach and proceed end-to-end.',
+    'Only ask the user for help if no safe path remains.'
+  ].join(' ');
+}
+
+module.exports = {
+  normalizeOutgoingMessage,
+  clampRunContext,
+  joinSentMessages,
+  normalizeInterimText,
+  buildBlankMessagingReplyPrompt,
+  parseToolExecutionSummary,
+  toolWorkDescription,
+  summarizeRecentWork,
+  hasFailureSignal,
+  extractToolFailureMessage,
+  buildDeterministicMessagingFallback,
+  buildMessagingFailureScenario,
+  buildDeterministicMessagingErrorReply,
+  buildModelFailureLoopPrompt,
+};

package/server/services/ai/models.js

@@ -6,6 +6,9 @@ const { OpenAIProvider } = require('./providers/openai');
 const { GithubCopilotProvider } = require('./providers/githubCopilot');
 const { OpenAICodexProvider } = require('./providers/openaiCodex');
 const { ClaudeCodeProvider } = require('./providers/claudeCode');
+const { GrokOAuthProvider } = require('./providers/grokOauth');
+const { NvidiaProvider } = require('./providers/nvidia');
+const { OpenRouterProvider } = require('./providers/openrouter');
 const {
     AI_PROVIDER_DEFINITIONS,
     getProviderConfigs,
@@ -13,12 +16,21 @@ const {
 } = require('./settings');
 
 const STATIC_MODELS = [
+    // — xAI OAuth — fallback entries shown when grok-oauth token is invalid/exhausted.
+    // When the token is valid, DYNAMIC_PROVIDERS will replace these with the live list.
     {
-        id: 'grok-4-1-fast-reasoning',
-        label: 'Grok 4.1 (Personality / Default)',
-        provider: 'grok',
-        purpose: 'general'
+        id: 'grok-4',
+        label: 'Grok 4 (xAI OAuth)',
+        provider: 'grok-oauth',
+        purpose: 'general',
+    },
+    {
+        id: 'grok-4-mini',
+        label: 'Grok 4 Mini (xAI OAuth)',
+        provider: 'grok-oauth',
+        purpose: 'fast',
     },
+    // — GitHub Copilot (subscription; no public /models endpoint) ————————
     {
         id: 'gpt-5.3',
         label: 'GPT-5.3 (Copilot Default)',
@@ -31,6 +43,7 @@ const STATIC_MODELS = [
         provider: 'github-copilot',
         purpose: 'coding'
     },
+    // — OpenAI Codex ——————————————————————————————————————————————————————
     {
         id: 'gpt-5.5',
         label: 'GPT-5.5 (Codex Default)',
@@ -49,29 +62,12 @@ const STATIC_MODELS = [
         provider: 'openai-codex',
         purpose: 'general'
     },
+    // — Claude Code ————————————————————————————————————————————————————————
     {
-        id: 'gpt-5-nano',
-        label: 'GPT-5 Nano (Fast / Subagents)',
-        provider: 'openai',
-        purpose: 'fast'
-    },
-    {
-        id: 'gpt-5-mini',
-        label: 'GPT-5 Mini (Planning / Complex)',
-        provider: 'openai',
-        purpose: 'planning'
-    },
-    {
-        id: 'claude-sonnet-4-20250514',
-        label: 'Claude Sonnet 4 (Analysis / Writing)',
-        provider: 'anthropic',
-        purpose: 'planning'
-    },
-    {
-        id: 'claude-3-5-haiku-20241022',
-        label: 'Claude 3.5 Haiku (Fast)',
-        provider: 'anthropic',
-        purpose: 'fast'
+        id: 'claude-opus-4-8',
+        label: 'Claude Opus 4.8 (Claude Code / Flagship)',
+        provider: 'claude-code',
+        purpose: 'general'
     },
     {
         id: 'claude-opus-4-7',
@@ -91,29 +87,155 @@ const STATIC_MODELS = [
         provider: 'claude-code',
         purpose: 'fast'
     },
-    {
-        id: 'gemini-3.1-flash-lite-preview',
-        label: 'Gemini 3.1 Flash Lite (Preview)',
-        provider: 'google',
-        purpose: 'general'
-    },
+    // — MiniMax ————————————————————————————————————————————————————————————
     {
         id: 'MiniMax-M2.7',
         label: 'MiniMax M2.7 (Coding Plan)',
         provider: 'minimax',
         purpose: 'coding'
     },
+    // — Ollama — default suggestions (full list loaded dynamically) ————————
     {
         id: 'qwen3.5:4b',
         label: 'Qwen 3.5 4B (Local / Ollama)',
         provider: 'ollama',
-        purpose: 'general'
+        purpose: 'general',
+    },
+    {
+        id: 'gemma4:12b',
+        label: 'Gemma 4 12B (Local / Ollama)',
+        provider: 'ollama',
+        purpose: 'general',
     }
 ];
 
+// Maps a provider id to its class and which runtime fields its constructor takes.
+// Adding a provider is a one-line entry here instead of another dispatch branch.
+// `apiKey`/`baseUrl` mirror exactly what each constructor was historically given;
+// they intentionally do not derive from AI_PROVIDER_DEFINITIONS.supportsBaseUrl,
+// which disagrees for github-copilot/openai-codex (those read their base URL from
+// env, not from per-user config).
+const PROVIDER_FACTORIES = Object.freeze({
+    grok: { Provider: GrokProvider, apiKey: true, baseUrl: true },
+    openai: { Provider: OpenAIProvider, apiKey: true, baseUrl: true },
+    anthropic: { Provider: AnthropicProvider, apiKey: true, baseUrl: true },
+    google: { Provider: GoogleProvider, apiKey: true, baseUrl: false },
+    minimax: { Provider: AnthropicProvider, apiKey: true, baseUrl: true },
+    ollama: { Provider: OllamaProvider, apiKey: false, baseUrl: true },
+    'github-copilot': { Provider: GithubCopilotProvider, apiKey: true, baseUrl: false },
+    'openai-codex': { Provider: OpenAICodexProvider, apiKey: true, baseUrl: false },
+    'claude-code': { Provider: ClaudeCodeProvider, apiKey: true, baseUrl: false },
+    'grok-oauth': { Provider: GrokOAuthProvider, apiKey: true, baseUrl: false },
+    nvidia: { Provider: NvidiaProvider, apiKey: true, baseUrl: true },
+    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);
@@ -277,8 +399,9 @@ async function getSupportedModels(userId, agentId = null) {
 
     const all = [...STATIC_MODELS];
     const staticIds = new Set(STATIC_MODELS.map((model) => model.id));
-    const ollama = providerById.get('ollama');
 
+    // Ollama: dynamic list from local server
+    const ollama = providerById.get('ollama');
     if (ollama?.enabled) {
         const dynamicModels = await refreshDynamicModels(ollama.baseUrl);
         for (const model of dynamicModels) {
@@ -288,10 +411,35 @@ async function getSupportedModels(userId, agentId = null) {
         }
     }
 
+    // API-backed providers: fetch model lists in parallel
+    const dynamicFetches = DYNAMIC_PROVIDERS
+        .filter((id) => providerById.get(id)?.available)
+        .map(async (id) => {
+            const runtime = getProviderRuntimeConfig(userId, id, agentId);
+            return refreshProviderModelList(id, runtime.apiKey, runtime.baseUrl);
+        });
+
+    const dynamicResults = await Promise.allSettled(dynamicFetches);
+    for (const result of dynamicResults) {
+        if (result.status === 'fulfilled') {
+            for (const model of result.value) {
+                if (!staticIds.has(model.id)) {
+                    all.push(model);
+                }
+            }
+        }
+    }
+
     return all.map((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).
+        const priceTier = model.provider === 'ollama'
+            ? 'free'
+            : (model.priceTier ?? classifyPriceTier(model.id));
         return {
             ...model,
+            priceTier,
             available: provider?.available !== false,
             providerStatus: provider?.status || 'unknown',
             providerStatusLabel: provider?.statusLabel || 'Unknown'
@@ -315,7 +463,7 @@ async function refreshDynamicModels(baseUrl) {
             id: name,
             label: `${name} (Ollama / Local)`,
             provider: 'ollama',
-            purpose: 'general'
+            purpose: 'general',
         }));
 
         dynamicModelsByBaseUrl.set(cacheKey, {
@@ -331,6 +479,11 @@ async function refreshDynamicModels(baseUrl) {
 }
 
 function createProviderInstance(providerStr, userId = null, configOverrides = {}) {
+    const factory = PROVIDER_FACTORIES[providerStr];
+    if (!factory) {
+        throw new Error(`Unknown provider: ${providerStr}`);
+    }
+
     const { agentId = null, ...providerOverrides } = configOverrides || {};
     const runtime = getProviderRuntimeConfig(userId, providerStr, agentId);
 
@@ -341,30 +494,16 @@ function createProviderInstance(providerStr, userId = null, configOverrides = {}
         throw new Error(`Provider '${providerStr}' is not configured on this deployment.`);
     }
 
-    if (providerStr === 'grok') {
-        return new GrokProvider({ apiKey: runtime.apiKey, baseUrl: runtime.baseUrl, ...providerOverrides });
-    } else if (providerStr === 'openai') {
-        return new OpenAIProvider({ apiKey: runtime.apiKey, baseUrl: runtime.baseUrl, ...providerOverrides });
-    } else if (providerStr === 'anthropic') {
-        return new AnthropicProvider({ apiKey: runtime.apiKey, baseUrl: runtime.baseUrl, ...providerOverrides });
-    } else if (providerStr === 'google') {
-        return new GoogleProvider({ apiKey: runtime.apiKey, ...providerOverrides });
-    } else if (providerStr === 'minimax') {
-        return new AnthropicProvider({ apiKey: runtime.apiKey, baseUrl: runtime.baseUrl, ...providerOverrides });
-    } else if (providerStr === 'ollama') {
-        return new OllamaProvider({ baseUrl: runtime.baseUrl, ...providerOverrides });
-    } else if (providerStr === 'github-copilot') {
-        return new GithubCopilotProvider({ apiKey: runtime.apiKey, ...providerOverrides });
-    } else if (providerStr === 'openai-codex') {
-        return new OpenAICodexProvider({ apiKey: runtime.apiKey, ...providerOverrides });
-    } else if (providerStr === 'claude-code') {
-        return new ClaudeCodeProvider({ apiKey: runtime.apiKey, ...providerOverrides });
-    }
-    throw new Error(`Unknown provider: ${providerStr}`);
+    const config = {};
+    if (factory.apiKey) config.apiKey = runtime.apiKey;
+    if (factory.baseUrl) config.baseUrl = runtime.baseUrl;
+
+    return new factory.Provider({ ...config, ...providerOverrides });
 }
 
 module.exports = {
     AI_PROVIDER_DEFINITIONS,
+    PROVIDER_FACTORIES,
     SUPPORTED_MODELS: STATIC_MODELS, // Backward compatibility
     createProviderInstance,
     getProviderCatalog,