neoagent 3.2.1-beta.0 → 3.2.1-beta.10

package/server/services/ai/loop/progress_classification.js

@@ -182,7 +182,9 @@ function buildReadOnlyChurnGuidance({ readOnlyCount = 0, alreadyRead = '' } = {}
       : 'Do not re-read or re-search anything already in this conversation.',
     'Decide from the evidence you have now.',
     'If the requested work is already done, no matching target exists, or the available tools cannot make the change, call task_complete with that truthful final answer or blocker.',
+    'If research targets remain uncovered, open a new primary source for one uncovered target now instead of re-querying the same lead.',
     'If exactly one concrete safe action remains, take that action now. Otherwise finish; more poking around is not progress.',
+    'Never invent missing targets, products, people, files, or outcomes to make the answer look complete.',
   ].join(' ');
 }
 

package/server/services/ai/loop/tool_dispatch.js

@@ -4,7 +4,10 @@ const { v4: uuidv4 } = require('uuid');
 const db = require('../../../db/database');
 const { globalHooks } = require('../hooks');
 const { summarizeForLog } = require('../logFormat');
-const { inferToolFailureMessage } = require('../toolEvidence');
+const {
+  inferToolFailureMessage,
+  resolveDeclaredToolAccess,
+} = require('../toolEvidence');
 
 function getAvailableTools(_engine, app, options = {}) {
   const { getAvailableTools: loadAvailableTools } = require('../tools');
@@ -16,8 +19,21 @@ async function executeTool(engine, toolName, args, context) {
   return runTool(toolName, args, context, engine);
 }
 
-function isReadOnlyToolCall(toolCall) {
+function isReadOnlyToolCall(toolCall, toolDefinition = null) {
   const name = String(toolCall?.function?.name || '');
+  let toolArgs = {};
+  try {
+    toolArgs = typeof toolCall?.function?.arguments === 'string'
+      ? JSON.parse(toolCall.function.arguments || '{}')
+      : (toolCall?.function?.arguments || {});
+  } catch {
+    return false;
+  }
+
+  const declaredAccess = resolveDeclaredToolAccess(toolDefinition, toolArgs);
+  if (declaredAccess === 'read') return true;
+  if (declaredAccess === 'write') return false;
+
   const readOnly = new Set([
     'read_file',
     'read_files',
@@ -35,12 +51,7 @@ function isReadOnlyToolCall(toolCall) {
     'read_health_data',
   ]);
   if (name === 'http_request') {
-    try {
-      const args = JSON.parse(toolCall.function.arguments || '{}');
-      return String(args.method || 'GET').toUpperCase() === 'GET';
-    } catch {
-      return false;
-    }
+    return String(toolArgs.method || 'GET').toUpperCase() === 'GET';
   }
   return readOnly.has(name);
 }
@@ -145,6 +156,14 @@ async function executeReadOnlyBatch(engine, toolCalls, context = {}) {
   }, { agentId });
   const results = await Promise.all(prepared.map(async (item) => {
     if (item.blocked) return item;
+    const runMeta = engine.getRunMeta(runId);
+    if (!runMeta || runMeta.status !== 'running') {
+      const result = { status: 'paused', reason: 'Run paused before this read-only call started.' };
+      db.prepare(
+        `UPDATE agent_steps SET status = 'paused', result = ?, completed_at = datetime('now') WHERE id = ? AND status = 'running'`,
+      ).run(JSON.stringify(result), item.stepId);
+      return { ...item, result };
+    }
     const startedAt = Date.now();
     try {
       const result = await executeTool(engine, item.toolName, item.toolArgs, {
@@ -162,6 +181,7 @@ async function executeReadOnlyBatch(engine, toolCalls, context = {}) {
         deliveryState: options.deliveryState || null,
         allowMultipleProactiveMessages: options.allowMultipleProactiveMessages === true,
         allowExternalSideEffects: false,
+        signal: runMeta.abortController?.signal,
       });
       const error = inferToolFailureMessage(item.toolName, result);
       const status = error ? 'failed' : 'completed';

package/server/services/ai/loopPolicy.js

@@ -1,21 +1,24 @@
-// Limits resolve in priority order: per-run options → agent AI settings → hardcoded defaults.
+// Limits resolve in priority order: per-run options → agent AI settings → conservative defaults.
 // They are safety nets only; task_complete / progress guards are the real exit signals.
 
 // The iteration ceiling is a pure runaway safety net, NOT the primary stop signal.
 // A run stops when it makes no real progress (consecutiveReadOnlyIterations cap,
-// which resets the moment the agent does anything state-changing), or when the
+// which resets on a state change or genuinely new evidence), or when the
 // repetition / tool-failure / model-recovery guards fire, or when the model signals
 // task_complete. These ceilings are set high so they only ever catch a genuine
 // runaway and never guillotine a long, legitimately-progressing complex task.
 const DEFAULT_MAX_ITERATIONS = 250;
+const DEFAULT_SIMPLE_MAX_ITERATIONS = 16;
 const DEFAULT_WIDGET_MAX_ITERATIONS = 150;
 const DEFAULT_PLAN_EXECUTE_MAX_ITERATIONS = 250;
 // Less aggressive than 0.60 so the model retains file contents it already read for
 // longer, instead of losing them to compaction and re-reading the same files.
 const DEFAULT_COMPACTION_THRESHOLD = 0.80;
-// The real "stop when stuck" guard. Counts consecutive turns of pure reading/
-// searching/inspecting with zero state change; resets to 0 on any concrete progress.
+// The real "stop when stuck" guard. Counts consecutive turns with no state
+// change and no new evidence; resets to 0 on any concrete progress.
 const DEFAULT_MAX_CONSECUTIVE_READ_ONLY_ITERATIONS = 8;
+const DEFAULT_SIMPLE_MAX_CONSECUTIVE_READ_ONLY_ITERATIONS = 3;
+const DEFAULT_COMPLEX_MAX_CONSECUTIVE_READ_ONLY_ITERATIONS = 14;
 const DEFAULT_MAX_CONSECUTIVE_TOOL_FAILURES = 5;
 const DEFAULT_MAX_MODEL_FAILURE_RECOVERIES = 3;
 
@@ -25,8 +28,9 @@ const MAX_ALLOWED_TOOL_FAILURES = 50;
 const MAX_ALLOWED_MODEL_RECOVERIES = 10;
 const MAX_ALLOWED_BUDGET_CHARS = 500_000;
 
-function finitePositive(n, fallback) {
-  return Number.isFinite(n) && n > 0 ? n : fallback;
+function optionalNumber(value) {
+  if (value == null || value === '') return Number.NaN;
+  return Number(value);
 }
 
 function clampFinite(n, lo, hi, fallback) {
@@ -56,6 +60,10 @@ function buildLoopPolicy(aiSettings = {}, triggerType = 'chat', analysisMode = '
     rawIterations = DEFAULT_PLAN_EXECUTE_MAX_ITERATIONS;
   } else if (complexity === 'complex' || autonomyLevel === 'high') {
     rawIterations = DEFAULT_PLAN_EXECUTE_MAX_ITERATIONS;
+  } else if (analysisMode === 'direct_answer' || complexity === 'simple') {
+    // Short Q&A / casual chat must stay cheap. This is a hard runaway cap, not
+    // a target: direct answers usually finish in 0-1 model turns.
+    rawIterations = DEFAULT_SIMPLE_MAX_ITERATIONS;
   } else if (parallelWork || complexity === 'standard') {
     rawIterations = Math.max(DEFAULT_MAX_ITERATIONS, 28);
   } else {
@@ -70,41 +78,58 @@ function buildLoopPolicy(aiSettings = {}, triggerType = 'chat', analysisMode = '
 
   // ── Tool result size budget ───────────────────────────────────────────────
   // Must be a finite positive integer; bad values fall back to 2400.
-  const defaultBudget = clampFinite(
-    Math.floor(Number(aiSettings.tool_replay_budget_chars) || 0),
-    500,
-    MAX_ALLOWED_BUDGET_CHARS,
-    2400,
-  );
+  const requestedDefaultBudget = optionalNumber(aiSettings.tool_replay_budget_chars);
+  const defaultBudget = Number.isFinite(requestedDefaultBudget) && requestedDefaultBudget > 0
+    ? clampFinite(Math.floor(requestedDefaultBudget), 500, MAX_ALLOWED_BUDGET_CHARS, 2400)
+    : 2400;
 
   // ── Scalar policy fields ─────────────────────────────────────────────────
   const maxConsecutiveToolFailures = clampFinite(
-    Math.floor(Number(aiSettings.max_consecutive_tool_failures)),
+    Math.floor(optionalNumber(
+      options.maxConsecutiveToolFailures
+      ?? aiSettings.max_consecutive_tool_failures,
+    )),
     1,
     MAX_ALLOWED_TOOL_FAILURES,
     DEFAULT_MAX_CONSECUTIVE_TOOL_FAILURES,
   );
 
   const maxModelFailureRecoveries = clampFinite(
-    Math.floor(Number(aiSettings.max_model_failure_recoveries)),
+    Math.floor(optionalNumber(
+      options.maxModelFailureRecoveries
+      ?? aiSettings.max_model_failure_recoveries,
+    )),
     0,
     MAX_ALLOWED_MODEL_RECOVERIES,
     DEFAULT_MAX_MODEL_FAILURE_RECOVERIES,
   );
 
+  let defaultReadOnlyIterations = DEFAULT_MAX_CONSECUTIVE_READ_ONLY_ITERATIONS;
+  if (analysisMode === 'direct_answer' || complexity === 'simple') {
+    defaultReadOnlyIterations = DEFAULT_SIMPLE_MAX_CONSECUTIVE_READ_ONLY_ITERATIONS;
+  } else if (
+    analysisMode === 'plan_execute'
+    || complexity === 'complex'
+    || autonomyLevel === 'high'
+  ) {
+    // Long-horizon research/implementation needs more productive read/search
+    // room before the hard no-progress wrap-up fires.
+    defaultReadOnlyIterations = DEFAULT_COMPLEX_MAX_CONSECUTIVE_READ_ONLY_ITERATIONS;
+  }
+
   const rawReadOnlyIterations = options.maxConsecutiveReadOnlyIterations != null
     ? Number(options.maxConsecutiveReadOnlyIterations)
-    : Number(aiSettings.max_consecutive_read_only_iterations);
+    : optionalNumber(aiSettings.max_consecutive_read_only_iterations);
   const maxConsecutiveReadOnlyIterations = clampFinite(
     Math.floor(rawReadOnlyIterations),
     3,
     MAX_ALLOWED_READ_ONLY_ITERATIONS,
-    DEFAULT_MAX_CONSECUTIVE_READ_ONLY_ITERATIONS,
+    defaultReadOnlyIterations,
   );
 
   // compactionThreshold must be in (0, 1]; clamp to [0.1, 1].
   const compactionThreshold = clampFinite(
-    Number(aiSettings.compaction_threshold),
+    optionalNumber(options.compactionThreshold ?? aiSettings.compaction_threshold),
     0.1,
     1,
     DEFAULT_COMPACTION_THRESHOLD,
@@ -122,9 +147,9 @@ function buildLoopPolicy(aiSettings = {}, triggerType = 'chat', analysisMode = '
     // Per-category tool result size budgets (chars)
     toolResultBudget: {
       default: defaultBudget,
-      file:    clampFinite(Math.floor(Number(aiSettings.tool_replay_budget_file_chars)),    500, MAX_ALLOWED_BUDGET_CHARS, Math.max(defaultBudget, 6000)),
-      browser: clampFinite(Math.floor(Number(aiSettings.tool_replay_budget_browser_chars)), 500, MAX_ALLOWED_BUDGET_CHARS, Math.max(defaultBudget, 4000)),
-      command: clampFinite(Math.floor(Number(aiSettings.tool_replay_budget_command_chars)), 500, MAX_ALLOWED_BUDGET_CHARS, Math.max(defaultBudget, 4000)),
+      file:    clampFinite(Math.floor(optionalNumber(aiSettings.tool_replay_budget_file_chars)),    500, MAX_ALLOWED_BUDGET_CHARS, Math.max(defaultBudget, 6000)),
+      browser: clampFinite(Math.floor(optionalNumber(aiSettings.tool_replay_budget_browser_chars)), 500, MAX_ALLOWED_BUDGET_CHARS, Math.max(defaultBudget, 4000)),
+      command: clampFinite(Math.floor(optionalNumber(aiSettings.tool_replay_budget_command_chars)), 500, MAX_ALLOWED_BUDGET_CHARS, Math.max(defaultBudget, 4000)),
     },
 
     // Hard ceiling is always 2× soft, capped at a reasonable absolute max
@@ -152,7 +177,9 @@ function resolveChurnNudgeThreshold(goalContract) {
   const complexity = String(goalContract?.complexity || 'standard').toLowerCase();
   const autonomyLevel = String(goalContract?.autonomyLevel || goalContract?.autonomy_level || 'normal').toLowerCase();
   if (complexity === 'simple') return 2;
-  if (complexity === 'complex' || autonomyLevel === 'high') return 5;
+  // Complex/high-autonomy work, including multi-target research, should get more
+  // productive inspection room before the soft churn nudge fires.
+  if (complexity === 'complex' || autonomyLevel === 'high') return 6;
   return 3;
 }
 

package/server/services/ai/messagingFallback.js

@@ -43,10 +43,10 @@ function normalizeInterimText(content, platform = null) {
 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 `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. Keep the same text-native voice you use with this user: short, direct, human. 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}`;
+  return `Your previous reply was empty. Return one non-empty message now. Do not call tools. If needed, explain the blocker in one short human sentence. Use the run evidence already in the conversation instead of asking the user to restate the task. Stay text-native and direct. 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 buildProgressUpdatePrompt() {
@@ -68,7 +68,7 @@ function buildProgressUpdatePrompt() {
 
 function buildMaxIterationWrapupPrompt(platform = null) {
   const formattingGuide = buildPlatformFormattingGuide(platform);
-  return `You have reached the step limit for this run, so this is your final turn. Stop here and do NOT call any tools. Write the single best, most complete answer you can for the user from the work already done in this conversation: lead with the concrete results and what you accomplished, then clearly name anything you could not finish and the specific blocker. Do not output a half-finished thought, a plan for what to do next, or a "let me…" fragment, this message is the final reply. Do not promise future work unless it already happened in this run.\n\n${formattingGuide}`;
+  return `You have reached the step limit for this run, so this is your final turn. Stop here and do NOT call any tools. Write the single best, most complete answer you can for the user from the work already done in this conversation: lead with the concrete results and what you accomplished, then clearly name anything you could not finish and the specific blocker. Do not invent entities, products, people, files, outcomes, or tool results that are not already supported by evidence in this conversation. Do not output a half-finished thought, a plan for what to do next, or a "let me…" fragment, this message is the final reply. Do not promise future work unless it already happened in this run.\n\n${formattingGuide}`;
 }
 
 function parseToolExecutionSummary(item) {
@@ -102,8 +102,8 @@ function summarizeRecentWork(toolExecutions = []) {
   }
 
   if (descriptions.length === 0) return '';
-  if (descriptions.length === 1) return `I ${descriptions[0]}`;
-  return `I ${descriptions[0]} and ${descriptions[1]}`;
+  if (descriptions.length === 1) return descriptions[0];
+  return `${descriptions[0]} and ${descriptions[1]}`;
 }
 
 function hasFailureSignal(text) {
@@ -122,7 +122,7 @@ function summarizeUserVisibleBlocker(text) {
   const normalized = normalizeOutgoingMessage(text);
   if (!normalized) return '';
   if (isInternalToolingFailure(normalized)) {
-    return 'I hit an internal tool issue while checking that';
+    return 'hit an internal tool issue while checking that';
   }
   return normalized;
 }
@@ -171,21 +171,21 @@ function buildDeterministicMessagingFallback({ failedStepCount, stepIndex, toolE
     .find(Boolean);
 
   if (workSummary && blocker) {
-    return `${workSummary}, but I got blocked: ${blocker}. I do not have a confirmed finished result yet.`;
+    return `${workSummary}, but hit a wall: ${blocker}. no finished result yet.`;
   }
   if (blocker) {
-    return `I got blocked while working on this: ${blocker}. I do not have a confirmed finished result yet.`;
+    return `got blocked on this: ${blocker}. no finished result yet.`;
   }
   if (workSummary && stepIndex > 0) {
-    return `${workSummary}, but I do not have a confirmed finished result yet.`;
+    return `${workSummary}, but no 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.';
+    return 'hit a tool problem while working on this, so no finished result yet.';
   }
   if (stepIndex > 0) {
-    return 'I completed part of the work, but I do not have a confirmed finished result yet.';
+    return 'got partway through, but no finished result yet.';
   }
-  return 'I could not produce a reliable final reply just now.';
+  return 'could not land a reliable final reply just now.';
 }
 
 function buildMessagingFailureScenario({ err, failedStepCount, stepIndex, toolExecutions = [] }) {
@@ -218,11 +218,11 @@ function buildMessagingFailureScenario({ err, failedStepCount, stepIndex, toolEx
 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.';
+    return 'can\'t continue right now: no AI provider is available for this account. check provider settings and I can pick it back up.';
   }
 
   if (/(timeout|timed out)/i.test(message)) {
-    return 'I hit a timeout while processing your request and could not finish it reliably.';
+    return 'timed out while working on that, so I could not finish it cleanly.';
   }
 
   const blocker = [...toolExecutions].reverse()
@@ -230,15 +230,15 @@ function buildDeterministicMessagingErrorReply({ err, failedStepCount, stepIndex
     .map((value) => summarizeUserVisibleBlocker(value))
     .find(Boolean);
   if (blocker) {
-    return `I got blocked while checking this: ${blocker}.`;
+    return `got blocked while checking this: ${blocker}.`;
   }
 
   if (isInternalToolingFailure(message)) {
-    return 'I hit an internal tool issue while checking that, so I do not have a verified answer yet.';
+    return 'hit an internal tool issue while checking that, so no verified answer yet.';
   }
 
   if (message) {
-    return `I got blocked while working on this: ${message}.`;
+    return `got blocked while working on this: ${message}.`;
   }
 
   return buildDeterministicMessagingFallback({ failedStepCount, stepIndex, toolExecutions });

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_failure_cache.js

@@ -0,0 +1,108 @@
+'use strict';
+
+const { isAbortError } = require('../../utils/abort');
+const {
+  getErrorCode,
+  getHttpStatus,
+  isTransientIoError,
+  retryAfterMilliseconds,
+} = require('../../utils/retry');
+
+const DEFAULT_COOLDOWN_MS = 15 * 60 * 1000;
+const DEFAULT_RECOVERY_COOLDOWN_MS = 60 * 1000;
+const failures = new Map();
+
+function cacheKey(userId, agentId, modelSelectionId) {
+  return [
+    String(userId ?? ''),
+    String(agentId ?? 'main'),
+    String(modelSelectionId || '').trim(),
+  ].join(':');
+}
+
+function readPermanentCooldownMs() {
+  const configured = Number(process.env.NEOAGENT_MODEL_NOT_FOUND_COOLDOWN_MS);
+  if (!Number.isFinite(configured)) return DEFAULT_COOLDOWN_MS;
+  return Math.max(1_000, Math.min(configured, 24 * 60 * 60 * 1000));
+}
+
+function readRecoveryCooldownMs() {
+  const configured = Number(process.env.NEOAGENT_MODEL_RECOVERY_COOLDOWN_MS);
+  if (!Number.isFinite(configured)) return DEFAULT_RECOVERY_COOLDOWN_MS;
+  return Math.max(1_000, Math.min(configured, 15 * 60 * 1000));
+}
+
+function isPermanentModelFailure(error) {
+  const status = getHttpStatus(error);
+  if (status === 404) return true;
+  return /\b404\b.*\b(model|nim|provider|request)\b|\b(model|nim)\b.*\b404\b/i
+    .test(String(error?.message || ''));
+}
+
+function isRecoverableModelFailure(error) {
+  if (!error || isAbortError(error) || isPermanentModelFailure(error)) return false;
+  const status = getHttpStatus(error);
+  if (status === 401 || status === 403 || status === 429 || (status >= 500 && status < 600)) {
+    return true;
+  }
+  const code = String(getErrorCode(error) || '');
+  if (code === 'MODEL_EMPTY_RESPONSE' || code === 'MODEL_CALL_TIMEOUT') return true;
+  if (isTransientIoError(error)) return true;
+  return /\bempty response|temporarily unavailable|overloaded|rate.?limit|timed? ?out|network error\b/i
+    .test(String(error?.message || ''));
+}
+
+function resolveCooldownMs(error, now) {
+  if (isPermanentModelFailure(error)) return readPermanentCooldownMs();
+  if (!isRecoverableModelFailure(error)) return 0;
+
+  const configured = readRecoveryCooldownMs();
+  const retryAfter = retryAfterMilliseconds(
+    error?.headers || error?.response?.headers,
+    now,
+  );
+  if (!Number.isFinite(retryAfter)) return configured;
+  return Math.max(configured, Math.min(retryAfter, 15 * 60 * 1000));
+}
+
+function recordModelFailure(userId, agentId, modelSelectionId, error, now = Date.now()) {
+  const modelId = String(modelSelectionId || '').trim();
+  const cooldownMs = resolveCooldownMs(error, now);
+  if (!modelId || cooldownMs <= 0) return false;
+  failures.set(cacheKey(userId, agentId, modelId), {
+    expiresAt: now + cooldownMs,
+  });
+  return true;
+}
+
+function recordModelSuccess(userId, agentId, modelSelectionId) {
+  const modelId = String(modelSelectionId || '').trim();
+  if (!modelId) return false;
+  return failures.delete(cacheKey(userId, agentId, modelId));
+}
+
+function isModelCoolingDown(userId, agentId, modelSelectionId, now = Date.now()) {
+  const modelId = String(modelSelectionId || '').trim();
+  if (!modelId) return false;
+  const key = cacheKey(userId, agentId, modelId);
+  const entry = failures.get(key);
+  if (!entry) return false;
+  if (entry.expiresAt <= now) {
+    failures.delete(key);
+    return false;
+  }
+  return true;
+}
+
+function clearModelFailureCache() {
+  failures.clear();
+}
+
+module.exports = {
+  clearModelFailureCache,
+  isModelCoolingDown,
+  isPermanentModelFailure,
+  isRecoverableModelFailure,
+  recordModelFailure,
+  recordModelSuccess,
+};