neoagent 2.4.1-beta.41 → 2.4.1-beta.43

package/server/services/ai/engine.js

@@ -231,7 +231,7 @@ async function getProviderForUser(userId, task = '', isSubagent = false, modelOv
   };
 }
 
-async function getFailureFallbackModelId(userId, agentId, currentModelId, preferredFallbackId = null) {
+async function getFailureFallbackModelId(userId, agentId, currentModelId, preferredFallbackId = null, failureError = null) {
   const { getSupportedModels } = require('./models');
   const aiSettings = getAiSettings(userId, agentId);
   const models = await getSupportedModels(userId, agentId);
@@ -247,7 +247,12 @@ async function getFailureFallbackModelId(userId, agentId, currentModelId, prefer
     || availableModels.find((model) => model.id === currentModelId)
     || null;
 
-  if (preferredFallbackId && preferredFallbackId !== currentModelId) {
+  // When the failure is a provider-level rate limit, the preferred fallback is
+  // likely on the same provider and will hit the same limit. Skip it and prefer
+  // a fallback from a different provider instead.
+  const isProviderRateLimit = /429|rate.?limit|free-models-per/i.test(String(failureError?.message || ''));
+
+  if (preferredFallbackId && preferredFallbackId !== currentModelId && !isProviderRateLimit) {
     const preferred = pool.find((model) => model.id === preferredFallbackId)
       || availableModels.find((model) => model.id === preferredFallbackId);
     if (preferred) return preferred.id;
@@ -259,6 +264,14 @@ async function getFailureFallbackModelId(userId, agentId, currentModelId, prefer
     if (differentProvider) return differentProvider.id;
   }
 
+  // If no different-provider model exists, still try the preferred fallback
+  // even on rate limits (it's better than nothing).
+  if (preferredFallbackId && preferredFallbackId !== currentModelId) {
+    const preferred = pool.find((model) => model.id === preferredFallbackId)
+      || availableModels.find((model) => model.id === preferredFallbackId);
+    if (preferred) return preferred.id;
+  }
+
   const differentModel = pool.find((model) => model.id !== currentModelId)
     || availableModels.find((model) => model.id !== currentModelId);
   return differentModel?.id || null;
@@ -1093,7 +1106,9 @@ class AgentEngine {
   }
 
   getMessagingRetryLimit(maxIterations) {
-    return Math.max(1, maxIterations);
+    // Cap at 3: more than 3 autonomous messaging retries indicates a structural
+    // problem (model unavailable, bad config) that more retries won't solve.
+    return Math.min(3, Math.max(1, maxIterations));
   }
 
   buildContextMessages(systemPrompt, summaryMessage, historyMessages, recallMsg) {
@@ -1234,7 +1249,7 @@ class AgentEngine {
     let model = selectedProvider.model;
     let providerName = selectedProvider.providerName;
     const switchToFallbackModel = async (failedModel, error, phase) => {
-      const fallbackModelId = await getFailureFallbackModelId(userId, agentId, failedModel, aiSettings.fallback_model_id);
+      const fallbackModelId = await getFailureFallbackModelId(userId, agentId, failedModel, aiSettings.fallback_model_id, error);
       if (!fallbackModelId || fallbackModelId === failedModel) return false;
       console.log(`[Engine] ${phase} failed on ${failedModel}; attempting fallback to: ${fallbackModelId}`);
       this.emit(userId, 'run:interim', {
@@ -1700,7 +1715,7 @@ class AgentEngine {
           } catch (err) {
             console.error(`[Engine] Model call failed (${model}):`, err.message);
             const fallbackModelId = retryForFallback
-              ? await getFailureFallbackModelId(userId, agentId, model, aiSettings.fallback_model_id)
+              ? await getFailureFallbackModelId(userId, agentId, model, aiSettings.fallback_model_id, err)
               : null;
             if (fallbackModelId) {
               const failedModel = model;
@@ -2503,11 +2518,16 @@ class AgentEngine {
 
       const runMeta = this.activeRuns.get(runId);
       const retryCount = Number(options.messagingAutonomousRetryCount || 0);
+      // Rate-limit errors (429) must not trigger messaging retries: the model
+      // won't be available in the milliseconds between retries, so spawning new
+      // runs just compounds the rate-limit pressure with no benefit.
+      const isRateLimitError = /429|rate.?limit|free-models-per/i.test(String(err?.message || ''));
       const canRetryMessagingRun = (
         triggerSource === 'messaging'
         && options.source
         && options.chatId
         && err?.disableAutonomousRetry !== true
+        && !isRateLimitError
         && retryCount < this.getMessagingRetryLimit(maxIterations)
       );
 

package/server/services/ai/models.js

@@ -224,6 +224,14 @@ async function refreshProviderModelList(providerId, apiKey, baseUrl) {
         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 || [];
     }
 }

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

@@ -16,6 +16,8 @@ class OpenRouterProvider extends OpenAICompatibleProvider {
     this.client = new OpenAI({
       apiKey: config.apiKey || process.env.OPENROUTER_API_KEY,
       baseURL: this.baseURL,
+      timeout: 90_000,  // 90 s — free models can queue; avoids hanging forever
+      maxRetries: 0,    // engine handles retries; avoid SDK silently re-queuing slow models
       defaultHeaders: {
         'HTTP-Referer': 'https://github.com/NeoLabs-Systems/NeoAgent',
         'X-Title': 'NeoAgent',
@@ -57,6 +59,14 @@ class OpenRouterProvider extends OpenAICompatibleProvider {
     return params;
   }
 
+  _extractOpenRouterError(obj) {
+    if (!obj) return null;
+    const e = obj.error;
+    if (!e) return null;
+    const msg = e.message || (typeof e === 'string' ? e : JSON.stringify(e));
+    return `OpenRouter: ${msg}${e.code ? ` (code ${e.code})` : ''}`;
+  }
+
   async chat(messages, tools = [], options = {}) {
     const model = options.model || this.getDefaultModel();
     const params = this._buildParams(model, messages, tools, options);
@@ -66,6 +76,12 @@ class OpenRouterProvider extends OpenAICompatibleProvider {
     } catch (err) {
       throw new Error(`OpenRouter request failed: ${err?.message || String(err)}`);
     }
+    // OpenRouter returns HTTP 200 even for errors (rate limits, model unavailable, etc.)
+    const orErr = this._extractOpenRouterError(response);
+    if (orErr) throw new Error(orErr);
+    if (!response?.choices?.length) {
+      throw new Error(`OpenRouter: model returned no choices (may be rate-limited or unavailable)`);
+    }
     return this.normalizeResponse(response);
   }
 
@@ -88,6 +104,9 @@ class OpenRouterProvider extends OpenAICompatibleProvider {
     let content = '';
     let finalUsage = null;
 
+    // The OpenAI SDK converts OpenRouter's SSE error events (data.error) into
+    // APIErrors before yielding — so we wrap the loop to add context.
+    try {
     for await (const chunk of stream) {
       if (chunk.usage && (!chunk.choices || chunk.choices.length === 0)) {
         finalUsage = this.normalizeUsage(chunk.usage);
@@ -127,6 +146,10 @@ class OpenRouterProvider extends OpenAICompatibleProvider {
         return;
       }
     }
+    } catch (err) {
+      // Re-throw SDK APIErrors (from OpenRouter SSE error events) with OpenRouter context.
+      throw new Error(`OpenRouter: ${err?.message || String(err)}`);
+    }
 
     if (toolCalls.length > 0) {
       yield { type: 'tool_calls', toolCalls, content, usage: finalUsage };