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

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

@@ -0,0 +1,108 @@
+'use strict';
+
+const db = require('../../../db/database');
+
+const TERMINAL_STATUSES = new Set(['completed', 'failed', 'stopped', 'interrupted']);
+const CONTROL_PRIORITY = Object.freeze({ pause: 1, stop: 2, interrupt: 3 });
+
+function getRunControl(runId) {
+  return db.prepare(
+    `SELECT action, reason, requested_at
+     FROM agent_run_controls
+     WHERE run_id = ? AND consumed_at IS NULL`,
+  ).get(runId) || null;
+}
+
+function requestRunControl(runId, userId, action, reason = '') {
+  if (!Object.hasOwn(CONTROL_PRIORITY, action)) {
+    throw new Error(`Unsupported run control action: ${action}`);
+  }
+  const run = db.prepare(
+    'SELECT status FROM agent_runs WHERE id = ? AND user_id = ?',
+  ).get(runId, userId);
+  if (!run) return { accepted: false, reason: 'not_found' };
+  if (TERMINAL_STATUSES.has(run.status)) return { accepted: false, reason: 'terminal', status: run.status };
+
+  const existing = getRunControl(runId);
+  if (existing && CONTROL_PRIORITY[existing.action] > CONTROL_PRIORITY[action]) {
+    return { accepted: false, reason: 'stronger_signal_pending', action: existing.action };
+  }
+  db.prepare(
+    `INSERT INTO agent_run_controls (run_id, user_id, action, reason)
+     VALUES (?, ?, ?, ?)
+     ON CONFLICT(run_id) DO UPDATE SET
+       action = excluded.action,
+       reason = excluded.reason,
+       requested_at = datetime('now'),
+       consumed_at = NULL`,
+  ).run(runId, userId, action, String(reason || '').slice(0, 1000));
+  return { accepted: true, action };
+}
+
+function checkpointRun(runId, phase, state = {}) {
+  db.prepare(
+    `INSERT INTO agent_run_checkpoints (run_id, version, phase, state_json)
+     VALUES (?, 1, ?, ?)
+     ON CONFLICT(run_id) DO UPDATE SET
+       version = 1,
+       phase = excluded.phase,
+       state_json = excluded.state_json,
+       updated_at = datetime('now')`,
+  ).run(runId, phase, JSON.stringify(state));
+}
+
+function transitionRun(runId, status, fields = {}, allowed = ['running']) {
+  const assignments = ['status = ?', "updated_at = datetime('now')"];
+  const values = [status];
+  if (Object.hasOwn(fields, 'error')) {
+    assignments.push('error = ?');
+    values.push(fields.error || null);
+  }
+  if (Object.hasOwn(fields, 'finalResponse')) {
+    assignments.push('final_response = ?');
+    values.push(fields.finalResponse || null);
+  }
+  if (Object.hasOwn(fields, 'totalTokens')) {
+    assignments.push('total_tokens = ?');
+    values.push(Number(fields.totalTokens) || 0);
+  }
+  if (TERMINAL_STATUSES.has(status)) assignments.push("completed_at = COALESCE(completed_at, datetime('now'))");
+  const placeholders = allowed.map(() => '?').join(', ');
+  values.push(runId, ...allowed);
+  const result = db.prepare(
+    `UPDATE agent_runs SET ${assignments.join(', ')}
+     WHERE id = ? AND status IN (${placeholders})`,
+  ).run(...values);
+  return result.changes > 0;
+}
+
+function closeRun(runId, status, fields = {}, allowed = ['running']) {
+  const transaction = db.transaction(() => {
+    if (!transitionRun(runId, status, fields, allowed)) return false;
+    db.prepare(
+      `UPDATE agent_steps
+       SET status = ?, error = COALESCE(NULLIF(error, ''), ?), completed_at = COALESCE(completed_at, datetime('now'))
+       WHERE run_id = ? AND status = 'running'`,
+    ).run(status, fields.error || null, runId);
+    db.prepare(
+      `UPDATE agent_delegations
+       SET status = ?, error = COALESCE(NULLIF(error, ''), ?), updated_at = datetime('now'), completed_at = COALESCE(completed_at, datetime('now'))
+       WHERE parent_run_id = ? AND status = 'running'`,
+    ).run(status, fields.error || null, runId);
+    db.prepare(
+      `UPDATE agent_run_controls SET consumed_at = datetime('now')
+       WHERE run_id = ? AND consumed_at IS NULL`,
+    ).run(runId);
+    return true;
+  });
+  return transaction();
+}
+
+module.exports = {
+  TERMINAL_STATUSES,
+  checkpointRun,
+  closeRun,
+  getRunControl,
+  requestRunControl,
+  transitionRun,
+};

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

@@ -6,7 +6,12 @@ const {
 const {
   normalizeOutgoingMessage,
 } = require('../messagingFallback');
-const { withProviderRetry, isTransientError } = require('../providerRetry');
+const { withProviderRetry } = require('../providerRetry');
+const {
+  abortableDelay,
+  getErrorCode,
+  getHttpStatus,
+} = require('../../../utils/retry');
 const { shortenRunId, summarizeForLog } = require('../logFormat');
 const {
   TICK_MS,
@@ -16,6 +21,15 @@ const {
   evaluateProgressLiveness,
 } = require('./progress_monitor');
 
+const SAFE_PRE_DELIVERY_NETWORK_CODES = new Set([
+  'EAI_AGAIN',
+  'ENOTFOUND',
+  'ECONNREFUSED',
+  'ENETUNREACH',
+  'EHOSTUNREACH',
+  'UND_ERR_CONNECT_TIMEOUT',
+]);
+
 function isoNow() {
   return new Date().toISOString();
 }
@@ -39,9 +53,26 @@ function requireSuccessfulMessagingDelivery(result, label = 'Messaging delivery'
   const error = new Error(`${label} failed: ${reason}`);
   error.code = 'MESSAGING_DELIVERY_FAILED';
   error.deliveryResult = result || null;
+  error.safeToRetry = result?.safeToRetry === true;
+  error.deliveryAmbiguous = result?.deliveryAmbiguous === true;
   throw error;
 }
 
+function isSafeMessagingDeliveryRetry(error) {
+  if (!error || error.retryable === false || error.deliveryAmbiguous === true) return false;
+  if (error.safeToRetry === true) return true;
+  const result = error.deliveryResult;
+  if (result?.deliveryAmbiguous === true || result?.retryable === false) return false;
+  if (result?.success === false) return true;
+
+  // A rate-limit response explicitly rejected the request. DNS/connect failures
+  // happen before a platform can accept it. Timeouts, resets, broken pipes, and
+  // generic 5xx responses are intentionally excluded because the message may
+  // already have been accepted and retrying would duplicate it.
+  if (getHttpStatus(error) === 429) return true;
+  return SAFE_PRE_DELIVERY_NETWORK_CODES.has(String(getErrorCode(error) || ''));
+}
+
 // Harness-driven progress: the originating chat must see autonomous updates during
 // long runs even when a weak model never calls send_interim_update itself. The
 // supervisor paces this call (FIRST/REPEAT thresholds + a repeat guard). The update
@@ -66,13 +97,30 @@ async function sendRuntimeMessagingHeartbeat(engine, runId, options = {}) {
     && typeof runMeta.composeProgressUpdate === 'function') {
     let statusMsg = '';
     try {
-      const composed = await runMeta.composeProgressUpdate({ stalled: options.stalled === true });
+      const composed = await runMeta.composeProgressUpdate({
+        stalled: options.stalled === true,
+        signal: runMeta.messagingProgressSupervisor?.abortController?.signal || null,
+      });
       if (normalizeOutgoingMessage(composed, platform)) statusMsg = String(composed).trim();
     } catch { /* no dynamic update available this tick */ }
+    const currentRunMeta = engine.getRunMeta(runId);
+    if (
+      currentRunMeta !== runMeta
+      || runMeta.aborted
+      || runMeta.status !== 'running'
+      || runMeta.terminalInterim
+      || runMeta.finalDeliverySent
+      || runMeta.deliveryState?.finalContentDelivered === true
+    ) {
+      return { sent: false, skipped: true, terminal: true };
+    }
     if (statusMsg) try {
       const delivery = await engine.messagingManager.sendMessage(runMeta.userId, platform, chatId, statusMsg, {
         runId,
         agentId: runMeta.agentId,
+        signal: runMeta.messagingProgressSupervisor?.abortController?.signal
+          || runMeta.abortController?.signal
+          || null,
       });
       if (delivery?.success === true && delivery?.suppressed !== true) {
         const nowIso = isoNow();
@@ -157,11 +205,12 @@ async function deliverMessagingFinalFallback(engine, {
   console.info(
     `[Run ${shortenRunId(runId)}] messaging_fallback chunks=${chunks.length} to=${summarizeForLog(chatId, 80)}`
   );
+  const deliveredChunks = [];
   for (let i = 0; i < chunks.length; i++) {
     if (i > 0) {
       const delay = Math.max(1000, Math.min(chunks[i].length * 30, 4000));
       await engine.messagingManager.sendTyping(userId, platform, chatId, true, { agentId }).catch(() => {});
-      await new Promise((resolve) => setTimeout(resolve, delay));
+      await abortableDelay(delay, runMeta.abortController?.signal || null);
     }
     try {
       await withProviderRetry(async () => {
@@ -170,32 +219,34 @@ async function deliverMessagingFinalFallback(engine, {
           platform,
           chatId,
           chunks[i],
-          { runId, agentId },
+          {
+            runId,
+            agentId,
+            idempotencyKey: `${runId}:final:${i}`,
+            signal: runMeta.abortController?.signal || null,
+          },
         );
         return requireSuccessfulMessagingDelivery(deliveryResult, 'Final messaging delivery');
       }, {
         ...engine.messagingDeliveryRetry,
         label: `MessagingDelivery ${platform}`,
-        isRetryable: (error) => (
-          error?.retryable !== false
-          && (
-            error?.code === 'MESSAGING_DELIVERY_FAILED'
-            || isTransientError(error)
-          )
-        ),
+        signal: runMeta.abortController?.signal || null,
+        isRetryable: isSafeMessagingDeliveryRetry,
       });
     } catch (error) {
       error.disableAutonomousRetry = true;
+      error.deliveredChunks = deliveredChunks.slice();
       throw error;
     }
+    deliveredChunks.push(chunks[i]);
+    runMeta.lastSentMessage = chunks[i];
+    if (!Array.isArray(runMeta.sentMessages)) runMeta.sentMessages = [];
+    runMeta.sentMessages.push(chunks[i]);
   }
 
-  runMeta.lastSentMessage = chunks[chunks.length - 1] || cleanedContent;
-  runMeta.sentMessages = Array.isArray(runMeta.sentMessages)
-    ? [...runMeta.sentMessages, ...chunks]
-    : chunks.slice();
+  runMeta.lastSentMessage = deliveredChunks[deliveredChunks.length - 1] || cleanedContent;
   engine.markRunFinalDelivery(runId, runMeta.lastSentMessage);
-  return { sent: true, chunks };
+  return { sent: true, chunks: deliveredChunks };
 }
 
 async function tickMessagingProgressSupervisor(engine, runId) {
@@ -206,54 +257,71 @@ async function tickMessagingProgressSupervisor(engine, runId) {
   if (runMeta.terminalInterim) {
     return { sent: false, skipped: true };
   }
+  if (runMeta.progressSupervisorTickInFlight === true) {
+    return { sent: false, skipped: true, inFlight: true };
+  }
+  runMeta.progressSupervisorTickInFlight = true;
+  let settleTick;
+  const tickPromise = new Promise((resolve) => { settleTick = resolve; });
+  runMeta.progressSupervisorTickPromise = tickPromise;
 
-  const ledger = runMeta.progressLedger || buildInitialProgressLedger({
-    startedAt: runMeta.startedAtIso || isoNow(),
-  });
-  runMeta.progressLedger = ledger;
-  const liveness = evaluateProgressLiveness(runMeta);
-  const stalled = liveness.stalled;
-
-  if (stalled && !ledger.stallNotifiedAt) {
-    engine.updateRunProgress(runId, {
-      stallNotifiedAt: isoNow(),
-      progressState: 'stalled',
+  try {
+    const ledger = runMeta.progressLedger || buildInitialProgressLedger({
+      startedAt: runMeta.startedAtIso || isoNow(),
     });
-    engine.recordRunEvent(runMeta.userId, runId, 'progress_stalled', {
-      currentTool: ledger.currentTool || null,
-      currentStep: ledger.currentStep || null,
-      phase: ledger.currentPhase || 'idle',
-    }, { agentId: runMeta.agentId });
-  }
+    runMeta.progressLedger = ledger;
+    const liveness = evaluateProgressLiveness(runMeta);
+    const stalled = liveness.stalled;
 
-  if (!liveness.shouldNudge) {
-    return { sent: false, skipped: true };
-  }
+    if (stalled && !ledger.stallNotifiedAt) {
+      engine.updateRunProgress(runId, {
+        stallNotifiedAt: isoNow(),
+        progressState: 'stalled',
+      });
+      engine.recordRunEvent(runMeta.userId, runId, 'progress_stalled', {
+        currentTool: ledger.currentTool || null,
+        currentStep: ledger.currentStep || null,
+        phase: ledger.currentPhase || 'idle',
+      }, { agentId: runMeta.agentId });
+    }
 
-  const lastSupervisorNudgeAtMs = timestampMs(runMeta.lastSupervisorNudgeAt, 0);
-  if (lastSupervisorNudgeAtMs > 0 && (Date.now() - lastSupervisorNudgeAtMs) < REPEAT_UPDATE_MS) {
-    return { sent: false, skipped: true };
-  }
+    if (!liveness.shouldNudge) {
+      return { sent: false, skipped: true };
+    }
 
-  if (ledger.currentPhase === 'tool' || ledger.currentPhase === 'model') {
-    return sendRuntimeMessagingHeartbeat(engine, runId, { stalled });
-  }
+    const lastSupervisorNudgeAtMs = timestampMs(runMeta.lastSupervisorNudgeAt, 0);
+    if (lastSupervisorNudgeAtMs > 0 && (Date.now() - lastSupervisorNudgeAtMs) < REPEAT_UPDATE_MS) {
+      return { sent: false, skipped: true };
+    }
 
-  if (ledger.currentPhase !== 'idle') {
-    return { sent: false, skipped: true };
-  }
+    if (ledger.currentPhase === 'tool' || ledger.currentPhase === 'model') {
+      return await sendRuntimeMessagingHeartbeat(engine, runId, { stalled });
+    }
 
-  const queued = engine.enqueueSystemSteering(runId, buildProgressNudge({ stalled }), {
-    reason: stalled ? 'stalled_progress_check' : 'progress_check',
-  });
-  if (!queued) {
-    return { sent: false, skipped: true };
+    if (ledger.currentPhase !== 'idle') {
+      return { sent: false, skipped: true };
+    }
+
+    const queued = engine.enqueueSystemSteering(runId, buildProgressNudge({ stalled }), {
+      reason: stalled ? 'stalled_progress_check' : 'progress_check',
+    });
+    if (!queued) {
+      return { sent: false, skipped: true };
+    }
+    runMeta.lastSupervisorNudgeAt = isoNow();
+    engine.updateRunProgress(runId, {
+      lastUserVisibleUpdateAt: ledger.lastUserVisibleUpdateAt || null,
+    });
+    return { sent: false, queued: true };
+  } finally {
+    settleTick();
+    if (engine.getRunMeta(runId) === runMeta) {
+      runMeta.progressSupervisorTickInFlight = false;
+      if (runMeta.progressSupervisorTickPromise === tickPromise) {
+        runMeta.progressSupervisorTickPromise = null;
+      }
+    }
   }
-  runMeta.lastSupervisorNudgeAt = isoNow();
-  engine.updateRunProgress(runId, {
-    lastUserVisibleUpdateAt: ledger.lastUserVisibleUpdateAt || null,
-  });
-  return { sent: false, queued: true };
 }
 
 function startMessagingProgressSupervisor(engine, runId) {
@@ -264,25 +332,29 @@ function startMessagingProgressSupervisor(engine, runId) {
   if (runMeta.messagingProgressSupervisor?.timer) {
     return true;
   }
+  const abortController = new AbortController();
   const timer = setInterval(() => {
     tickMessagingProgressSupervisor(engine, runId).catch((error) => {
       console.warn('[Engine] Messaging progress supervisor failed:', error?.message || error);
     });
   }, TICK_MS);
   timer.unref?.();
-  runMeta.messagingProgressSupervisor = { timer };
+  runMeta.messagingProgressSupervisor = { timer, abortController };
   return true;
 }
 
 function stopMessagingProgressSupervisor(engine, runId) {
   const runMeta = engine.getRunMeta(runId);
+  const inFlight = runMeta?.progressSupervisorTickPromise || null;
   const timer = runMeta?.messagingProgressSupervisor?.timer || null;
   if (timer) {
     clearInterval(timer);
   }
+  runMeta?.messagingProgressSupervisor?.abortController?.abort('Progress supervisor stopped.');
   if (runMeta?.messagingProgressSupervisor) {
     runMeta.messagingProgressSupervisor = null;
   }
+  return inFlight || Promise.resolve();
 }
 
 module.exports = {

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

@@ -0,0 +1,91 @@
+'use strict';
+
+const MODEL_CALL_TIMEOUT_MS = 5 * 60 * 1000;
+
+function formatElapsedDuration(durationMs) {
+  const totalSeconds = Math.max(1, Math.floor(Number(durationMs || 0) / 1000));
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  if (seconds === 0) return `${minutes}m`;
+  return `${minutes}m ${seconds}s`;
+}
+
+function resolveModelCallTimeoutMs(options = {}) {
+  const requested = Number(options?.modelCallTimeoutMs);
+  if (Number.isFinite(requested) && requested > 0) {
+    return Math.max(10, requested);
+  }
+  return MODEL_CALL_TIMEOUT_MS;
+}
+
+function abortError(reason = null) {
+  if (reason instanceof Error) return reason;
+  const error = new Error(String(reason || 'Model call aborted.'));
+  error.name = 'AbortError';
+  error.code = 'ABORT_ERR';
+  return error;
+}
+
+async function withModelCallTimeout(promise, options = {}, label = 'Model call') {
+  const timeoutMs = resolveModelCallTimeoutMs(options);
+  const signal = options?.modelAbortController?.signal || options?.signal || null;
+  let timer = null;
+  let abortListener = null;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      const error = new Error(`${label} timed out after ${formatElapsedDuration(timeoutMs)}.`);
+      error.code = 'MODEL_CALL_TIMEOUT';
+      options?.modelAbortController?.abort(error);
+      reject(error);
+    }, timeoutMs);
+  });
+  const aborted = new Promise((_, reject) => {
+    if (!signal) return;
+    abortListener = () => reject(abortError(signal.reason));
+    if (signal.aborted) abortListener();
+    else signal.addEventListener('abort', abortListener, { once: true });
+  });
+
+  try {
+    return await Promise.race([Promise.resolve(promise), timeout, aborted]);
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (abortListener) signal?.removeEventListener('abort', abortListener);
+  }
+}
+
+async function runAbortableModelCall(factory, options = {}, label = 'Model call') {
+  const modelAbortController = new AbortController();
+  const parentSignals = [...new Set([
+    options?.signal,
+    ...(Array.isArray(options?.signals) ? options.signals : []),
+  ].filter((signal) => signal && typeof signal.addEventListener === 'function'))];
+  const parentListeners = new Map();
+  for (const parentSignal of parentSignals) {
+    const abortFromParent = () => modelAbortController.abort(parentSignal.reason);
+    parentListeners.set(parentSignal, abortFromParent);
+    if (parentSignal.aborted) abortFromParent();
+    else parentSignal.addEventListener('abort', abortFromParent, { once: true });
+  }
+
+  try {
+    const promise = Promise.resolve().then(() => factory(modelAbortController.signal));
+    return await withModelCallTimeout(
+      promise,
+      { ...options, modelAbortController },
+      label,
+    );
+  } finally {
+    for (const [parentSignal, abortFromParent] of parentListeners) {
+      parentSignal.removeEventListener('abort', abortFromParent);
+    }
+  }
+}
+
+module.exports = {
+  abortError,
+  resolveModelCallTimeoutMs,
+  runAbortableModelCall,
+  withModelCallTimeout,
+};

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

@@ -5,47 +5,16 @@ const { sanitizeModelOutput } = require('../outputSanitizer');
 const { parseJsonObject } = require('../taskAnalysis');
 const { withProviderRetry, isTransientError } = require('../providerRetry');
 const { normalizeUsage, recordModelUsage } = require('../usage');
-
-const MODEL_CALL_TIMEOUT_MS = 5 * 60 * 1000;
+const {
+  resolveModelCallTimeoutMs,
+  runAbortableModelCall,
+  withModelCallTimeout,
+} = require('./model_call_guard');
 
 function isoNow() {
   return new Date().toISOString();
 }
 
-function formatElapsedDuration(durationMs) {
-  const totalSeconds = Math.max(1, Math.floor(Number(durationMs || 0) / 1000));
-  if (totalSeconds < 60) return `${totalSeconds}s`;
-  const minutes = Math.floor(totalSeconds / 60);
-  const seconds = totalSeconds % 60;
-  if (seconds === 0) return `${minutes}m`;
-  return `${minutes}m ${seconds}s`;
-}
-
-function resolveModelCallTimeoutMs(options = {}) {
-  const requested = Number(options?.modelCallTimeoutMs);
-  if (Number.isFinite(requested) && requested > 0) {
-    return Math.max(10, requested);
-  }
-  return MODEL_CALL_TIMEOUT_MS;
-}
-
-async function withModelCallTimeout(promise, options = {}, label = 'Model call') {
-  const timeoutMs = resolveModelCallTimeoutMs(options);
-  let timer = null;
-  const timeout = new Promise((_, reject) => {
-    timer = setTimeout(() => {
-      const error = new Error(`${label} timed out after ${formatElapsedDuration(timeoutMs)}.`);
-      error.code = 'MODEL_CALL_TIMEOUT';
-      reject(error);
-    }, timeoutMs);
-  });
-  try {
-    return await Promise.race([Promise.resolve(promise), timeout]);
-  } finally {
-    if (timer) clearTimeout(timer);
-  }
-}
-
 async function requestStructuredJson(engine, {
   provider,
   providerName,
@@ -61,6 +30,11 @@ async function requestStructuredJson(engine, {
 }) {
   const startedAt = Date.now();
   const structuredStep = `model:${phase}`;
+  const modelAbortController = new AbortController();
+  const parentSignal = telemetry?.signal;
+  const abortFromParent = () => modelAbortController.abort(parentSignal?.reason);
+  if (parentSignal?.aborted) abortFromParent();
+  else parentSignal?.addEventListener('abort', abortFromParent, { once: true });
   if (telemetry?.runId) {
     engine.updateRunProgress(telemetry.runId, {
       currentPhase: 'model',
@@ -70,7 +44,6 @@ async function requestStructuredJson(engine, {
     });
   }
 
-  let completed = false;
   try {
     const response = await withProviderRetry(
       () => withModelCallTimeout(
@@ -84,14 +57,18 @@ async function requestStructuredJson(engine, {
             model,
             maxTokens,
             reasoningEffort: reasoningEffort || engine.getReasoningEffort(providerName, {}),
+            signal: modelAbortController.signal,
           }
         ),
-        telemetry || {},
+        { ...(telemetry || {}), modelAbortController },
         `${phase} model call`,
       ),
-      { label: `Engine ${model} (structured)` }
+      {
+        label: `Engine ${model} (structured)`,
+        isRetryable: (err) => !modelAbortController.signal.aborted && isTransientError(err),
+        signal: modelAbortController.signal,
+      }
     );
-    completed = true;
     if (telemetry?.runId && telemetry?.userId) {
       recordModelUsage({
         runId: telemetry.runId,
@@ -114,6 +91,7 @@ async function requestStructuredJson(engine, {
       usage: normalizedUsage?.totalTokens || 0,
     };
   } finally {
+    parentSignal?.removeEventListener('abort', abortFromParent);
     const runMeta = telemetry?.runId ? engine.getRunMeta(telemetry.runId) : null;
     if (runMeta?.progressLedger?.currentStep === structuredStep) {
       engine.updateRunProgress(telemetry.runId, {
@@ -121,8 +99,6 @@ async function requestStructuredJson(engine, {
         currentStep: null,
         currentTool: null,
         currentStepStartedAt: null,
-      }, {
-        verified: completed,
       });
     }
   }
@@ -140,9 +116,15 @@ async function requestModelResponse(engine, {
 }) {
   const startedAt = Date.now();
   const requestMessages = sanitizeConversationMessages(messages);
+  const modelAbortController = new AbortController();
+  const parentSignal = options.signal;
+  const abortFromParent = () => modelAbortController.abort(parentSignal?.reason);
+  if (parentSignal?.aborted) abortFromParent();
+  else parentSignal?.addEventListener('abort', abortFromParent, { once: true });
   const callOptions = {
     model,
     reasoningEffort: engine.getReasoningEffort(providerName, options),
+    signal: modelAbortController.signal,
   };
 
   const attemptModelCall = async () => {
@@ -157,7 +139,7 @@ async function requestModelResponse(engine, {
         while (true) {
           const next = await withModelCallTimeout(
             iterator.next(),
-            options,
+            { ...options, modelAbortController },
             `Model stream iteration ${iteration}`,
           );
           if (next.done) break;
@@ -194,7 +176,7 @@ async function requestModelResponse(engine, {
     } else {
       response = await withModelCallTimeout(
         provider.chat(requestMessages, tools, callOptions),
-        options,
+        { ...options, modelAbortController },
         `Model iteration ${iteration}`,
       );
     }
@@ -202,18 +184,27 @@ async function requestModelResponse(engine, {
     return { response, streamContent };
   };
 
-  const { response, streamContent } = await withProviderRetry(attemptModelCall, {
-    ...(options.retry || {}),
-    label: `Engine ${model}`,
-    isRetryable: (err) => !err?.__providerRetryUnsafe && isTransientError(err),
-    onRetry: ({ attempt, delayMs }) => {
-      engine.emit(options.userId, 'run:interim', {
-        runId,
-        message: `Model service busy; retrying (attempt ${attempt}) in ${Math.max(1, Math.round(delayMs / 1000))}s.`,
-        phase: 'recovering',
-      });
-    },
-  });
+  let response;
+  let streamContent;
+  try {
+    ({ response, streamContent } = await withProviderRetry(attemptModelCall, {
+      ...(options.retry || {}),
+      label: `Engine ${model}`,
+      isRetryable: (err) => !modelAbortController.signal.aborted
+        && !err?.__providerRetryUnsafe
+        && isTransientError(err),
+      onRetry: ({ attempt, delayMs }) => {
+        engine.emit(options.userId, 'run:interim', {
+          runId,
+          message: `Model service busy; retrying (attempt ${attempt}) in ${Math.max(1, Math.round(delayMs / 1000))}s.`,
+          phase: 'recovering',
+        });
+      },
+      signal: modelAbortController.signal,
+    }));
+  } finally {
+    parentSignal?.removeEventListener('abort', abortFromParent);
+  }
 
   const resolvedResponse = response || {
     content: streamContent,
@@ -254,5 +245,6 @@ module.exports = {
   requestModelResponse,
   requestStructuredJson,
   resolveModelCallTimeoutMs,
+  runAbortableModelCall,
   withModelCallTimeout,
 };