neoagent 3.2.1-beta.1 → 3.2.1-beta.3

package/server/services/tasks/runtime.js

@@ -15,6 +15,7 @@ const scheduleAdapter = require('./adapters/schedule');
 const { normalizeJsonObject } = require('./utils');
 const { normalizeOutgoingMessageForPlatform } = require('../messaging/formatting_guides');
 const { isTransientError } = require('../ai/providerRetry');
+const { isAbortError, throwIfAborted } = require('../../utils/abort');
 
 const MAX_AUTONOMOUS_RETRIES = 1;
 const MAX_RECURRING_TASK_START_DELAY_MS = 90 * 1000;
@@ -112,6 +113,7 @@ class TaskRuntime {
     this.runningTaskExecutions = new Set();
     this.activeExecutionPromises = new Set();
     this.activePolls = new Map();
+    this.abortController = new AbortController();
     this.integrationEventCleanups = [];
     this.triggerRegistry = new TriggerRegistry(taskAdapters);
     this.started = false;
@@ -149,6 +151,9 @@ class TaskRuntime {
       throw new Error('Task runtime cannot start while shutdown is in progress.');
     }
 
+    if (this.abortController.signal.aborted) {
+      this.abortController = new AbortController();
+    }
     this.started = true;
     this.stopping = false;
     this.state = 'starting';
@@ -208,6 +213,7 @@ class TaskRuntime {
     this.started = false;
     this.stopping = true;
     this.state = 'stopping';
+    this.abortController.abort('Task runtime is stopping.');
     this._stopScheduling();
 
     this.stopPromise = (async () => {
@@ -301,6 +307,9 @@ class TaskRuntime {
   runTaskNow(taskId, userId) {
     const task = this.taskRepository.getTaskById(taskId, userId);
     if (!task) throw new Error('Task not found');
+    if (this.stopping || this.abortController.signal.aborted) {
+      return { running: false, skipped: true, reason: 'runtime_stopping' };
+    }
     void this._executeTask(taskId, userId, {
       scheduledAt: new Date().toISOString(),
       manual: true,
@@ -349,6 +358,7 @@ class TaskRuntime {
     const due = this.taskRepository.listDueOneTimeTasks();
 
     for (const task of due) {
+      if (this.abortController.signal.aborted) break;
       this.scheduleJobs.delete(task.id);
       try {
         const result = await this._executeTask(task.id, task.user_id, {
@@ -373,9 +383,13 @@ class TaskRuntime {
       return this._runPoll('integration', async () => {
         const tasks = this.taskRepository.listEnabledByTriggerTypes(POLLED_TRIGGER_TYPES);
         for (const task of tasks) {
+          if (this.abortController.signal.aborted) break;
           try {
-            await pollIntegrationTask(this, task);
+            await pollIntegrationTask(this, task, {
+              signal: this.abortController.signal,
+            });
           } catch (error) {
+            if (isAbortError(error, this.abortController.signal) && this.stopping) break;
             console.error(`[Tasks] Trigger poll failed for task ${task.id}:`, error.message);
           }
         }
@@ -390,13 +404,16 @@ class TaskRuntime {
     if (active) {
       return active;
     }
-    if (this.stopping) {
+    if (this.stopping || this.abortController.signal.aborted) {
       return Promise.resolve({ skipped: true, reason: 'runtime_stopping' });
     }
 
     const promise = Promise.resolve()
-      .then(callback)
+      .then(() => callback(this.abortController.signal))
       .catch((error) => {
+        if (isAbortError(error, this.abortController.signal) && this.stopping) {
+          return { skipped: true, reason: 'runtime_stopping' };
+        }
         this.lastError = error.message;
         onError(error);
         return { error: error.message };
@@ -453,7 +470,7 @@ class TaskRuntime {
   }
 
   async _executeTask(taskId, userId, executionMeta = {}) {
-    if (this.stopping) {
+    if (this.stopping || this.abortController.signal.aborted) {
       return { skipped: true, reason: 'runtime_stopping' };
     }
     const executionKey = `${userId}:${taskId}`;
@@ -488,6 +505,8 @@ class TaskRuntime {
   }
 
   async _executeTaskSerial(taskId, userId, executionMeta = {}) {
+    const signal = this.abortController.signal;
+    if (signal.aborted) return { skipped: true, reason: 'runtime_stopping' };
     const task = this.taskRepository.getTaskById(taskId, userId);
     if (!task || !task.enabled) return { skipped: true, reason: 'missing_or_disabled' };
 
@@ -582,7 +601,11 @@ class TaskRuntime {
           taskId,
           manual: executionMeta.manual === true,
           scheduledAt: executionMeta.scheduledAt || null,
+          signal,
         });
+        if (this.stopping || signal.aborted) {
+          return { skipped: true, reason: 'runtime_stopping' };
+        }
         this.io.to(`user:${userId}`).emit('tasks:task_complete', { taskId, result });
         this._recordTaskLifecycle({
           userId,
@@ -647,12 +670,16 @@ class TaskRuntime {
           skipVerifier: false,
           stream: false,
           context: executionMeta.triggerPayload || {},
+          signal,
         };
         try {
           const result = typeof this.agentEngine.runWithModel === 'function'
             ? await this.agentEngine.runWithModel(userId, finalPrompt, runOptions, normalizedConfig.model || null)
             : await this.agentEngine.run(userId, finalPrompt, runOptions);
           completedRunId = result?.runId || null;
+          if (this.stopping || signal.aborted) {
+            return { skipped: true, reason: 'runtime_stopping', runId: completedRunId };
+          }
           const fallbackDelivery = await this._deliverTaskResultIfNeeded({
             userId,
             agentId,
@@ -692,6 +719,9 @@ class TaskRuntime {
           });
           return result;
         } catch (err) {
+          if (isAbortError(err, signal) && this.stopping) {
+            return { skipped: true, reason: 'runtime_stopping', runId: completedRunId };
+          }
           const transientExecutionError = isTransientError(err);
           if (completedRunId && !transientExecutionError) {
             this.taskRepository.markAgentRunFailed(completedRunId, userId, err.message);
@@ -733,6 +763,9 @@ class TaskRuntime {
         }
       }
     } catch (err) {
+      if (isAbortError(err, signal) && this.stopping) {
+        return { skipped: true, reason: 'runtime_stopping', runId: completedRunId };
+      }
       console.error(`[Tasks] Task ${taskId} error:`, err.message);
       if (err?.code !== 'TASK_DELIVERY_FAILED') {
         const failureMessage = this._buildTaskFailureMessage(taskName, err);
@@ -1045,6 +1078,7 @@ class TaskRuntime {
     deliveryState,
     allowPlainResultFallback = true,
   }) {
+    throwIfAborted(this.abortController.signal, 'Task runtime is stopping.');
     if (deliveryState?.messagingSent || deliveryState?.noResponse || taskConfig.callTo) return null;
     const targets = this._buildNotifyTargets(userId, agentId, taskConfig);
     if (!targets.length) return null;
@@ -1118,6 +1152,7 @@ class TaskRuntime {
           mediaPath: target.mediaPath || null,
           runId: result?.runId || null,
           persistConversation: true,
+          signal: this.abortController.signal,
         });
         deliveryState.messagingSent = true;
         deliveryState.proactiveMessageStaged = false;

package/server/services/voice/agentBridge.js

@@ -3,6 +3,7 @@
 const { randomUUID } = require('crypto');
 
 const { runVoiceTranscriptTurn } = require('./turnRunner');
+const { createAbortError, throwIfAborted } = require('../../utils/abort');
 
 class VoiceAgentBridge {
   constructor({ agentEngine, memoryManager, runtimeManager }) {
@@ -20,6 +21,8 @@ class VoiceAgentBridge {
     await session.publishTranscriptFinal(transcriptText);
     await session.setState('thinking');
     const runId = randomUUID();
+    let ownedRunId = runId;
+    const turnSignal = session.signal;
     session.currentRunId = runId;
 
     try {
@@ -40,8 +43,11 @@ class VoiceAgentBridge {
         allowInterimUpdates: true,
         voiceSessionId: session.id,
         runId,
+        signal: turnSignal,
       });
-      session.currentRunId = result.runId || runId;
+      throwIfAborted(turnSignal, 'Voice turn was interrupted.');
+      ownedRunId = result.runId || runId;
+      session.currentRunId = ownedRunId;
       const replyText = String(result.replyText || '').trim();
       if (replyText) {
         if (deferredFollowUp) {
@@ -50,6 +56,7 @@ class VoiceAgentBridge {
             deferredFollowUp,
             replyText,
             result.runId || runId,
+            { signal: turnSignal },
           );
           if (!followUp?.sent) {
             await this.runtimeManager.deliverAssistantMessage(session, replyText, {
@@ -62,12 +69,18 @@ class VoiceAgentBridge {
           });
         }
       }
+      throwIfAborted(turnSignal, 'Voice turn was interrupted.');
       await session.setState('idle');
-      session.currentRunId = null;
+      if (session.currentRunId === ownedRunId) {
+        session.currentRunId = null;
+      }
       return result;
     } catch (error) {
-      session.currentRunId = null;
-      await session.setState('idle');
+      if (session.currentRunId === ownedRunId) session.currentRunId = null;
+      if (session.signal === turnSignal && !session.closed) {
+        await session.setState('idle');
+      }
+      if (turnSignal.aborted) throw createAbortError(turnSignal);
       throw error;
     }
   }

package/server/services/voice/bufferedLiveRelayAdapter.js

@@ -3,6 +3,7 @@
 const { getProviderRuntimeConfig } = require('../ai/models');
 const { resolveSttModel, transcribeVoiceInput } = require('./providers');
 const { writeTempAudioFile, removeTempFile } = require('./liveAudio');
+const { createAbortError } = require('../../utils/abort');
 
 const DEFAULT_PARTIAL_DEBOUNCE_MS = 700;
 const DEFAULT_MIN_PARTIAL_BYTES = 8000;
@@ -68,6 +69,7 @@ class BufferedLiveRelayAdapter {
         userId: session.userId,
         agentId: session.agentId,
         timeoutMs: 20000,
+        signal: session.signal,
       });
     } finally {
       // Release buffered audio immediately after commit so completed turns do
@@ -99,6 +101,7 @@ class BufferedLiveRelayAdapter {
           userId: session.userId,
           agentId: session.agentId,
           timeoutMs: 6000,
+          signal: session.signal,
         });
         if (transcript) {
           await session.publishTranscriptPartial(transcript);
@@ -136,9 +139,11 @@ class BufferedLiveRelayAdapter {
             apiKey: attempt.apiKey,
             baseUrl: attempt.baseUrl,
             timeoutMs: options.timeoutMs,
+            signal: options.signal,
           });
           return String(transcript || '').trim();
         } catch (error) {
+          if (options.signal?.aborted) throw createAbortError(options.signal);
           lastError = error;
         }
       }

package/server/services/voice/liveSession.js

@@ -1,5 +1,12 @@
 'use strict';
 
+function voiceAbortError(message, code) {
+  const error = new Error(message);
+  error.name = 'AbortError';
+  error.code = code;
+  return error;
+}
+
 class VoiceLiveSession {
   constructor({
     id,
@@ -32,6 +39,11 @@ class VoiceLiveSession {
     this.lastAssistantText = '';
     this.assistantMessageCount = 0;
     this.closed = false;
+    this.turnAbortController = new AbortController();
+  }
+
+  get signal() {
+    return this.turnAbortController.signal;
   }
 
   resetInput(mimeType = 'audio/pcm;rate=16000;channels=1') {
@@ -46,6 +58,13 @@ class VoiceLiveSession {
   }
 
   resetTurnState() {
+    if (!this.turnAbortController.signal.aborted) {
+      this.turnAbortController.abort(voiceAbortError(
+        'Voice turn was reset.',
+        'VOICE_TURN_RESET',
+      ));
+    }
+    this.turnAbortController = new AbortController();
     this.lastPartialTranscript = '';
     this.lastFinalTranscript = '';
     this.lastAssistantText = '';
@@ -204,6 +223,12 @@ class VoiceLiveSession {
 
   async interruptOutput() {
     this.interrupted = true;
+    if (!this.turnAbortController.signal.aborted) {
+      this.turnAbortController.abort(voiceAbortError(
+        'Voice output was interrupted.',
+        'VOICE_INTERRUPTED',
+      ));
+    }
     if (typeof this.sink?.interruptOutput === 'function') {
       await this.sink.interruptOutput(this);
     }
@@ -217,6 +242,12 @@ class VoiceLiveSession {
 
   async close(reason = 'closed') {
     this.closed = true;
+    if (!this.turnAbortController.signal.aborted) {
+      this.turnAbortController.abort(voiceAbortError(
+        `Voice session closed: ${reason}.`,
+        'VOICE_SESSION_CLOSED',
+      ));
+    }
     if (typeof this.sink?.close === 'function') {
       await this.sink.close(this, reason);
     }

package/server/services/voice/openaiSpeech.js

@@ -1,9 +1,22 @@
 'use strict';
 
+const { readResponseBuffer } = require('../network/http');
+const { runWithAbortTimeout } = require('../../utils/abort');
+
+const DEFAULT_SPEECH_TIMEOUT_MS = 30000;
+const DEFAULT_MAX_SPEECH_BYTES = 32 * 1024 * 1024;
+
 async function synthesizeSpeechBuffer(
   client,
   text,
-  { model = 'gpt-4o-mini-tts', voice = 'alloy', responseFormat = 'mp3' } = {},
+  {
+    model = 'gpt-4o-mini-tts',
+    voice = 'alloy',
+    responseFormat = 'mp3',
+    signal = null,
+    timeoutMs = DEFAULT_SPEECH_TIMEOUT_MS,
+    maxResponseBytes = DEFAULT_MAX_SPEECH_BYTES,
+  } = {},
 ) {
   if (!client) {
     throw new Error('OpenAI client is not configured for speech synthesis.');
@@ -14,14 +27,26 @@ async function synthesizeSpeechBuffer(
     throw new Error('Speech input is empty; cannot synthesize audio.');
   }
 
-  const response = await client.audio.speech.create({
-    model: String(model || 'gpt-4o-mini-tts').trim() || 'gpt-4o-mini-tts',
-    voice: String(voice || 'alloy').trim() || 'alloy',
-    input: content,
-    response_format: String(responseFormat || 'mp3').trim() || 'mp3',
-  });
+  return runWithAbortTimeout(async (operationSignal) => {
+    const response = await client.audio.speech.create({
+      model: String(model || 'gpt-4o-mini-tts').trim() || 'gpt-4o-mini-tts',
+      voice: String(voice || 'alloy').trim() || 'alloy',
+      input: content,
+      response_format: String(responseFormat || 'mp3').trim() || 'mp3',
+    }, { signal: operationSignal });
 
-  return Buffer.from(await response.arrayBuffer());
+    return readResponseBuffer(response, {
+      maxResponseBytes,
+      serviceName: 'OpenAI speech synthesis',
+      signal: operationSignal,
+      tooLargeCode: 'VOICE_PROVIDER_RESPONSE_TOO_LARGE',
+    });
+  }, {
+    signal,
+    timeoutMs,
+    timeoutCode: 'VOICE_PROVIDER_TIMEOUT',
+    label: 'OpenAI speech synthesis',
+  });
 }
 
 module.exports = {