neoagent 3.2.1-beta.7 → 3.2.1-beta.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neoagent",
-  "version": "3.2.1-beta.7",
+  "version": "3.2.1-beta.9",
   "description": "Self-hosted AI agent for long-running tasks, automation, messaging, device control, and local memory",
   "license": "AGPL-3.0-only",
   "main": "server/index.js",
@@ -68,7 +68,7 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
     "@bitwarden/cli": "^2026.6.0",
-    "@google/generative-ai": "^0.24.0",
+    "@google/genai": "^2.13.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@remotion/cli": "^4.0.459",
     "@slidev/cli": "^52.18.0",

package/server/http/routes.js

@@ -56,6 +56,13 @@ function registerApiRoutes(app) {
   if (isBillingEnabled()) {
     app.use('/api/billing/webhook', require('../routes/billing_webhook'));
     app.use('/api/billing', require('../routes/billing'));
+  } else {
+    // The Flutter client probes this public endpoint to decide whether to show
+    // billing. Return an explicit disabled state instead of generating a noisy
+    // 404 on every client startup.
+    app.get('/api/billing/plans', (_req, res) => {
+      res.json({ enabled: false, plans: null });
+    });
   }
 
   setupTelnyxWebhook(app);

package/server/public/.last_build_id

@@ -1 +1 @@
-4e3d49d31cbb561d89adf60e16759ebe
+1a325740c55a320441979a83b65c758d

package/server/public/flutter_bootstrap.js

@@ -33,10 +33,10 @@ addEventListener("message", eventListener);
 if (!window._flutter) {
   window._flutter = {};
 }
-_flutter.buildConfig = {"engineRevision":"69c8c61792f04cc809dfef0c910414fb9afc06cd","builds":[{"compileTarget":"dart2js","renderer":"canvaskit","mainJsPath":"main.dart.js"},{}]};
+_flutter.buildConfig = {"engineRevision":"0cd610717bde95fd88343c64f81c11ba4e5c0010","builds":[{"compileTarget":"dart2js","renderer":"canvaskit","mainJsPath":"main.dart.js"},{}]};
 
 _flutter.loader.load({
   serviceWorkerSettings: {
-    serviceWorkerVersion: "3827219452" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
+    serviceWorkerVersion: "393614478" /* Flutter's service worker is deprecated and will be removed in a future Flutter release. */
   }
 });

package/server/public/main.dart.js

@@ -44367,7 +44367,7 @@ $S:4}
 A.bnI.prototype={
 $1(a){var s=A.fp().b
 s=s==null?null:s.canvasKitBaseUrl
-return(s==null?"https://www.gstatic.com/flutter-canvaskit/69c8c61792f04cc809dfef0c910414fb9afc06cd/":s)+a},
+return(s==null?"https://www.gstatic.com/flutter-canvaskit/0cd610717bde95fd88343c64f81c11ba4e5c0010/":s)+a},
 $S:42}
 A.a2F.prototype={
 gF(a){var s=this.a
@@ -144506,7 +144506,7 @@ if(r){r=s.d
 r===$&&A.b()
 p.push(A.ju(q,A.jx(!1,new A.Y(B.wP,A.cU(new A.cH(B.kE,new A.acU(r,q),q),q,q),q),!1,B.J,!0),q,q,0,0,0,q))}if(!s.ay){r=s.e
 r===$&&A.b()
-r=B.b.t("mry3rvmk-b952e5d").length!==0&&r.b}else r=!1
+r=B.b.t("ms0ggj2e-2c398a2").length!==0&&r.b}else r=!1
 if(r){r=s.d
 r===$&&A.b()
 r=r.aU&&!r.ag?84:0
@@ -150393,7 +150393,7 @@ $S:0}
 A.a3j.prototype={}
 A.WC.prototype={
 r9(a){var s=this
-if(B.b.t("mry3rvmk-b952e5d").length===0||s.a!=null)return
+if(B.b.t("ms0ggj2e-2c398a2").length===0||s.a!=null)return
 s.Co()
 s.a=A.mL(B.Yh,new A.bmK(s))},
 Co(){var s=0,r=A.l(t.H),q,p=2,o=[],n=this,m,l,k,j,i,h,g,f
@@ -150411,7 +150411,7 @@ if(!t.f.b(k)){s=1
 break}i=J.a0(k,"buildId")
 h=i==null?null:B.b.t(J.q(i))
 j=h==null?"":h
-if(J.bv(j)===0||J.e(j,"mry3rvmk-b952e5d")){s=1
+if(J.bv(j)===0||J.e(j,"ms0ggj2e-2c398a2")){s=1
 break}n.b=!0
 n.H()
 p=2
@@ -150428,7 +150428,7 @@ case 2:return A.i(o.at(-1),r)}})
 return A.k($async$Co,r)},
 wV(){var s=0,r=A.l(t.H),q,p=2,o=[],n=this,m,l,k,j,i,h,g,f,e,d,c,b,a,a0,a1
 var $async$wV=A.h(function(a2,a3){if(a2===1){o.push(a3)
-s=p}for(;;)switch(s){case 0:if(B.b.t("mry3rvmk-b952e5d").length===0||n.c){s=1
+s=p}for(;;)switch(s){case 0:if(B.b.t("ms0ggj2e-2c398a2").length===0||n.c){s=1
 break}n.c=!0
 n.H()
 p=4

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

@@ -87,6 +87,7 @@ const {
 } = require('../messagingFallback');
 const { isDeferredWorkReply } = require('../terminal_reply');
 const {
+  assessResearchAdequacy,
   summarizeToolExecutions,
 } = require('../toolEvidence');
 const {
@@ -793,6 +794,11 @@ class AgentEngine {
   }) {
     const runMeta = options?.runId ? this.getRunMeta(options.runId) : null;
     const goalContext = resolveRunGoalContext(runMeta, analysis, plan);
+    const researchAdequacy = assessResearchAdequacy({
+      analysis,
+      goalContext,
+      toolExecutions,
+    });
     const response = await this.requestStructuredJson({
       provider,
       providerName,
@@ -808,6 +814,8 @@ class AgentEngine {
         lastReply,
         iteration,
         maxIterations,
+        analysis,
+        researchAdequacy,
       }),
       maxTokens: 500,
       normalize: (raw) => normalizeCompletionDecision(raw, 'continue'),
@@ -817,9 +825,15 @@ class AgentEngine {
       phase: 'completion_decision',
     });
     return {
-      decision: enforceTerminalReplyDecision(response.value, lastReply),
+      decision: enforceTerminalReplyDecision(response.value, lastReply, {
+        analysis,
+        goalContext,
+        toolExecutions,
+        researchAdequacy,
+      }),
       usage: response.usage,
       raw: response.raw,
+      researchAdequacy,
     };
   }
 
@@ -905,6 +919,12 @@ class AgentEngine {
         goalContext,
         toolExecutions,
         iteration,
+        analysis,
+        researchAdequacy: assessResearchAdequacy({
+          analysis,
+          goalContext,
+          toolExecutions,
+        }),
       }),
       maxTokens: 200,
       normalize: normalizeChurnAssessment,

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

@@ -2,8 +2,13 @@
 
 const { normalizeCompletionConfidence } = require('../completion');
 const { normalizeOutgoingMessage } = require('../messagingFallback');
-const { isDeferredWorkReply } = require('../terminal_reply');
 const {
+  isDeferredWorkReply,
+  isTerminalQuestionOrBlockerReply,
+} = require('../terminal_reply');
+const {
+  assessResearchAdequacy,
+  formatResearchAdequacyGuidance,
   summarizeAvailableTools,
   summarizeToolExecutions,
 } = require('../toolEvidence');
@@ -195,8 +200,15 @@ function buildCompletionDecisionPrompt({
   lastReply,
   iteration,
   maxIterations,
+  analysis = null,
+  researchAdequacy = null,
 }) {
   const draftReply = normalizeOutgoingMessage(lastReply) || '';
+  const adequacy = researchAdequacy || assessResearchAdequacy({
+    analysis,
+    goalContext,
+    toolExecutions,
+  });
   const lines = [
     'Return JSON only.',
     'Decide whether this run should continue autonomously or stop now.',
@@ -211,13 +223,29 @@ function buildCompletionDecisionPrompt({
     '- A tool-specific API error, timeout, rate limit, or missing result inside this run is usually "continue", not "blocked", if any other available tool could still make progress.',
     '- Repeated read-only inspection that has already established the relevant object is absent or unchanged is not progress. Accept a concise complete/blocker reply instead of requiring more searching.',
     `- If completion_confidence_required is ${goalContext.effectiveCompletionConfidence} and the latest draft depends on unverified assumptions, use "continue" so the run can gather evidence, inspect state, or narrow the reply.`,
-    triggerSource === 'messaging' && messagingSent
-      ? '- A final reply was already delivered via send_message. Use "complete" unless concrete task work remains.'
-      : triggerSource === 'messaging'
-        ? '- For messaging, do not stop on a partial status message. Continue unless the task is actually complete or externally blocked.'
-        : '- Do not stop just because you wrote a status update. Continue unless the task is actually complete or externally blocked.',
+    '- When research intensity is light or deep, use "continue" until the required primary/source coverage and target coverage are met, or the draft is an explicit blocker naming exactly what could not be verified.',
+    '- Search snippets, memory, and model priors are leads, not completion evidence. Prefer opened/fetched primary sources before "complete".',
   ];
 
+  if (adequacy.intensity !== 'none') {
+    lines.push(
+      `- Research intensity for this run is ${adequacy.intensity}. Current coverage: primary=${adequacy.primarySourceCount}/${adequacy.requiredPrimarySources}, secondary=${adequacy.secondarySourceCount}, targets_covered=${adequacy.coveredTargets.length}/${Math.max(adequacy.requiredTargetCoverage, adequacy.targets.length)}.`,
+    );
+  }
+  if (adequacy.adequate === false) {
+    lines.push(
+      `- Research is still incomplete (${adequacy.reason}). Use "continue" unless the latest draft is an explicit blocker naming the exact missing evidence.`,
+    );
+  }
+
+  if (triggerSource === 'messaging' && messagingSent) {
+    lines.push('- A final reply was already delivered via send_message. Use "complete" unless concrete task work remains.');
+  } else if (triggerSource === 'messaging') {
+    lines.push('- For messaging, do not stop on a partial status message. Continue unless the task is actually complete or externally blocked.');
+  } else {
+    lines.push('- Do not stop just because you wrote a status update. Continue unless the task is actually complete or externally blocked.');
+  }
+
   lines.push(
     goalContext.effectiveGoal ? `Goal: ${goalContext.effectiveGoal}` : '',
     goalContext.persistedGoalPrompt,
@@ -228,6 +256,16 @@ function buildCompletionDecisionPrompt({
     `Current iteration: ${iteration} of ${maxIterations}.`,
     `Available tools in this run: ${summarizeAvailableTools(tools) || 'none'}`,
     `Recent tool evidence:\n${summarizeToolExecutions(toolExecutions, 8) || 'none'}`,
+    adequacy.intensity !== 'none'
+      ? `Research adequacy: intensity=${adequacy.intensity}; adequate=${adequacy.adequate}; reason=${adequacy.reason}`
+      : '',
+    adequacy.targets.length
+      ? `Research targets: ${adequacy.targets.join('; ')}`
+      : '',
+    adequacy.uncoveredTargets.length
+      ? `Uncovered research targets: ${adequacy.uncoveredTargets.join('; ')}`
+      : '',
+    formatResearchAdequacyGuidance(adequacy),
     `Latest draft reply:\n${draftReply || '(empty)'}`,
   );
   return lines.filter(Boolean).join('\n');
@@ -242,14 +280,39 @@ function normalizeCompletionDecision(raw, fallbackStatus = 'continue') {
   };
 }
 
-function enforceTerminalReplyDecision(decision, lastReply) {
-  if (decision?.status === 'continue' || !isDeferredWorkReply(lastReply)) {
-    return decision;
+function enforceTerminalReplyDecision(decision, lastReply, options = {}) {
+  if (isDeferredWorkReply(lastReply)) {
+    return {
+      status: 'continue',
+      reason: 'The latest reply only announces or promises unfinished work; the run must continue or return a concrete blocker.',
+    };
   }
-  return {
-    status: 'continue',
-    reason: 'The latest reply only announces or promises unfinished work; the run must continue or return a concrete blocker.',
-  };
+  if (decision?.status === 'continue' && isTerminalQuestionOrBlockerReply(lastReply)) {
+    return {
+      status: 'blocked',
+      reason: 'The latest reply asks for user input or states a concrete blocker, so the run must wait instead of repeating it.',
+    };
+  }
+
+  const researchAdequacy = options.researchAdequacy
+    || assessResearchAdequacy({
+      analysis: options.analysis || null,
+      goalContext: options.goalContext || null,
+      toolExecutions: options.toolExecutions || [],
+    });
+  if (
+    researchAdequacy
+    && researchAdequacy.adequate === false
+    && (decision?.status === 'complete' || decision?.status === 'blocked')
+    && !isTerminalQuestionOrBlockerReply(lastReply)
+  ) {
+    return {
+      status: 'continue',
+      reason: researchAdequacy.reason
+        || 'Research evidence is still incomplete for the requested targets; continue gathering sources before finishing.',
+    };
+  }
+  return decision;
 }
 
 // Intentionally lightweight (200-token cap, self-contained) so the model can
@@ -260,7 +323,14 @@ function buildChurnAssessmentPrompt({
   goalContext,
   toolExecutions,
   iteration,
+  analysis = null,
+  researchAdequacy = null,
 }) {
+  const adequacy = researchAdequacy || assessResearchAdequacy({
+    analysis,
+    goalContext,
+    toolExecutions,
+  });
   const lines = [
     'Return JSON only.',
     'Self-assess your current loop state — are you making genuine progress or spinning?',
@@ -274,11 +344,19 @@ function buildChurnAssessmentPrompt({
       : '',
     `Iteration: ${iteration}`,
     `Recent tool evidence:\n${summarizeToolExecutions(toolExecutions, 6) || 'none'}`,
+    adequacy.intensity !== 'none'
+      ? `Research adequacy: intensity=${adequacy.intensity}; adequate=${adequacy.adequate}; covered=${adequacy.coveredTargets.length}/${Math.max(adequacy.requiredTargetCoverage, adequacy.targets.length)}; primary=${adequacy.primarySourceCount}/${adequacy.requiredPrimarySources}.`
+      : '',
+    adequacy.uncoveredTargets.length
+      ? `Still uncovered research targets: ${adequacy.uncoveredTargets.join('; ')}.`
+      : '',
     '',
     'Assessment rules:',
     '- "progressing": You are systematically gathering necessary context and the next concrete action is already determined — you know exactly what to do next.',
     '- "churn": You are re-reading/re-searching information already in context, or exploring without a clear next concrete step. Accept the nudge and act.',
     '- "blocked": No concrete action is available in this run. You have all the evidence needed to deliver a truthful final answer or a specific external blocker.',
+    '- For multi-target research, keep "progressing" while uncovered targets remain and a fresh primary source can still be opened. Do not mark "blocked" just because you have partial notes.',
+    '- Re-querying the same snippet source for an already covered target is "churn". Opening a different primary source for an uncovered target is "progressing".',
   ];
   return lines.filter(Boolean).join('\n');
 }

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

@@ -422,13 +422,20 @@ async function getFailureFallbackModelId(
   preferredFallbackId = null,
   failureError = null,
   signal = null,
+  excludedModelIds = [],
 ) {
   const { getSupportedModels } = require('../models');
   const aiSettings = getAiSettings(userId, agentId);
   const models = await getSupportedModels(userId, agentId, { signal });
+  const excluded = new Set(
+    [...excludedModelIds]
+      .map((id) => String(id || '').trim())
+      .filter(Boolean),
+  );
   const availableModels = models.filter(
     (model) => model.available !== false
-      && !isModelCoolingDown(userId, agentId, model.id),
+      && !isModelCoolingDown(userId, agentId, model.id)
+      && !excluded.has(model.id),
   );
   const configuredEnabledIds = Array.isArray(aiSettings.enabled_models)
     ? aiSettings.enabled_models.map((id) => String(id).trim()).filter(Boolean)
@@ -438,15 +445,26 @@ async function getFailureFallbackModelId(
     ? availableModels.filter((model) => enabledIds.includes(model.id))
     : availableModels;
   const fallbackSearchPool = pool;
-  const currentModel = resolveModelSelection(pool, currentModelId)
-    || resolveModelSelection(availableModels, 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 || ''));
+  const currentModel = resolveModelSelection(models, currentModelId);
+
+  // Provider-wide failures (credentials, throttling, or service outages) are
+  // likely to affect another model on the same provider. Prefer a different
+  // provider before consulting the configured fallback.
+  const failureStatus = Number(
+    failureError?.status
+    ?? failureError?.statusCode
+    ?? failureError?.response?.status,
+  );
+  const isProviderScopedFailure = (
+    failureStatus === 401
+    || failureStatus === 403
+    || failureStatus === 429
+    || (failureStatus >= 500 && failureStatus < 600)
+    || /rate.?limit|free-models-per|service unavailable|provider unavailable|authentication|api key/i
+      .test(String(failureError?.message || ''))
+  );
 
-  if (preferredFallbackId && !isProviderRateLimit) {
+  if (preferredFallbackId && !isProviderScopedFailure) {
     const preferred = resolveModelSelection(fallbackSearchPool, preferredFallbackId)
       || resolveModelSelection(availableModels, preferredFallbackId);
     if (preferred && preferred.id !== currentModel?.id) return preferred.id;
@@ -458,8 +476,7 @@ async function getFailureFallbackModelId(
     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 no different-provider model exists, still try the preferred fallback.
   if (preferredFallbackId) {
     const preferred = resolveModelSelection(fallbackSearchPool, preferredFallbackId)
       || resolveModelSelection(availableModels, preferredFallbackId);
@@ -491,6 +508,7 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
   let model = null;
   let modelSelectionId = null;
   let providerName = null;
+  const modelTurnFailedModelSelectionIds = new Set();
   let messages = [];
   let iteration = 0;
   let totalTokens = 0;
@@ -606,8 +624,17 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
   }
   db.prepare('UPDATE agent_runs SET model = ?, updated_at = datetime(\'now\') WHERE id = ?')
     .run(modelSelectionId, runId);
-  const switchToFallbackModel = async (failedSelectionId, error, phase) => {
+  const recordFailedModel = (failedSelectionId, error, excludedModels) => {
+    excludedModels.add(failedSelectionId);
     recordModelFailure(userId, agentId, failedSelectionId, error);
+  };
+  const switchToFallbackModel = async (
+    failedSelectionId,
+    error,
+    phase,
+    excludedModels,
+  ) => {
+    recordFailedModel(failedSelectionId, error, excludedModels);
     const fallbackModelId = await getFailureFallbackModelId(
       userId,
       agentId,
@@ -615,9 +642,21 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
       aiSettings.fallback_model_id,
       error,
       engine.getRunMeta(runId)?.abortController?.signal,
+      excludedModels,
     );
     if (!fallbackModelId || fallbackModelId === failedSelectionId) return false;
-    console.log(`[Engine] ${phase} failed on ${failedSelectionId}; attempting fallback to: ${fallbackModelId}`);
+    const failureSummary = summarizeForLog(error?.message || error, 180);
+    console.log(
+      `[Engine] ${phase} failed on ${failedSelectionId}: ${failureSummary}; attempting fallback to: ${fallbackModelId}`
+    );
+    engine.recordRunEvent(userId, runId, 'model_fallback', {
+      phase,
+      failedModel: failedSelectionId,
+      fallbackModel: fallbackModelId,
+      errorCode: error?.code || null,
+      errorStatus: error?.status || error?.statusCode || error?.response?.status || null,
+      error: failureSummary,
+    }, { agentId });
     engine.emit(userId, 'run:interim', {
       runId,
       message: `Model service failed on ${failedSelectionId}; retrying with ${fallbackModelId}.`,
@@ -647,17 +686,28 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
     return true;
   };
   const runWithModelFallback = async (phase, fn) => {
-    try {
-      const result = await fn();
-      recordModelSuccess(userId, agentId, modelSelectionId);
-      return result;
-    } catch (err) {
-      const failedSelectionId = modelSelectionId;
-      const switched = await switchToFallbackModel(failedSelectionId, err, phase);
-      if (!switched) throw err;
-      const result = await fn();
-      recordModelSuccess(userId, agentId, modelSelectionId);
-      return result;
+    let recoveries = 0;
+    const failedModels = new Set();
+    while (true) {
+      try {
+        const result = await fn();
+        recordModelSuccess(userId, agentId, modelSelectionId);
+        return result;
+      } catch (err) {
+        if (recoveries >= loopPolicy.maxModelFailureRecoveries) {
+          recordFailedModel(modelSelectionId, err, failedModels);
+          throw err;
+        }
+        const failedSelectionId = modelSelectionId;
+        const switched = await switchToFallbackModel(
+          failedSelectionId,
+          err,
+          phase,
+          failedModels,
+        );
+        if (!switched) throw err;
+        recoveries += 1;
+      }
     }
   };
 
@@ -1483,102 +1533,69 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
       let responseModel = model;
       let streamContent = '';
 
-      const tryModelCall = async (retryForFallback = true) => {
-        try {
-          const modelCall = await engine.requestModelResponse({
-            provider,
-            providerName,
-            model,
-            messages,
-            tools,
-            options: {
-              ...options,
-              userId,
-              agentId,
-              runId,
-              phase: 'model_turn',
-              signal: engine.getRunMeta(runId)?.abortController?.signal,
-            },
-            runId,
-            iteration,
-          });
-          response = modelCall.response;
-          responseModel = modelCall.responseModel;
-          streamContent = modelCall.streamContent;
-          recordModelSuccess(userId, agentId, modelSelectionId);
-        } catch (err) {
-          console.error(`[Engine] Model call failed (${model}):`, err.message);
-          recordModelFailure(userId, agentId, modelSelectionId, err);
-          const fallbackModelId = retryForFallback
-            ? await getFailureFallbackModelId(
-              userId,
-              agentId,
-              modelSelectionId,
-              aiSettings.fallback_model_id,
-              err,
-              engine.getRunMeta(runId)?.abortController?.signal,
-            )
-            : null;
-          if (fallbackModelId) {
-            const failedModel = model;
-            console.log(`[Engine] Attempting fallback to: ${fallbackModelId}`);
-            const fallback = await getProviderForUser(
-              userId,
-              userMessage,
-              triggerType === 'subagent',
-              fallbackModelId,
-              {
-                ...providerStatusConfig,
-                signal: engine.getRunMeta(runId)?.abortController?.signal,
-              }
-            );
-            provider = fallback.provider;
-            model = fallback.model;
-            modelSelectionId = fallback.modelSelectionId;
-            providerName = fallback.providerName;
-            db.prepare('UPDATE agent_runs SET model = ?, updated_at = datetime(\'now\') WHERE id = ?')
-              .run(modelSelectionId, runId);
-            Object.assign(engine.getRunMeta(runId) || {}, {
-              model,
-              modelSelectionId,
-              providerName,
-            });
-
-            const retryMessages = sanitizeConversationMessages([
-              ...messages,
-              {
-                role: 'system',
-                content: buildModelFailureLoopPrompt({
-                  failedModel,
-                  nextModel: model,
-                  errorMessage: err.message
-                })
-              }
-            ]);
-
-            const fallbackCall = await engine.requestModelResponse({
+      const tryModelCall = async () => {
+        let requestMessages = messages;
+        let requestPhase = 'model_turn';
+        while (true) {
+          try {
+            const modelCall = await engine.requestModelResponse({
               provider,
               providerName,
               model,
-              messages: retryMessages,
+              messages: requestMessages,
               tools,
               options: {
                 ...options,
                 userId,
                 agentId,
                 runId,
-                phase: 'model_turn_fallback',
+                phase: requestPhase,
                 signal: engine.getRunMeta(runId)?.abortController?.signal,
               },
               runId,
               iteration,
             });
-            response = fallbackCall.response;
-            responseModel = fallbackCall.responseModel;
-            streamContent = fallbackCall.streamContent;
+            response = modelCall.response;
+            responseModel = modelCall.responseModel;
+            streamContent = modelCall.streamContent;
             recordModelSuccess(userId, agentId, modelSelectionId);
-          } else {
-            throw err;
+            return;
+          } catch (err) {
+            console.error(`[Engine] Model call failed (${model}):`, err.message);
+            const runSignal = engine.getRunMeta(runId)?.abortController?.signal;
+            if (isAbortError(err) || runSignal?.aborted) throw err;
+            if (modelFailureRecoveries >= loopPolicy.maxModelFailureRecoveries) {
+              recordFailedModel(
+                modelSelectionId,
+                err,
+                modelTurnFailedModelSelectionIds,
+              );
+              throw err;
+            }
+
+            const failedModel = model;
+            const switched = await switchToFallbackModel(
+              modelSelectionId,
+              err,
+              'model turn',
+              modelTurnFailedModelSelectionIds,
+            );
+            if (!switched) throw err;
+
+            modelFailureRecoveries += 1;
+            failedStepCount += 1;
+            requestPhase = 'model_turn_fallback';
+            requestMessages = sanitizeConversationMessages([
+              ...messages,
+              {
+                role: 'system',
+                content: buildModelFailureLoopPrompt({
+                  failedModel,
+                  nextModel: model,
+                  errorMessage: err.message
+                })
+              }
+            ]);
           }
         }
       };
@@ -1601,30 +1618,6 @@ async function runConversation(engine, userId, userMessage, options = {}, _model
           continue;
         }
         if (lifecycleControl?.action === 'stop' || lifecycleControl?.action === 'interrupt') break;
-        const modelError = String(err?.message || 'Model call failed');
-
-        if (modelFailureRecoveries < loopPolicy.maxModelFailureRecoveries) {
-          const failedModel = model;
-          const switched = await switchToFallbackModel(modelSelectionId, err, 'model turn');
-          if (!switched) throw err;
-          modelFailureRecoveries += 1;
-          failedStepCount += 1;
-          messages.push({
-            role: 'system',
-            content: buildModelFailureLoopPrompt({
-              failedModel,
-              nextModel: model,
-              errorMessage: modelError
-            })
-          });
-          engine.emit(userId, 'run:interim', {
-            runId,
-            message: 'Model call failed; adapting and retrying autonomously.',
-            phase: 'recovering'
-          });
-          continue;
-        }
-
         throw err;
       }